preflight-mcp 0.1.2 → 0.1.4

package/dist/trace/service.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import * as z from 'zod';
+import { findBundleStorageDir, getBundlePathsForId, listBundlesMulti } from '../bundle/service.js';
+import { ensureTraceDb, queryTraceEdges, upsertTraceEdges } from './store.js';
+export const TraceUpsertInputSchema = {
+    bundleId: z.string().describe('Bundle ID to attach trace links to.'),
+    edges: z
+        .array(z.object({
+        id: z.string().optional(),
+        source: z.object({ type: z.string(), id: z.string() }),
+        target: z.object({ type: z.string(), id: z.string() }),
+        type: z.string().describe('Edge type, e.g. mentions/tests/implements/relates_to'),
+        confidence: z.number().min(0).max(1).optional(),
+        method: z.enum(['exact', 'heuristic']).optional(),
+        sources: z
+            .array(z.object({
+            file: z.string().optional(),
+            range: z
+                .object({
+                startLine: z.number().int().min(1),
+                startCol: z.number().int().min(1),
+                endLine: z.number().int().min(1),
+                endCol: z.number().int().min(1),
+            })
+                .optional(),
+            externalUrl: z.string().optional(),
+            note: z.string().optional(),
+        }))
+            .optional(),
+    }))
+        .min(1)
+        .describe('Trace edges to upsert.'),
+};
+export const TraceQueryInputSchema = {
+    // When omitted, the query may scan across bundles (best-effort, capped).
+    bundleId: z.string().optional().describe('Optional bundleId. If omitted, scans across bundles (capped).'),
+    source_type: z.string(),
+    source_id: z.string(),
+    target_type: z.string().optional(),
+    target_id: z.string().optional(),
+    edge_type: z.string().optional(),
+    limit: z.number().int().min(1).max(500).default(50),
+    timeBudgetMs: z.number().int().min(500).max(30_000).default(5_000),
+    maxBundles: z.number().int().min(1).max(200).default(50),
+};
+function traceDbPathForBundleRoot(bundleRoot) {
+    return path.join(bundleRoot, 'trace', 'trace.sqlite3');
+}
+async function getTraceDbPathForBundleId(cfg, bundleId) {
+    const storageDir = await findBundleStorageDir(cfg.storageDirs, bundleId);
+    if (!storageDir) {
+        throw new Error(`Bundle not found: ${bundleId}`);
+    }
+    const paths = getBundlePathsForId(storageDir, bundleId);
+    const traceDbPath = traceDbPathForBundleRoot(paths.rootDir);
+    await ensureTraceDb(traceDbPath);
+    return traceDbPath;
+}
+export async function traceUpsert(cfg, rawArgs) {
+    const args = z.object(TraceUpsertInputSchema).parse(rawArgs);
+    const traceDbPath = await getTraceDbPathForBundleId(cfg, args.bundleId);
+    const res = await upsertTraceEdges(traceDbPath, args.edges);
+    return { bundleId: args.bundleId, ...res };
+}
+export async function traceQuery(cfg, rawArgs) {
+    const args = z.object(TraceQueryInputSchema).parse(rawArgs);
+    const source = { type: args.source_type, id: args.source_id };
+    const target = args.target_type && args.target_id ? { type: args.target_type, id: args.target_id } : undefined;
+    // Fast path: single bundle
+    if (args.bundleId) {
+        const dbPath = await getTraceDbPathForBundleId(cfg, args.bundleId);
+        const rows = queryTraceEdges(dbPath, { source, target, edgeType: args.edge_type, limit: args.limit });
+        return { bundleId: args.bundleId, edges: rows };
+    }
+    // Slow path: scan across bundles (best-effort, capped)
+    const startedAt = Date.now();
+    const timeLeft = () => args.timeBudgetMs - (Date.now() - startedAt);
+    let truncated = false;
+    const bundleIds = (await listBundlesMulti(cfg.storageDirs)).slice(0, args.maxBundles);
+    const collected = [];
+    for (const bundleId of bundleIds) {
+        if (timeLeft() <= 0) {
+            truncated = true;
+            break;
+        }
+        try {
+            const dbPath = await getTraceDbPathForBundleId(cfg, bundleId);
+            const rows = queryTraceEdges(dbPath, { source, target, edgeType: args.edge_type, limit: Math.min(50, args.limit) });
+            for (const r of rows) {
+                collected.push({ ...r, bundleId });
+                if (collected.length >= args.limit)
+                    break;
+            }
+        }
+        catch {
+            // ignore bundles without trace
+        }
+        if (collected.length >= args.limit)
+            break;
+    }
+    // Sort by updatedAt desc across bundles
+    collected.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    return {
+        scannedBundles: bundleIds.length,
+        truncated: truncated ? true : undefined,
+        edges: collected.slice(0, args.limit),
+    };
+}

package/dist/trace/store.js

@@ -0,0 +1,170 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import Database from 'better-sqlite3';
+function sha256Hex(text) {
+    return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+}
+function edgeDeterministicId(e) {
+    if (e.id && e.id.trim())
+        return e.id.trim();
+    return `tr_${sha256Hex(`${e.source.type}|${e.source.id}|${e.type}|${e.target.type}|${e.target.id}`).slice(0, 24)}`;
+}
+async function ensureDir(p) {
+    await fs.mkdir(p, { recursive: true });
+}
+export async function ensureTraceDb(traceDbPath) {
+    await ensureDir(path.dirname(traceDbPath));
+    const db = new Database(traceDbPath);
+    try {
+        db.pragma('journal_mode = WAL');
+        db.pragma('synchronous = NORMAL');
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS trace_edges (
+        id TEXT PRIMARY KEY,
+        source_type TEXT NOT NULL,
+        source_id TEXT NOT NULL,
+        target_type TEXT NOT NULL,
+        target_id TEXT NOT NULL,
+        edge_type TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        method TEXT NOT NULL,
+        sources_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_trace_edges_source ON trace_edges(source_type, source_id);
+      CREATE INDEX IF NOT EXISTS idx_trace_edges_target ON trace_edges(target_type, target_id);
+      CREATE INDEX IF NOT EXISTS idx_trace_edges_edge_type ON trace_edges(edge_type);
+    `);
+    }
+    finally {
+        db.close();
+    }
+}
+export async function upsertTraceEdges(traceDbPath, edges) {
+    await ensureTraceDb(traceDbPath);
+    const db = new Database(traceDbPath);
+    try {
+        db.pragma('journal_mode = WAL');
+        db.pragma('synchronous = NORMAL');
+        const upsert = db.prepare(`
+      INSERT INTO trace_edges (
+        id, source_type, source_id, target_type, target_id, edge_type,
+        confidence, method, sources_json, created_at, updated_at
+      ) VALUES (
+        @id, @source_type, @source_id, @target_type, @target_id, @edge_type,
+        @confidence, @method, @sources_json, @created_at, @updated_at
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        source_type=excluded.source_type,
+        source_id=excluded.source_id,
+        target_type=excluded.target_type,
+        target_id=excluded.target_id,
+        edge_type=excluded.edge_type,
+        confidence=excluded.confidence,
+        method=excluded.method,
+        sources_json=excluded.sources_json,
+        updated_at=excluded.updated_at;
+    `);
+        const now = new Date().toISOString();
+        const tx = db.transaction((items) => {
+            const ids = [];
+            for (const e of items) {
+                const id = edgeDeterministicId(e);
+                const confidence = typeof e.confidence === 'number' ? Math.max(0, Math.min(1, e.confidence)) : 0.5;
+                const method = e.method === 'exact' ? 'exact' : 'heuristic';
+                const sourcesJson = JSON.stringify(e.sources ?? []);
+                // Preserve created_at on update by reading existing row (cheap single get)
+                const existing = db
+                    .prepare('SELECT created_at FROM trace_edges WHERE id = ?')
+                    .get(id);
+                upsert.run({
+                    id,
+                    source_type: e.source.type,
+                    source_id: e.source.id,
+                    target_type: e.target.type,
+                    target_id: e.target.id,
+                    edge_type: e.type,
+                    confidence,
+                    method,
+                    sources_json: sourcesJson,
+                    created_at: existing?.created_at ?? now,
+                    updated_at: now,
+                });
+                ids.push(id);
+            }
+            return ids;
+        });
+        const ids = tx(edges);
+        return { upserted: ids.length, ids };
+    }
+    finally {
+        db.close();
+    }
+}
+export function queryTraceEdges(traceDbPath, params) {
+    const db = new Database(traceDbPath, { readonly: true });
+    try {
+        const where = [];
+        const bind = {};
+        if (params.source) {
+            where.push('source_type = @source_type AND source_id = @source_id');
+            bind.source_type = params.source.type;
+            bind.source_id = params.source.id;
+        }
+        if (params.target) {
+            where.push('target_type = @target_type AND target_id = @target_id');
+            bind.target_type = params.target.type;
+            bind.target_id = params.target.id;
+        }
+        if (params.edgeType) {
+            where.push('edge_type = @edge_type');
+            bind.edge_type = params.edgeType;
+        }
+        const sqlWhere = where.length ? `WHERE ${where.join(' AND ')}` : '';
+        const limit = Math.min(500, Math.max(1, params.limit ?? 50));
+        const stmt = db.prepare(`
+      SELECT
+        id,
+        source_type,
+        source_id,
+        target_type,
+        target_id,
+        edge_type,
+        confidence,
+        method,
+        sources_json,
+        created_at,
+        updated_at
+      FROM trace_edges
+      ${sqlWhere}
+      ORDER BY updated_at DESC
+      LIMIT ${limit}
+    `);
+        const rows = stmt.all(bind);
+        return rows.map((r) => ({
+            id: r.id,
+            source: { type: r.source_type, id: r.source_id },
+            target: { type: r.target_type, id: r.target_id },
+            type: r.edge_type,
+            confidence: r.confidence,
+            method: r.method === 'exact' ? 'exact' : 'heuristic',
+            sources: (() => {
+                try {
+                    const parsed = JSON.parse(r.sources_json);
+                    return Array.isArray(parsed) ? parsed : [];
+                }
+                catch {
+                    return [];
+                }
+            })(),
+            createdAt: r.created_at,
+            updatedAt: r.updated_at,
+        }));
+    }
+    finally {
+        db.close();
+    }
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "preflight-mcp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "MCP server that creates evidence-based preflight bundles for GitHub repositories and library docs.",
   "type": "module",
   "license": "MIT",
   "author": "preflight-mcp contributors",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jonnyhoo/preflight-mcp.git"
+    "url": "git+https://github.com/jonnyhoo/preflight-mcp.git"
   },
   "bugs": {
     "url": "https://github.com/jonnyhoo/preflight-mcp/issues"
@@ -48,10 +48,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
+    "@vscode/tree-sitter-wasm": "^0.3.0",
     "adm-zip": "^0.5.16",
     "better-sqlite3": "^12.5.0",
     "ignore": "^7.0.5",
     "node-cron": "^4.2.1",
+    "web-tree-sitter": "^0.26.3",
     "zod": "^4.2.1"
   },
   "devDependencies": {

package/dist/bundle/deepwiki.js

@@ -1,206 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-function nowIso() {
-    return new Date().toISOString();
-}
-function toPosix(p) {
-    return p.replaceAll('\\', '/');
-}
-function sha256Hex(text) {
-    return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
-}
-async function ensureDir(p) {
-    await fs.mkdir(p, { recursive: true });
-}
-/**
- * Parse DeepWiki URL to extract owner/repo.
- * Supports formats like:
- * - https://deepwiki.com/owner/repo
- * - https://deepwiki.com/owner/repo/path/to/doc
- */
-function parseDeepWikiUrl(url) {
-    try {
-        const parsed = new URL(url);
-        if (!parsed.hostname.includes('deepwiki.com'))
-            return null;
-        const parts = parsed.pathname.split('/').filter(Boolean);
-        if (parts.length < 2)
-            return null;
-        return { owner: parts[0], repo: parts[1] };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Fetch a DeepWiki page and extract its content.
- * Returns the page content as Markdown.
- */
-async function fetchDeepWikiPage(url, timeoutMs = 30000) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const res = await fetch(url, {
-            headers: {
-                'User-Agent': 'preflight-mcp/0.1.1',
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            },
-            signal: controller.signal,
-        });
-        if (!res.ok) {
-            throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-        }
-        const html = await res.text();
-        // Extract main content - DeepWiki typically renders docs in a main content area.
-        // This is a best-effort extraction; real implementation would need more sophisticated parsing.
-        const content = extractMarkdownFromHtml(html);
-        const title = extractTitle(html);
-        return { content, title };
-    }
-    finally {
-        clearTimeout(timeoutId);
-    }
-}
-/**
- * Simple HTML to Markdown-ish text extraction.
- * This is a best-effort converter for documentation pages.
- */
-function extractMarkdownFromHtml(html) {
-    // Remove script and style tags
-    let text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '');
-    text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
-    // Convert common HTML elements to Markdown-ish format
-    text = text.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, '\n# $1\n');
-    text = text.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '\n## $1\n');
-    text = text.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, '\n### $1\n');
-    text = text.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, '\n#### $1\n');
-    text = text.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, '\n##### $1\n');
-    text = text.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, '\n###### $1\n');
-    // Code blocks
-    text = text.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, '\n```\n$1\n```\n');
-    text = text.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, '\n```\n$1\n```\n');
-    text = text.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
-    // Lists
-    text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, '- $1\n');
-    text = text.replace(/<ul[^>]*>/gi, '\n');
-    text = text.replace(/<\/ul>/gi, '\n');
-    text = text.replace(/<ol[^>]*>/gi, '\n');
-    text = text.replace(/<\/ol>/gi, '\n');
-    // Paragraphs and line breaks
-    text = text.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, '\n$1\n');
-    text = text.replace(/<br\s*\/?>/gi, '\n');
-    text = text.replace(/<hr\s*\/?>/gi, '\n---\n');
-    // Bold and italic
-    text = text.replace(/<strong[^>]*>([\s\S]*?)<\/strong>/gi, '**$1**');
-    text = text.replace(/<b[^>]*>([\s\S]*?)<\/b>/gi, '**$1**');
-    text = text.replace(/<em[^>]*>([\s\S]*?)<\/em>/gi, '*$1*');
-    text = text.replace(/<i[^>]*>([\s\S]*?)<\/i>/gi, '*$1*');
-    // Links
-    text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
-    // Remove remaining HTML tags
-    text = text.replace(/<[^>]+>/g, '');
-    // Decode HTML entities
-    text = text.replace(/&amp;/g, '&');
-    text = text.replace(/&lt;/g, '<');
-    text = text.replace(/&gt;/g, '>');
-    text = text.replace(/&quot;/g, '"');
-    text = text.replace(/&#39;/g, "'");
-    text = text.replace(/&nbsp;/g, ' ');
-    // Clean up whitespace
-    text = text.replace(/\n{3,}/g, '\n\n');
-    text = text.trim();
-    return text;
-}
-function extractTitle(html) {
-    const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
-    if (match?.[1]) {
-        return match[1].replace(/\s*[-|]\s*DeepWiki.*$/i, '').trim();
-    }
-    return undefined;
-}
-function clipUtf8(text, maxBytes) {
-    const normalized = text.replace(/\r\n/g, '\n');
-    const buf = Buffer.from(normalized, 'utf8');
-    if (buf.length <= maxBytes)
-        return { text: normalized, truncated: false };
-    const clipped = buf.subarray(0, maxBytes).toString('utf8');
-    return { text: `${clipped}\n\n[TRUNCATED]\n`, truncated: true };
-}
-export async function ingestDeepWikiRepo(params) {
-    const parsed = parseDeepWikiUrl(params.url);
-    if (!parsed) {
-        return {
-            files: [],
-            summary: {
-                kind: 'deepwiki',
-                url: params.url,
-                repoId: params.url,
-                fetchedAt: nowIso(),
-                notes: ['Invalid DeepWiki URL format'],
-            },
-        };
-    }
-    const repoId = `${parsed.owner}/${parsed.repo}`;
-    const fetchedAt = nowIso();
-    const notes = [];
-    const files = [];
-    const fileRelPaths = [];
-    // Create deepwiki directory structure
-    const deepwikiDir = path.join(params.bundlePaths.rootDir, 'deepwiki', parsed.owner, parsed.repo);
-    const normDir = path.join(deepwikiDir, 'norm');
-    await ensureDir(normDir);
-    try {
-        const { content, title } = await fetchDeepWikiPage(params.url);
-        if (!content.trim()) {
-            notes.push('DeepWiki page returned empty content');
-        }
-        else {
-            const clipped = clipUtf8(content, params.cfg.maxFileBytes);
-            if (clipped.truncated) {
-                notes.push(`Content truncated to maxFileBytes=${params.cfg.maxFileBytes}`);
-            }
-            // Add header with source info
-            const header = `# ${title || repoId} (DeepWiki)\n\nSource: ${params.url}\nFetched: ${fetchedAt}\n\n---\n\n`;
-            const finalContent = header + clipped.text;
-            const fileName = 'index.md';
-            const absDocPath = path.join(normDir, fileName);
-            await fs.writeFile(absDocPath, finalContent, 'utf8');
-            const bundleRelPosix = toPosix(path.relative(params.bundlePaths.rootDir, absDocPath));
-            fileRelPaths.push(bundleRelPosix);
-            files.push({
-                repoId: `deepwiki:${repoId}`,
-                kind: 'doc',
-                repoRelativePath: fileName,
-                bundleNormRelativePath: bundleRelPosix,
-                bundleNormAbsPath: absDocPath,
-                sha256: sha256Hex(finalContent),
-                bytes: Buffer.byteLength(finalContent, 'utf8'),
-            });
-        }
-    }
-    catch (err) {
-        notes.push(`Failed to fetch DeepWiki page: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    // Write meta.json
-    const metaPath = path.join(deepwikiDir, 'meta.json');
-    await fs.writeFile(metaPath, JSON.stringify({
-        kind: 'deepwiki',
-        url: params.url,
-        repoId,
-        fetchedAt,
-        files: fileRelPaths,
-        notes: notes.length > 0 ? notes : undefined,
-    }, null, 2) + '\n', 'utf8');
-    return {
-        files,
-        summary: {
-            kind: 'deepwiki',
-            url: params.url,
-            repoId,
-            fetchedAt,
-            files: fileRelPaths.length > 0 ? fileRelPaths : undefined,
-            notes: notes.length > 0 ? notes : undefined,
-        },
-    };
-}