preflight-mcp 0.1.2 → 0.1.4

package/dist/http/server.js

@@ -0,0 +1,109 @@
+import http from 'node:http';
+import { URL } from 'node:url';
+import { logger } from '../logging/logger.js';
+import { wrapPreflightError } from '../mcp/errorKinds.js';
+import { generateDependencyGraph } from '../evidence/dependencyGraph.js';
+import { traceQuery, traceUpsert } from '../trace/service.js';
+function sendJson(res, status, body) {
+    const text = JSON.stringify(body, null, 2);
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json; charset=utf-8');
+    res.setHeader('cache-control', 'no-store');
+    res.end(text);
+}
+async function readJsonBody(req, maxBytes) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buf.length;
+        if (total > maxBytes) {
+            throw new Error(`Request body too large (>${maxBytes} bytes)`);
+        }
+        chunks.push(buf);
+    }
+    const raw = Buffer.concat(chunks).toString('utf8');
+    if (!raw.trim())
+        return {};
+    return JSON.parse(raw);
+}
+export function startHttpServer(cfg) {
+    if (!cfg.httpEnabled) {
+        logger.info('REST API disabled (PREFLIGHT_HTTP_ENABLED=false)');
+        return null;
+    }
+    const server = http.createServer(async (req, res) => {
+        try {
+            const method = (req.method ?? 'GET').toUpperCase();
+            const url = new URL(req.url ?? '/', `http://${cfg.httpHost}:${cfg.httpPort}`);
+            const pathname = url.pathname;
+            // Basic CORS (local development convenience). Keep permissive but local-only by default host.
+            res.setHeader('access-control-allow-origin', '*');
+            res.setHeader('access-control-allow-headers', 'content-type');
+            res.setHeader('access-control-allow-methods', 'GET,POST,OPTIONS');
+            if (method === 'OPTIONS') {
+                res.statusCode = 204;
+                res.end();
+                return;
+            }
+            if (method === 'GET' && pathname === '/health') {
+                sendJson(res, 200, { ok: true, name: 'preflight-mcp', time: new Date().toISOString() });
+                return;
+            }
+            if (method === 'POST' && pathname === '/api/v1/evidence/dependency-graph') {
+                const body = await readJsonBody(req, 2_000_000);
+                const out = await generateDependencyGraph(cfg, body);
+                sendJson(res, 200, out);
+                return;
+            }
+            if (method === 'POST' && pathname === '/api/v1/trace/upsert') {
+                const body = await readJsonBody(req, 2_000_000);
+                const out = await traceUpsert(cfg, body);
+                sendJson(res, 200, out);
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/v1/trace') {
+                const query = Object.fromEntries(url.searchParams.entries());
+                // Convert known numeric params
+                const body = { ...query };
+                if (typeof query.limit === 'string')
+                    body.limit = Number(query.limit);
+                if (typeof query.timeBudgetMs === 'string')
+                    body.timeBudgetMs = Number(query.timeBudgetMs);
+                if (typeof query.maxBundles === 'string')
+                    body.maxBundles = Number(query.maxBundles);
+                const out = await traceQuery(cfg, body);
+                sendJson(res, 200, out);
+                return;
+            }
+            sendJson(res, 404, { error: { message: `Not found: ${method} ${pathname}` } });
+        }
+        catch (err) {
+            const wrapped = wrapPreflightError(err);
+            sendJson(res, 400, { error: { message: wrapped.message } });
+        }
+    });
+    server.on('error', (err) => {
+        // Non-fatal: MCP should still work.
+        logger.warn(`REST server error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+    try {
+        server.listen(cfg.httpPort, cfg.httpHost, () => {
+            logger.info(`REST API listening on http://${cfg.httpHost}:${cfg.httpPort}`);
+        });
+        // Allow process to exit if stdio transport closes.
+        server.unref();
+        return {
+            host: cfg.httpHost,
+            port: cfg.httpPort,
+            close: () => new Promise((resolve) => {
+                server.close(() => resolve());
+            }),
+        };
+    }
+    catch (err) {
+        // Binding failures should not crash MCP.
+        logger.warn(`Failed to start REST API server: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/dist/jobs/progressTracker.js

@@ -0,0 +1,191 @@
+/**
+ * Progress tracking for long-running bundle creation tasks.
+ * Enables progress notifications via MCP and prevents duplicate task creation.
+ */
+import crypto from 'node:crypto';
+function nowIso() {
+    return new Date().toISOString();
+}
+/**
+ * Tracks progress of bundle creation tasks.
+ * Provides in-memory state for active tasks and emits progress updates.
+ */
+export class ProgressTracker {
+    tasks = new Map();
+    fingerprintToTaskId = new Map();
+    progressCallback;
+    /**
+     * Set a callback to receive progress updates.
+     * Used to forward updates to MCP progress notifications.
+     */
+    setProgressCallback(callback) {
+        this.progressCallback = callback;
+    }
+    /**
+     * Start tracking a new task.
+     * @returns taskId for the new task
+     */
+    startTask(fingerprint, repos) {
+        // Check if task already exists for this fingerprint
+        const existingTaskId = this.fingerprintToTaskId.get(fingerprint);
+        if (existingTaskId) {
+            const existingTask = this.tasks.get(existingTaskId);
+            if (existingTask && existingTask.phase !== 'complete' && existingTask.phase !== 'failed') {
+                // Return existing active task
+                return existingTaskId;
+            }
+        }
+        const taskId = crypto.randomUUID();
+        const now = nowIso();
+        const task = {
+            taskId,
+            fingerprint,
+            phase: 'starting',
+            progress: 0,
+            message: `Starting bundle creation for ${repos.join(', ')}`,
+            startedAt: now,
+            updatedAt: now,
+            repos,
+        };
+        this.tasks.set(taskId, task);
+        this.fingerprintToTaskId.set(fingerprint, taskId);
+        this.emitProgress(task);
+        return taskId;
+    }
+    /**
+     * Update progress for an existing task.
+     */
+    updateProgress(taskId, phase, progress, message, total) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        task.phase = phase;
+        task.progress = progress;
+        task.message = message;
+        task.updatedAt = nowIso();
+        if (total !== undefined) {
+            task.total = total;
+        }
+        this.emitProgress(task);
+    }
+    /**
+     * Mark a task as complete.
+     */
+    completeTask(taskId, bundleId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        task.phase = 'complete';
+        task.progress = 100;
+        task.message = `Bundle created: ${bundleId}`;
+        task.updatedAt = nowIso();
+        task.bundleId = bundleId;
+        this.emitProgress(task);
+        // Clean up after a delay to allow final status queries
+        setTimeout(() => {
+            this.tasks.delete(taskId);
+            if (this.fingerprintToTaskId.get(task.fingerprint) === taskId) {
+                this.fingerprintToTaskId.delete(task.fingerprint);
+            }
+        }, 60_000); // Keep completed task for 1 minute
+    }
+    /**
+     * Mark a task as failed.
+     */
+    failTask(taskId, error) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        task.phase = 'failed';
+        task.message = `Failed: ${error}`;
+        task.updatedAt = nowIso();
+        task.error = error;
+        this.emitProgress(task);
+        // Clean up after a delay
+        setTimeout(() => {
+            this.tasks.delete(taskId);
+            if (this.fingerprintToTaskId.get(task.fingerprint) === taskId) {
+                this.fingerprintToTaskId.delete(task.fingerprint);
+            }
+        }, 60_000);
+    }
+    /**
+     * Get task by ID.
+     */
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    /**
+     * Get task by fingerprint.
+     */
+    getTaskByFingerprint(fingerprint) {
+        const taskId = this.fingerprintToTaskId.get(fingerprint);
+        if (!taskId)
+            return undefined;
+        return this.tasks.get(taskId);
+    }
+    /**
+     * List all active (non-complete, non-failed) tasks.
+     */
+    listActiveTasks() {
+        return Array.from(this.tasks.values()).filter((t) => t.phase !== 'complete' && t.phase !== 'failed');
+    }
+    /**
+     * List all tasks (including recently completed/failed).
+     */
+    listAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    /**
+     * Check if a task is active (in progress).
+     */
+    isTaskActive(fingerprint) {
+        const task = this.getTaskByFingerprint(fingerprint);
+        return task !== undefined && task.phase !== 'complete' && task.phase !== 'failed';
+    }
+    /**
+     * Remove a task (e.g., when lock times out).
+     */
+    removeTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (task) {
+            this.tasks.delete(taskId);
+            if (this.fingerprintToTaskId.get(task.fingerprint) === taskId) {
+                this.fingerprintToTaskId.delete(task.fingerprint);
+            }
+        }
+    }
+    emitProgress(task) {
+        if (this.progressCallback) {
+            this.progressCallback(task);
+        }
+    }
+}
+// Singleton instance for global access
+let globalTracker;
+export function getProgressTracker() {
+    if (!globalTracker) {
+        globalTracker = new ProgressTracker();
+    }
+    return globalTracker;
+}
+/**
+ * Helper to format bytes for display.
+ */
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}
+/**
+ * Helper to calculate percentage.
+ */
+export function calcPercent(current, total) {
+    if (total <= 0)
+        return 0;
+    return Math.min(100, Math.round((current / total) * 100));
+}

package/dist/search/sqliteFts.js

@@ -278,6 +278,118 @@ export async function rebuildIndex(dbPathOrFiles, filesOrDbPath, opts) {
         db.close();
     }
 }
+/**
+ * Extract code context for a search hit.
+ * Finds the surrounding function/class definition and surrounding lines.
+ */
+function extractContext(fileContent, hitLineNo) {
+    const lines = fileContent.split('\n');
+    const hitIndex = hitLineNo - 1; // Convert 1-based to 0-based
+    if (hitIndex < 0 || hitIndex >= lines.length) {
+        return undefined;
+    }
+    // Extract surrounding lines (±3 lines)
+    const surroundStart = Math.max(0, hitIndex - 3);
+    const surroundEnd = Math.min(lines.length - 1, hitIndex + 3);
+    const surroundingLines = lines.slice(surroundStart, surroundEnd + 1);
+    // Find function/class definition by scanning upwards (max 50 lines)
+    let functionName;
+    let className;
+    let startLine = hitLineNo;
+    let endLine = hitLineNo;
+    const scanStartIndex = Math.max(0, hitIndex - 50);
+    // Patterns for TypeScript/JavaScript/Python/Go functions and classes
+    const functionPatterns = [
+        // TypeScript/JavaScript
+        /^\s*(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_$][\w$]*)\s*\(/,
+        /^\s*(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=\s*(?:async\s+)?\(/,
+        /^\s*(?:async\s+)?([a-zA-Z_$][\w$]*)\s*\([^)]*\)\s*\{/,
+        /^\s*([a-zA-Z_$][\w$]*)\s*:\s*(?:async\s+)?function\s*\(/,
+        // Python
+        /^\s*(?:async\s+)?def\s+([a-zA-Z_][\w]*)\s*\(/,
+        // Go
+        /^\s*func\s+(?:\([^)]*\)\s*)?([a-zA-Z_][\w]*)\s*\(/,
+    ];
+    const classPatterns = [
+        // TypeScript/JavaScript
+        /^\s*(?:export\s+)?(?:abstract\s+)?class\s+([a-zA-Z_$][\w$]*)/,
+        /^\s*(?:export\s+)?interface\s+([a-zA-Z_$][\w$]*)/,
+        /^\s*(?:export\s+)?type\s+([a-zA-Z_$][\w$]*)\s*=/,
+        // Python
+        /^\s*class\s+([a-zA-Z_][\w]*)\s*[:(]/,
+        // Go
+        /^\s*type\s+([a-zA-Z_][\w]*)\s+struct/,
+    ];
+    // Scan upward to find function or class definition
+    for (let i = hitIndex; i >= scanStartIndex; i--) {
+        const line = lines[i] ?? '';
+        // Try to match function patterns
+        if (!functionName) {
+            for (const pattern of functionPatterns) {
+                const match = line.match(pattern);
+                if (match?.[1]) {
+                    functionName = match[1];
+                    startLine = i + 1; // Convert to 1-based
+                    break;
+                }
+            }
+        }
+        // Try to match class patterns (only if we haven't found function yet)
+        if (!className) {
+            for (const pattern of classPatterns) {
+                const match = line.match(pattern);
+                if (match?.[1]) {
+                    className = match[1];
+                    if (!functionName) {
+                        startLine = i + 1;
+                    }
+                    break;
+                }
+            }
+        }
+        // If we found function name, stop scanning
+        if (functionName) {
+            break;
+        }
+    }
+    // Find end of the function/block by scanning downward for closing brace
+    // Simple bracket matching (stops at first balanced closing brace)
+    if (functionName || className) {
+        let braceCount = 0;
+        let foundOpenBrace = false;
+        for (let i = startLine - 1; i < lines.length && i < hitIndex + 100; i++) {
+            const line = lines[i] ?? '';
+            for (const char of line) {
+                if (char === '{') {
+                    braceCount++;
+                    foundOpenBrace = true;
+                }
+                else if (char === '}') {
+                    braceCount--;
+                    if (foundOpenBrace && braceCount === 0) {
+                        endLine = i + 1;
+                        return {
+                            functionName,
+                            className,
+                            startLine,
+                            endLine,
+                            surroundingLines,
+                        };
+                    }
+                }
+            }
+        }
+        // If we didn't find closing brace, estimate end line
+        endLine = Math.min(lines.length, startLine + 50);
+    }
+    return {
+        functionName,
+        className,
+        startLine,
+        endLine,
+        surroundingLines,
+    };
+}
 function tokenizeForSafeQuery(input) {
     const s = input.trim();
     if (!s)
@@ -308,7 +420,7 @@ export function buildFtsQuery(input) {
     // Quote each token to keep syntax safe.
     return tokens.map((t) => `"${t.replaceAll('"', '""')}"`).join(' OR ');
 }
-export function searchIndex(dbPath, query, scope, limit) {
+export function searchIndex(dbPath, query, scope, limit, bundleRoot) {
     const db = new Database(dbPath, { readonly: true });
     try {
         const ftsQuery = buildFtsQuery(query);
@@ -326,13 +438,41 @@ export function searchIndex(dbPath, query, scope, limit) {
       LIMIT ?
       `);
         const rows = stmt.all(ftsQuery, limit);
-        return rows.map((r) => ({
-            path: r.path,
-            repo: r.repo,
-            kind: r.kind,
-            lineNo: r.lineNo,
-            snippet: r.snippet,
-        }));
+        // Cache for file contents to avoid re-reading same files
+        const fileCache = new Map();
+        return rows.map((r) => {
+            const hit = {
+                path: r.path,
+                repo: r.repo,
+                kind: r.kind,
+                lineNo: r.lineNo,
+                snippet: r.snippet,
+            };
+            // Add context for code files if bundleRoot is provided
+            if (r.kind === 'code' && bundleRoot) {
+                try {
+                    // r.path is bundleNormRelativePath (e.g., "repos/owner/repo/norm/path/to/file.ts")
+                    // Construct absolute path to the normalized file
+                    const filePath = path.join(bundleRoot, r.path);
+                    // Read file content (use cache to avoid re-reading)
+                    let fileContent = fileCache.get(filePath);
+                    if (!fileContent) {
+                        fileContent = fsSync.readFileSync(filePath, 'utf8');
+                        fileCache.set(filePath, fileContent);
+                    }
+                    // Extract context
+                    const context = extractContext(fileContent, r.lineNo);
+                    if (context) {
+                        hit.context = context;
+                    }
+                }
+                catch (err) {
+                    // Silently skip context extraction on error (file not found, etc.)
+                    // Context is optional enhancement, shouldn't break search
+                }
+            }
+            return hit;
+        });
     }
     finally {
         db.close();
@@ -464,9 +604,9 @@ function generateVerificationSummary(claim, supporting, contradicting, related,
  * 2. Calculating an overall confidence score
  * 3. Providing a human-readable summary
  */
-export function verifyClaimInIndex(dbPath, claim, scope, limit) {
+export function verifyClaimInIndex(dbPath, claim, scope, limit, bundleRoot) {
     // Get raw search results
-    const rawHits = searchIndex(dbPath, claim, scope, limit);
+    const rawHits = searchIndex(dbPath, claim, scope, limit, bundleRoot);
     // Extract tokens from claim for classification
     const claimTokens = tokenizeForSafeQuery(claim);
     // Classify each hit