core

type AIContext struct {
	NaturalLanguageSummary string            `json:"natural_language_summary"`
	SimilarObjects         []ObjectReference `json:"similar_objects"`
	RefactoringSuggestions []string          `json:"refactoring_suggestions"`
	CodeSmells             []CodeSmell       `json:"code_smells"`
	BestPractices          []string          `json:"best_practices"`
}

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

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

type AnalysisConfig struct {
	DetectEntryPoints   bool     `json:"detect_entry_points"`
	CalculateDepth      bool     `json:"calculate_depth"`
	FindCriticalPaths   bool     `json:"find_critical_paths"`
	EntryPointLabels    []string `json:"entry_point_labels"`    // Labels that indicate entry points
	CriticalLabels      []string `json:"critical_labels"`       // Labels that indicate critical functionality
	HighImpactThreshold float64  `json:"high_impact_threshold"` // Threshold for high-impact classification
}

type AnalysisContext struct {
	Domain       string   `json:"domain"`       // ui, api, data, etc.
	Framework    string   `json:"framework"`    // detected framework (if any)
	Language     string   `json:"language"`     // programming language
	FileType     string   `json:"file_type"`    // source, test, config, etc.
	Complexity   string   `json:"complexity"`   // low, medium, high
	Dependencies []string `json:"dependencies"` // key dependencies detected
}

type AnnotatedSymbol struct {
	FileID     types.FileID        `json:"file_id"`
	SymbolID   types.SymbolID      `json:"symbol_id"`
	Symbol     types.Symbol        `json:"symbol"`
	Annotation *SemanticAnnotation `json:"annotation"`
	FilePath   string              `json:"file_path"`
}

type AnnotationLocation struct {
	FileID    types.FileID   `json:"file_id"`
	SymbolID  types.SymbolID `json:"symbol_id"`
	StartLine int            `json:"start_line"`
	EndLine   int            `json:"end_line"`
	Context   string         `json:"context"`
}

type AntiPattern struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Category    string   `json:"category"`    // performance, security, maintainability
	Patterns    []string `json:"patterns"`    // Regex patterns that indicate anti-pattern
	Contexts    []string `json:"contexts"`    // Where this anti-pattern applies
	Severity    string   `json:"severity"`    // critical, high, medium, low
	Remediation string   `json:"remediation"` // How to fix the anti-pattern
	Examples    []string `json:"examples"`    // Examples of the anti-pattern
}

type ArchitecturalPattern struct {
	Name        string
	Description string
	Scope       []string      // File patterns this applies to
	Rules       []PatternRule // Rules that must be satisfied
}

type ArchitectureOverview struct {
	Components   []string               `json:"components"`
	Patterns     []string               `json:"patterns"`
	Dependencies []string               `json:"dependencies"`
	Structure    map[string]interface{} `json:"structure"`
	Complexity   string                 `json:"complexity"`
}

type AssemblyResult struct {
	Fragments []Fragment           // The fragments that could assemble the string
	Coverage  float64              // Percentage of target string covered
	Pattern   string               // Assembly pattern detected (concat, format, template)
	Score     float64              // Overall confidence score
	FileID    uint32               // File containing the assembly
	Location  types.SymbolLocation // Primary location of assembly
	Context   string               // Code snippet showing assembly
	GroupID   int                  // For grouping related results
}

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

type AssemblySearchParams struct {
	Pattern           string   // The target string to search for
	MinCoverage       float64  // Minimum coverage threshold (0.0-1.0)
	MinFragmentLength int      // Minimum fragment size in characters
	MaxResults        int      // Maximum number of results to return
	Languages         []string // Language filters (empty = all)
}

type BatchLoadResult struct {
	Loaded     []LoadResult
	Failed     []LoadResult
	Skipped    []string
	TotalFiles int
}

type BucketedTrigramData struct {
	Trigrams map[uint32][]uint32 // trigramHash -> []offsets
}

type BucketedTrigramResult struct {
	FileID  types.FileID
	Buckets []BucketedTrigramData // One per bucket (sparse - only populated buckets have data)
}

type ChangeImpactInfo struct {
	BreakingChangeRisk  string   `json:"breaking_change_risk"` // "low", "medium", "high"
	DependentComponents []string `json:"dependent_components"`
	EstimatedImpact     int      `json:"estimated_impact"` // 1-10 scale
	RequiresTests       bool     `json:"requires_tests"`
}

type CodeExample struct {
	FilePath    string `json:"file_path"`
	Function    string `json:"function,omitempty"`
	Purpose     string `json:"purpose"`
	Code        string `json:"code"`
	Explanation string `json:"explanation"`
	Relevance   string `json:"relevance"`
	LineRange   string `json:"line_range"`
}

type CodeObjectContext struct {
	// Basic identification
	ObjectID      CodeObjectID         `json:"object_id"`
	Signature     string               `json:"signature"`
	Documentation string               `json:"documentation"`
	Location      types.SymbolLocation `json:"location"`

	// Direct relationships
	DirectRelationships DirectRelationships `json:"direct_relationships"`

	// Variable and data context
	VariableContext VariableContext `json:"variable_context"`

	// Semantic and dependency context
	SemanticContext SemanticContext `json:"semantic_context"`

	// Code structure context
	StructureContext StructureContext `json:"structure_context"`

	// Usage and impact analysis
	UsageAnalysis UsageAnalysis `json:"usage_analysis"`

	// AI-enhanced context
	AIContext AIContext `json:"ai_context"`

	// Metadata
	GeneratedAt    time.Time `json:"generated_at"`
	ContextVersion string    `json:"context_version"`

	// Diagnostics - reports any issues encountered during lookup
	Diagnostics *LookupDiagnostics `json:"diagnostics,omitempty"`
}

type CodeObjectID struct {
	FileID   types.FileID     `json:"file_id"`
	SymbolID string           `json:"symbol_id"` // Unique symbol identifier
	Name     string           `json:"name"`      // Human-readable name
	Type     types.SymbolType `json:"type"`      // Function, Class, Method, etc.
}

type CodeSmell struct {
	Type        string               `json:"type"` // "long-function", "god-class", etc."
	Description string               `json:"description"`
	Severity    string               `json:"severity"` // "low", "medium", "high", "critical"`
	Location    types.SymbolLocation `json:"location"`
}

type ColumnRange struct {
	Start int
	End   int
}

type ComplexityMetrics struct {
	CyclomaticComplexity int `json:"cyclomatic_complexity"`
	CognitiveComplexity  int `json:"cognitive_complexity"`
	LineCount            int `json:"line_count"`
	ParameterCount       int `json:"parameter_count"`
	NestingDepth         int `json:"nesting_depth"`
}

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

type ConfigTemplate struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	Version     string                 `json:"version"`
	Config      *PropagationConfig     `json:"config"`
	Variables   map[string]interface{} `json:"variables,omitempty"`
	Extends     string                 `json:"extends,omitempty"`
}

type ContentFilter struct {
	CommentsOnly    bool // Search only in comments
	CodeOnly        bool // Search only in code (exclude comments and strings)
	StringsOnly     bool // Search only in string literals
	TemplateStrings bool // Include template strings (sql“, gql“, etc.)
	ExcludeComments bool // Exclude comments from search (legacy, kept for compatibility)
}

type ContentRange struct {
	Start   int
	End     int
	Content string
	Type    string // "comment", "string", "template", "code", etc.
	Tag     string // For tagged templates: sql, gql, etc.
}

type ContentSegment struct {
	Type    string // "comment", "code", "string", "template_string", "all"
	Content string
	Start   int
	End     int
	Tag     string // For template strings: sql, gql, etc.
}

type ContentType int

type ContentUpdate struct {
	Type      UpdateType
	Path      string
	Content   []byte
	FileID    types.FileID
	BatchData []struct {
		Path    string
		Content []byte
	}
	Response chan UpdateResult
}

type ContextAnalyzer struct {
	Domain      string                 `json:"domain"` // ui, api, data, etc.
	Description string                 `json:"description"`
	Patterns    []string               `json:"patterns"`     // File/package patterns this applies to
	IntentRules []IntentRule           `json:"intent_rules"` // Domain-specific intent detection
	Metadata    map[string]interface{} `json:"metadata"`
}

type ContextKey struct {
	Name    string
	FileID  types.FileID
	Context string
}

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

type CoordinationError struct {
	Code      ErrorCode    `json:"code"`
	Message   string       `json:"message"`
	Details   string       `json:"details,omitempty"`
	Timestamp time.Time    `json:"timestamp"`
	Retryable bool         `json:"retryable"`
	Context   ErrorContext `json:"context,omitempty"`
}

type CriticalPath struct {
	Path        []types.SymbolID       `json:"path"`
	Labels      []string               `json:"labels"`
	TotalImpact float64                `json:"total_impact"`
	Description string                 `json:"description"`
	Metadata    map[string]interface{} `json:"metadata"`
}

type CriticalityInfo struct {
	IsCritical         bool     `json:"is_critical"`
	CriticalityType    string   `json:"criticality_type"` // "security", "performance", "business-logic"
	ImpactScore        float64  `json:"impact_score"`
	AffectedComponents []string `json:"affected_components"`
}

type CustomPropagationRule struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	Trigger     string                 `json:"trigger"` // Trigger condition
	Action      string                 `json:"action"`  // Action to take
	Parameters  map[string]interface{} `json:"parameters"`
	Priority    int                    `json:"priority"`
}

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

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

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

type Dependency struct {
	Type     string            `json:"type"`     // database, service, file, etc.
	Name     string            `json:"name"`     // specific resource name
	Mode     string            `json:"mode"`     // read, write, read-write
	Metadata map[string]string `json:"metadata"` // additional attributes
}

type DependencyDetail struct {
	Name     string           `json:"name"`
	Source   types.SymbolID   `json:"source"`
	Path     []types.SymbolID `json:"path"`
	Mode     string           `json:"mode"`
	Weight   float64          `json:"weight"`
	Distance int              `json:"distance"`
}

type DependencyPropagationRule struct {
	DependencyType string  `json:"dependency_type"` // Type of dependency to track
	Direction      string  `json:"direction"`       // upstream, downstream
	Aggregation    string  `json:"aggregation"`     // sum, max, unique, concat, weighted_sum
	WeightFunction string  `json:"weight_function"` // linear, exponential, log
	MaxDepth       int     `json:"max_depth"`       // Maximum aggregation depth
	Threshold      float64 `json:"threshold"`       // Minimum threshold for inclusion
}

type DetectedAntiPattern struct {
	Name        string                 `json:"name"`
	Category    string                 `json:"category"`
	Severity    string                 `json:"severity"`
	Confidence  float64                `json:"confidence"`
	Evidence    []string               `json:"evidence"`
	Location    IntentLocation         `json:"location"`
	Remediation string                 `json:"remediation"`
	Impact      string                 `json:"impact"`
	Metadata    map[string]interface{} `json:"metadata"`
}

type DetectedIntent struct {
	Intent      string                 `json:"intent"`
	Category    string                 `json:"category"`
	Confidence  float64                `json:"confidence"`
	Evidence    []string               `json:"evidence"` // Code patterns that support this intent
	Location    IntentLocation         `json:"location"` // Where in the code this intent was found
	Description string                 `json:"description"`
	Metadata    map[string]interface{} `json:"metadata"`
}

type DirectRelationships struct {
	// Incoming: things that use/reference this object
	IncomingReferences []ObjectReference `json:"incoming_references"`
	CallerFunctions    []ObjectReference `json:"caller_functions"`
	ParentClasses      []ObjectReference `json:"parent_classes"`
	ImplementingTypes  []ObjectReference `json:"implementing_types"`

	// Outgoing: things that this object uses/references
	OutgoingReferences []ObjectReference `json:"outgoing_references"`
	CalledFunctions    []ObjectReference `json:"called_functions"`
	UsedTypes          []ObjectReference `json:"used_types"`
	ImportedModules    []ModuleReference `json:"imported_modules"`

	// Hierarchy
	ParentObjects []ObjectReference `json:"parent_objects"` // Parent functions, classes, namespaces
	ChildObjects  []ObjectReference `json:"child_objects"`  // Member functions, nested types
}

type EntryPointRef struct {
	EntryPointID CodeObjectID `json:"entry_point_id"`
	Type         string       `json:"type"` // "HTTP endpoint", "main function", etc.
	Path         string       `json:"path"` // URL path, command name, etc.
	Confidence   float64      `json:"confidence"`
}

type ErrorCode string

type ErrorContext struct {
	IndexType     IndexType     `json:"indexType,omitempty"`
	OperationType string        `json:"operationType,omitempty"`
	LockType      LockType      `json:"lockType,omitempty"`
	WaitTime      time.Duration `json:"waitTime,omitempty"`
	ConcurrentOps int           `json:"concurrentOps,omitempty"`
	QueueDepth    int           `json:"queueDepth,omitempty"`
}

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

type ErrorLogger interface {
	LogError(err *CoordinationError)
	LogWarning(message string, context ErrorContext)
	LogInfo(message string, context ErrorContext)
}

type ExportInfo struct {
	Name        string   `json:"name"`
	Type        string   `json:"type"`
	ExportStyle string   `json:"export_style"`
	UsedBy      []string `json:"used_by"`
}

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

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

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

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

type FileContent struct {
	FileID      types.FileID
	Content     []byte       // The actual file content
	LineOffsets []uint32     // Byte offsets for start of each line
	FastHash    uint64       // xxhash for quick equality checks (~0.5ns)
	ContentHash [32]byte     // Pre-computed SHA256 hash for cache optimization
	RefCount    atomic.Int32 // Reference counting for cleanup
}

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

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

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

type FileImportData struct {
	FileID   types.FileID
	Bindings []ImportBinding
}

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

type FileLoaderOptions struct {
	FileService         *FileService
	SupportedExtensions []string
	ExcludePatterns     []string
	MaxConcurrentLoads  int
}

type FileLocation struct {
	FileID types.FileID
	Offset uint32
}

type FileMetadata struct {
	Path    string
	Size    int64
	ModTime time.Time
	IsDir   bool
	Exists  bool
	FileID  types.FileID // Only set for loaded files
}

type FileProvider interface {
	GetFileInfo(fileID types.FileID) *types.FileInfo
}

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

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

type FileServiceOptions struct {
	ContentStore     *FileContentStore
	FileSystem       FileSystemInterface
	MaxFileSizeBytes int64
	IgnoreDotFiles   bool
	IgnorePatterns   []string
}

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

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

type FileSystemInterface interface {
	Stat(path string) (fs.FileInfo, error)
	ReadFile(path string) ([]byte, error)
	ReadDir(path string) ([]fs.DirEntry, error)
	Exists(path string) bool
	IsDir(path string) bool
	IsFile(path string) bool
}

type Fragment struct {
	Text          string               // The fragment text
	FileID        uint32               // File containing fragment
	Location      types.SymbolLocation // Location in file
	InStringLit   bool                 // Is this found in a string literal?
	SymbolContext string               // Function/class containing fragment
	Confidence    float64              // Confidence this is part of assembly
}

type FunctionTreeNode struct {
	Name     string                 `json:"name"`
	Children []*FunctionTreeNode    `json:"children,omitempty"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

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

type HealthMonitor interface {
	// CheckHealth checks the health of a specific index
	CheckHealth(indexType IndexType) IndexHealth

	// StartMonitoring begins continuous health monitoring
	StartMonitoring(interval time.Duration) error

	// StopMonitoring stops continuous health monitoring
	StopMonitoring() error

	// GetHealthHistory returns historical health data
	GetHealthHistory(indexType IndexType, duration time.Duration) []IndexHealth

	// RegisterHealthCallback registers a callback for health changes
	RegisterHealthCallback(callback func(IndexHealth)) error

	// UnregisterHealthCallback removes a health change callback
	UnregisterHealthCallback(callbackID string) error
}

type HealthStatus int

type ImplementationAttribution struct {
	SymbolID   types.SymbolID `json:"symbol_id"`
	Confidence float64        `json:"confidence"` // 0.0-1.0, higher = more confident
	Quality    string         `json:"quality"`    // Quality from reference (assigned, returned, cast, heuristic)
	Evidence   string         `json:"evidence"`   // Description of why this implementation was chosen
}

type ImplementorWithQuality struct {
	SymbolID types.SymbolID
	Quality  string
	Rank     int // Higher rank = more confident (from types.RefQualityRank)
}

type ImportBinding struct {
	ImportedName string // Name as imported (might be aliased)
	OriginalName string // Original symbol name in source file
	SourceFile   string // File path being imported from (relative)
	LineNumber   int    // Line where import occurs
	IsWildcard   bool   // true for "import *" or "use .*"
}

type ImportInfo struct {
	ModulePath  string `json:"module_path"`
	ImportName  string `json:"import_name"`
	ImportStyle string `json:"import_style"`
	IsUsed      bool   `json:"is_used"`
}

type ImportPattern struct {
	// Regex patterns to find import statements
	ImportRegexes []*regexp.Regexp

	// How to extract the imported symbol and source
	SymbolExtractor func(importLine string) []ImportBinding

	// How to determine if a symbol is exported
	ExportChecker func(symbol types.Symbol) bool
}

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

type IndexCoordinationConfig struct {
	// Default timeout for lock acquisition
	DefaultLockTimeout time.Duration
	// Maximum number of concurrent operations per index
	MaxConcurrentOps int
	// Enable adaptive timeout based on system load
	AdaptiveTimeout bool
	// Lock metrics collection interval
	MetricsInterval time.Duration
	// Maximum queue depth for index operations
	MaxQueueDepth int
}

type IndexCoordinator interface {
	// Lock acquisition for operations
	AcquireIndexLock(indexType IndexType, forWriting bool, timeout time.Duration) (LockRelease, error)
	AcquireIndexLockCtx(ctx context.Context, indexType IndexType, forWriting bool) (LockRelease, error)
	AcquireMultipleLocks(requirements SearchRequirements, forWriting bool, timeout time.Duration) (LockRelease, error)
	AcquireMultipleLocksCtx(ctx context.Context, requirements SearchRequirements, forWriting bool) (LockRelease, error)

	// Status and monitoring
	GetIndexStatus(indexType IndexType) IndexStatus
	GetAllIndexStatus() map[IndexType]IndexStatus
	WaitForIndex(indexType IndexType, timeout time.Duration) error
}

type IndexHealth struct {
	IndexType     IndexType        `json:"indexType"`
	Status        HealthStatus     `json:"status"`
	LastChecked   time.Time        `json:"lastChecked"`
	ErrorMessage  string           `json:"errorMessage,omitempty"`
	QueueSize     int              `json:"queueSize"`
	OperationRate float64          `json:"operationRate"` // operations per second
	ErrorRate     float64          `json:"errorRate"`     // errors per second
	ResponseTime  time.Duration    `json:"responseTime"`
	LastUpdate    time.Time        `json:"lastUpdate"`
	UpdateCount   int64            `json:"updateCount"`
	ErrorCount    int              `json:"errorCount"`
	Availability  float64          `json:"availability"` // percentage
	IsAvailable   bool             `json:"isAvailable"`
	Performance   IndexPerformance `json:"performance"`
	LastError     error            `json:"-"` // not JSON serializable
	LastErrorTime time.Time        `json:"lastErrorTime"`
}

type IndexLockInfo struct {
	IndexType         IndexType
	Priority          int
	ContentionRate    float64
	AverageWaitTime   time.Duration
	CurrentQueueDepth int
	IsIndexing        bool
	Dependencies      []IndexType
	Dependents        []IndexType
}

type IndexOpStatus int

type IndexOperation struct {
	ID                 string              `json:"id"`
	IndexType          IndexType           `json:"indexType"`
	OperationType      IndexUpdateType     `json:"operationType"`
	Status             IndexOpStatus       `json:"status"`
	Progress           float64             `json:"progress"`
	StartTime          time.Time           `json:"startTime"`
	EndTime            time.Time           `json:"endTime,omitempty"`
	Timeout            time.Duration       `json:"timeout"`
	Priority           int                 `json:"priority"`
	Context            *context.CancelFunc `json:"-"`
	CancelFunc         func()              `json:"-"`
	LastProgressUpdate time.Time           `json:"lastProgressUpdate"`
}

type IndexOperationResult struct {
	OperationID    string           `json:"operationID"`
	Success        bool             `json:"success"`
	OperationType  IndexUpdateType  `json:"operationType"`
	IndexType      IndexType        `json:"indexType"`
	Status         IndexOpStatus    `json:"status"`
	Progress       float64          `json:"progress"`
	Duration       time.Duration    `json:"duration"`
	FilesProcessed int              `json:"filesProcessed"`
	BytesProcessed int64            `json:"bytesProcessed"`
	Error          string           `json:"error,omitempty"`
	Metrics        OperationMetrics `json:"metrics"`
}

type IndexPerformance struct {
	AverageResponseTime time.Duration `json:"averageResponseTime"`
	LockWaitTime        time.Duration `json:"lockWaitTime"`
	ContentionRate      float64       `json:"contentionRate"`
}

type IndexState struct {
	// Core index identification
	Type IndexType
	// contains filtered or unexported fields
}

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

type IndexStatus struct {
	Type        IndexType `json:"type"`
	IsIndexing  bool      `json:"isIndexing"`
	LastUpdate  time.Time `json:"lastUpdate"`
	UpdateCount int64     `json:"updateCount"`
	LockHolders int       `json:"lockHolders"`
	QueueDepth  int       `json:"queueDepth"`
}

type IndexStatusSnapshot struct {
	Timestamp              time.Time     `json:"timestamp"`
	IndexType              IndexType     `json:"indexType"`
	IsIndexing             bool          `json:"isIndexing"`
	Progress               float64       `json:"progress"`
	CurrentOperation       int64         `json:"currentOperation"`
	FilesProcessed         int64         `json:"filesProcessed"`
	TotalFiles             int64         `json:"totalFiles"`
	BytesProcessed         int64         `json:"bytesProcessed"`
	TotalBytes             int64         `json:"totalBytes"`
	LockHolders            int           `json:"lockHolders"`
	QueueDepth             int           `json:"queueDepth"`
	LastUpdate             time.Time     `json:"lastUpdate"`
	UpdateCount            int64         `json:"updateCount"`
	HasError               bool          `json:"hasError"`
	ErrorMessage           string        `json:"errorMessage,omitempty"`
	EstimatedTimeRemaining time.Duration `json:"estimatedTimeRemaining"`
}

type IndexSystemLogger struct {
	*DefaultErrorLogger
}

type IndexType int

type IndexUpdateOptions struct {
	// Force rebuild even if index appears up to date
	Force bool
	// Files to include in the update (empty means all files)
	Files []string
	// Priority of the update operation
	Priority int
	// Timeout for the update operation
	Timeout time.Duration
	// Whether to validate after update
	Validate bool
	// Callback function for progress updates
	ProgressCallback func(progress float64)
}

type IndexUpdateType int

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

type IntentAnalysisResult struct {
	FileID        types.FileID           `json:"file_id"`
	FilePath      string                 `json:"file_path"`
	PrimaryIntent string                 `json:"primary_intent"`
	IntentScore   float64                `json:"intent_score"`
	Intents       []DetectedIntent       `json:"intents"`
	AntiPatterns  []DetectedAntiPattern  `json:"anti_patterns"`
	Context       AnalysisContext        `json:"context"`
	Summary       IntentSummary          `json:"summary"`
	Metadata      map[string]interface{} `json:"metadata"`
}

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

type IntentLocation struct {
	StartLine int    `json:"start_line"`
	EndLine   int    `json:"end_line"`
	Function  string `json:"function"`
	Symbol    string `json:"symbol"`
	Context   string `json:"context"`
}

type IntentPattern struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	Category    string                 `json:"category"`   // ui, business-logic, data-access, etc.
	Patterns    []string               `json:"patterns"`   // Regex patterns to match
	Keywords    []string               `json:"keywords"`   // Intent-indicating keywords
	Contexts    []string               `json:"contexts"`   // File/package contexts where this applies
	Confidence  float64                `json:"confidence"` // Base confidence score (0.0-1.0)
	Examples    []string               `json:"examples"`   // Example code snippets
	Metadata    map[string]interface{} `json:"metadata"`
}

type IntentRule struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Trigger     string   `json:"trigger"`    // Pattern that triggers this rule
	Intent      string   `json:"intent"`     // The intent this rule identifies
	Confidence  float64  `json:"confidence"` // Confidence multiplier
	Context     []string `json:"context"`    // Additional context requirements
}

type IntentSummary struct {
	TotalIntents     int      `json:"total_intents"`
	PrimaryCategory  string   `json:"primary_category"`
	ConfidenceScore  float64  `json:"confidence_score"`
	AntiPatternCount int      `json:"anti_pattern_count"`
	ComplexityScore  float64  `json:"complexity_score"`
	Recommendations  []string `json:"recommendations"`
}

type InterfaceCallAttribution struct {
	InterfaceSymbolID types.SymbolID              `json:"interface_symbol_id"`
	Implementations   []ImplementationAttribution `json:"implementations"`
	AttributionMethod string                      `json:"attribution_method"` // "code_analysis", "heuristic", "combined"
}