services

type BaselineFile struct {
	Version      int            `json:"version"`
	MinTokens    int            `json:"min_tokens,omitempty"` // informative: threshold the baseline was built with
	Fingerprints map[string]int `json:"fingerprints"`         // clone hash → instance count at baseline time
}

type DetectOptions struct {
	MinTokens     int
	MinSimilarity float64
	MaxBucket     int // max blocks per fuzzy mini-hash bucket (0 = default 500)
	// MaxPairs, if > 0, caps the number of fuzzy candidate pairs the detector
	// evaluates — a runaway backstop that bounds CPU time on pathological
	// inputs. When the cap is reached, type-3 detection stops at the next block
	// boundary and returns the matches found so far (a deterministic PARTIAL
	// result); type-1/2 clones are unaffected. 0 means no cap.
	MaxPairs int
	// InScopeFiles, when non-nil, restricts detection to clones where at
	// least one instance is in a file marked true. Indexed by the position
	// of the file in the `files` slice passed to DetectWithOptions. The
	// fuzzy detector also uses this to skip candidate pairs where neither
	// block is in scope, which is the main cost win for diff-aware scanning.
	// Nil means "all files in scope" (original behavior).
	InScopeFiles []bool
}

type DetectStats struct {
	// CappedPairs is true when --max-pairs stopped fuzzy detection early:
	// the type-3 results are a deterministic partial set.
	CappedPairs bool
	// BucketTruncated is true when at least one fuzzy candidate bucket was
	// cut to --max-bucket, so some near-miss pairs were never compared.
	BucketTruncated bool
	// EvaluatedPairs counts the fuzzy candidate pairs actually compared.
	EvaluatedPairs int
}

type FormatOptions struct {
	ScanPath       string // base path for relative file paths
	Verbose        bool   // show all clones with previews
	Top            int    // max clones shown (0 = use defaultTopClones, -1 = all)
	ShowSuppressed bool   // include suppressed clones in output
}

type FuncSpan struct {
	Start int
	End   int
	Name  string
}

type FunctionDef struct {
	Name   string
	File   string
	Line   int
	Lang   string
	DefTok int // token index of the function name
}

type IgnoreRule struct {
	Raw       string // original text
	Hash      string // 8+ hex chars → suppress by clone hash
	PathGlob  string // path glob (may contain **) → suppress all clones touching this path
	FilePath  string // file:start-end → suppress specific line range
	FileStart int
	FileEnd   int
}

type ScanOptions struct {
	Path           string
	MinTokens      int
	MinLines       int // deprecated; if MinTokens == 0, converted to MinTokens = MinLines * 10
	Exclude        []string
	Include        []string // if non-empty, only files matching at least one pattern are scanned
	Language       string
	MinSimilarity  float64 // minimum Jaccard similarity for type-3 detection (0.50–1.00)
	MaxBucket      int     // max blocks per fuzzy bucket (0 = default 500)
	Staged         bool    // only report clones involving git-staged files
	Top            int     // max clones to show in text/md output (0 = all)
	Since          string  // git ref for diff-aware scanning
	ShowSuppressed bool    // include suppressed clones in output
	DeadCode       bool    // enable dead function detection
	GitChurn       bool    // annotate clones with git churn scores
	ChurnDays      int     // number of days for git churn window (default 90)
	IgnoreFile     string  // path to .dupehound-ignore file (auto-discovered if empty)
	MaxFiles       int     // hard cap on collected files (0 = no cap); fail-fast safety net
	MaxPairs       int     // runaway backstop on fuzzy pairs (0 = no cap); caps type-3 to a partial result past the limit
	MaxFileSize    int64   // per-file size cap in bytes (0 = no cap); oversized files are skipped before being read
	ScanGenerated  bool    // when true, do NOT skip machine-generated files (default: skip them)
	Baseline       string  // path to a baseline file: known clones become recorded debt, only new ones fail
	WriteBaseline  string  // path to write a new baseline capturing the current clones as accepted debt
}

type ScannerService struct{}

type Token struct {
	Kind       TokenKind
	Text       string // empty for Ident/Number/String; verbatim for Keyword/Operator
	OrigText   string // original text for Ident/Number/String; empty for Keyword/Operator
	Line       int    // 1-indexed original source line
	IgnoreMark bool   // true if this token is on a dupehound:ignore annotated line marker
}

type TokenKind uint8

type TokenizedFile struct {
	Path    string
	Tokens  []Token    // normalized token sequence (no newlines)
	InFunc  []bool     // per-token: true if inside a function/method body
	Ignored []bool     // per-token: true if in a dupehound:ignore annotated block
	Funcs   []FuncSpan // function body spans with best-effort names, for clone attribution
}