structx 1.0.0

package/dist/cli.js

@@ -0,0 +1,753 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const config_1 = require("./config");
+const connection_1 = require("./db/connection");
+const queries_1 = require("./db/queries");
+const logger_1 = require("./utils/logger");
+const scanner_1 = require("./ingest/scanner");
+const parser_1 = require("./ingest/parser");
+const relationships_1 = require("./ingest/relationships");
+const differ_1 = require("./ingest/differ");
+const analyzer_1 = require("./semantic/analyzer");
+const cost_1 = require("./semantic/cost");
+const queries_2 = require("./db/queries");
+const classifier_1 = require("./query/classifier");
+const retriever_1 = require("./query/retriever");
+const context_builder_1 = require("./query/context-builder");
+const answerer_1 = require("./query/answerer");
+const runner_1 = require("./benchmark/runner");
+const reporter_1 = require("./benchmark/reporter");
+const program = new commander_1.Command();
+program
+    .name('structx')
+    .description('Graph-powered code intelligence CLI for TypeScript')
+    .version('1.0.0')
+    .option('--verbose', 'Enable verbose logging')
+    .hook('preAction', (thisCommand) => {
+    if (thisCommand.opts().verbose) {
+        (0, logger_1.setLogLevel)('debug');
+    }
+});
+// ── setup (one-step bootstrap) ──
+program
+    .command('setup')
+    .description('One-step bootstrap: init + ingest + analyze')
+    .argument('[repo-path]', 'Path to TypeScript repository', '.')
+    .action(async (repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    // Step 1: Init
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    if (fs.existsSync(dbPath)) {
+        console.log(`StructX already initialized at ${structxDir}`);
+    }
+    else {
+        const db = (0, connection_1.initializeDatabase)(dbPath);
+        db.close();
+        (0, config_1.saveConfig)(structxDir, { repoPath: resolved });
+        console.log(`Initialized StructX at ${structxDir}`);
+    }
+    // Step 2: Ingest
+    const config = (0, config_1.loadConfig)(structxDir);
+    const db = (0, connection_1.openDatabase)(dbPath);
+    const project = (0, parser_1.createProject)(resolved);
+    console.log(`\nScanning ${resolved} for TypeScript files...`);
+    const files = (0, scanner_1.scanDirectory)(resolved);
+    console.log(`Found ${files.length} TypeScript files.`);
+    let newFiles = 0;
+    let changedFiles = 0;
+    let unchangedFiles = 0;
+    let totalFunctions = 0;
+    let totalRelationships = 0;
+    let queued = 0;
+    for (const filePath of files) {
+        const relativePath = path.relative(resolved, filePath);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const contentHash = (0, parser_1.hashFileContent)(content);
+        const existingFile = (0, queries_1.getFileByPath)(db, relativePath);
+        if (existingFile && existingFile.content_hash === contentHash) {
+            unchangedFiles++;
+            continue;
+        }
+        const isNew = !existingFile;
+        if (isNew)
+            newFiles++;
+        else
+            changedFiles++;
+        const fileId = (0, queries_1.upsertFile)(db, relativePath, contentHash);
+        const oldFunctions = isNew ? [] : (0, queries_1.getFunctionsByFileId)(db, fileId);
+        const oldFunctionMap = new Map(oldFunctions.map(f => [f.name, f]));
+        if (!isNew) {
+            for (const oldFn of oldFunctions) {
+                (0, queries_1.deleteRelationshipsByCallerFunctionId)(db, oldFn.id);
+            }
+            (0, queries_1.deleteFunctionsByFileId)(db, fileId);
+        }
+        let functions;
+        try {
+            functions = (0, parser_1.parseFile)(project, filePath);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to parse ${relativePath}: ${err.message}`);
+            continue;
+        }
+        const functionIdMap = new Map();
+        for (const fn of functions) {
+            const fnId = (0, queries_1.insertFunction)(db, {
+                file_id: fileId,
+                name: fn.name,
+                signature: fn.signature,
+                body: fn.body,
+                code_hash: fn.codeHash,
+                start_line: fn.startLine,
+                end_line: fn.endLine,
+                is_exported: fn.isExported,
+                is_async: fn.isAsync,
+            });
+            functionIdMap.set(fn.name, fnId);
+            totalFunctions++;
+            const oldFn = oldFunctionMap.get(fn.name);
+            if (!oldFn) {
+                (0, queries_1.enqueueForAnalysis)(db, fnId, 'new', (0, differ_1.getPriority)('new', fn.isExported));
+                queued++;
+            }
+            else {
+                const { reanalyze, reason } = (0, differ_1.shouldReanalyze)(oldFn, fn.signature, fn.codeHash, fn.body, config.diffThreshold);
+                if (reanalyze) {
+                    (0, queries_1.enqueueForAnalysis)(db, fnId, reason, (0, differ_1.getPriority)(reason, fn.isExported));
+                    queued++;
+                }
+            }
+        }
+        try {
+            const calls = (0, relationships_1.extractCallsFromFile)(project, filePath);
+            for (const call of calls) {
+                if (call.callerName === '__file__')
+                    continue;
+                const callerId = functionIdMap.get(call.callerName);
+                if (!callerId)
+                    continue;
+                const callee = (0, queries_1.getFunctionByName)(db, call.calleeName);
+                (0, queries_1.insertRelationship)(db, callerId, call.calleeName, call.relationType, callee?.id);
+                totalRelationships++;
+            }
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to extract calls from ${relativePath}: ${err.message}`);
+        }
+    }
+    console.log(`\nIngestion complete:`);
+    console.log(`  New files:       ${newFiles}`);
+    console.log(`  Changed files:   ${changedFiles}`);
+    console.log(`  Unchanged:       ${unchangedFiles}`);
+    console.log(`  Functions:       ${totalFunctions}`);
+    console.log(`  Relationships:   ${totalRelationships}`);
+    console.log(`  Queued:          ${queued} functions for semantic analysis`);
+    // Step 3: Analyze (auto-confirm)
+    if (queued > 0 && config.anthropicApiKey) {
+        const pendingCount = (0, queries_2.getPendingAnalysisCount)(db);
+        const estimate = (0, cost_1.estimateAnalysisCost)(pendingCount, config.batchSize, config.analysisModel);
+        console.log('\n' + (0, cost_1.formatCostEstimate)(estimate));
+        console.log('\nAnalyzing...');
+        let totalAnalyzed = 0;
+        let totalCached = 0;
+        let totalFailed = 0;
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let totalCost = 0;
+        let batchNum = 0;
+        while (true) {
+            const pending = (0, queries_2.getPendingAnalysis)(db, config.batchSize);
+            if (pending.length === 0)
+                break;
+            batchNum++;
+            const items = pending.map(p => ({ id: p.id, function_id: p.function_id }));
+            console.log(`  Batch ${batchNum}: ${items.length} functions...`);
+            const batchResult = await (0, analyzer_1.analyzeBatch)(db, items, config.analysisModel, config.anthropicApiKey);
+            totalAnalyzed += batchResult.analyzed;
+            totalCached += batchResult.cached;
+            totalFailed += batchResult.failed;
+            totalInputTokens += batchResult.totalInputTokens;
+            totalOutputTokens += batchResult.totalOutputTokens;
+            totalCost += batchResult.totalCost;
+        }
+        (0, analyzer_1.rebuildSearchIndex)(db);
+        console.log(`\nAnalysis complete:`);
+        console.log(`  Analyzed:       ${totalAnalyzed}`);
+        console.log(`  From cache:     ${totalCached}`);
+        console.log(`  Failed:         ${totalFailed}`);
+        console.log(`  Input tokens:   ${totalInputTokens.toLocaleString()}`);
+        console.log(`  Output tokens:  ${totalOutputTokens.toLocaleString()}`);
+        console.log(`  Total cost:     $${totalCost.toFixed(4)}`);
+    }
+    else if (queued > 0) {
+        console.log('\nSkipping analysis: ANTHROPIC_API_KEY not set.');
+        console.log('Set the key and run "structx analyze . --yes" to enrich functions.');
+    }
+    else {
+        console.log('\nNo functions to analyze.');
+    }
+    db.close();
+    console.log('\nSetup complete.');
+});
+// ── install (drop instruction files into project) ──
+program
+    .command('install')
+    .description('Install AI agent instruction files into a project')
+    .argument('[repo-path]', 'Path to target project', '.')
+    .action((repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const instructionsDir = path.join(__dirname, 'instructions');
+    if (!fs.existsSync(instructionsDir)) {
+        console.log('Instruction templates not found. Package may be incorrectly installed.');
+        return;
+    }
+    const genericContent = fs.readFileSync(path.join(instructionsDir, 'generic.md'), 'utf-8');
+    let installed = 0;
+    // CLAUDE.md — append if exists, create if not
+    const claudeMdPath = path.join(resolved, 'CLAUDE.md');
+    const claudeContent = fs.readFileSync(path.join(instructionsDir, 'claude.md'), 'utf-8');
+    if (fs.existsSync(claudeMdPath)) {
+        const existing = fs.readFileSync(claudeMdPath, 'utf-8');
+        if (existing.includes('StructX')) {
+            console.log('  CLAUDE.md — already contains StructX section, skipping.');
+        }
+        else {
+            fs.appendFileSync(claudeMdPath, '\n\n' + claudeContent, 'utf-8');
+            console.log('  CLAUDE.md — appended StructX section.');
+            installed++;
+        }
+    }
+    else {
+        fs.writeFileSync(claudeMdPath, claudeContent, 'utf-8');
+        console.log('  CLAUDE.md — created.');
+        installed++;
+    }
+    // .cursorrules
+    const cursorPath = path.join(resolved, '.cursorrules');
+    const cursorContent = fs.readFileSync(path.join(instructionsDir, 'cursor.md'), 'utf-8');
+    if (fs.existsSync(cursorPath)) {
+        const existing = fs.readFileSync(cursorPath, 'utf-8');
+        if (existing.includes('StructX')) {
+            console.log('  .cursorrules — already contains StructX section, skipping.');
+        }
+        else {
+            fs.appendFileSync(cursorPath, '\n\n' + cursorContent, 'utf-8');
+            console.log('  .cursorrules — appended StructX section.');
+            installed++;
+        }
+    }
+    else {
+        fs.writeFileSync(cursorPath, cursorContent, 'utf-8');
+        console.log('  .cursorrules — created.');
+        installed++;
+    }
+    // .github/copilot-instructions.md
+    const githubDir = path.join(resolved, '.github');
+    const copilotPath = path.join(githubDir, 'copilot-instructions.md');
+    const copilotContent = fs.readFileSync(path.join(instructionsDir, 'copilot.md'), 'utf-8');
+    if (!fs.existsSync(githubDir)) {
+        fs.mkdirSync(githubDir, { recursive: true });
+    }
+    if (fs.existsSync(copilotPath)) {
+        const existing = fs.readFileSync(copilotPath, 'utf-8');
+        if (existing.includes('StructX')) {
+            console.log('  .github/copilot-instructions.md — already contains StructX section, skipping.');
+        }
+        else {
+            fs.appendFileSync(copilotPath, '\n\n' + copilotContent, 'utf-8');
+            console.log('  .github/copilot-instructions.md — appended StructX section.');
+            installed++;
+        }
+    }
+    else {
+        fs.writeFileSync(copilotPath, copilotContent, 'utf-8');
+        console.log('  .github/copilot-instructions.md — created.');
+        installed++;
+    }
+    console.log(`\nInstalled ${installed} instruction file(s) into ${resolved}`);
+});
+// ── init ──
+program
+    .command('init')
+    .description('Initialize StructX for the current repository')
+    .argument('[repo-path]', 'Path to TypeScript repository', '.')
+    .action((repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    if (fs.existsSync((0, connection_1.getDbPath)(structxDir))) {
+        console.log(`StructX already initialized at ${structxDir}`);
+        return;
+    }
+    // Create DB
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    const db = (0, connection_1.initializeDatabase)(dbPath);
+    db.close();
+    // Create config
+    (0, config_1.saveConfig)(structxDir, {
+        repoPath: resolved,
+    });
+    console.log(`Initialized StructX at ${structxDir}`);
+    console.log(`  Database: ${dbPath}`);
+    console.log(`  Config:   ${path.join(structxDir, 'config.json')}`);
+    console.log(`\nNext: run 'structx ingest ${repoPath}' to parse your codebase.`);
+});
+// ── status ──
+program
+    .command('status')
+    .description('Show current StructX statistics')
+    .argument('[repo-path]', 'Path to TypeScript repository', '.')
+    .action((repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    if (!fs.existsSync(dbPath)) {
+        console.log('StructX not initialized. Run "structx init" first.');
+        return;
+    }
+    const db = (0, connection_1.openDatabase)(dbPath);
+    const stats = (0, queries_1.getStats)(db);
+    db.close();
+    console.log('StructX Status');
+    console.log('──────────────────────────');
+    console.log(`  Files:           ${stats.totalFiles}`);
+    console.log(`  Functions:       ${stats.totalFunctions}`);
+    console.log(`  Relationships:   ${stats.totalRelationships}`);
+    console.log(`  Analyzed:        ${stats.analyzedFunctions} / ${stats.totalFunctions}`);
+    console.log(`  Pending:         ${stats.pendingAnalysis}`);
+    console.log(`  QA Runs:         ${stats.totalQaRuns}`);
+});
+// ── doctor ──
+program
+    .command('doctor')
+    .description('Validate StructX environment and configuration')
+    .argument('[repo-path]', 'Path to TypeScript repository', '.')
+    .action((repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    let allGood = true;
+    // Check Node version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    if (major >= 18) {
+        console.log(`  [OK] Node.js ${nodeVersion}`);
+    }
+    else {
+        console.log(`  [FAIL] Node.js ${nodeVersion} (requires >= 18)`);
+        allGood = false;
+    }
+    // Check DB
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    if (fs.existsSync(dbPath)) {
+        console.log(`  [OK] Database exists at ${dbPath}`);
+    }
+    else {
+        console.log(`  [FAIL] Database not found. Run 'structx init' first.`);
+        allGood = false;
+    }
+    // Check config
+    try {
+        const config = (0, config_1.loadConfig)(structxDir);
+        // Check API key
+        if (config.anthropicApiKey) {
+            console.log('  [OK] Anthropic API key is set');
+        }
+        else {
+            console.log('  [WARN] Anthropic API key not set (set ANTHROPIC_API_KEY env var or add to config)');
+            allGood = false;
+        }
+        // Check repo path
+        if (fs.existsSync(config.repoPath)) {
+            console.log(`  [OK] Repository path: ${config.repoPath}`);
+        }
+        else {
+            console.log(`  [FAIL] Repository path not found: ${config.repoPath}`);
+            allGood = false;
+        }
+    }
+    catch {
+        console.log('  [FAIL] Config not found. Run "structx init" first.');
+        allGood = false;
+    }
+    console.log();
+    if (allGood) {
+        console.log('All checks passed.');
+    }
+    else {
+        console.log('Some checks failed. Fix the issues above and try again.');
+    }
+});
+// ── ingest ──
+program
+    .command('ingest')
+    .description('Parse codebase into function graph')
+    .argument('[repo-path]', 'Path to TypeScript repository', '.')
+    .action((repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    if (!fs.existsSync(dbPath)) {
+        console.log('StructX not initialized. Run "structx init" first.');
+        return;
+    }
+    const config = (0, config_1.loadConfig)(structxDir);
+    const db = (0, connection_1.openDatabase)(dbPath);
+    const project = (0, parser_1.createProject)(resolved);
+    console.log(`Scanning ${resolved} for TypeScript files...`);
+    const files = (0, scanner_1.scanDirectory)(resolved);
+    console.log(`Found ${files.length} TypeScript files.`);
+    let newFiles = 0;
+    let changedFiles = 0;
+    let unchangedFiles = 0;
+    let totalFunctions = 0;
+    let totalRelationships = 0;
+    let queued = 0;
+    for (const filePath of files) {
+        const relativePath = path.relative(resolved, filePath);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const contentHash = (0, parser_1.hashFileContent)(content);
+        // Check if file changed
+        const existingFile = (0, queries_1.getFileByPath)(db, relativePath);
+        if (existingFile && existingFile.content_hash === contentHash) {
+            unchangedFiles++;
+            continue;
+        }
+        const isNew = !existingFile;
+        if (isNew)
+            newFiles++;
+        else
+            changedFiles++;
+        // Upsert file record
+        const fileId = (0, queries_1.upsertFile)(db, relativePath, contentHash);
+        // Get old functions for diff comparison
+        const oldFunctions = isNew ? [] : (0, queries_1.getFunctionsByFileId)(db, fileId);
+        const oldFunctionMap = new Map(oldFunctions.map(f => [f.name, f]));
+        // Clear old data for this file
+        if (!isNew) {
+            // Delete relationships for all old functions in this file
+            for (const oldFn of oldFunctions) {
+                (0, queries_1.deleteRelationshipsByCallerFunctionId)(db, oldFn.id);
+            }
+            (0, queries_1.deleteFunctionsByFileId)(db, fileId);
+        }
+        // Parse functions
+        let functions;
+        try {
+            functions = (0, parser_1.parseFile)(project, filePath);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to parse ${relativePath}: ${err.message}`);
+            continue;
+        }
+        // Insert functions and check for re-analysis needs
+        const functionIdMap = new Map();
+        for (const fn of functions) {
+            const fnId = (0, queries_1.insertFunction)(db, {
+                file_id: fileId,
+                name: fn.name,
+                signature: fn.signature,
+                body: fn.body,
+                code_hash: fn.codeHash,
+                start_line: fn.startLine,
+                end_line: fn.endLine,
+                is_exported: fn.isExported,
+                is_async: fn.isAsync,
+            });
+            functionIdMap.set(fn.name, fnId);
+            totalFunctions++;
+            // Determine if we need semantic re-analysis
+            const oldFn = oldFunctionMap.get(fn.name);
+            if (!oldFn) {
+                // New function — queue for analysis
+                (0, queries_1.enqueueForAnalysis)(db, fnId, 'new', (0, differ_1.getPriority)('new', fn.isExported));
+                queued++;
+            }
+            else {
+                const { reanalyze, reason } = (0, differ_1.shouldReanalyze)(oldFn, fn.signature, fn.codeHash, fn.body, config.diffThreshold);
+                if (reanalyze) {
+                    (0, queries_1.enqueueForAnalysis)(db, fnId, reason, (0, differ_1.getPriority)(reason, fn.isExported));
+                    queued++;
+                }
+            }
+        }
+        // Extract and insert relationships
+        try {
+            const calls = (0, relationships_1.extractCallsFromFile)(project, filePath);
+            for (const call of calls) {
+                if (call.callerName === '__file__')
+                    continue; // Skip file-level imports for now
+                const callerId = functionIdMap.get(call.callerName);
+                if (!callerId)
+                    continue;
+                // Try to resolve callee to a function ID
+                const callee = (0, queries_1.getFunctionByName)(db, call.calleeName);
+                (0, queries_1.insertRelationship)(db, callerId, call.calleeName, call.relationType, callee?.id);
+                totalRelationships++;
+            }
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to extract calls from ${relativePath}: ${err.message}`);
+        }
+    }
+    db.close();
+    console.log(`\nIngestion complete:`);
+    console.log(`  New files:       ${newFiles}`);
+    console.log(`  Changed files:   ${changedFiles}`);
+    console.log(`  Unchanged:       ${unchangedFiles}`);
+    console.log(`  Functions:       ${totalFunctions}`);
+    console.log(`  Relationships:   ${totalRelationships}`);
+    console.log(`  Queued:          ${queued} functions for semantic analysis`);
+    if (queued > 0) {
+        console.log(`\nNext: run 'structx analyze' to enrich functions with semantic metadata.`);
+    }
+});
+// ── analyze ──
+program
+    .command('analyze')
+    .description('Run LLM semantic analysis on extracted functions')
+    .argument('[repo-path]', 'Path to TypeScript repository', '.')
+    .option('--yes', 'Skip cost confirmation prompt')
+    .action(async (repoPath, opts) => {
+    const resolved = path.resolve(repoPath);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    if (!fs.existsSync(dbPath)) {
+        console.log('StructX not initialized. Run "structx init" first.');
+        return;
+    }
+    const config = (0, config_1.loadConfig)(structxDir);
+    if (!config.anthropicApiKey) {
+        console.log('Anthropic API key not set. Set ANTHROPIC_API_KEY env var or add to .structx/config.json');
+        return;
+    }
+    const db = (0, connection_1.openDatabase)(dbPath);
+    const pendingCount = (0, queries_2.getPendingAnalysisCount)(db);
+    if (pendingCount === 0) {
+        console.log('No functions pending analysis. Run "structx ingest" first.');
+        db.close();
+        return;
+    }
+    // Show cost estimate
+    const estimate = (0, cost_1.estimateAnalysisCost)(pendingCount, config.batchSize, config.analysisModel);
+    console.log('\n' + (0, cost_1.formatCostEstimate)(estimate));
+    if (!opts.yes) {
+        const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(resolve => {
+            rl.question('\nProceed? [y/N] ', resolve);
+        });
+        rl.close();
+        if (answer.toLowerCase() !== 'y') {
+            console.log('Aborted.');
+            db.close();
+            return;
+        }
+    }
+    console.log('\nAnalyzing...');
+    let totalAnalyzed = 0;
+    let totalCached = 0;
+    let totalFailed = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCost = 0;
+    let batchNum = 0;
+    while (true) {
+        const pending = (0, queries_2.getPendingAnalysis)(db, config.batchSize);
+        if (pending.length === 0)
+            break;
+        batchNum++;
+        const items = pending.map(p => ({ id: p.id, function_id: p.function_id }));
+        console.log(`  Batch ${batchNum}: ${items.length} functions...`);
+        const batchResult = await (0, analyzer_1.analyzeBatch)(db, items, config.analysisModel, config.anthropicApiKey);
+        totalAnalyzed += batchResult.analyzed;
+        totalCached += batchResult.cached;
+        totalFailed += batchResult.failed;
+        totalInputTokens += batchResult.totalInputTokens;
+        totalOutputTokens += batchResult.totalOutputTokens;
+        totalCost += batchResult.totalCost;
+    }
+    // Rebuild FTS index
+    (0, analyzer_1.rebuildSearchIndex)(db);
+    db.close();
+    console.log(`\nAnalysis complete:`);
+    console.log(`  Analyzed:       ${totalAnalyzed}`);
+    console.log(`  From cache:     ${totalCached}`);
+    console.log(`  Failed:         ${totalFailed}`);
+    console.log(`  Input tokens:   ${totalInputTokens.toLocaleString()}`);
+    console.log(`  Output tokens:  ${totalOutputTokens.toLocaleString()}`);
+    console.log(`  Total cost:     $${totalCost.toFixed(4)}`);
+});
+// ── ask ──
+program
+    .command('ask')
+    .description('Ask a question about the codebase')
+    .argument('<question>', 'The question to ask')
+    .option('--repo <path>', 'Path to TypeScript repository', '.')
+    .action(async (question, opts) => {
+    const resolved = path.resolve(opts.repo);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    if (!fs.existsSync(dbPath)) {
+        console.log('StructX not initialized. Run "structx init" first.');
+        return;
+    }
+    const config = (0, config_1.loadConfig)(structxDir);
+    if (!config.anthropicApiKey) {
+        console.log('Anthropic API key not set. Set ANTHROPIC_API_KEY env var or add to .structx/config.json');
+        return;
+    }
+    const db = (0, connection_1.openDatabase)(dbPath);
+    const startTime = Date.now();
+    // Step 1: Classify the question
+    console.log('Classifying question...');
+    const classification = await (0, classifier_1.classifyQuestion)(question, config.classifierModel, config.anthropicApiKey);
+    logger_1.logger.debug('Classification', classification);
+    // Step 2: Retrieve context
+    console.log(`Retrieving context (strategy: ${classification.strategy})...`);
+    const graphQueryStart = Date.now();
+    let retrieved;
+    switch (classification.strategy) {
+        case 'direct':
+            retrieved = (0, retriever_1.directLookup)(db, classification.functionName || '');
+            break;
+        case 'relationship':
+            retrieved = (0, retriever_1.relationshipQuery)(db, classification.functionName || '', classification.direction || 'callers');
+            break;
+        case 'semantic':
+            retrieved = (0, retriever_1.semanticSearch)(db, classification.keywords);
+            break;
+        case 'domain':
+            retrieved = (0, retriever_1.domainQuery)(db, classification.domain || 'other');
+            break;
+        case 'impact':
+            retrieved = (0, retriever_1.impactAnalysis)(db, classification.functionName || '');
+            break;
+        default:
+            retrieved = (0, retriever_1.semanticSearch)(db, classification.keywords);
+    }
+    const graphQueryTimeMs = Date.now() - graphQueryStart;
+    // Step 3: Build context
+    const context = (0, context_builder_1.buildContext)(retrieved, question);
+    // Step 4: Generate answer
+    console.log('Generating answer...\n');
+    const answerResult = await (0, answerer_1.generateAnswer)(question, context, config.answerModel, config.anthropicApiKey);
+    // Display answer
+    console.log('─'.repeat(60));
+    console.log(answerResult.answer);
+    console.log('─'.repeat(60));
+    console.log(`\nStrategy: ${classification.strategy} | Functions: ${retrieved.functions.length} | Graph query: ${graphQueryTimeMs}ms`);
+    console.log(`Tokens: ${answerResult.inputTokens} in / ${answerResult.outputTokens} out | Cost: $${answerResult.cost.toFixed(4)} | Time: ${answerResult.responseTimeMs}ms`);
+    // Save run to DB
+    (0, queries_2.insertQaRun)(db, {
+        mode: 'structx',
+        question,
+        input_tokens: answerResult.inputTokens,
+        output_tokens: answerResult.outputTokens,
+        total_tokens: answerResult.inputTokens + answerResult.outputTokens,
+        cost_usd: answerResult.cost,
+        response_time_ms: answerResult.responseTimeMs,
+        files_accessed: null,
+        functions_retrieved: retrieved.functions.length,
+        graph_query_time_ms: graphQueryTimeMs,
+        answer_text: answerResult.answer,
+    });
+    db.close();
+});
+// ── benchmark (placeholder) ──
+const benchmarkCmd = program
+    .command('benchmark')
+    .description('Run and view benchmark comparisons');
+benchmarkCmd
+    .command('run')
+    .description('Run comparison benchmark')
+    .option('--repo <path>', 'Path to TypeScript repository', '.')
+    .action(async (opts) => {
+    const resolved = path.resolve(opts.repo);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    const dbPath = (0, connection_1.getDbPath)(structxDir);
+    if (!fs.existsSync(dbPath)) {
+        console.log('StructX not initialized. Run "structx init" first.');
+        return;
+    }
+    const config = (0, config_1.loadConfig)(structxDir);
+    if (!config.anthropicApiKey) {
+        console.log('Anthropic API key not set.');
+        return;
+    }
+    const db = (0, connection_1.openDatabase)(dbPath);
+    console.log('Starting benchmark...');
+    console.log('Running 8 questions in both StructX and Traditional modes.\n');
+    const results = await (0, runner_1.runBenchmark)(db, config);
+    // Generate and save reports
+    const markdown = (0, reporter_1.generateMarkdownReport)(results);
+    const csv = (0, reporter_1.generateCsvReport)(results);
+    const { markdownPath, csvPath } = (0, reporter_1.saveReport)(structxDir, markdown, csv);
+    console.log(`\nReports saved:`);
+    console.log(`  Markdown: ${markdownPath}`);
+    console.log(`  CSV:      ${csvPath}`);
+    db.close();
+});
+benchmarkCmd
+    .command('report')
+    .description('Show latest benchmark report')
+    .option('--repo <path>', 'Path to TypeScript repository', '.')
+    .action((opts) => {
+    const resolved = path.resolve(opts.repo);
+    const structxDir = (0, config_1.getStructXDir)(resolved);
+    const reportsDir = path.join(structxDir, 'reports');
+    if (!fs.existsSync(reportsDir)) {
+        console.log('No benchmark reports found. Run "structx benchmark run" first.');
+        return;
+    }
+    // Find latest markdown report
+    const files = fs.readdirSync(reportsDir)
+        .filter(f => f.endsWith('.md'))
+        .sort()
+        .reverse();
+    if (files.length === 0) {
+        console.log('No benchmark reports found. Run "structx benchmark run" first.');
+        return;
+    }
+    const latestReport = fs.readFileSync(path.join(reportsDir, files[0]), 'utf-8');
+    console.log(latestReport);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map