vibecheck-ai 2.0.1 → 5.0.0

package/dist/guardrail/index.d.ts

@@ -0,0 +1,2405 @@
+/**
+ * Core types for Guardrail system
+ */
+interface GuardrailConfig {
+    projectRoot: string;
+    settings: {
+        strictMode: boolean;
+        autoRefresh: boolean;
+        refreshInterval: number;
+        maxContextTokens: number;
+    };
+    scanners: ScannerConfig;
+    firewall: FirewallConfig;
+    docguard: DocGuardConfig;
+    forge: ForgeConfig;
+}
+interface ScannerConfig {
+    routes: {
+        enabled: boolean;
+        frameworks: string[];
+        patterns: string[];
+    };
+    env: {
+        enabled: boolean;
+        files: string[];
+    };
+    auth: {
+        enabled: boolean;
+        patterns: string[];
+    };
+    contracts: {
+        enabled: boolean;
+        sources: string[];
+    };
+}
+interface FirewallConfig {
+    enabled: boolean;
+    strictMode: boolean;
+    allowPartialMatches: boolean;
+    maxClaimsPerRequest: number;
+    blockOnViolation: boolean;
+}
+interface DocGuardConfig {
+    enabled: boolean;
+    similarityThreshold: number;
+    minAnchors: number;
+    maxFluffRatio: number;
+    docDirectories: string[];
+    ignorePatterns: string[];
+    strictMode: boolean;
+}
+interface ForgeConfig {
+    enabled: boolean;
+    autoGenerate: boolean;
+    tier: 'minimal' | 'standard' | 'extended' | 'comprehensive';
+    baselineSkills: {
+        enabled: boolean;
+        skills: string[];
+    };
+    platforms: ('cursor' | 'windsurf')[];
+}
+interface TruthpackData {
+    routes: RouteInfo[];
+    envVars: EnvVarInfo[];
+    authRules: AuthRule[];
+    contracts: ContractInfo[];
+    meta: TruthpackMeta;
+}
+interface TruthpackMeta {
+    version: string;
+    generatedAt: string;
+    hash: string;
+    scannerVersions: Record<string, string>;
+    summary: {
+        routes: number;
+        envVars: number;
+        authRules: number;
+        contracts: number;
+    };
+}
+interface RouteInfo {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+    handler: string;
+    file: string;
+    line: number;
+    parameters: RouteParameter[];
+    middleware: string[];
+    auth?: {
+        required: boolean;
+        roles?: string[];
+    };
+}
+interface RouteParameter {
+    name: string;
+    type: string;
+    required: boolean;
+    in?: 'path' | 'query' | 'body' | 'header';
+}
+interface EnvVarInfo {
+    name: string;
+    file: string;
+    line: number;
+    hasDefault: boolean;
+    defaultValue?: string;
+    description?: string;
+    required: boolean;
+    sensitive: boolean;
+}
+interface AuthRule {
+    name: string;
+    type: 'role' | 'permission' | 'middleware';
+    description?: string;
+    file: string;
+    line: number;
+}
+interface ContractInfo {
+    name: string;
+    type: 'interface' | 'type' | 'schema' | 'enum';
+    file: string;
+    line: number;
+    properties?: PropertyInfo[];
+    source: 'typescript' | 'zod' | 'openapi';
+}
+interface PropertyInfo {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+}
+interface GeneratedRule {
+    id: string;
+    name: string;
+    category: RuleCategory;
+    description: string;
+    content: string;
+    priority: number;
+    impact: number;
+    globs?: string[];
+    alwaysApply: boolean;
+}
+type RuleCategory = 'anti-hallucination' | 'architecture' | 'security' | 'testing' | 'conventions' | 'documentation' | 'performance' | 'accessibility';
+interface GeneratedSubagent {
+    id: string;
+    name: string;
+    description: string;
+    capabilities: string[];
+    content: string;
+}
+interface GeneratedHook {
+    id: string;
+    name: string;
+    trigger: 'pre-commit' | 'post-commit' | 'pre-push' | 'save' | 'generate';
+    description: string;
+    content: string;
+}
+interface GeneratedSkill {
+    id: string;
+    name: string;
+    description: string;
+    trigger: string;
+    content: string;
+    references?: string[];
+}
+interface ConventionRule {
+    category: string;
+    rules: string[];
+}
+interface PatternDefinition {
+    name: string;
+    category: string;
+    description: string;
+    example: string;
+    antiPatterns: string[];
+}
+interface DuplicateCheckResult {
+    isDuplicate: boolean;
+    similarity: number;
+    existingFile?: string;
+    existingContent?: string;
+    suggestion?: 'merge' | 'update' | 'skip';
+}
+interface DocGuardResult {
+    valid: boolean;
+    score: number;
+    issues: DocGuardIssue[];
+    anchors: string[];
+    slopPhrases: string[];
+    fluffRatio: number;
+}
+interface DocGuardIssue {
+    type: 'missing-anchor' | 'slop-phrase' | 'high-fluff' | 'no-example' | 'duplicate';
+    message: string;
+    line?: number;
+    suggestion?: string;
+}
+interface WatcherEvent {
+    type: 'add' | 'change' | 'unlink';
+    path: string;
+    timestamp: Date;
+}
+interface RefreshResult {
+    rulesUpdated: number;
+    rulesAdded: number;
+    rulesRemoved: number;
+    conventionsLearned: string[];
+    patternsDetected: string[];
+    duration: number;
+}
+
+/**
+ * Guardrail Scanners
+ *
+ * Scan the codebase to build the Truthpack - ground truth data
+ * that AI agents use to verify their claims.
+ */
+
+declare class TruthpackScanner {
+    private projectRoot;
+    private config;
+    constructor(projectRoot: string, config: ScannerConfig);
+    scan(): Promise<TruthpackData>;
+    private scanRoutes;
+    private extractRoutes;
+    private extractHandler;
+    private extractRouteParams;
+    private extractMiddleware;
+    private detectAuthRequirement;
+    private filePathToApiRoute;
+    private scanEnvVars;
+    private isSensitiveEnvVar;
+    private scanAuth;
+    private scanContracts;
+    private computeHash;
+}
+declare function scanTruthpack(projectRoot: string, config: ScannerConfig): Promise<TruthpackData>;
+declare function saveTruthpack(projectRoot: string, data: TruthpackData): Promise<void>;
+declare function loadTruthpack(projectRoot: string): Promise<TruthpackData | null>;
+
+/**
+ * Large Codebase Scanner
+ *
+ * Optimized scanner for handling codebases with 1,000,000+ lines of code.
+ * Features:
+ * - Chunked file processing with configurable batch sizes
+ * - Incremental scanning with file hash caching
+ * - Parallel processing using worker threads
+ * - Memory-efficient streaming for large files
+ * - Progress reporting for UI integration
+ */
+
+interface LargeScannerConfig extends ScannerConfig {
+    largeCodebase?: {
+        enabled: boolean;
+        chunkSize: number;
+        maxConcurrency: number;
+        incrementalScan: boolean;
+        memoryLimit: number;
+        streamLargeFiles: boolean;
+        largeFileThreshold: number;
+    };
+}
+interface ScanProgress {
+    phase: 'discovery' | 'scanning' | 'processing' | 'finalizing';
+    totalFiles: number;
+    processedFiles: number;
+    currentFile?: string;
+    estimatedTimeRemaining?: number;
+    memoryUsage?: number;
+    errors: ScanError[];
+}
+interface ScanError {
+    file: string;
+    error: string;
+    recoverable: boolean;
+}
+interface FileCache {
+    hash: string;
+    lastModified: number;
+    routes: RouteInfo[];
+    contracts: ContractInfo[];
+    authRules: AuthRule[];
+}
+type ProgressCallback = (progress: ScanProgress) => void;
+declare class LargeCodebaseScanner {
+    private projectRoot;
+    private config;
+    private cache;
+    private cacheDir;
+    private progress;
+    private progressCallback?;
+    private startTime;
+    constructor(projectRoot: string, config: LargeScannerConfig, progressCallback?: ProgressCallback);
+    private normalizeConfig;
+    scan(): Promise<TruthpackData>;
+    private discoverFiles;
+    private processFilesInChunks;
+    private processChunkWithConcurrency;
+    private processFile;
+    private readLargeFile;
+    private extractRoutes;
+    private extractContracts;
+    private extractAuthRules;
+    private getLineNumber;
+    private extractHandler;
+    private extractRouteParams;
+    private extractMiddleware;
+    private detectAuthRequirement;
+    private filePathToApiRoute;
+    private scanEnvVars;
+    private isSensitiveEnvVar;
+    private computeFileHash;
+    private computeHash;
+    private chunkArray;
+    private checkMemory;
+    private updateProgress;
+    private loadCache;
+    private saveCache;
+}
+declare function scanLargeCodebase(projectRoot: string, config: LargeScannerConfig, progressCallback?: ProgressCallback): Promise<TruthpackData>;
+declare function estimateCodebaseSize(projectRoot: string): Promise<{
+    fileCount: number;
+    estimatedLines: number;
+    isLarge: boolean;
+    recommendedChunkSize: number;
+}>;
+
+/**
+ * Guardrail Forge
+ *
+ * Auto-generates MDC rules, subagents, hooks, and skills based on
+ * codebase analysis. Learns project conventions and creates tailored
+ * guardrails to prevent AI drift.
+ */
+
+interface ForgeResult {
+    rules: GeneratedRule[];
+    subagents: GeneratedSubagent[];
+    hooks: GeneratedHook[];
+    skills: GeneratedSkill[];
+    conventions: ConventionRule[];
+    patterns: PatternDefinition[];
+}
+declare class GuardrailForge {
+    private projectRoot;
+    private config;
+    private truthpack;
+    constructor(projectRoot: string, config: GuardrailConfig);
+    forge(): Promise<ForgeResult>;
+    private analyzeProject;
+    private detectFramework;
+    private detectArchitecture;
+    private hasDocumentation;
+    private learnConventions;
+    private analyzeNamingConventions;
+    private analyzeImportConventions;
+    private analyzeErrorHandling;
+    private detectPatterns;
+    private generateRules;
+    private createAntiHallucinationRule;
+    private createArchitectureRule;
+    private generateDirectoryGuidelines;
+    private createNextJsRule;
+    private createReactRule;
+    private createTypeScriptRule;
+    private createTestingRule;
+    private createApiRule;
+    private createAuthRule;
+    private generateSubagents;
+    private generateHooks;
+    private generateSkills;
+    private writeArtifacts;
+    private writeCursorRules;
+}
+declare function forge(projectRoot: string, config: GuardrailConfig): Promise<ForgeResult>;
+
+/**
+ * Task Tracker - Ensures AI agents document remaining work
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Forces AI to document what's remaining before stopping
+ * - Creates checkpoints for task resumption
+ * - Tracks progress across sessions
+ * - Prevents abandoned incomplete work
+ */
+interface TaskStep {
+    id: string;
+    description: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'skipped';
+    startedAt?: string;
+    completedAt?: string;
+    notes?: string;
+    blockedReason?: string;
+    filesModified?: string[];
+    dependencies?: string[];
+}
+interface TaskCheckpoint {
+    id: string;
+    taskId: string;
+    timestamp: string;
+    currentStep: number;
+    totalSteps: number;
+    completedSteps: string[];
+    remainingSteps: TaskStep[];
+    contextSnapshot: ContextSnapshot;
+    resumptionNotes: string;
+    canResume: boolean;
+}
+interface ContextSnapshot {
+    openFiles: string[];
+    lastModifiedFile?: string;
+    cursorPosition?: {
+        file: string;
+        line: number;
+    };
+    relevantVariables?: Record<string, string>;
+    environmentState?: Record<string, string>;
+}
+interface Task {
+    id: string;
+    title: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+    status: 'active' | 'paused' | 'completed' | 'abandoned';
+    steps: TaskStep[];
+    checkpoints: TaskCheckpoint[];
+    totalEstimatedSteps: number;
+    completionPercentage: number;
+    lastActiveAgent?: string;
+    tags?: string[];
+}
+interface TaskSummary {
+    completed: string[];
+    inProgress: string[];
+    remaining: string[];
+    blocked: string[];
+    estimatedRemainingWork: string;
+    nextSteps: string[];
+    warnings: string[];
+}
+interface StopValidation {
+    canStop: boolean;
+    mustDocument: string[];
+    warnings: string[];
+    suggestedCheckpoint: Partial<TaskCheckpoint>;
+}
+declare class TaskTracker {
+    private workspaceRoot;
+    private tasksPath;
+    private currentTask;
+    private tasks;
+    constructor(workspaceRoot: string);
+    /**
+     * Start a new task
+     */
+    startTask(title: string, description: string, estimatedSteps?: string[]): Task;
+    /**
+     * Add steps to current task
+     */
+    addSteps(steps: string[]): void;
+    /**
+     * Update step status
+     */
+    updateStep(stepId: string, status: TaskStep['status'], notes?: string): void;
+    /**
+     * Mark current step as in progress
+     */
+    startStep(stepId: string): void;
+    /**
+     * Complete current step
+     */
+    completeStep(stepId: string, notes?: string, filesModified?: string[]): void;
+    /**
+     * Mark step as blocked
+     */
+    blockStep(stepId: string, reason: string): void;
+    /**
+     * CRITICAL: Validate if agent can stop working
+     * This is the key feature - prevents stopping without documenting remaining work
+     */
+    validateStop(): StopValidation;
+    /**
+     * Create a checkpoint before stopping
+     * REQUIRED if task is incomplete
+     */
+    createCheckpoint(resumptionNotes: string, contextSnapshot?: Partial<ContextSnapshot>): TaskCheckpoint;
+    /**
+     * Generate a task summary for handoff or resumption
+     */
+    generateSummary(): TaskSummary;
+    /**
+     * Generate markdown summary for documentation
+     */
+    generateMarkdownSummary(): string;
+    /**
+     * Resume from a checkpoint
+     */
+    resumeFromCheckpoint(checkpointId: string): Task | null;
+    /**
+     * Resume the most recent paused task
+     */
+    resumeLatest(): Task | null;
+    /**
+     * Complete the current task
+     */
+    completeTask(): void;
+    /**
+     * Abandon task (with documentation)
+     */
+    abandonTask(reason: string): TaskCheckpoint;
+    /**
+     * Get current task
+     */
+    getCurrentTask(): Task | null;
+    /**
+     * Get all tasks
+     */
+    getAllTasks(): Task[];
+    /**
+     * Get paused tasks
+     */
+    getPausedTasks(): Task[];
+    /**
+     * Load task by ID
+     */
+    loadTask(taskId: string): Task | null;
+    private updateCompletionPercentage;
+    private loadTasks;
+    private saveTasks;
+}
+/**
+ * Create task tracker instance
+ */
+declare function createTaskTracker(workspaceRoot: string): TaskTracker;
+
+/**
+ * Completion Guard - Ensures tasks are properly completed
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Enforces documentation of remaining work before stopping
+ * - Validates task completion criteria
+ * - Generates handoff documentation automatically
+ * - Prevents silent task abandonment
+ */
+
+interface CompletionCriteria {
+    requireAllStepsComplete: boolean;
+    requireNoBlockedSteps: boolean;
+    requireResumptionNotes: boolean;
+    minCompletionPercentage: number;
+    requireFilesDocumented: boolean;
+    requireNextStepsDocumented: boolean;
+}
+interface CompletionResult {
+    canComplete: boolean;
+    violations: string[];
+    suggestions: string[];
+    requiredActions: RequiredAction[];
+    handoffDocument?: string;
+}
+interface RequiredAction {
+    type: 'document' | 'complete' | 'unblock' | 'checkpoint';
+    description: string;
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    targetStepId?: string;
+}
+interface HandoffDocument {
+    taskTitle: string;
+    summary: string;
+    completedWork: string[];
+    remainingWork: string[];
+    blockedItems: string[];
+    contextNotes: string;
+    resumptionInstructions: string;
+    filesModified: string[];
+    estimatedRemainingTime: string;
+    createdAt: string;
+    createdBy: string;
+}
+declare class CompletionGuard {
+    private workspaceRoot;
+    private taskTracker;
+    private criteria;
+    private handoffPath;
+    constructor(workspaceRoot: string, taskTracker: TaskTracker, criteria?: Partial<CompletionCriteria>);
+    /**
+     * Validate if work can be stopped
+     * This is the CRITICAL check before any AI agent stops working
+     */
+    validateCompletion(): CompletionResult;
+    /**
+     * Force create a handoff document before stopping
+     */
+    createHandoff(contextNotes: string, resumptionInstructions: string, agentId?: string): HandoffDocument;
+    /**
+     * Generate handoff documentation markdown
+     */
+    generateHandoffDocument(task: Task, summary: TaskSummary): string;
+    /**
+     * Validate and enforce completion with automatic handoff
+     */
+    enforceCompletion(contextNotes?: string, agentId?: string): {
+        allowed: boolean;
+        handoff?: HandoffDocument;
+        message: string;
+    };
+    /**
+     * Generate automatic resumption instructions
+     */
+    private generateResumptionInstructions;
+    /**
+     * Save handoff document to disk
+     */
+    private saveHandoff;
+    /**
+     * Get all handoff documents
+     */
+    getHandoffs(): HandoffDocument[];
+    /**
+     * Get latest handoff for a task
+     */
+    getLatestHandoff(taskId: string): HandoffDocument | null;
+    /**
+     * Update completion criteria
+     */
+    updateCriteria(criteria: Partial<CompletionCriteria>): void;
+    /**
+     * Get current criteria
+     */
+    getCriteria(): CompletionCriteria;
+}
+/**
+ * Create completion guard instance
+ */
+declare function createCompletionGuard(workspaceRoot: string, taskTracker: TaskTracker, criteria?: Partial<CompletionCriteria>): CompletionGuard;
+
+/**
+ * Guardrail DocGuard
+ *
+ * Documentation quality control system that prevents drift, detects slop,
+ * ensures documentation stays grounded in reality, and tracks task progress.
+ */
+
+declare class DocGuard {
+    private projectRoot;
+    private config;
+    private documentRegistry;
+    constructor(projectRoot: string, config: DocGuardConfig);
+    /**
+     * Evaluate a document for quality
+     */
+    evaluate(content: string, filePath?: string): Promise<DocGuardResult>;
+    /**
+     * Quick slop check - fast validation
+     */
+    quickCheck(content: string): {
+        hasSop: boolean;
+        phrases: string[];
+    };
+    /**
+     * Check for duplicate content
+     */
+    checkDuplicate(content: string, filePath: string): Promise<DuplicateCheckResult>;
+    /**
+     * Scan all documentation and update registry
+     */
+    scanDocuments(): Promise<void>;
+    /**
+     * Find canonical document for a topic
+     */
+    findCanonical(topic: string): Promise<string | null>;
+    /**
+     * Get suggestion for where to place content
+     */
+    suggestLocation(topic: string): string;
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        totalDocs: number;
+        avgScore: number;
+        duplicates: number;
+    };
+    private loadDocumentRegistry;
+    private computeSimHash;
+}
+/**
+ * Create a DocGuard instance
+ */
+declare function createDocGuard(projectRoot: string, config: DocGuardConfig): DocGuard;
+/**
+ * Quick evaluation of document content
+ */
+declare function evaluateDoc(content: string, projectRoot: string, config: DocGuardConfig): Promise<DocGuardResult>;
+/**
+ * Check if content should be blocked due to quality issues
+ */
+declare function shouldBlock(result: DocGuardResult, strictMode: boolean): boolean;
+
+/**
+ * Guardrail Watcher
+ *
+ * Continuously monitors the codebase for changes and triggers
+ * automatic re-analysis to keep guardrails up-to-date.
+ */
+
+interface WatcherOptions {
+    projectRoot: string;
+    config: GuardrailConfig;
+    onRefresh?: (result: RefreshResult) => void;
+    onError?: (error: Error) => void;
+    debounceMs?: number;
+}
+declare class GuardrailWatcher {
+    private projectRoot;
+    private config;
+    private watcher;
+    private debounceTimer;
+    private debounceMs;
+    private pendingChanges;
+    private lastTruthpackHash;
+    private isRefreshing;
+    private onRefresh?;
+    private onError?;
+    constructor(options: WatcherOptions);
+    /**
+     * Start watching for changes
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watching
+     */
+    stop(): Promise<void>;
+    /**
+     * Force a refresh now
+     */
+    forceRefresh(): Promise<RefreshResult>;
+    private handleChange;
+    private processChanges;
+    private categorizeChanges;
+    private doRefresh;
+    private refreshDocRules;
+    private schedulePeriodicRefresh;
+    private handleError;
+}
+/**
+ * Create and start a watcher
+ */
+declare function startWatcher(options: WatcherOptions): Promise<GuardrailWatcher>;
+/**
+ * Quick one-time refresh
+ */
+declare function refreshGuardrails(projectRoot: string, config: GuardrailConfig): Promise<RefreshResult>;
+
+/**
+ * Anti-Hallucination Type Definitions
+ */
+interface CodeSuggestion {
+    id: string;
+    code: string;
+    language: string;
+    filePath?: string;
+    lineRange?: {
+        start: number;
+        end: number;
+    };
+    source: 'ai' | 'user' | 'template';
+    timestamp: number;
+}
+interface VerificationResult$1 {
+    valid: boolean;
+    confidence: number;
+    issues: VerificationIssue$1[];
+    suggestions: string[];
+    metrics: VerificationMetrics;
+}
+interface VerificationIssue$1 {
+    type: HallucinationType;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    line?: number;
+    column?: number;
+    evidence?: string;
+    fix?: string;
+}
+type HallucinationType = 'fake_import' | 'invented_api' | 'wrong_signature' | 'type_mismatch' | 'nonexistent_file' | 'deprecated_api' | 'pattern_violation' | 'env_hallucination' | 'route_mismatch' | 'schema_violation' | 'security_antipattern' | 'stale_reference';
+interface VerificationMetrics {
+    importVerification: number;
+    apiVerification: number;
+    typeVerification: number;
+    patternAlignment: number;
+    overallConfidence: number;
+}
+interface HallucinationFingerprint {
+    id: string;
+    pattern: string;
+    type: HallucinationType;
+    description: string;
+    examples: string[];
+    frequency: number;
+    falsePositiveRate: number;
+}
+interface ConfidenceFactors {
+    importFamiliarity: number;
+    patternSimilarity: number;
+    typeConsistency: number;
+    apiAccuracy: number;
+    contextRelevance: number;
+    historicalAccuracy: number;
+}
+interface PatternSignature {
+    id: string;
+    name: string;
+    category: 'naming' | 'structure' | 'import' | 'error_handling' | 'async' | 'testing' | 'api';
+    pattern: string;
+    examples: string[];
+    frequency: number;
+    lastSeen: string;
+}
+interface LearningFeedback {
+    suggestionId: string;
+    accepted: boolean;
+    editedBefore: boolean;
+    editDistance?: number;
+    timeToDecision: number;
+    context: string;
+    reason?: string;
+}
+interface ContextChunk {
+    id: string;
+    filePath: string;
+    content: string;
+    startLine: number;
+    endLine: number;
+    relevanceScore: number;
+    tokens: number;
+    type: 'definition' | 'usage' | 'import' | 'type' | 'test' | 'doc' | 'config';
+}
+interface OptimizedContext {
+    chunks: ContextChunk[];
+    totalTokens: number;
+    coverage: ContextCoverage;
+    strategy: string;
+}
+interface ContextCoverage {
+    definitions: number;
+    types: number;
+    usages: number;
+    tests: number;
+}
+interface CodebaseKnowledge {
+    imports: Map<string, ImportInfo>;
+    exports: Map<string, ExportInfo>;
+    types: Map<string, TypeInfo>;
+    functions: Map<string, AHFunctionInfo>;
+    patterns: PatternSignature[];
+    envVars: Set<string>;
+    routes: AHRouteInfo[];
+}
+interface ImportInfo {
+    source: string;
+    isLocal: boolean;
+    isNodeModule: boolean;
+    exports: string[];
+    usageCount: number;
+    lastUsed: string;
+}
+interface ExportInfo {
+    name: string;
+    type: 'function' | 'class' | 'const' | 'type' | 'interface' | 'enum';
+    filePath: string;
+    signature?: string;
+    usedBy: string[];
+}
+interface TypeInfo {
+    name: string;
+    filePath: string;
+    kind: 'interface' | 'type' | 'class' | 'enum';
+    properties?: AHPropertyInfo[];
+    methods?: AHMethodInfo[];
+}
+interface AHPropertyInfo {
+    name: string;
+    type: string;
+    optional: boolean;
+}
+interface AHMethodInfo {
+    name: string;
+    parameters: AHParameterInfo[];
+    returnType: string;
+}
+interface AHParameterInfo {
+    name: string;
+    type: string;
+    optional: boolean;
+    defaultValue?: string;
+}
+interface AHFunctionInfo {
+    name: string;
+    filePath: string;
+    parameters: AHParameterInfo[];
+    returnType: string;
+    isAsync: boolean;
+    isExported: boolean;
+    usageCount: number;
+}
+interface AHRouteInfo {
+    method: string;
+    path: string;
+    handler: string;
+    filePath: string;
+    parameters?: AHParameterInfo[];
+    responseType?: string;
+}
+
+/**
+ * Semantic Verification Engine
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Verifies AI suggestions against ACTUAL codebase state
+ * - Cross-references imports with real node_modules and local files
+ * - Validates function signatures against real definitions
+ * - Checks type compatibility with actual TypeScript types
+ */
+
+declare class SemanticVerifier {
+    private workspaceRoot;
+    private knowledge;
+    private nodeModulesCache;
+    constructor(workspaceRoot: string);
+    private initializeKnowledge;
+    /**
+     * Main verification entry point
+     */
+    verify(suggestion: CodeSuggestion): Promise<VerificationResult$1>;
+    /**
+     * Extract import statements from code
+     */
+    private extractImports;
+    /**
+     * Extract function calls from code
+     */
+    private extractFunctionCalls;
+    /**
+     * Extract type references from code
+     */
+    private extractTypeReferences;
+    /**
+     * Extract environment variable references
+     */
+    private extractEnvReferences;
+    /**
+     * Verify imports against actual node_modules and local files
+     */
+    private verifyImports;
+    /**
+     * Verify API/function calls against known signatures
+     */
+    private verifyAPICalls;
+    /**
+     * Verify type references against defined types
+     */
+    private verifyTypes;
+    /**
+     * Verify environment variable references
+     */
+    private verifyEnvVars;
+    /**
+     * Resolve local import path
+     */
+    private resolveLocalImport;
+    /**
+     * Extract exports from a file
+     */
+    private extractExportsFromFile;
+    /**
+     * Check if a node module exists
+     */
+    private checkNodeModule;
+    /**
+     * Verify module exports (basic check for popular packages)
+     */
+    private verifyModuleExports;
+    /**
+     * Check for common API mistakes
+     */
+    private checkCommonAPIMistakes;
+    /**
+     * Load known environment variables from .env files
+     */
+    private loadKnownEnvVars;
+    /**
+     * Calculate verification metrics
+     */
+    private calculateMetrics;
+    /**
+     * Generate fix suggestions based on issues
+     */
+    private generateFixSuggestions;
+    /**
+     * Update knowledge base with new information
+     */
+    updateKnowledge(knowledge: Partial<CodebaseKnowledge>): void;
+}
+
+/**
+ * Hallucination Fingerprint Detector
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Detects common hallucination patterns before they cause issues
+ * - Maintains a fingerprint database of known AI mistakes
+ * - Uses pattern matching to catch fake packages, invented APIs
+ * - Learns new patterns from user feedback
+ */
+
+interface DetectionResult {
+    detected: boolean;
+    fingerprints: HallucinationFingerprint[];
+    issues: VerificationIssue$1[];
+    riskScore: number;
+}
+declare class HallucinationDetector {
+    private workspaceRoot;
+    private fingerprints;
+    private customFingerprints;
+    private fingerprintPath;
+    constructor(workspaceRoot: string);
+    /**
+     * Initialize built-in hallucination fingerprints
+     * These are common patterns that AI models frequently get wrong
+     */
+    private initializeBuiltInFingerprints;
+    /**
+     * Load custom fingerprints from project
+     */
+    private loadCustomFingerprints;
+    /**
+     * Save custom fingerprints
+     */
+    private saveCustomFingerprints;
+    /**
+     * Detect hallucinations in code
+     */
+    detect(code: string): DetectionResult;
+    /**
+     * Detect hallucinations that require context
+     */
+    private detectContextualHallucinations;
+    /**
+     * Get severity based on fingerprint characteristics
+     */
+    private getSeverity;
+    /**
+     * Get fix suggestion for a detected fingerprint
+     */
+    private getFix;
+    /**
+     * Add a new fingerprint learned from user feedback
+     */
+    addFingerprint(fingerprint: Omit<HallucinationFingerprint, 'id'>): void;
+    /**
+     * Update fingerprint frequency based on detection
+     */
+    updateFrequency(fingerprintId: string, detected: boolean): void;
+    /**
+     * Get all fingerprints for analysis
+     */
+    getAllFingerprints(): HallucinationFingerprint[];
+    /**
+     * Get high-risk fingerprints
+     */
+    getHighRiskFingerprints(): HallucinationFingerprint[];
+}
+
+/**
+ * Confidence Scoring System
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Multi-dimensional confidence scoring based on codebase familiarity
+ * - Historical accuracy tracking per code pattern type
+ * - Weighted scoring based on context relevance
+ * - Adaptive thresholds that learn from feedback
+ */
+
+interface ConfidenceScore {
+    overall: number;
+    factors: ConfidenceFactors;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    recommendation: 'accept' | 'review' | 'reject';
+    reasoning: string[];
+}
+interface HistoricalAccuracy {
+    category: string;
+    totalSuggestions: number;
+    accepted: number;
+    acceptedWithEdits: number;
+    rejected: number;
+    averageEditDistance: number;
+    lastUpdated: string;
+}
+declare class ConfidenceScorer {
+    private workspaceRoot;
+    private knowledge;
+    private historicalAccuracy;
+    private historyPath;
+    private acceptThreshold;
+    private reviewThreshold;
+    constructor(workspaceRoot: string);
+    /**
+     * Calculate confidence score for a suggestion
+     */
+    score(suggestion: CodeSuggestion, knowledge?: CodebaseKnowledge): ConfidenceScore;
+    /**
+     * Calculate individual confidence factors
+     */
+    private calculateFactors;
+    /**
+     * Calculate how familiar the imports are to the codebase
+     */
+    private calculateImportFamiliarity;
+    /**
+     * Calculate pattern similarity to existing codebase
+     */
+    private calculatePatternSimilarity;
+    /**
+     * Calculate type consistency with codebase types
+     */
+    private calculateTypeConsistency;
+    /**
+     * Calculate API accuracy based on known function signatures
+     */
+    private calculateAPIAccuracy;
+    /**
+     * Calculate context relevance
+     */
+    private calculateContextRelevance;
+    /**
+     * Calculate based on historical accuracy for similar code
+     */
+    private calculateHistoricalAccuracy;
+    /**
+     * Calculate overall confidence score
+     */
+    private calculateOverall;
+    /**
+     * Calculate letter grade
+     */
+    private calculateGrade;
+    /**
+     * Get recommendation based on score and factors
+     */
+    private getRecommendation;
+    /**
+     * Generate human-readable reasoning
+     */
+    private generateReasoning;
+    /**
+     * Record feedback to improve future scoring
+     */
+    recordFeedback(suggestion: CodeSuggestion, accepted: boolean, edited: boolean, editDistance?: number): void;
+    /**
+     * Adapt thresholds based on accumulated feedback
+     */
+    private adaptThresholds;
+    /**
+     * Helper methods
+     */
+    private extractImports;
+    private extractTypeReferences;
+    private extractFunctionCalls;
+    private categorizeCode;
+    private isCommonPackage;
+    private isPrimitiveType;
+    private isBuiltInType;
+    private isBuiltInFunction;
+    private loadHistory;
+    private saveHistory;
+    /**
+     * Update codebase knowledge
+     */
+    updateKnowledge(knowledge: CodebaseKnowledge): void;
+    /**
+     * Get current thresholds
+     */
+    getThresholds(): {
+        accept: number;
+        review: number;
+    };
+    /**
+     * Get historical accuracy stats
+     */
+    getStats(): {
+        categories: HistoricalAccuracy[];
+        overall: {
+            accepted: number;
+            rejected: number;
+            total: number;
+        };
+    };
+}
+
+/**
+ * Pattern Learning Engine
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Learns coding patterns from user accept/reject decisions
+ * - Builds a personalized model of what "good code" looks like
+ * - Identifies anti-patterns from rejected suggestions
+ * - Continuously improves pattern matching over time
+ */
+
+interface LearnedPattern {
+    id: string;
+    pattern: string;
+    type: 'positive' | 'negative';
+    category: PatternSignature['category'];
+    confidence: number;
+    examples: string[];
+    frequency: number;
+    acceptRate: number;
+    rejectRate: number;
+    lastSeen: string;
+}
+interface LearningStats {
+    totalFeedback: number;
+    patternsLearned: number;
+    positivePatterns: number;
+    negativePatterns: number;
+    accuracyImprovement: number;
+}
+declare class PatternLearner {
+    private workspaceRoot;
+    private patterns;
+    private feedbackHistory;
+    private patternsPath;
+    private minFrequencyForPattern;
+    constructor(workspaceRoot: string);
+    /**
+     * Record feedback and learn from it
+     */
+    learn(feedback: LearningFeedback): void;
+    /**
+     * Extract patterns from code
+     */
+    private extractPatterns;
+    /**
+     * Extract API usage patterns
+     */
+    private extractAPIPatterns;
+    /**
+     * Extract naming convention patterns
+     */
+    private extractNamingPatterns;
+    /**
+     * Extract code structure patterns
+     */
+    private extractStructurePatterns;
+    /**
+     * Extract import patterns
+     */
+    private extractImportPatterns;
+    /**
+     * Extract error handling patterns
+     */
+    private extractErrorPatterns;
+    /**
+     * Extract async patterns
+     */
+    private extractAsyncPatterns;
+    /**
+     * Extract testing patterns
+     */
+    private extractTestingPatterns;
+    /**
+     * Update or create a pattern based on feedback
+     */
+    private updatePattern;
+    /**
+     * Prune low-value patterns
+     */
+    private prunePatterns;
+    /**
+     * Score a suggestion based on learned patterns
+     */
+    scorePatterns(suggestion: CodeSuggestion): {
+        score: number;
+        matchedPatterns: LearnedPattern[];
+    };
+    /**
+     * Get suggestions for improving code based on learned patterns
+     */
+    getSuggestions(code: string): string[];
+    /**
+     * Get learning statistics
+     */
+    getStats(): LearningStats;
+    /**
+     * Get all learned patterns
+     */
+    getPatterns(): LearnedPattern[];
+    /**
+     * Get positive patterns (good patterns to follow)
+     */
+    getPositivePatterns(): LearnedPattern[];
+    /**
+     * Get negative patterns (anti-patterns to avoid)
+     */
+    getNegativePatterns(): LearnedPattern[];
+    /**
+     * Export patterns for backup or sharing
+     */
+    exportPatterns(): string;
+    /**
+     * Import patterns from backup
+     */
+    importPatterns(data: string): void;
+    private loadPatterns;
+    private savePatterns;
+}
+
+/**
+ * Context Window Optimizer
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Smart context selection that maximizes relevant code in limited token budget
+ * - Prioritizes definitions, types, and usage patterns that matter
+ * - Uses semantic similarity and dependency graphs
+ * - Adaptive chunking based on code structure
+ */
+
+interface ContextRequest {
+    targetFile: string;
+    targetLine?: number;
+    intent: string;
+    maxTokens: number;
+    preferredTypes?: ContextChunk['type'][];
+}
+declare class ContextOptimizer {
+    private workspaceRoot;
+    private knowledge;
+    private fileAnalysisCache;
+    private avgCharsPerToken;
+    constructor(workspaceRoot: string);
+    /**
+     * Optimize context selection for a request
+     */
+    optimize(request: ContextRequest): Promise<OptimizedContext>;
+    /**
+     * Analyze a file for imports, exports, types, functions
+     */
+    private analyzeFile;
+    /**
+     * Build candidate chunks with relevance scores
+     */
+    private buildCandidates;
+    /**
+     * Chunk a file into semantic segments
+     */
+    private chunkFile;
+    /**
+     * Create a context chunk
+     */
+    private createChunk;
+    /**
+     * Score chunk relevance based on multiple factors
+     */
+    private scoreRelevance;
+    /**
+     * Greedy selection with diversity
+     */
+    private greedySelect;
+    /**
+     * Calculate context coverage metrics
+     */
+    private calculateCoverage;
+    /**
+     * Describe the optimization strategy used
+     */
+    private describeStrategy;
+    /**
+     * Helper: Extract imports from content
+     */
+    private extractImports;
+    /**
+     * Helper: Extract exports from content
+     */
+    private extractExports;
+    /**
+     * Helper: Extract type references
+     */
+    private extractTypes;
+    /**
+     * Helper: Extract function names
+     */
+    private extractFunctions;
+    /**
+     * Find files containing type definitions
+     */
+    private findTypeFiles;
+    /**
+     * Find test file for a source file
+     */
+    private findTestFile;
+    /**
+     * Find files that import the target file
+     */
+    private findUsageFiles;
+    /**
+     * Get config file chunks
+     */
+    private getConfigChunks;
+    /**
+     * Update codebase knowledge
+     */
+    updateKnowledge(knowledge: CodebaseKnowledge): void;
+    /**
+     * Clear file analysis cache
+     */
+    clearCache(): void;
+}
+
+/**
+ * Vibecheck Verification System
+ *
+ * Adds provenance tracking to AI-generated code:
+ * - Marks verified code with "Verified by Vibecheck" badge
+ * - Tracks which context folders/files were used
+ * - Generates verification metadata for audit trails
+ * - Embeds verification comments in generated code
+ */
+interface VerificationMetadata {
+    id: string;
+    timestamp: string;
+    verified: boolean;
+    confidenceScore: number;
+    confidenceGrade: string;
+    contextUsed: ContextSource[];
+    issues: string[];
+    checksum: string;
+}
+interface ContextSource {
+    path: string;
+    type: 'file' | 'folder';
+    relevance: number;
+    linesUsed?: {
+        start: number;
+        end: number;
+    }[];
+}
+interface VerificationBadge {
+    comment: string;
+    metadata: VerificationMetadata;
+}
+interface VerificationOptions {
+    addComment: boolean;
+    commentStyle: 'block' | 'line' | 'jsdoc';
+    includeTimestamp: boolean;
+    includeChecksum: boolean;
+    includeContextPaths: boolean;
+    includeConfidence: boolean;
+    minConfidenceForBadge: number;
+}
+declare class VibecheckVerifier {
+    private workspaceRoot;
+    private verificationLog;
+    private logPath;
+    constructor(workspaceRoot: string);
+    /**
+     * Generate a verification badge for code
+     */
+    generateBadge(code: string, confidenceScore: number, confidenceGrade: string, contextUsed: ContextSource[], issues: string[], options?: Partial<VerificationOptions>): VerificationBadge;
+    /**
+     * Add verification badge to code
+     */
+    addBadgeToCode(code: string, badge: VerificationBadge, language: string): string;
+    /**
+     * Check if code already has a Vibecheck badge
+     */
+    hasVibecheckBadge(code: string): boolean;
+    /**
+     * Extract verification metadata from code with badge
+     */
+    extractBadgeMetadata(code: string): VerificationMetadata | null;
+    /**
+     * Verify that code matches its checksum
+     */
+    verifyChecksum(code: string): {
+        valid: boolean;
+        metadata?: VerificationMetadata;
+    };
+    /**
+     * Generate verification report for a file
+     */
+    generateReport(filePath: string): {
+        hasVerification: boolean;
+        metadata?: VerificationMetadata;
+        checksumValid?: boolean;
+        contextStillExists?: boolean;
+    };
+    /**
+     * Get all verified files in workspace
+     */
+    getVerifiedFiles(): Promise<Array<{
+        path: string;
+        metadata: VerificationMetadata;
+        status: 'valid' | 'modified' | 'context_missing';
+    }>>;
+    /**
+     * Create verification metadata
+     */
+    private createMetadata;
+    /**
+     * Format the verification comment
+     */
+    private formatComment;
+    /**
+     * Wrap comment in language-appropriate comment syntax
+     */
+    private wrapInComment;
+    /**
+     * Remove Vibecheck badge from code
+     */
+    private removeBadge;
+    /**
+     * Generate unique verification ID
+     */
+    private generateId;
+    /**
+     * Generate checksum for code
+     */
+    private generateChecksum;
+    /**
+     * Load verification log from disk
+     */
+    private loadLog;
+    /**
+     * Save verification log to disk
+     */
+    private saveLog;
+    /**
+     * Get verification statistics
+     */
+    getStats(): {
+        totalVerifications: number;
+        verified: number;
+        needsReview: number;
+        avgConfidence: number;
+        topContextSources: Array<{
+            path: string;
+            count: number;
+        }>;
+    };
+    /**
+     * Clear all verification history
+     */
+    clearHistory(): void;
+}
+/**
+ * Generate a simple Vibecheck badge comment for quick use
+ */
+declare function generateQuickBadge(language: string, confidenceScore: number, contextPaths: string[]): string;
+
+/**
+ * Anti-Hallucination Engine - Main Orchestrator
+ *
+ * This is the unified interface that combines all anti-hallucination features:
+ * - Semantic Verification
+ * - Hallucination Fingerprinting
+ * - Confidence Scoring
+ * - Pattern Learning
+ * - Context Optimization
+ *
+ * WHAT MAKES THIS BEST IN THE WORLD:
+ * 1. Multi-layer validation - catches hallucinations at multiple levels
+ * 2. Learning system - gets better with every accept/reject
+ * 3. Confidence-based gating - prevents low-quality suggestions
+ * 4. Smart context - maximizes relevant code in prompts
+ * 5. Real-time feedback loop - adapts to your codebase
+ */
+
+interface AnalysisResult {
+    suggestion: CodeSuggestion;
+    verification: VerificationResult$1;
+    detection: DetectionResult;
+    confidence: ConfidenceScore;
+    patternScore: {
+        score: number;
+        matchedPatterns: any[];
+    };
+    shouldAccept: boolean;
+    shouldReview: boolean;
+    shouldReject: boolean;
+    summary: AnalysisSummary;
+}
+interface AnalysisSummary {
+    overallScore: number;
+    grade: string;
+    recommendation: 'accept' | 'review' | 'reject';
+    topIssues: string[];
+    topStrengths: string[];
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+}
+interface EngineStats {
+    totalAnalyzed: number;
+    accepted: number;
+    rejected: number;
+    reviewed: number;
+    averageConfidence: number;
+    hallucinationsDetected: number;
+    patternsLearned: number;
+    accuracyImprovement: number;
+}
+declare class AntiHallucinationEngine {
+    private workspaceRoot;
+    private verifier;
+    private detector;
+    private scorer;
+    private learner;
+    private optimizer;
+    private vibecheckVerifier;
+    private knowledge;
+    private statsPath;
+    private stats;
+    private lastContextUsed;
+    constructor(workspaceRoot: string);
+    /**
+     * Analyze a code suggestion through all anti-hallucination layers
+     */
+    analyze(suggestion: CodeSuggestion): Promise<AnalysisResult>;
+    /**
+     * Quick check - fast path for obvious cases
+     */
+    quickCheck(code: string): {
+        pass: boolean;
+        issues: string[];
+    };
+    /**
+     * Record user feedback for learning
+     */
+    recordFeedback(feedback: LearningFeedback): void;
+    /**
+     * Get optimized context for a request and track it for Vibecheck badge
+     */
+    getOptimizedContext(request: ContextRequest): Promise<OptimizedContext>;
+    /**
+     * Analyze and generate verified code with "Verified by Vibecheck" badge
+     * This is the main method AI agents should use
+     */
+    analyzeAndVerify(code: string, language: string, contextUsed?: ContextSource[]): Promise<{
+        analysis: AnalysisResult;
+        verifiedCode: string;
+        badge: VerificationBadge;
+    }>;
+    /**
+     * Generate a Vibecheck badge for already-analyzed code
+     */
+    generateVibecheckBadge(code: string, confidenceScore: number, confidenceGrade: string, contextUsed: ContextSource[], issues?: string[]): VerificationBadge;
+    /**
+     * Add Vibecheck badge to code
+     */
+    addVibecheckBadge(code: string, badge: VerificationBadge, language: string): string;
+    /**
+     * Check if code has a Vibecheck badge
+     */
+    hasVibecheckBadge(code: string): boolean;
+    /**
+     * Verify the integrity of a Vibecheck badge in code
+     */
+    verifyVibecheckBadge(code: string): {
+        valid: boolean;
+        metadata?: any;
+    };
+    /**
+     * Get Vibecheck verification statistics
+     */
+    getVibecheckStats(): {
+        totalVerifications: number;
+        verified: number;
+        needsReview: number;
+        avgConfidence: number;
+        topContextSources: Array<{
+            path: string;
+            count: number;
+        }>;
+    };
+    /**
+     * Update codebase knowledge (call after scanning)
+     */
+    updateKnowledge(knowledge: CodebaseKnowledge): void;
+    /**
+     * Generate analysis summary
+     */
+    private generateSummary;
+    /**
+     * Get engine statistics
+     */
+    getStats(): EngineStats;
+    /**
+     * Get detailed breakdown for dashboard
+     */
+    getDashboardData(): {
+        stats: EngineStats;
+        thresholds: {
+            accept: number;
+            review: number;
+        };
+        recentHallucinations: {
+            type: string;
+            count: number;
+        }[];
+        patternStats: LearningStats;
+        confidenceHistory: {
+            date: string;
+            avgConfidence: number;
+        }[];
+    };
+    /**
+     * Get improvement suggestions
+     */
+    getImprovementSuggestions(): string[];
+    /**
+     * Export all learned data for backup
+     */
+    exportLearnedData(): string;
+    /**
+     * Reset learning (use with caution)
+     */
+    resetLearning(): void;
+    private loadStats;
+    private saveStats;
+}
+declare function createAntiHallucinationEngine(workspaceRoot: string): AntiHallucinationEngine;
+
+/**
+ * Code Quality Analyzer
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Deep static analysis of AI-generated code
+ * - Complexity metrics and maintainability scores
+ * - Security vulnerability detection
+ * - Best practices enforcement
+ * - Code smell detection
+ */
+interface QualityMetrics {
+    complexity: ComplexityMetrics;
+    maintainability: MaintainabilityMetrics;
+    security: SecurityMetrics;
+    bestPractices: BestPracticesMetrics;
+    codeSmells: CodeSmell[];
+    overallScore: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+}
+interface ComplexityMetrics {
+    cyclomaticComplexity: number;
+    cognitiveComplexity: number;
+    nestingDepth: number;
+    linesOfCode: number;
+    functionsCount: number;
+    avgFunctionLength: number;
+    score: number;
+}
+interface MaintainabilityMetrics {
+    commentRatio: number;
+    namingQuality: number;
+    modularity: number;
+    codeReuse: number;
+    score: number;
+}
+interface SecurityMetrics {
+    vulnerabilities: SecurityVulnerability[];
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    score: number;
+}
+interface SecurityVulnerability {
+    type: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    line: number;
+    message: string;
+    fix?: string;
+}
+interface BestPracticesMetrics {
+    violations: BestPracticeViolation[];
+    adherenceScore: number;
+    score: number;
+}
+interface BestPracticeViolation {
+    rule: string;
+    severity: 'info' | 'warning' | 'error';
+    line: number;
+    message: string;
+    fix?: string;
+}
+interface CodeSmell {
+    type: string;
+    severity: 'minor' | 'major' | 'critical';
+    location: {
+        start: number;
+        end: number;
+    };
+    description: string;
+    suggestion: string;
+}
+declare class CodeQualityAnalyzer {
+    private workspaceRoot;
+    constructor(workspaceRoot: string);
+    /**
+     * Analyze code quality
+     */
+    analyze(code: string, language?: string): QualityMetrics;
+    /**
+     * Analyze code complexity
+     */
+    private analyzeComplexity;
+    /**
+     * Analyze maintainability
+     */
+    private analyzeMaintainability;
+    /**
+     * Analyze security vulnerabilities
+     */
+    private analyzeSecurity;
+    /**
+     * Analyze best practices
+     */
+    private analyzeBestPractices;
+    /**
+     * Detect code smells
+     */
+    private detectCodeSmells;
+    /**
+     * Calculate grade from score
+     */
+    private calculateGrade;
+    /**
+     * Generate quality report
+     */
+    generateReport(metrics: QualityMetrics): string;
+}
+declare function createCodeQualityAnalyzer(workspaceRoot: string): CodeQualityAnalyzer;
+
+/**
+ * Prompt Optimizer
+ *
+ * WHAT NOBODY ELSE IS DOING:
+ * - Automatically improves AI prompts to reduce hallucinations
+ * - Adds context anchors and constraints
+ * - Learns from successful/failed prompts
+ * - Generates codebase-aware prompt enhancements
+ */
+interface PromptAnalysis {
+    original: string;
+    issues: PromptIssue[];
+    suggestions: PromptSuggestion[];
+    score: number;
+    optimized: string;
+}
+interface PromptIssue {
+    type: 'vague' | 'no_context' | 'no_constraints' | 'too_broad' | 'missing_examples' | 'ambiguous';
+    severity: 'low' | 'medium' | 'high';
+    description: string;
+    location?: {
+        start: number;
+        end: number;
+    };
+}
+interface PromptSuggestion {
+    type: 'add_context' | 'add_constraint' | 'add_example' | 'be_specific' | 'add_format' | 'add_validation';
+    priority: 'low' | 'medium' | 'high';
+    suggestion: string;
+    insertion?: string;
+}
+interface OptimizationOptions {
+    addCodebaseContext: boolean;
+    addTypeConstraints: boolean;
+    addExamples: boolean;
+    addValidation: boolean;
+    maxContextTokens: number;
+    style: 'minimal' | 'detailed' | 'comprehensive';
+}
+interface PromptTemplate {
+    id: string;
+    name: string;
+    template: string;
+    variables: string[];
+    category: string;
+    successRate: number;
+    usageCount: number;
+}
+declare class PromptOptimizer {
+    private workspaceRoot;
+    private templates;
+    private promptHistory;
+    private historyPath;
+    constructor(workspaceRoot: string);
+    /**
+     * Analyze and optimize a prompt
+     */
+    optimize(prompt: string, options?: Partial<OptimizationOptions>): PromptAnalysis;
+    /**
+     * Analyze prompt for issues
+     */
+    private analyzePrompt;
+    /**
+     * Generate optimization suggestions
+     */
+    private generateSuggestions;
+    /**
+     * Apply optimizations to prompt
+     */
+    private applyOptimizations;
+    /**
+     * Insert suggestion into prompt
+     */
+    private insertSuggestion;
+    /**
+     * Generate context insertion
+     */
+    private generateContextInsertion;
+    /**
+     * Generate constraint insertion
+     */
+    private generateConstraintInsertion;
+    /**
+     * Generate context header based on style
+     */
+    private generateContextHeader;
+    /**
+     * Generate constraints footer based on style
+     */
+    private generateConstraintsFooter;
+    /**
+     * Generate validation section
+     */
+    private generateValidationSection;
+    /**
+     * Calculate prompt quality score
+     */
+    private calculateScore;
+    /**
+     * Record prompt result for learning
+     */
+    recordResult(prompt: string, success: boolean): void;
+    /**
+     * Get prompt templates
+     */
+    getTemplates(category?: string): PromptTemplate[];
+    /**
+     * Apply a template
+     */
+    applyTemplate(templateId: string, variables: Record<string, string>): string;
+    /**
+     * Get prompt improvement suggestions based on history
+     */
+    getHistoricalInsights(): {
+        successRate: number;
+        commonIssues: string[];
+        recommendations: string[];
+    };
+    /**
+     * Initialize built-in templates
+     */
+    private initializeTemplates;
+    private loadHistory;
+    private saveHistory;
+}
+declare function createPromptOptimizer(workspaceRoot: string): PromptOptimizer;
+
+/**
+ * AST-Based Code Analyzer
+ *
+ * THE MOST COMPREHENSIVE HALLUCINATION DETECTION:
+ * - Deep AST parsing for structural analysis
+ * - Token-level validation
+ * - Scope analysis for variable/function resolution
+ * - Type inference and checking
+ * - Import graph building and validation
+ * - Dead code and unreachable path detection
+ */
+interface ASTNode {
+    type: string;
+    name?: string;
+    value?: any;
+    children?: ASTNode[];
+    location: {
+        start: number;
+        end: number;
+        line: number;
+        column: number;
+    };
+    scope?: ScopeInfo;
+    metadata?: Record<string, any>;
+}
+interface ScopeInfo {
+    id: string;
+    type: 'global' | 'function' | 'block' | 'class' | 'module';
+    parent?: string;
+    variables: Map<string, VariableInfo>;
+    functions: Map<string, FunctionInfo>;
+    types: Map<string, ASTTypeInfo>;
+    imports: Map<string, ASTImportInfo>;
+}
+interface VariableInfo {
+    name: string;
+    type: string;
+    definedAt: number;
+    usedAt: number[];
+    isConst: boolean;
+    isExported: boolean;
+    value?: any;
+}
+interface FunctionInfo {
+    name: string;
+    params: ParamInfo[];
+    returnType: string;
+    isAsync: boolean;
+    isGenerator: boolean;
+    isExported: boolean;
+    definedAt: number;
+    calledAt: number[];
+    complexity: number;
+}
+interface ParamInfo {
+    name: string;
+    type: string;
+    optional: boolean;
+    defaultValue?: string;
+    rest: boolean;
+}
+interface ASTTypeInfo {
+    name: string;
+    kind: 'interface' | 'type' | 'class' | 'enum';
+    properties: Map<string, {
+        type: string;
+        optional: boolean;
+    }>;
+    methods: Map<string, FunctionInfo>;
+    extends?: string[];
+    implements?: string[];
+}
+interface ASTImportInfo {
+    source: string;
+    specifiers: {
+        name: string;
+        alias?: string;
+        isDefault: boolean;
+        isNamespace: boolean;
+    }[];
+    isTypeOnly: boolean;
+    resolvedPath?: string;
+    exists: boolean;
+}
+interface ASTAnalysisResult {
+    isValid: boolean;
+    errors: ASTError[];
+    warnings: ASTWarning[];
+    scopes: Map<string, ScopeInfo>;
+    imports: ASTImportInfo[];
+    exports: string[];
+    unresolvedReferences: UnresolvedReference[];
+    suspiciousPatterns: SuspiciousPattern[];
+    metrics: CodeMetrics;
+}
+interface ASTError {
+    type: string;
+    message: string;
+    location: {
+        line: number;
+        column: number;
+    };
+    severity: 'error' | 'critical';
+    fix?: string;
+}
+interface ASTWarning {
+    type: string;
+    message: string;
+    location: {
+        line: number;
+        column: number;
+    };
+    confidence: number;
+}
+interface UnresolvedReference {
+    name: string;
+    type: 'variable' | 'function' | 'type' | 'import';
+    location: {
+        line: number;
+        column: number;
+    };
+    possibleMatches: string[];
+}
+interface SuspiciousPattern {
+    pattern: string;
+    description: string;
+    location: {
+        line: number;
+        column: number;
+    };
+    confidence: number;
+    category: 'hallucination' | 'bug' | 'smell' | 'security';
+}
+interface CodeMetrics {
+    lines: number;
+    statements: number;
+    functions: number;
+    classes: number;
+    imports: number;
+    exports: number;
+    complexity: number;
+    depth: number;
+    maintainabilityIndex: number;
+}
+declare class ASTAnalyzer {
+    private workspaceRoot;
+    private scopeStack;
+    private globalScope;
+    private currentScopeId;
+    private knownGlobals;
+    private knownBuiltins;
+    constructor(workspaceRoot: string);
+    /**
+     * Analyze code and return comprehensive results
+     */
+    analyze(code: string, language?: string): ASTAnalysisResult;
+    /**
+     * Extract and validate imports
+     */
+    private extractImports;
+    /**
+     * Extract declarations from code
+     */
+    private extractDeclarations;
+    /**
+     * Analyze references and find unresolved ones
+     */
+    private analyzeReferences;
+    /**
+     * Detect suspicious patterns that may indicate hallucination
+     */
+    private detectSuspiciousPatterns;
+    /**
+     * Validate type consistency
+     */
+    private validateTypes;
+    /**
+     * Check for common hallucination patterns
+     */
+    private checkHallucinationPatterns;
+    /**
+     * Calculate code metrics
+     */
+    private calculateMetrics;
+    private createScope;
+    private initializeGlobals;
+    private initializeBuiltins;
+    private isKeyword;
+    private validateImportSource;
+    private isSuspiciousImport;
+    private parseParams;
+    private calculateFunctionComplexity;
+    private getLocation;
+    private getLineNumber;
+    private findSimilarIdentifiers;
+    private levenshteinDistance;
+    private looksLikeReference;
+    private guessReferenceType;
+    private inferType;
+    private typesCompatible;
+    private suggestAlternative;
+}
+declare function createASTAnalyzer(workspaceRoot: string): ASTAnalyzer;
+
+/**
+ * Package & API Verifier
+ *
+ * THE MOST COMPREHENSIVE PACKAGE VERIFICATION:
+ * - Verifies NPM packages exist
+ * - Validates package exports
+ * - Checks API signatures match documentation
+ * - Detects deprecated APIs
+ * - Validates version compatibility
+ * - Maintains local cache of known packages
+ */
+interface PackageInfo {
+    name: string;
+    version: string;
+    exports: string[];
+    types: string[];
+    deprecated: boolean;
+    lastVerified: string;
+}
+interface APISignature {
+    name: string;
+    type: 'function' | 'class' | 'constant' | 'type' | 'interface';
+    params?: {
+        name: string;
+        type: string;
+        optional: boolean;
+    }[];
+    returnType?: string;
+    isAsync?: boolean;
+    deprecated?: boolean;
+    since?: string;
+}
+interface VerificationResult {
+    valid: boolean;
+    packageExists: boolean;
+    exportExists: boolean;
+    signatureMatches: boolean;
+    issues: VerificationIssue[];
+    suggestions: string[];
+}
+interface VerificationIssue {
+    type: 'package_not_found' | 'export_not_found' | 'signature_mismatch' | 'deprecated' | 'version_incompatible';
+    message: string;
+    severity: 'error' | 'warning';
+    fix?: string;
+}
+declare class PackageVerifier {
+    private workspaceRoot;
+    private packageCache;
+    private knownPackages;
+    private cachePath;
+    constructor(workspaceRoot: string);
+    /**
+     * Verify an import statement
+     */
+    verifyImport(source: string, specifiers: string[]): VerificationResult;
+    /**
+     * Verify a function call matches expected signature
+     */
+    verifyAPICall(packageName: string, functionName: string, args: any[]): VerificationResult;
+    /**
+     * Get all exports for a package
+     */
+    getPackageExports(packageName: string): string[];
+    /**
+     * Check if a package export exists
+     */
+    exportExists(packageName: string, exportName: string): boolean;
+    private verifyRelativeImport;
+    private verifyKnownPackage;
+    private verifyInstalledPackage;
+    private verifyNodeBuiltin;
+    private isNodeBuiltin;
+    private getNodeBuiltinAPIs;
+    private isKnownFakePackage;
+    private suggestRealPackage;
+    private findSimilarPackages;
+    private findSimilarAPIs;
+    private similarity;
+    private levenshteinDistance;
+    private initializeKnownPackages;
+    private loadCache;
+    private saveCache;
+}
+declare function createPackageVerifier(workspaceRoot: string): PackageVerifier;
+
+/**
+ * Cross-File Consistency Analyzer
+ *
+ * THE MOST COMPREHENSIVE CROSS-FILE VERIFICATION:
+ * - Tracks type definitions across files
+ * - Validates import/export consistency
+ * - Detects circular dependencies
+ * - Verifies interface implementations
+ * - Checks for duplicate definitions
+ * - Analyzes call graph for dead code
+ */
+interface FileAnalysis {
+    path: string;
+    exports: CFExportInfo[];
+    imports: CFImportInfo[];
+    types: TypeDefinition[];
+    functions: FunctionDefinition[];
+    dependencies: string[];
+    dependents: string[];
+}
+interface CFExportInfo {
+    name: string;
+    type: 'function' | 'class' | 'type' | 'interface' | 'const' | 'let' | 'var' | 'enum' | 'default';
+    isReExport: boolean;
+    originalSource?: string;
+    line: number;
+}
+interface CFImportInfo {
+    source: string;
+    specifiers: {
+        name: string;
+        alias?: string;
+        isDefault: boolean;
+    }[];
+    isTypeOnly: boolean;
+    line: number;
+    resolved: boolean;
+    resolvedPath?: string;
+}
+interface TypeDefinition {
+    name: string;
+    kind: 'interface' | 'type' | 'class' | 'enum';
+    properties: {
+        name: string;
+        type: string;
+        optional: boolean;
+    }[];
+    methods: {
+        name: string;
+        params: string;
+        returnType: string;
+    }[];
+    extends?: string[];
+    implements?: string[];
+    line: number;
+}
+interface FunctionDefinition {
+    name: string;
+    params: {
+        name: string;
+        type: string;
+        optional: boolean;
+    }[];
+    returnType: string;
+    isAsync: boolean;
+    isExported: boolean;
+    line: number;
+    calls: string[];
+    calledBy: string[];
+}
+interface ConsistencyIssue {
+    type: 'missing_export' | 'missing_import' | 'type_mismatch' | 'circular_dependency' | 'duplicate_definition' | 'dead_code' | 'inconsistent_signature' | 'missing_implementation';
+    severity: 'error' | 'warning' | 'info';
+    file: string;
+    line?: number;
+    message: string;
+    relatedFiles?: string[];
+    fix?: string;
+}
+interface CrossFileAnalysisResult {
+    files: Map<string, FileAnalysis>;
+    issues: ConsistencyIssue[];
+    dependencyGraph: Map<string, Set<string>>;
+    circularDependencies: string[][];
+    unusedExports: {
+        file: string;
+        export: string;
+    }[];
+    missingTypes: {
+        file: string;
+        type: string;
+        referencedIn: string[];
+    }[];
+    duplicateDefinitions: {
+        name: string;
+        files: string[];
+    }[];
+}
+declare class CrossFileAnalyzer {
+    private workspaceRoot;
+    private fileCache;
+    private typeRegistry;
+    private exportRegistry;
+    constructor(workspaceRoot: string);
+    /**
+     * Analyze multiple files for cross-file consistency
+     */
+    analyzeProject(files: string[]): Promise<CrossFileAnalysisResult>;
+    /**
+     * Analyze a single file
+     */
+    analyzeFile(filePath: string): Promise<FileAnalysis>;
+    /**
+     * Validate code snippet against project context
+     */
+    validateSnippet(code: string, targetFile: string): ConsistencyIssue[];
+    private extractExports;
+    private extractImports;
+    private extractTypes;
+    private extractFunctions;
+    private buildTypeRegistry;
+    private buildExportRegistry;
+    private buildDependencyGraph;
+    private detectCircularDependencies;
+    private validateImports;
+    private findDuplicateDefinitions;
+    private findUnusedExports;
+    private findMissingTypes;
+    private validateImplementations;
+    private resolveImportPath;
+    private getExportType;
+    private getLineNumber;
+    private extractBraceContent;
+    private parseParams;
+    private parseTypeProperties;
+    private parseTypeMethods;
+    private parseClassProperties;
+    private parseClassMethods;
+    private extractTypeReferences;
+    private extractFunctionCalls;
+    private isBuiltinType;
+    private isBuiltinFunction;
+    private isKeyword;
+}
+declare function createCrossFileAnalyzer(workspaceRoot: string): CrossFileAnalyzer;
+
+export { type AHFunctionInfo, type AHMethodInfo, type AHParameterInfo, type AHPropertyInfo, type AHRouteInfo, type APISignature, type ASTAnalysisResult, ASTAnalyzer, type ASTError, type ASTImportInfo, type ASTNode, type ASTTypeInfo, type ASTWarning, type AnalysisResult, type AnalysisSummary, AntiHallucinationEngine, type AuthRule, type BestPracticeViolation, type BestPracticesMetrics, type CFExportInfo, type CFImportInfo, type CodeMetrics, CodeQualityAnalyzer, type CodeSmell, type CodeSuggestion, type CodebaseKnowledge, type CompletionCriteria, CompletionGuard, type CompletionResult, type ComplexityMetrics, type ConfidenceFactors, type ConfidenceScore, ConfidenceScorer, type ConsistencyIssue, type ContextChunk, type ContextCoverage, ContextOptimizer, type ContextRequest, type ContextSnapshot, type ContextSource, type ContractInfo, type ConventionRule, type CrossFileAnalysisResult, CrossFileAnalyzer, type DetectionResult, DocGuard, type DocGuardConfig, type DocGuardIssue, type DocGuardResult, type DuplicateCheckResult, type EngineStats, type EnvVarInfo, type ExportInfo, type FileAnalysis, type FileCache, type FirewallConfig, type ForgeConfig, type FunctionDefinition, type FunctionInfo, type GeneratedHook, type GeneratedRule, type GeneratedSkill, type GeneratedSubagent, type GuardrailConfig, GuardrailForge, GuardrailWatcher, HallucinationDetector, type HallucinationFingerprint, type HallucinationType, type HandoffDocument, type ImportInfo, LargeCodebaseScanner, type LargeScannerConfig, type LearnedPattern, type LearningFeedback, type LearningStats, type MaintainabilityMetrics, type OptimizationOptions, type OptimizedContext, type PackageInfo, PackageVerifier, type ParamInfo, type PatternDefinition, PatternLearner, type PatternSignature, type VerificationIssue as PkgVerificationIssue, type VerificationResult as PkgVerificationResult, type ProgressCallback, type PromptAnalysis, type PromptIssue, PromptOptimizer, type PromptSuggestion, type PromptTemplate, type PropertyInfo, type QualityMetrics, type RefreshResult, type RequiredAction, type RouteInfo, type RouteParameter, type RuleCategory, type ScanError, type ScanProgress, type ScannerConfig, type ScopeInfo, type SecurityMetrics, type SecurityVulnerability, SemanticVerifier, type StopValidation, type SuspiciousPattern, type Task, type TaskCheckpoint, type TaskStep, type TaskSummary, TaskTracker, type TruthpackData, type TruthpackMeta, TruthpackScanner, type TypeDefinition, type TypeInfo, type UnresolvedReference, type VariableInfo, type VerificationBadge, type VerificationIssue$1 as VerificationIssue, type VerificationMetadata, type VerificationMetrics, type VerificationOptions, type VerificationResult$1 as VerificationResult, VibecheckVerifier, type WatcherEvent, type WatcherOptions, createASTAnalyzer, createAntiHallucinationEngine, createCodeQualityAnalyzer, createCompletionGuard, createCrossFileAnalyzer, createDocGuard, createPackageVerifier, createPromptOptimizer, createTaskTracker, estimateCodebaseSize, evaluateDoc, forge, generateQuickBadge, loadTruthpack, refreshGuardrails, saveTruthpack, scanLargeCodebase, scanTruthpack, shouldBlock, startWatcher };