type AutoFix struct {
	// contains filtered or unexported fields
}

type ChatOpts struct {
	Model       string  `json:"model,omitempty"`
	MaxTokens   int     `json:"max_tokens,omitempty"`
	Temperature float64 `json:"temperature,omitempty"`
	System      string  `json:"system,omitempty"`
}

type ConcernSpec struct {
	Type          ConcernType
	SystemPrompt  string
	Enabled       bool
	MinConfidence float64
}

type ConcernType string

type ConfidenceBreakdown struct {
	// High are findings with confidence >= 0.7.
	High []Finding `json:"high"`
	// Medium are findings with 0.5 <= confidence < 0.7.
	Medium []Finding `json:"medium"`
	// Low are findings with confidence < 0.5.
	Low []Finding `json:"low"`
}

type Convention struct {
	Name        string
	Description string
	Pattern     string // regex pattern that indicates violation
	FilePattern string // only check files matching this glob
	Severity    Severity
	// contains filtered or unexported fields
}

type ConventionChecker struct {
	// contains filtered or unexported fields
}

type CustomCheck struct {
	// Name is derived from the filename (e.g., "no-console-log" from no-console-log.md).
	Name string

	// Prompt is the markdown body that describes the check rules and gets
	// injected into the LLM system prompt.
	Prompt string

	// Severity is the default severity for findings from this check.
	// Parsed from YAML frontmatter; defaults to "medium".
	Severity string

	// Languages restricts the check to files matching these extensions
	// (e.g., ["go", "py"]). Empty means all languages.
	Languages []string

	// Enabled controls whether the check is active. Defaults to true.
	Enabled bool
}

type DedupConfig struct {
	SameFileOnly        bool    // Only merge findings within the same file
	MergeDistance       int     // Line distance threshold for merging nearby findings
	SimilarityThreshold float64 // Jaccard similarity threshold (0-1) for treating findings as near-duplicates
}

type DedupResult struct {
	Unique     []Finding        // Findings that survived deduplication
	Duplicates []DuplicateGroup // Groups of findings that were merged
}

type Description struct {
	Title      string   `json:"title"`
	Summary    string   `json:"summary"`
	Changes    []string `json:"changes"`
	ChangeType string   `json:"change_type"`
	Risk       string   `json:"risk"`
	TestPlan   string   `json:"test_plan"`
}

type DuplicateGroup struct {
	Representative Finding   // The highest-confidence finding in the group
	Duplicates     []Finding // The remaining findings that were folded in
	Reason         string    // Human-readable explanation of why they were grouped
}

type EvalCase struct {
	Name           string            `json:"name"`
	Diff           string            `json:"diff"`
	ExpectFindings []EvalExpectation `json:"expect_findings"`
	DenyFindings   []EvalDenial      `json:"deny_findings"`
}

type EvalDenial struct {
	MessageContains string `json:"message_contains,omitempty"`
	Concern         string `json:"concern,omitempty"`
}

type EvalExpectation struct {
	Concern         string `json:"concern,omitempty"`
	MinSeverity     string `json:"min_severity,omitempty"`
	MessageContains string `json:"message_contains,omitempty"`
	File            string `json:"file,omitempty"`
}

type EvalResult struct {
	Case     string    `json:"case"`
	Passed   bool      `json:"passed"`
	Failures []string  `json:"failures,omitempty"`
	Findings []Finding `json:"findings"`
}

type EvalSuite struct {
	Cases []EvalCase `json:"cases"`
}

type FileChange struct {
	Path    string
	OldPath string
	Diff    string
	Content string
}

type FileConfig struct {
	Model      string            `json:"model"`
	Concerns   []string          `json:"concerns"`
	FailOn     string            `json:"fail_on"`
	MaxTokens  int               `json:"max_tokens"`
	Exclude    []string          `json:"exclude"`
	GitContext *bool             `json:"git_context"`
	Reflection *bool             `json:"reflection"`
	Parallel   *bool             `json:"parallel"`
	Prompts    map[string]string `json:"prompts"`
}

type FilterConfig struct {
	MinSeverity         Severity
	ConfidenceThreshold float64
	MaxParallel         int
	BatchSize           int
}

type FilterMode = comment.FilterMode

type FilterResult struct {
	Finding    Finding
	Confirmed  bool
	Confidence float64
	Reasoning  string
}

type Finding struct {
	Concern   string   `json:"concern"`
	Severity  Severity `json:"severity"`
	File      string   `json:"file"`
	Line      int      `json:"line"`
	EndLine   int      `json:"end_line,omitempty"`
	Message   string   `json:"message"`
	Fix       string   `json:"fix,omitempty"`
	Reasoning string   `json:"reasoning,omitempty"`
	CWE       string   `json:"cwe,omitempty"`
	// Confidence is a numeric score from 0.0 to 1.0 indicating how certain
	// the system is that this finding is a true positive. Values closer to
	// 1.0 mean higher confidence.
	Confidence float64 `json:"confidence"`
	// SASTSource marks findings that originated from static analysis (SAST)
	// and were fed into the LLM prompt for validation.
	SASTSource bool `json:"sast_source,omitempty"`
}

type FixPipeline struct {
	// contains filtered or unexported fields
}

type FixRule struct {
	// MatchFn returns true when this rule applies to the given Finding.
	MatchFn func(Finding) bool
	// Generator produces a FixSuggestion for a matched Finding.
	Generator func(Finding) FixSuggestion
}

type FixSuggestion struct {
	Finding     *Finding
	FixedCode   string  // the corrected code
	Explanation string  // why this fix works
	Confidence  float64 // 0-1 how confident the fix is correct

	// FindingID links this suggestion back to the originating Finding.
	FindingID string `json:"finding_id"`
	// Title is a short, human-readable summary of the fix.
	Title string `json:"title"`
	// Description explains why the fix is needed and what it does.
	Description string `json:"description"`
	// FixCode contains the suggested code or configuration change.
	FixCode string `json:"fix_code"`
	// Category classifies the fix area, e.g. "input-validation", "auth",
	// "crypto", "injection", "xss", "ssrf".
	Category string `json:"category"`
	// Severity mirrors the severity of the original finding.
	Severity string `json:"severity"`
	// EstimatedEffort indicates how much work the fix requires:
	// "trivial", "easy", "moderate", or "complex".
	EstimatedEffort string `json:"estimated_effort"`
	// Priority ranks this suggestion (1 = highest, 5 = lowest).
	Priority int `json:"priority"`
}

type ImproveResult struct {
	Improvements []Improvement `json:"improvements"`
	TokensUsed   int           `json:"tokens_used"`
}

type Improvement struct {
	File        string `json:"file"`
	Line        int    `json:"line"`
	EndLine     int    `json:"end_line,omitempty"`
	Category    string `json:"category"`
	Description string `json:"description"`
	Before      string `json:"before"`
	After       string `json:"after"`
	Reasoning   string `json:"reasoning"`
}

type IncrementalState struct {
	// contains filtered or unexported fields
}

type InlineComment struct {
	Path       string `json:"path"`
	StartLine  int    `json:"start_line"`
	EndLine    int    `json:"end_line,omitempty"`
	Body       string `json:"body"`
	Suggestion string `json:"suggestion,omitempty"`
}

type MemoryBridge struct {
	// contains filtered or unexported fields
}

type MemoryBridgeOption func(*MemoryBridge)

type MemoryResult struct {
	ID      string   `json:"id"`
	Content string   `json:"content"`
	Score   float64  `json:"score"`
	Tags    []string `json:"tags,omitempty"`
}

type MemorySource interface {
	// Recall returns up to limit results relevant to query, sorted by
	// descending relevance score.
	Recall(ctx context.Context, query string, limit int) ([]MemoryResult, error)

	// Store persists content under key with the given tags for future recall.
	Store(ctx context.Context, key, content string, tags []string) error
}

type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type Option interface {
	// contains filtered or unexported methods
}

type PRSource struct {
	Owner  string
	Repo   string
	Number int
}

type Provider interface {
	Chat(ctx context.Context, messages []Message, opts ChatOpts) (*Response, error)
}

type Response struct {
	Content    string `json:"content"`
	TokensUsed int    `json:"tokens_used"`
}

type Result struct {
	Findings []Finding       `json:"findings"`
	Comments []InlineComment `json:"comments"`
	Stats    Stats           `json:"stats"`
	Report   string          `json:"report"`
	FailOn   Severity        `json:"fail_on"`
	// SASTFusion tracks which SAST findings the LLM confirmed vs dismissed.
	// Only populated when SAST-LLM fusion is active (preAnalysis enabled).
	SASTFusion *SASTFusionResult `json:"sast_fusion,omitempty"`
	// ConfidenceBreakdown groups findings by confidence band for quick triage.
	ConfidenceBreakdown *ConfidenceBreakdown `json:"confidence_breakdown,omitempty"`
}

type Reviewer struct {
	// contains filtered or unexported fields
}

type SASTCheck struct {
	ID          string
	Name        string
	Description string
	Severity    string // "critical", "high", "medium", "low"
	Languages   []string
	Pattern     string // regex or keyword pattern
	Check       func(source string, filePath string) []SASTFinding
}

type SASTFinding struct {
	CheckID    string
	Rule       string
	Message    string
	File       string
	Line       int
	Severity   string
	Confidence float64 // 0-1
	Evidence   string  // the suspicious code
}

type SASTFusion struct {
	// MaxFindings caps the number of SAST findings injected into the prompt.
	// Zero means no limit.
	MaxFindings int
	// MaxEvidenceLen truncates each evidence snippet to this many characters.
	// Zero uses a default of 200.
	MaxEvidenceLen int
}

type SASTFusionResult struct {
	// Confirmed lists SAST findings the LLM validated as real issues.
	Confirmed []Finding
	// Dismissed lists SAST findings the LLM considered false positives.
	Dismissed []Finding
	// Unaddressed lists SAST findings the LLM did not mention (implicitly dismissed).
	Unaddressed []Finding
}

type SASTIntegration struct {
	// contains filtered or unexported fields
}

type SSATaintAnalyzer struct {
	// MaxFindings caps the number of findings returned (0 = unlimited).
	MaxFindings int
	// Env, when non-nil, overrides the environment used to load packages
	// (e.g. append "GOWORK=off" to ignore a parent workspace). Nil inherits the
	// process environment.
	Env []string
}

type Severity = types.Severity

type StaticAnalyzer struct {
	Rules []StaticRule
}

type StaticRule struct {
	ID          string         // unique identifier, e.g. "SEC-GO-001"
	Name        string         // short human-readable name
	Description string         // detailed explanation
	Language    string         // "go", "python", "typescript", "javascript", "any"
	Pattern     *regexp.Regexp // primary detection pattern
	Antipattern *regexp.Regexp // if this also matches the same line, suppress the finding
	Severity    string         // "critical", "high", "medium", "low"
	Category    string         // "security", "correctness", "performance"
	CWE         string         // e.g., "CWE-89"
	Fix         string         // suggested fix description
}

type Stats struct {
	FilesReviewed      int                      `json:"files_reviewed"`
	HunksAnalyzed      int                      `json:"hunks_analyzed"`
	FindingsTotal      int                      `json:"findings_total"`
	BySeverity         map[Severity]int         `json:"by_severity"`
	ByConcern          map[string]int           `json:"by_concern"`
	TokensUsed         int                      `json:"tokens_used"`
	DurationPerConcern map[string]time.Duration `json:"duration_per_concern"`
	// AverageConfidence is the mean confidence score across all findings (0.0-1.0).
	AverageConfidence float64 `json:"average_confidence"`
	// HighConfidenceCount is the number of findings with confidence >= 0.7.
	HighConfidenceCount int `json:"high_confidence_count"`
	// LowConfidenceCount is the number of findings with confidence < 0.5.
	LowConfidenceCount int `json:"low_confidence_count"`
}

type TaintAnalyzer struct{}

type TaintFinding struct {
	Source   string // description of the taint source
	Sink     string // description of the sink
	SinkType string // category: "sql_injection", "command_injection", "path_traversal", "log_leak"
	Variable string // the tainted variable name
	File     string
	Line     int
	Severity string
	CWE      string
	Message  string
	Fix      string
}