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 DiagnosticContext struct {
	FailingFile  string
	ErrorLog     string
	OriginalCode string
	Prompt       string
	Target       *types.ASTPointer
}

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)
	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 EvolutionEngine struct {
	// contains filtered or unexported fields
}

type EvolutionService interface {
	ProposeEvolution(ctx context.Context, proposal string, force bool, messenger Messenger) (string, error)
	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 FixCandidate struct {
	ID       int
	Code     string
	FullCode string
	Valid    bool
	Score    float64
}

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

	Diagnostic *DiagnosticEngine
	// 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 LLMSolver struct {
	DoFixRequest func(ctx context.Context, prompt string) (string, error)
}

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

type LSPValidator struct {
	ProjectRoot string
}

type LSPVerifier struct{}

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 ShinigamiPipeline struct {
	// contains filtered or unexported fields
}

type Solver interface {
	Generate(ctx context.Context, diag *DiagnosticContext) (<-chan FixCandidate, error)
}

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)
}

type Verifier interface {
	Evaluate(ctx context.Context, diag *DiagnosticContext, c *FixCandidate) (bool, error)
}