engine

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

type AnalysisEngine struct {
	ProjectRoot string
	// contains filtered or unexported fields
}

type AnalysisStore interface {
	store.SymbolRegistry
	store.StructuralGraph
	store.DiagnosticStore
	store.TransactionManager
}

type AnalyzeOption func(*AnalyzeOptions)

type AnalyzeOptions struct {
	UseSSA       bool
	SSATargetPkg string
	SSAVarName   string
}

type BFSPropagationStrategy struct {
	ImpactEngine ImpactAnalyzer
	// contains filtered or unexported fields
}

type BuildValidator struct{}

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

type ChronosDiff struct {
	MissingSymbols []string // Symbols that existed before but were deleted
	MangledSymbols []string // Symbols whose structural hash changed (broken syntax/logic)
	AddedSymbols   []string // New symbols added
	Unchanged      int      // Number of symbols that remained perfectly intact
}

type ChronosEngine struct{}

type ChronosSnapshot struct {
	ID        string
	FilePath  string
	Symbols   map[string]types.ASTPointer // Key: Symbol Name
	Timestamp time.Time
}

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

type ChurnStore interface {
	store.SymbolRegistry
	store.TransactionManager
}

type CompactionEngine struct {
	Ledger *Ledger
	// contains filtered or unexported fields
}

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

type DiagnosticHUD struct {
	FailingSymbol      string
	LastCommit         string
	RiskLevel          string
	RiskScore          float64
	BlastRadius        int
	SimilarPatternPath string
}

type DiagnosticProvider interface {
	Diagnose(ctx context.Context, errorLog string) (*DiagnosticReport, error)
	Heal(ctx context.Context, report *DiagnosticReport, messenger Messenger) (*types.HealResult, error)
	AssessRisk(ctx context.Context, symbol, path string) (*RiskAssessment, error)
}

type DiagnosticReport struct {
	FailingSymbol string
	FailingFile   string
	Line          int
	ErrorLog      string
	Context       string
	Risk          *types.ImpactResult
	Insights      []string // Historical insights from Engram
}

type DiscoveryService interface {
	HybridSearch(ctx context.Context, query string, limit, offset int) (*types.HybridSearchResult, error)
	FindLogicalTwins(ctx context.Context, symbolName, path string) ([]types.Symbol, error)
	GetNeighborhood(ctx context.Context, filePath string) (string, error)
}

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

type EnricherStore interface {
	store.SymbolRegistry
	store.StructuralGraph
	store.TransactionManager
}

type EvolutionService interface {
	Propagate(ctx context.Context, symbol, transformation string, messenger Messenger) (string, error)
	CommitLedger(ctx context.Context) (string, error)
	RollbackLedger(ctx context.Context) (string, error)
	GetLedgerDiff(ctx context.Context) (string, error)
	GetLedgerSummary(ctx context.Context) string
	StageMutation(ctx context.Context, filePath, newContent string) error
}

type GraphStore interface {
	store.SymbolRegistry
	store.StructuralGraph
}

type HealerEngine struct {
	Ledger *Ledger

	// Bridge to MCP sampling
	DoFixRequest func(ctx context.Context, prompt string) (string, error)

	Search *SearchEngine
	// contains filtered or unexported fields
}

type HealerService interface {
	Fix(ctx context.Context, errorLog string, messenger Messenger) (string, error)
	DiagnoseHUD(ctx context.Context, errorLog string) (*DiagnosticHUD, error)
}

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

type ImpactAnalyzer interface {
	GetDeterministicCallers(ctx context.Context, symbolName string) ([]store.Call, error)
}

type ImpactEngine struct {
	LSPManager *lsp.Manager
	// contains filtered or unexported fields
}

type IndexerConfig struct {
	Store    store.Store
	Semantic *SemanticEngine
	Analyzer *AnalysisEngine
	Search   *SearchEngine
	ASTRules *ASTRuleEngine
	Logger   *slog.Logger
}

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

type IndexerService interface {
	Index(ctx context.Context, path string) error
}

type IntelligenceService interface {
	AnalyzeImpact(ctx context.Context, symbol, path string, verbose bool, messenger Messenger) (*types.ImpactResult, error)
	GetCriticalSymbols(ctx context.Context, limit int) ([]store.CriticalSymbol, error)
	PredictTests(ctx context.Context, diff string) ([]types.TestTarget, error)
	AuditArchitecture(ctx context.Context, targetPath string) ([]types.ASTRuleMatch, error)
}

type LSPProvider interface {
	GetClient(ctx context.Context, filePath string) (lsp.LSPClient, error)
}

type LSPValidator struct {
	ProjectRoot string
}

type LanguageConfig struct {
	Language    *gotreesitter.Language
	Query       *gotreesitter.Query
	CallQuery   *gotreesitter.Query
	ImportQuery *gotreesitter.Query
	FlowQuery   *gotreesitter.Query
}

type Ledger struct {
	Staged    map[string]Patch `json:"staged"`
	Stats     MissionStats     `json:"stats"`
	KiLimit   int64            `json:"ki_limit"`
	TurnLimit int              `json:"turn_limit"`
	Project   string           `json:"project"`
	// contains filtered or unexported fields
}

type LineProvenance struct {
	Line           int
	Commit         string
	Author         string
	EngineeringEra string
}

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

type LocalFileResolver struct{}

type MCPTransformer struct {
	DoTransform func(ctx context.Context, file, symbol, transformation string) (string, error)
	// contains filtered or unexported fields
}

type Messenger interface {
	Ask(ctx context.Context, systemPrompt string, userPrompt string) (string, error)
}

type MissionStats struct {
	StartTime  time.Time `json:"start_time"`
	TotalKi    int64     `json:"total_ki"`   // Token usage (approximated)
	TurnCount  int       `json:"turn_count"` // Number of iterations
	FilesCount int       `json:"files_count"`
}

type PagerankOption func(*PagerankOptions)

type PagerankOptions struct {
	TaskSeeds []string
}

type ParsedPackageData struct {
	File *ast.File
	Fset *token.FileSet
	Pkg  *packages.Package
}

type Patch struct {
	FilePath   string `json:"file_path"`
	Original   string `json:"original,omitempty"`
	NewContent string `json:"new_content"`
	Diff       string `json:"diff,omitempty"`
}

type Pipeline struct {
	Registry   *filter.Registry
	Tracker    *telemetry.Tracker
	LSPManager *lsp.Manager

	TeeConfig    tee.Config
	Verbose      int
	GainLevel    int // 0: compact, 1: signal (SNR), 2: raw
	UltraCompact bool
	Enrich       bool
	// contains filtered or unexported fields
}

type PropagationStrategy interface {
	Discover(ctx context.Context, startSymbol string, depth int) iter.Seq2[PropagationTask, error]
}

type PropagationTask struct {
	SymbolName     string // Local name for matching (e.g., "Greet")
	ImpactedSymbol string // FQN of the impacted symbol (e.g., "tests.S1.Greet")
	FilePath       string
	Action         string
}

type Result struct {
	Stdout   string
	Stderr   string
	ExitCode int
	Duration time.Duration
}

type RippleEngine struct {
	Transformer  Transformer
	ImpactEngine ImpactAnalyzer
	Strategy     PropagationStrategy
	Validators   []Validator
	// contains filtered or unexported fields
}

type RiskAssessment struct {
	Symbol     string
	Path       string
	RiskScore  float64
	Centrality int
	Callers    int
	RiskLevel  string
}

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

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

type SovereignBoundary struct {
	ID          string           `json:"boundary_id"`
	TruthKernel string           `json:"truth_kernel"` // Dense summary of discoveries
	StagingArea map[string]Patch `json:"staging_area"` // Current Ledger state
	Budget      MissionStats     `json:"budget"`       // Ki/Turns consumption
	Timestamp   string           `json:"timestamp"`
}

type StructuralMatch struct {
	Path      string            `json:"path"`
	Range     types.Range       `json:"range"`
	StartLine int               `json:"start_line"`
	EndLine   int               `json:"end_line"`
	Content   string            `json:"content"`
	Captures  map[string]string `json:"captures"`
}

type StructuralTransformer struct {
	Pattern string
}

type TestResultStore interface {
	SaveTestResult(ctx context.Context, res *types.TestResult) error
}

type TestValidator struct {
	SpecificTests []string
}

type TransactionalStore interface {
	GraphStore
	store.DiagnosticStore
	store.TransactionManager
}

type Transformer interface {
	Transform(ctx context.Context, file string, symbolName string, transformation string) (string, error)
}

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

type TruthOption func(*TruthEngine)

type ValidationResult struct {
	Valid   bool
	Message string
	Details map[string]any
}

type Validator interface {
	Validate(ctx context.Context, ledger *Ledger) (ValidationResult, error)
}