analysis

type AllocationPattern struct {
	Pattern     *regexp.Regexp
	Category    string  // "heap", "stack", "pool", "gc-managed"
	Weight      float64 // Relative allocation cost (1.0 = baseline)
	Description string
}

type AnalysisConfig struct {
	// Language support
	EnabledLanguages []string `json:"enabled_languages"`

	// Relationship types to analyze
	AnalyzeExtends        bool `json:"analyze_extends"`
	AnalyzeImplements     bool `json:"analyze_implements"`
	AnalyzeContains       bool `json:"analyze_contains"`
	AnalyzeDependencies   bool `json:"analyze_dependencies"`
	AnalyzeCalls          bool `json:"analyze_calls"`
	AnalyzeReferences     bool `json:"analyze_references"`
	AnalyzeImports        bool `json:"analyze_imports"`
	AnalyzeFileCoLocation bool `json:"analyze_file_co_location"`
	AnalyzeCrossLanguage  bool `json:"analyze_cross_language"`

	// Analysis depth and limits
	MaxCallDepth    int `json:"max_call_depth"`
	MaxReferences   int `json:"max_references"`
	MaxDependencies int `json:"max_dependencies"`

	// Performance settings
	ConcurrentAnalysis bool `json:"concurrent_analysis"`
	MaxConcurrentFiles int  `json:"max_concurrent_files"`

	// Feature flags
	EnableIncrementalAnalysis bool `json:"enable_incremental_analysis"`
	EnableCrossFileAnalysis   bool `json:"enable_cross_file_analysis"`
}

type AnalysisStats struct {
	TotalSymbols      int            `json:"total_symbols"`
	SymbolsByLanguage map[string]int `json:"symbols_by_language"`
	SymbolsByKind     map[string]int `json:"symbols_by_kind"`
	RelationshipCount map[string]int `json:"relationship_count"`
	QueryCount        int64          `json:"query_count"`
	AvgQueryTime      time.Duration  `json:"avg_query_time"`
	LastUpdated       time.Time      `json:"last_updated"`
	MemoryUsage       int64          `json:"memory_usage"`
	EnabledAnalyzers  []string       `json:"enabled_analyzers"`
}

type ArchitectureMetrics struct {
	ModuleStability      float64 `json:"module_stability"`       // incoming/(incoming+outgoing)
	AbstractionLevel     float64 `json:"abstraction_level"`      // interfaces/total_types
	DistanceFromMainSeq  float64 `json:"distance_main_sequence"` // |A + I - 1|
	ComponentCohesion    float64 `json:"component_cohesion"`
	InterfaceSegregation float64 `json:"interface_segregation"`
	DependencyInversion  float64 `json:"dependency_inversion"`
}

type AwaitInfo struct {
	Line        int
	AssignedVar string   // Variable receiving the result (empty if not assigned)
	CallTarget  string   // Function/method being awaited
	UsedVars    []string // Variables referenced in the await arguments
}

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

type BasicSymbolMetrics struct {
	// Core metrics
	Complexity     float64  `json:"complexity"`
	LinesOfCode    int      `json:"lines_of_code"`
	ReferenceCount int      `json:"reference_count"`
	Dependencies   []string `json:"dependencies"`

	// Quality indicators
	Quality   map[string]float64 `json:"quality"`
	RiskScore float64            `json:"risk_score"`
	Tags      []string           `json:"tags"`
}

type BlockKey struct {
	FileID    types.FileID
	StartLine int
	EndLine   int
}

type BlockSize struct {
	Lines      int
	Tokens     int
	Characters int
	Complexity int // cyclomatic complexity
}

type BlockType string

type BranchAllocation struct {
	BranchType     string // "if", "else", "switch_case", "loop_body", "try", "catch"
	StartLine      int
	EndLine        int
	Depth          int     // Nesting depth
	Created        int     // Objects created in this branch
	Dropped        int     // Objects that go out of scope
	Retained       int     // Objects that escape the branch
	Weight         float64 // Weighted allocation score based on patterns
	LoopMultiplier float64 // If in loop, estimated iteration count multiplier
}

type CachedMetricsCalculator struct {
	*MetricsCalculator // Embed the original calculator
	// contains filtered or unexported fields
}

type CachedMetricsConfig struct {
	EnableCaching bool              `json:"enable_caching"`
	CacheConfig   cache.CacheConfig `json:"cache_config"`
	MetricsConfig MetricsConfig     `json:"metrics_config"`
}

type CallGraphNode struct {
	Symbol      *types.EnhancedSymbol `json:"symbol"`
	DirectCalls []*FunctionDependency `json:"direct_calls"`
	CalledBy    []*FunctionDependency `json:"called_by"`
	Depth       int                   `json:"depth"`
	IsRecursive bool                  `json:"is_recursive"`
	CyclePaths  [][]types.SymbolID    `json:"cycle_paths,omitempty"`
	IsCritical  bool                  `json:"is_critical"` // Many dependents
	IsLeaf      bool                  `json:"is_leaf"`     // No dependencies
	IsRoot      bool                  `json:"is_root"`     // No callers
}

type CallInfo struct {
	Target    string // Function/method name
	Line      int
	InLoop    bool // Whether this call is inside a loop
	LoopDepth int  // Depth of containing loop (0 if not in loop)
	LoopLine  int  // Line of containing loop
}

type CallType string

type CodeBlock struct {
	FileID            types.FileID
	FilePath          string
	StartLine         int
	EndLine           int
	StartColumn       int
	EndColumn         int
	Content           string
	NormalizedContent string
	Tokens            []string
	ASTHash           string
	FunctionName      string
	BlockType         BlockType
	Size              BlockSize
}

type CodeQualityMetrics struct {
	CyclomaticComplexity int     `json:"cyclomatic_complexity"`
	CognitiveComplexity  int     `json:"cognitive_complexity"`
	NestingDepth         int     `json:"nesting_depth"`
	LinesOfCode          int     `json:"lines_of_code"`
	LinesOfComments      int     `json:"lines_of_comments"`
	HalsteadVolume       float64 `json:"halstead_volume"`
	HalsteadDifficulty   float64 `json:"halstead_difficulty"`
	MaintainabilityIndex float64 `json:"maintainability_index"`
}

type DependencyMetrics struct {
	IncomingDependencies   int     `json:"incoming_dependencies"`
	OutgoingDependencies   int     `json:"outgoing_dependencies"`
	TransitiveDependencies int     `json:"transitive_dependencies"`
	CouplingStrength       float64 `json:"coupling_strength"` // 0-1 scale
	CohesionStrength       float64 `json:"cohesion_strength"` // 0-1 scale
	DepthInCallTree        int     `json:"depth_in_call_tree"`
	HasCircularDeps        bool    `json:"has_circular_deps"`
	StabilityIndex         float64 `json:"stability_index"`   // incoming/(incoming+outgoing)
	InstabilityIndex       float64 `json:"instability_index"` // outgoing/(incoming+outgoing)
}

type DependencyQuery struct {
	SymbolID          types.SymbolID `json:"symbol_id,omitempty"`
	SymbolName        string         `json:"symbol_name,omitempty"`
	FileID            types.FileID   `json:"file_id,omitempty"`
	Direction         string         `json:"direction"` // "incoming", "outgoing", "both"
	IncludeTransitive bool           `json:"include_transitive"`
	MaxDepth          int            `json:"max_depth"`
	IncludeExternal   bool           `json:"include_external"`
	FilterByType      []CallType     `json:"filter_by_type,omitempty"`
	MinProbability    float64        `json:"min_probability,omitempty"`
	ExcludeFiles      []types.FileID `json:"exclude_files,omitempty"`
}

type DependencySet struct {
	SymbolID types.SymbolID `json:"symbol_id"`

	// Direct dependencies
	DirectDeps       []*FunctionDependency `json:"direct_deps"`
	DirectDependents []*FunctionDependency `json:"direct_dependents"`

	// Transitive dependencies
	TransitiveDeps       []*FunctionDependency `json:"transitive_deps"`
	TransitiveDependents []*FunctionDependency `json:"transitive_dependents"`

	// File-level dependencies
	FileDeps     []types.FileID        `json:"file_deps"`
	ExternalDeps []*ExternalDependency `json:"external_deps"`

	// Analysis results
	DepthLevels       [][]types.SymbolID `json:"depth_levels"`
	CyclicDeps        [][]types.SymbolID `json:"cyclic_deps"`
	CriticalPath      []types.SymbolID   `json:"critical_path"`
	BottleneckSymbols []types.SymbolID   `json:"bottleneck_symbols"`

	// Metrics
	MaxDepth          int `json:"max_depth"`
	TotalDependencies int `json:"total_dependencies"`
	UniqueFiles       int `json:"unique_files"`
	CircularCount     int `json:"circular_count"`
	FanOut            int `json:"fan_out"`
	FanIn             int `json:"fan_in"`

	// Cache management
	CalculatedAt int64 `json:"calculated_at"`
	IsStale      bool  `json:"is_stale"`
}

type DuplicateCluster struct {
	ID         string
	Type       DuplicateType
	Blocks     []CodeBlock
	Similarity float64
	Impact     DuplicateImpact
	Suggestion string
}

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

type DuplicateImpact struct {
	Severity        ImpactSeverity
	LinesCount      int
	FilesCount      int
	Maintainability float64 // 0.0 (hard) to 1.0 (easy)
	Refactorable    bool
}

type DuplicateType string

type ExclusionChecker interface {
	IsExcludedFromAnalysis(fileID types.FileID, symbolID types.SymbolID, analysisType string) bool
}

type ExpensiveCallConfig struct {
	Pattern     *regexp.Regexp // Compiled regex for matching
	Category    string         // "regex", "io", "network", "parse", "reflection"
	Description string         // Human-readable description
	Severity    string         // "high", "medium", "low"
}

type ExternalDepType string

type ExternalDependency struct {
	Name              string            `json:"name"`
	Type              ExternalDepType   `json:"type"`
	Version           string            `json:"version,omitempty"`
	Source            string            `json:"source"`      // package manager, URL, etc.
	IsStandard        bool              `json:"is_standard"` // stdlib vs third-party
	SecurityRisk      SecurityRisk      `json:"security_risk"`
	PerformanceImpact PerformanceImpact `json:"performance_impact"`
	Stability         float64           `json:"stability"` // 0-1 stability score
}

type FileGraphNode struct {
	FileID          types.FileID     `json:"file_id"`
	FilePath        string           `json:"file_path"`
	ImportedFiles   []types.FileID   `json:"imported_files"`
	ImportedBy      []types.FileID   `json:"imported_by"`
	InternalSymbols []types.SymbolID `json:"internal_symbols"`
	ExportedSymbols []types.SymbolID `json:"exported_symbols"`
	ModuleStability float64          `json:"module_stability"`
	CouplingFactor  float64          `json:"coupling_factor"`
}

type FileImportProvider interface {
	GetFileImports(fileID types.FileID) []types.Import
	GetFileInfo(fileID types.FileID) *types.FileInfo
}

type FileInfo struct {
	Path         string    `json:"path"`
	Language     string    `json:"language"`
	Size         int64     `json:"size"`
	LastModified time.Time `json:"last_modified"`
	IsGenerated  bool      `json:"is_generated"`
}

type FileMetrics struct {
	FileID   types.FileID `json:"file_id"`
	FilePath string       `json:"file_path"`

	// Aggregated metrics
	TotalComplexity   int     `json:"total_complexity"`
	AverageComplexity float64 `json:"average_complexity"`
	MaxComplexity     int     `json:"max_complexity"`
	TotalLines        int     `json:"total_lines"`
	CodeLines         int     `json:"code_lines"`
	CommentLines      int     `json:"comment_lines"`

	// Dependency metrics
	InternalDependencies int `json:"internal_dependencies"`
	ExternalDependencies int `json:"external_dependencies"`
	Dependents           int `json:"dependents"`

	// Symbol breakdown
	Functions  int `json:"functions"`
	Classes    int `json:"classes"`
	Interfaces int `json:"interfaces"`
	Variables  int `json:"variables"`

	// Quality indicators
	OverallQualityScore float64 `json:"overall_quality_score"`
	TechnicalDebt       float64 `json:"technical_debt"`
	MaintainabilityRank string  `json:"maintainability_rank"` // A, B, C, D, F

	// Hot spots
	MostComplexSymbol *SymbolMetrics   `json:"most_complex_symbol,omitempty"`
	HighRiskSymbols   []*SymbolMetrics `json:"high_risk_symbols,omitempty"`
}

type FileServiceInterface interface {
	// GetFileContent returns the content of a file
	GetFileContent(fileID types.FileID) (string, error)

	// GetFilePath returns the path of a file
	GetFilePath(fileID types.FileID) (string, error)

	// GetFileInfo returns information about a file
	GetFileInfo(fileID types.FileID) (FileInfo, error)
}

type FunctionAnalysis struct {
	Name      string
	SymbolID  types.SymbolID
	StartLine int
	EndLine   int
	IsAsync   bool
	Loops     []LoopInfo  // All loops in the function
	Awaits    []AwaitInfo // All await expressions
	Calls     []CallInfo  // All function calls
	Language  string
	FilePath  string
}

type FunctionAnalysisContext struct {
	// Function identity
	Name      string
	File      string
	StartLine int
	EndLine   int

	// Parameters (names to track for parameter writes)
	Parameters   map[string]int // name -> parameter index
	ReceiverName string         // "this", "self", or Go receiver name
	ReceiverType string         // Type of receiver (for methods)

	// Scope tracking for closure detection
	LocalVariables map[string]int   // name -> declaration line
	ScopeDepth     int              // Current nesting depth
	OuterScopes    []map[string]int // Variables from enclosing scopes (closures)

	// Access tracking
	Accesses []types.FieldAccess
	SeqNum   int // Next sequence number

	// Detected effects
	SideEffects types.SideEffectCategory

	// External calls (truly external: I/O, network, etc.)
	ExternalCalls []types.ExternalCallInfo

	// Unresolved function calls (need Phase 2 resolution)
	UnresolvedCalls []types.UnresolvedCallInfo

	// Throw sites
	ThrowSites []types.ThrowSiteInfo

	// Error handling
	DeferCount      int
	TryFinallyCount int
	ReturnsError    bool

	// Impurity reasons (for debugging)
	ImpurityReasons []string
}

type FunctionDependency struct {
	SourceSymbol      types.SymbolID    `json:"source_symbol"`
	TargetSymbol      types.SymbolID    `json:"target_symbol"`
	CallType          CallType          `json:"call_type"`
	CallStrength      types.RefStrength `json:"call_strength"`
	CallContext       []types.ScopeInfo `json:"call_context"`
	FileLocation      types.FileID      `json:"file_location"`
	LineNumber        int               `json:"line_number"`
	Distance          int               `json:"distance"`        // Degrees of separation
	ThroughSymbols    []types.SymbolID  `json:"through_symbols"` // For transitive deps
	Probability       float64           `json:"probability"`     // 0-1 likelihood of execution
	PerformanceImpact PerformanceImpact `json:"performance_impact"`
}

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

type FunctionMemoryProfile struct {
	Name      string
	FilePath  string
	StartLine int
	EndLine   int
	Language  string
	FileID    types.FileID   // For annotation lookup
	SymbolID  types.SymbolID // For integration with GraphPropagator

	// Branch-level data
	Branches []BranchAllocation

	// Aggregated metrics
	TotalCreated   int
	TotalDropped   int
	TotalRetained  int     // Objects that escape function scope
	WeightedScore  float64 // Weighted allocation score
	LoopAllocScore float64 // Extra score for allocations in loops

	// Call relationships for propagation
	Callees []string // Functions this function calls
	Callers []string // Functions that call this function

	// Memory analysis hints from @lci annotations
	MemoryHints *core.MemoryAnalysisHints
}

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

type GraphComparison struct {
	FileID                  types.FileID `json:"file_id"`
	ImportVsUsageGap        float64      `json:"import_vs_usage_gap"`
	UnusedImports           []string     `json:"unused_imports"`
	MissingImports          []string     `json:"missing_imports"`
	ArchitecturalViolations []string     `json:"architectural_violations"`
	CouplingDiscrepancies   []string     `json:"coupling_discrepancies"`
}

type HalsteadMetrics struct {
	Volume     float64
	Difficulty float64
	Effort     float64
	Time       float64
	Bugs       float64
}

type ImpactSeverity string

type ImportResolution struct {
	ImportPath   string                    `json:"import_path"`   // The import path
	ResolvedPath string                    `json:"resolved_path"` // Resolved file path
	Symbols      []types.CompositeSymbolID `json:"symbols"`       // Imported symbols
	ImportType   ImportType                `json:"import_type"`   // Type of import
	Location     types.SymbolLocation      `json:"location"`      // Location of import statement
}

type ImportType uint8

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

type JavaScriptGoFastAnalyzer struct{}

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

type LanguageAnalyzer interface {
	// ExtractSymbols extracts all symbols from file content
	ExtractSymbols(fileID types.FileID, content, filePath string) ([]*types.UniversalSymbolNode, error)

	// AnalyzeExtends analyzes inheritance/extension relationships
	AnalyzeExtends(symbol *types.UniversalSymbolNode, content, filePath string) ([]types.CompositeSymbolID, error)

	// AnalyzeImplements analyzes interface implementation relationships
	AnalyzeImplements(symbol *types.UniversalSymbolNode, content, filePath string) ([]types.CompositeSymbolID, error)

	// AnalyzeContains analyzes containment relationships (methods in classes, etc.)
	AnalyzeContains(symbol *types.UniversalSymbolNode, content, filePath string) ([]types.CompositeSymbolID, error)

	// AnalyzeDependencies analyzes dependency relationships
	AnalyzeDependencies(symbol *types.UniversalSymbolNode, content, filePath string) ([]types.SymbolDependency, error)

	// AnalyzeCalls analyzes function call relationships
	AnalyzeCalls(symbol *types.UniversalSymbolNode, content, filePath string) ([]types.FunctionCall, error)

	// GetLanguageName returns the name of the language this analyzer handles
	GetLanguageName() string
}

type LoopInfo struct {
	NodeType  string // "for_statement", "while_statement", etc.
	StartLine int
	EndLine   int
	Depth     int // Nesting depth (1 = top-level loop)
}

type MemoryAnalysisResult struct {
	Functions []FunctionMemoryProfile
	Scores    []MemoryPressureScore
	Summary   MemorySummary
	Hotspots  []MemoryHotspot
}

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

type MemoryAnalyzerOptions struct {
	// IncludeTestFiles controls whether test files are included in the analysis.
	// When false (default), test files receive a 0.1x score penalty, effectively
	// filtering them from top hotspots while still tracking them.
	// When true, test files are scored normally (useful for analyzing test performance).
	IncludeTestFiles bool

	// TestFilePenalty is the multiplier applied to test file scores when
	// IncludeTestFiles is false. Default is 0.1 (10% of normal score).
	TestFilePenalty float64

	// TestFilePatterns configures how test files are detected.
	// If nil, uses DefaultTestFilePatterns().
	TestFilePatterns *TestFilePatterns
}

type MemoryHotspot struct {
	FunctionName string
	FilePath     string
	Line         int
	Score        float64
	Reason       string
	Suggestion   string
}

type MemoryPressureScore struct {
	FunctionName     string
	FilePath         string
	Line             int
	SymbolID         types.SymbolID
	DirectScore      float64 // Score from direct allocations
	PropagatedScore  float64 // Score propagated from callees via GraphPropagator
	TotalScore       float64 // Combined score
	HeapPressure     float64 // Estimated heap allocation pressure
	LoopPressure     float64 // Pressure from loop allocations
	BranchComplexity float64 // Memory complexity from branching
	RetentionRisk    float64 // Risk of memory retention/leaks
	Percentile       float64 // Where this function ranks (0-100)
	Severity         string  // "critical", "high", "medium", "low"
	IsTestFile       bool    // Whether this function is in a test file
	IsExcluded       bool    // Whether this function is excluded via @lci:exclude[memory]

	// Call frequency context from @lci:call-frequency annotation
	// Values: "hot-path", "once-per-file", "once-per-request", "once-per-session",
	//         "startup-only", "cli-output", "test-only", "rare", or "" (unknown)
	CallFrequency string

	// Whether this function has bounded loops (reduces false positives for retry loops)
	HasBoundedLoops bool
}

type MemorySummary struct {
	TotalFunctions   int
	TotalAllocations int
	AvgAllocPerFunc  float64
	MaxAllocInFunc   int
	LoopAllocCount   int // Allocations inside loops
	BranchAllocCount int // Allocations in conditional branches
	CriticalCount    int
	HighCount        int
	MediumCount      int
	LowCount         int
	ExcludedCount    int // Functions excluded via @lci:exclude[memory]
}

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

type MetricsConfig struct {
	EnableHalstead          bool `json:"enable_halstead"`
	EnableMaintainability   bool `json:"enable_maintainability"`
	EnableDependencyMetrics bool `json:"enable_dependency_metrics"`
}

type MetricsFilter struct {
	MinComplexity    int      `json:"min_complexity,omitempty"`
	MaxComplexity    int      `json:"max_complexity,omitempty"`
	MinDependencies  int      `json:"min_dependencies,omitempty"`
	MaxDependencies  int      `json:"max_dependencies,omitempty"`
	SymbolTypes      []string `json:"symbol_types,omitempty"`
	CouplingStrength string   `json:"coupling_strength,omitempty"` // tight, loose, any
	HasCircularDeps  *bool    `json:"has_circular_deps,omitempty"`
	MinRiskScore     int      `json:"min_risk_score,omitempty"`
	MaxRiskScore     int      `json:"max_risk_score,omitempty"`
	Tags             []string `json:"tags,omitempty"`
	FilePaths        []string `json:"file_paths,omitempty"`
}

type PatternDetails struct {
	// For sequential-awaits pattern
	TotalAwaits         int      // Total await count in function
	ParallelizableCount int      // How many could be concurrent
	AwaitLines          []int    // Lines of parallelizable awaits
	AwaitTargets        []string // Function names being awaited

	// For nested-loops pattern
	NestingDepth  int // Depth of loop nesting
	OuterLoopLine int // Line of outermost loop
	InnerLoopLine int // Line of innermost loop

	// For expensive-call-in-loop pattern
	ExpensiveCall   string // The expensive function name
	LoopLine        int    // Line of containing loop
	CallLine        int    // Line of the expensive call
	ExpenseCategory string // "regex", "io", "network", "parse"
}

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

type PerformanceImpact string

type PerformancePattern struct {
	Type        string          // Pattern type
	Symbol      string          // Containing function name
	SymbolID    types.SymbolID  // Symbol ID for drill-down
	FilePath    string          // File path
	Line        int             // Line number
	Severity    string          // "high", "medium", "low"
	Description string          // Human-readable description
	Language    string          // Language where detected
	Suggestion  string          // Recommended fix
	Details     *PatternDetails // Additional details
}

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

type ReferenceProvider interface {
	GetEnhancedSymbol(symbolID types.SymbolID) *types.EnhancedSymbol
}

type ReferenceType uint8

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

type ResolvedReference struct {
	Target         types.CompositeSymbolID `json:"target"`          // Target symbol ID
	SourceLocation types.SymbolLocation    `json:"source_location"` // Where the reference occurs
	ImportPath     string                  `json:"import_path"`     // Import path if applicable
	Confidence     float64                 `json:"confidence"`      // Confidence in resolution (0-1)
	RefType        ReferenceType           `json:"ref_type"`        // Type of reference
}

type SecurityRisk string

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

type SideEffectAnalyzerConfig struct {
	// TrustAnnotations: if true, @pure/@side-effect annotations override analysis
	TrustAnnotations bool

	// StrictMode: if true, any uncertainty marks function as impure
	// (recommended for high-signal analysis)
	StrictMode bool

	// TrackFieldAccess: if true, track field-level access patterns
	TrackFieldAccess bool

	// MaxAccessesPerFunction: limit to prevent memory issues on huge functions
	MaxAccessesPerFunction int
}

type SymbolLinkerInterface interface {
	// ResolveReferences resolves symbol references for a given symbol
	ResolveReferences(symbolID types.CompositeSymbolID) ([]ResolvedReference, error)

	// ResolveDependencies resolves dependencies for a symbol
	ResolveDependencies(symbolID types.CompositeSymbolID) ([]types.SymbolDependency, error)

	// ResolveImports resolves import statements for a file
	ResolveImports(fileID types.FileID) ([]ImportResolution, error)
}

type SymbolMetrics struct {
	SymbolID types.SymbolID   `json:"symbol_id"`
	Name     string           `json:"name"`
	Type     types.SymbolType `json:"type"`
	FileID   types.FileID     `json:"file_id"`
	FilePath string           `json:"file_path"`

	// Core metrics
	Quality      CodeQualityMetrics  `json:"quality"`
	Dependencies DependencyMetrics   `json:"dependencies"`
	Architecture ArchitectureMetrics `json:"architecture"`

	// Additional context
	ScopeChain []types.ScopeInfo `json:"scope_chain"`
	Tags       []string          `json:"tags"`       // HIGH_COMPLEXITY, PUBLIC_API, etc.
	RiskScore  int               `json:"risk_score"` // 0-10 risk assessment

	// Timestamps for caching
	CalculatedAt int64 `json:"calculated_at"`
	IsStale      bool  `json:"is_stale"`
}

type TestFilePatterns struct {
	// SuffixPatterns maps file extensions to suffix patterns (without extension)
	// e.g., ".go" -> ["_test"] matches "*_test.go"
	SuffixPatterns map[string][]string

	// PrefixPatterns maps file extensions to prefix patterns
	// e.g., ".py" -> ["test_"] matches "test_*.py"
	PrefixPatterns map[string][]string

	// DirectoryPatterns are directory path patterns that indicate test files
	// e.g., "/tests/", "/__tests__/"
	DirectoryPatterns []string

	// CustomMatcher is an optional function for custom test file detection
	// If provided, it's called after built-in patterns; returns true if file is a test
	CustomMatcher func(filePath string) bool
}

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