cto-ai-cli 1.3.0 → 3.0.0

package/dist/engine/index.d.ts

@@ -0,0 +1,816 @@
+import { Project } from 'ts-morph';
+import { EventEmitter } from 'node:events';
+
+interface AnalyzedFile {
+    path: string;
+    relativePath: string;
+    extension: string;
+    size: number;
+    tokens: number;
+    lines: number;
+    lastModified: Date;
+    kind: FileKind;
+    imports: string[];
+    importedBy: string[];
+    isHub: boolean;
+    complexity: number;
+    riskScore: number;
+    riskFactors: RiskFactor[];
+    exclusionImpact: ExclusionImpact;
+}
+type FileKind = 'source' | 'type' | 'test' | 'config' | 'entry' | 'asset';
+type ExclusionImpact = 'critical' | 'high' | 'medium' | 'low' | 'none';
+interface ProjectAnalysis {
+    projectPath: string;
+    projectName: string;
+    analyzedAt: Date;
+    hash: string;
+    files: AnalyzedFile[];
+    totalFiles: number;
+    totalTokens: number;
+    graph: ProjectGraph;
+    riskProfile: RiskProfile;
+    stack: string[];
+    tokenMethod: 'chars4' | 'tiktoken';
+}
+interface ProjectGraph {
+    nodes: string[];
+    edges: GraphEdge[];
+    hubs: HubNode[];
+    leaves: string[];
+    orphans: string[];
+    clusters: FileCluster[];
+}
+interface GraphEdge {
+    from: string;
+    to: string;
+    type: 'import' | 'export' | 're-export';
+}
+interface HubNode {
+    relativePath: string;
+    dependents: number;
+    dependencies: number;
+    score: number;
+}
+interface FileCluster {
+    id: string;
+    name: string;
+    files: string[];
+    totalTokens: number;
+    internalEdges: number;
+    externalEdges: number;
+    cohesion: number;
+}
+interface RiskProfile {
+    distribution: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+    topRiskFiles: AnalyzedFile[];
+    overallComplexity: number;
+}
+interface RiskFactor {
+    type: RiskFactorType;
+    score: number;
+    weight: number;
+    detail: string;
+}
+type RiskFactorType = 'hub' | 'type-provider' | 'complexity' | 'recency' | 'config' | 'churn';
+interface RiskWeights {
+    hub: number;
+    typeProvider: number;
+    complexity: number;
+    recency: number;
+    config: number;
+    churn: number;
+}
+interface CoverageResult {
+    score: number;
+    relevantFiles: string[];
+    includedRelevant: string[];
+    missingRelevant: string[];
+    missingCritical: string[];
+    explanation: string;
+}
+interface ContextSelection {
+    files: SelectedFile[];
+    totalTokens: number;
+    budget: number;
+    usedPercent: number;
+    coverage: CoverageResult;
+    riskScore: number;
+    deterministic: boolean;
+    hash: string;
+    decisions: SelectionDecision[];
+}
+interface SelectedFile {
+    relativePath: string;
+    tokens: number;
+    originalTokens: number;
+    pruneLevel: PruneLevel;
+    riskScore: number;
+    reason: string;
+}
+type PruneLevel = 'full' | 'signatures' | 'skeleton' | 'excluded';
+interface SelectionDecision {
+    file: string;
+    action: 'include-full' | 'include-signatures' | 'include-skeleton' | 'exclude';
+    reason: string;
+    alternatives?: string;
+}
+interface BudgetPlan {
+    budget: number;
+    used: number;
+    remaining: number;
+    fillPercent: number;
+    files: BudgetEntry[];
+}
+interface BudgetEntry {
+    relativePath: string;
+    originalTokens: number;
+    allocatedTokens: number;
+    pruneLevel: PruneLevel;
+    included: boolean;
+    reason: string;
+}
+interface PrunedContent {
+    relativePath: string;
+    originalTokens: number;
+    prunedTokens: number;
+    pruneLevel: PruneLevel;
+    content: string;
+    savingsPercent: number;
+}
+interface WalkEntry {
+    path: string;
+    relativePath: string;
+    extension: string;
+    size: number;
+    lastModified: Date;
+    lines: number;
+}
+interface WalkOptions {
+    ignoreDirs: string[];
+    ignorePatterns: string[];
+    extensions: string[];
+    maxDepth?: number;
+}
+
+interface CTOConfig {
+    version: string;
+    analysis: {
+        extensions: {
+            code: string[];
+            config: string[];
+            docs: string[];
+        };
+        ignore: {
+            dirs: string[];
+            patterns: string[];
+        };
+        maxDepth: number;
+    };
+    risk: {
+        weights: RiskWeights;
+    };
+    interaction: {
+        defaultBudget: number;
+        defaultModel: string;
+    };
+    tokens: {
+        method: 'chars4' | 'tiktoken';
+    };
+    governance: {
+        auditEnabled: boolean;
+        secretDetection: boolean;
+        retentionDays: number;
+    };
+}
+
+declare function walkProject(rootPath: string, options: WalkOptions): Promise<WalkEntry[]>;
+declare function classifyFileKind(relativePath: string): FileKind;
+declare function detectStack(files: WalkEntry[]): string[];
+declare function analyzeProject(projectPath: string, config?: Partial<CTOConfig>): Promise<ProjectAnalysis>;
+
+declare function createProject(projectPath: string, filePaths: string[]): Project;
+declare function buildProjectGraph(projectPath: string, files: AnalyzedFile[]): ProjectGraph;
+
+interface AdjacencyList {
+    forward: Map<string, string[]>;
+    reverse: Map<string, string[]>;
+}
+declare function buildAdjacencyList(edges: GraphEdge[]): AdjacencyList;
+declare function bfsBidirectional(seeds: string[], adj: AdjacencyList, depth: number): Set<string>;
+declare function matchGlob(path: string, pattern: string): boolean;
+
+interface PolicySet {
+    version: string;
+    name: string;
+    rules: PolicyRule[];
+}
+interface PolicyRule {
+    id: string;
+    type: PolicyRuleType;
+    pattern?: string;
+    threshold?: number;
+    category?: string;
+    reason: string;
+    enabled: boolean;
+}
+type PolicyRuleType = 'include-always' | 'exclude-always' | 'budget-limit' | 'coverage-minimum' | 'risk-maximum' | 'secret-block';
+
+declare function getConfigPath(projectPath: string): string;
+declare function getPolicyPath(projectPath: string): string;
+declare function getCTODir(projectPath: string): string;
+declare function loadConfig(projectPath: string): Promise<CTOConfig>;
+declare function saveConfig(projectPath: string, config: CTOConfig): Promise<string>;
+declare function initProjectConfig(projectPath: string): Promise<{
+    configPath: string;
+    policyPath: string;
+    created: string[];
+}>;
+declare function loadPolicyFromYAML(projectPath: string): Promise<PolicySet | null>;
+
+interface CacheOptions {
+    maxAgeMs: number;
+    maxEntries: number;
+    enabled: boolean;
+}
+/**
+ * Get a project analysis, using cache when possible.
+ *
+ * Cache hit: ~1-5ms (fingerprint check only)
+ * Cache miss: full analyzeProject() + cache update
+ */
+declare function getCachedAnalysis(projectPath: string, config?: Partial<CTOConfig>): Promise<ProjectAnalysis>;
+/**
+ * Invalidate cache for a specific project (e.g., after a known file change).
+ */
+declare function invalidateCache(projectPath?: string): void;
+/**
+ * Get cache statistics for debugging/monitoring.
+ */
+declare function getCacheStats(): {
+    entries: number;
+    totalHits: number;
+    projects: {
+        path: string;
+        hits: number;
+        ageMs: number;
+    }[];
+};
+/**
+ * Configure cache behavior.
+ */
+declare function configureCache(options: Partial<CacheOptions>): void;
+
+interface WatcherOptions {
+    debounceMs?: number;
+    config?: Partial<CTOConfig>;
+}
+interface FileChangeEvent {
+    type: 'add' | 'change' | 'unlink';
+    path: string;
+    timestamp: Date;
+}
+declare class ProjectWatcher extends EventEmitter {
+    private watcher;
+    private projectPath;
+    private debounceMs;
+    private config;
+    private debounceTimer;
+    private pendingChanges;
+    private running;
+    constructor(projectPath: string, options?: WatcherOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    getProjectPath(): string;
+    private handleEvent;
+    private flush;
+}
+/**
+ * Start watching a project. Returns the watcher instance.
+ * If already watching, returns the existing watcher.
+ */
+declare function watchProject(projectPath: string, options?: WatcherOptions): Promise<ProjectWatcher>;
+/**
+ * Stop watching a specific project.
+ */
+declare function unwatchProject(projectPath: string): Promise<void>;
+/**
+ * Stop all active watchers. Call on process shutdown.
+ */
+declare function unwatchAll(): Promise<void>;
+/**
+ * Get all actively watched projects.
+ */
+declare function getActiveWatchers(): {
+    path: string;
+    running: boolean;
+}[];
+
+type ChangeType = 'added' | 'modified' | 'deleted' | 'renamed';
+interface ChangedFile {
+    relativePath: string;
+    changeType: ChangeType;
+    linesAdded: number;
+    linesRemoved: number;
+}
+interface PRContextResult {
+    baseBranch: string;
+    currentBranch: string;
+    isGitRepo: boolean;
+    changedFiles: ChangedFile[];
+    dependencyFiles: string[];
+    allRelevantFiles: AnalyzedFile[];
+    totalChangedTokens: number;
+    totalContextTokens: number;
+    riskSummary: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+        maxRiskFile: string;
+        maxRiskScore: number;
+    };
+    renderedSummary: string;
+}
+interface PRContextOptions {
+    baseBranch?: string;
+    depth?: number;
+    includeTests?: boolean;
+}
+/**
+ * Generate PR-focused context by analyzing git changes and expanding dependencies.
+ *
+ * @param analysis - Project analysis (from analyzeProject or getCachedAnalysis)
+ * @param options - PR context options (baseBranch, depth, includeTests)
+ * @returns Structured PR context with changed files, dependencies, risk summary
+ */
+declare function generatePRContext(analysis: ProjectAnalysis, options?: PRContextOptions): Promise<PRContextResult>;
+
+type Grade = 'A+' | 'A' | 'A-' | 'B+' | 'B' | 'B-' | 'C+' | 'C' | 'C-' | 'D' | 'F';
+interface ContextScore {
+    overall: number;
+    grade: Grade;
+    dimensions: {
+        efficiency: DimensionScore;
+        coverage: DimensionScore;
+        riskControl: DimensionScore;
+        structure: DimensionScore;
+        governance: DimensionScore;
+    };
+    insights: ScoreInsight[];
+    comparison: {
+        naiveTokens: number;
+        optimizedTokens: number;
+        savedTokens: number;
+        savedPercent: number;
+        monthlySavingsUSD: number;
+    };
+    meta: {
+        projectName: string;
+        totalFiles: number;
+        totalTokens: number;
+        analyzedAt: Date;
+    };
+}
+interface DimensionScore {
+    score: number;
+    weight: number;
+    weighted: number;
+    detail: string;
+}
+interface ScoreInsight {
+    type: 'strength' | 'weakness' | 'opportunity';
+    title: string;
+    detail: string;
+    impact: 'high' | 'medium' | 'low';
+}
+/**
+ * Compute the Context Score™ for a project.
+ *
+ * @param analysis - Project analysis (from analyzeProject or getCachedAnalysis)
+ * @param task - Representative task (default: "general code review")
+ * @param budget - Token budget (default: 50000)
+ */
+declare function computeContextScore(analysis: ProjectAnalysis, task?: string, budget?: number): Promise<ContextScore>;
+/**
+ * Render the Context Score as a beautiful terminal-friendly string.
+ */
+declare function renderContextScore(score: ContextScore): string;
+
+interface BenchmarkResult {
+    project: string;
+    totalFiles: number;
+    totalTokens: number;
+    budget: number;
+    task: string;
+    strategies: {
+        cto: StrategyResult;
+        naive: StrategyResult;
+        random: StrategyResult;
+    };
+    winner: 'cto' | 'naive' | 'random';
+    ctoAdvantage: {
+        vsNaiveTokensSaved: number;
+        vsNaiveTokensSavedPercent: number;
+        vsRandomCoverageGain: number;
+        vsNaiveCostSavedMonthlyUSD: number;
+    };
+}
+interface StrategyResult {
+    filesSelected: number;
+    tokensUsed: number;
+    coverageScore: number;
+    criticalFilesCovered: number;
+    criticalFilesTotal: number;
+    highRiskCovered: number;
+    highRiskTotal: number;
+    costPerInteractionUSD: number;
+    timeMs: number;
+}
+/**
+ * Run a full benchmark comparing CTO vs naive vs random selection.
+ */
+declare function runBenchmark(analysis: ProjectAnalysis, task?: string, budget?: number): Promise<BenchmarkResult>;
+/**
+ * Render benchmark results as a formatted comparison table.
+ */
+declare function renderBenchmark(result: BenchmarkResult): string;
+
+type TaskType = 'debug' | 'review' | 'refactor' | 'test' | 'docs' | 'feature' | 'architecture' | 'simple-edit';
+
+interface QualityBenchmarkResult {
+    project: string;
+    task: string;
+    taskType: TaskType;
+    budget: number;
+    strategies: {
+        cto: QualityMetrics;
+        naive: QualityMetrics;
+        random: QualityMetrics;
+    };
+    comparison: {
+        ctoVsNaiveRelevance: number;
+        ctoVsRandomRelevance: number;
+        ctoVsNaiveCompleteness: number;
+        ctoVsRandomCompleteness: number;
+        ctoNoiseReduction: number;
+    };
+    prompts: {
+        cto: {
+            rendered: string;
+            tokens: number;
+        };
+        naive: {
+            rendered: string;
+            tokens: number;
+        };
+    };
+    verdict: string;
+}
+interface QualityMetrics {
+    filesSelected: number;
+    tokensUsed: number;
+    relevanceScore: number;
+    completenessScore: number;
+    noiseRatio: number;
+    typeCoverage: number;
+    dependencyClosure: number;
+    relevantFilesIncluded: number;
+    relevantFilesTotal: number;
+    typeFilesIncluded: number;
+    typeFilesNeeded: number;
+    depsIncluded: number;
+    depsNeeded: number;
+}
+/**
+ * Run a quality benchmark comparing CTO vs naive vs random context selection.
+ * Measures relevance, completeness, noise, and dependency closure.
+ */
+declare function runQualityBenchmark(analysis: ProjectAnalysis, task: string, budget?: number): Promise<QualityBenchmarkResult>;
+declare function renderQualityBenchmark(result: QualityBenchmarkResult): string;
+
+interface PredictorModel {
+    version: number;
+    trainedAt: string;
+    totalObservations: number;
+    taskTypeFrequency: Record<string, Record<string, number>>;
+    keywordFrequency: Record<string, Record<string, number>>;
+    fileStats: Record<string, {
+        totalSelections: number;
+        avgRiskScore: number;
+        avgTokens: number;
+        lastSelected: string;
+    }>;
+    coSelection: Record<string, Record<string, number>>;
+}
+interface PredictionResult {
+    filePath: string;
+    predictedScore: number;
+    reasons: string[];
+}
+interface PredictorConfig {
+    maxCoSelectionPairs: number;
+    decayFactor: number;
+    minObservations: number;
+}
+declare function loadModel(projectPath: string): Promise<PredictorModel>;
+declare function recordSelection(projectPath: string, task: string, selectedFiles: {
+    relativePath: string;
+    riskScore: number;
+    tokens: number;
+}[]): Promise<PredictorModel>;
+declare function predictRelevantFiles(projectPath: string, task: string, analysis: ProjectAnalysis, config?: Partial<PredictorConfig>): Promise<PredictionResult[]>;
+declare function getPredictorBoosts(projectPath: string, task: string, analysis: ProjectAnalysis): Promise<Map<string, number>>;
+declare function getModelStats(model: PredictorModel): {
+    observations: number;
+    taskTypes: number;
+    keywords: number;
+    trackedFiles: number;
+    coSelectionPairs: number;
+    trainedAt: string;
+};
+
+interface ProjectFingerprint {
+    stack: string[];
+    sizeClass: 'tiny' | 'small' | 'medium' | 'large' | 'huge';
+    hasTypes: boolean;
+    hasTests: boolean;
+    isMonorepo: boolean;
+    entryPointPatterns: string[];
+    dominantLanguage: string;
+}
+interface CrossRepoModel {
+    version: number;
+    updatedAt: string;
+    totalProjects: number;
+    totalObservations: number;
+    archetypes: Record<string, ArchetypeProfile>;
+    universalPatterns: PatternStats[];
+}
+interface ArchetypeProfile {
+    name: string;
+    fingerprint: ProjectFingerprint;
+    projectCount: number;
+    observationCount: number;
+    taskPatterns: Record<string, Record<string, PatternStats>>;
+    criticalKinds: {
+        kind: string;
+        importance: number;
+    }[];
+    criticalDirs: {
+        pattern: string;
+        importance: number;
+    }[];
+}
+interface PatternStats {
+    pattern: string;
+    hitCount: number;
+    totalSelections: number;
+    hitRate: number;
+    avgRelevanceBoost: number;
+}
+interface CrossRepoPrediction {
+    filePath: string;
+    boost: number;
+    reason: string;
+    confidence: number;
+}
+declare function computeFingerprint(analysis: ProjectAnalysis): ProjectFingerprint;
+declare function loadGlobalModel(): Promise<CrossRepoModel>;
+declare function recordCrossRepoSelection(analysis: ProjectAnalysis, task: string, selectedFiles: {
+    relativePath: string;
+    riskScore: number;
+    tokens: number;
+}[]): Promise<CrossRepoModel>;
+declare function predictFromCrossRepo(analysis: ProjectAnalysis, task: string): Promise<CrossRepoPrediction[]>;
+declare function getCrossRepoStats(model: CrossRepoModel): {
+    totalProjects: number;
+    totalObservations: number;
+    archetypes: {
+        name: string;
+        projects: number;
+        observations: number;
+    }[];
+    universalPatterns: number;
+};
+
+interface FeedbackEntry {
+    id: string;
+    timestamp: string;
+    task: string;
+    taskType: TaskType;
+    contextHash: string;
+    filesIncluded: string[];
+    tokensUsed: number;
+    budget: number;
+    outcome: FeedbackOutcome;
+    model?: string;
+    promptTokens?: number;
+}
+interface FeedbackOutcome {
+    accepted: boolean;
+    compilable?: boolean;
+    testsPassed?: number;
+    testsTotal?: number;
+    linesGenerated?: number;
+    linesAccepted?: number;
+    timeToAcceptMs?: number;
+    userRating?: 1 | 2 | 3 | 4 | 5;
+    notes?: string;
+}
+interface FeedbackModel {
+    version: number;
+    updatedAt: string;
+    totalFeedback: number;
+    acceptRate: number;
+    fileAcceptance: Record<string, {
+        includedCount: number;
+        acceptedCount: number;
+        acceptRate: number;
+        avgTimeToAccept: number;
+    }>;
+    taskTypeAcceptance: Record<string, {
+        totalCount: number;
+        acceptedCount: number;
+        acceptRate: number;
+        avgCompilable: number;
+    }>;
+    pairAcceptance: Record<string, {
+        count: number;
+        acceptedCount: number;
+        acceptRate: number;
+    }>;
+    insights: FeedbackInsight[];
+}
+interface FeedbackInsight {
+    type: 'positive' | 'negative' | 'opportunity';
+    title: string;
+    detail: string;
+    impact: number;
+}
+declare function loadFeedbackModel(projectPath: string): Promise<FeedbackModel>;
+declare function recordFeedback(projectPath: string, entry: Omit<FeedbackEntry, 'id' | 'timestamp' | 'taskType'>): Promise<FeedbackModel>;
+declare function getFeedbackBoosts(projectPath: string, task: string): Promise<Map<string, number>>;
+declare function renderFeedbackReport(model: FeedbackModel): string;
+
+interface SemanticFingerprint {
+    filePath: string;
+    domains: SemanticDomain[];
+    exports: string[];
+    concepts: string[];
+    patterns: CodePattern[];
+    intentScore: Map<string, number>;
+}
+interface SemanticDomain {
+    name: string;
+    confidence: number;
+    signals: string[];
+}
+interface CodePattern {
+    type: 'route' | 'model' | 'middleware' | 'config' | 'test' | 'type' | 'util' | 'entry' | 'event' | 'error';
+    evidence: string;
+}
+interface SemanticAnalysis {
+    files: SemanticFingerprint[];
+    domainGraph: {
+        from: string;
+        to: string;
+        strength: number;
+    }[];
+    domainClusters: {
+        domain: string;
+        files: string[];
+        tokenBudget: number;
+    }[];
+}
+declare function analyzeSemantics(analysis: ProjectAnalysis): SemanticAnalysis;
+declare function semanticBoosts(semantics: SemanticAnalysis, task: string): Map<string, number>;
+declare function renderSemanticAnalysis(semantics: SemanticAnalysis): string;
+
+interface CompilabilityResult {
+    project: string;
+    task: string;
+    budget: number;
+    strategies: {
+        cto: CompilabilityMetrics;
+        naive: CompilabilityMetrics;
+        random: CompilabilityMetrics;
+    };
+    comparison: {
+        ctoVsNaiveTypeAvailability: number;
+        ctoVsRandomTypeAvailability: number;
+        ctoVsNaivePredictedErrors: number;
+        naiveMissingTypes: string[];
+        randomMissingTypes: string[];
+    };
+    verdict: string;
+}
+interface CompilabilityMetrics {
+    typeFilesAvailable: number;
+    typeFilesTotal: number;
+    typeAvailabilityPercent: number;
+    importChainsComplete: number;
+    importChainsTotal: number;
+    importCompletenessPercent: number;
+    missingTypeFiles: string[];
+    missingDependencies: string[];
+    predictedTypeErrors: number;
+    predictedImportErrors: number;
+    predictedTotalErrors: number;
+    compilabilityScore: number;
+    filesSelected: number;
+    tokensUsed: number;
+}
+declare function runCompilabilityBenchmark(analysis: ProjectAnalysis, task: string, budget?: number): Promise<CompilabilityResult>;
+declare function renderCompilabilityBenchmark(result: CompilabilityResult): string;
+
+interface CompileProofResult {
+    project: string;
+    task: string;
+    budget: number;
+    cto: CompileProofStrategy;
+    naive: CompileProofStrategy;
+    random: CompileProofStrategy;
+    headline: string;
+    details: string;
+}
+interface CompileProofStrategy {
+    name: string;
+    filesIncluded: number;
+    tokensUsed: number;
+    typeFilesIncluded: string[];
+    typeFilesMissing: string[];
+    compileErrors: number;
+    errorMessages: string[];
+    compiles: boolean;
+}
+declare function runCompileProof(analysis: ProjectAnalysis, task: string, budget?: number): Promise<CompileProofResult>;
+declare function renderCompileProof(result: CompileProofResult): string;
+
+interface ModelProfile {
+    id: string;
+    name: string;
+    provider: 'openai' | 'anthropic' | 'google' | 'mistral' | 'meta' | 'custom';
+    contextWindow: number;
+    maxOutput: number;
+    costPer1MInput: number;
+    costPer1MOutput: number;
+    strengths: ModelStrength[];
+    recommendedBudgetPercent: number;
+}
+type ModelStrength = 'code-generation' | 'analysis' | 'refactoring' | 'debugging' | 'documentation' | 'testing' | 'general';
+interface MultiModelResult {
+    task: string;
+    models: ModelOptimization[];
+    recommendation: {
+        bestValue: string;
+        bestQuality: string;
+        bestSpeed: string;
+        reasoning: string;
+    };
+}
+interface ModelOptimization {
+    model: ModelProfile;
+    budget: number;
+    selection: ContextSelection;
+    estimatedCost: number;
+    qualityScore: number;
+    recommendation: string;
+}
+declare const MODEL_REGISTRY: ModelProfile[];
+declare function optimizeForModels(analysis: ProjectAnalysis, task: string, models?: string[]): Promise<MultiModelResult>;
+declare function renderMultiModelResult(result: MultiModelResult): string;
+
+declare function scoreAllFiles(files: AnalyzedFile[], graph: ProjectGraph, weights?: RiskWeights): void;
+declare function scoreFile(file: AnalyzedFile, graph: ProjectGraph, weights?: RiskWeights): number;
+
+declare function calculateCoverage(targetPaths: string[], includedPaths: string[], allFiles: AnalyzedFile[], graph: ProjectGraph, depth?: number): CoverageResult;
+
+interface SelectionInput {
+    task: string;
+    analysis: ProjectAnalysis;
+    budget: number;
+    policies?: PolicySet;
+    depth?: number;
+}
+declare function selectContext(input: SelectionInput): Promise<ContextSelection>;
+
+declare function getPruneLevelForRisk(riskScore: number): PruneLevel;
+declare function optimizeBudget(files: AnalyzedFile[], budget: number): Promise<BudgetPlan>;
+
+declare function pruneFile(file: AnalyzedFile, level: PruneLevel): Promise<PrunedContent>;
+declare function pruneFiles(files: AnalyzedFile[], levelFn: (file: AnalyzedFile) => PruneLevel): Promise<PrunedContent[]>;
+
+declare function countTokensTiktoken(text: string): number;
+declare function countTokensChars4(sizeInBytes: number): number;
+declare function estimateTokens(content: string, sizeInBytes: number, method?: 'chars4' | 'tiktoken'): number;
+declare function estimateFileTokens(filePath: string, method?: 'chars4' | 'tiktoken'): Promise<number>;
+declare function freeEncoder(): void;
+
+export { type BenchmarkResult, type ChangeType, type ChangedFile, type CompilabilityMetrics, type CompilabilityResult, type CompileProofResult, type CompileProofStrategy, type ContextScore, type CrossRepoModel, type CrossRepoPrediction, type DimensionScore, type FeedbackEntry, type FeedbackInsight, type FeedbackModel, type FeedbackOutcome, type FileChangeEvent, type Grade, MODEL_REGISTRY, type ModelOptimization, type ModelProfile, type MultiModelResult, type PRContextOptions, type PRContextResult, type PredictionResult, type PredictorModel, type ProjectFingerprint, ProjectWatcher, type QualityBenchmarkResult, type QualityMetrics, type ScoreInsight, type SelectionInput, type SemanticAnalysis, type SemanticDomain, type SemanticFingerprint, type StrategyResult, type WatcherOptions, analyzeProject, analyzeSemantics, bfsBidirectional, buildAdjacencyList, buildProjectGraph, calculateCoverage, classifyFileKind, computeContextScore, computeFingerprint, configureCache, countTokensChars4, countTokensTiktoken, createProject, detectStack, estimateFileTokens, estimateTokens, freeEncoder, generatePRContext, getActiveWatchers, getCTODir, getCacheStats, getCachedAnalysis, getConfigPath, getCrossRepoStats, getFeedbackBoosts, getModelStats, getPolicyPath, getPredictorBoosts, getPruneLevelForRisk, initProjectConfig, invalidateCache, loadConfig, loadFeedbackModel, loadGlobalModel, loadModel, loadPolicyFromYAML, matchGlob, optimizeBudget, optimizeForModels, predictFromCrossRepo, predictRelevantFiles, pruneFile, pruneFiles, recordCrossRepoSelection, recordFeedback, recordSelection, renderBenchmark, renderCompilabilityBenchmark, renderCompileProof, renderContextScore, renderFeedbackReport, renderMultiModelResult, renderQualityBenchmark, renderSemanticAnalysis, runBenchmark, runCompilabilityBenchmark, runCompileProof, runQualityBenchmark, saveConfig, scoreAllFiles, scoreFile, selectContext, semanticBoosts, unwatchAll, unwatchProject, walkProject, watchProject };