preflight-mcp 0.1.0

package/dist/bundle/context7.js

@@ -0,0 +1,301 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { connectContext7 } from '../context7/client.js';
+import { extractContext7IdsFromResult, textFromToolResult } from '../context7/tools.js';
+function normalizeKey(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, '');
+}
+function parseResolveEntries(text) {
+    const entries = [];
+    for (const chunk of text.split('----------')) {
+        const lines = chunk
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean);
+        let title;
+        let id;
+        let benchmarkScore;
+        let sourceReputation;
+        let codeSnippets;
+        for (const line of lines) {
+            if (line.startsWith('- Title:')) {
+                title = line.slice('- Title:'.length).trim();
+            }
+            else if (line.toLowerCase().includes('context7-compatible library id:')) {
+                const idx = line.toLowerCase().indexOf('context7-compatible library id:');
+                id = line.slice(idx + 'context7-compatible library id:'.length).trim();
+            }
+            else if (line.toLowerCase().startsWith('- benchmark score:')) {
+                const raw = line.slice('- Benchmark Score:'.length).trim();
+                const n = Number(raw);
+                if (Number.isFinite(n))
+                    benchmarkScore = n;
+            }
+            else if (line.toLowerCase().startsWith('- source reputation:')) {
+                const raw = line.slice('- Source Reputation:'.length).trim();
+                if (raw === 'High' || raw === 'Medium' || raw === 'Low') {
+                    sourceReputation = raw;
+                }
+                else {
+                    sourceReputation = 'Unknown';
+                }
+            }
+            else if (line.toLowerCase().startsWith('- code snippets:')) {
+                const raw = line.slice('- Code Snippets:'.length).trim();
+                const n = Number(raw);
+                if (Number.isFinite(n))
+                    codeSnippets = n;
+            }
+        }
+        if (id && id.startsWith('/') && id.includes('/')) {
+            entries.push({ title, id, benchmarkScore, sourceReputation, codeSnippets });
+        }
+    }
+    return entries;
+}
+function reputationWeight(rep) {
+    if (rep === 'High')
+        return 3;
+    if (rep === 'Medium')
+        return 2;
+    if (rep === 'Low')
+        return 1;
+    return 0;
+}
+function chooseBestEntry(entries, input) {
+    const notes = [];
+    if (entries.length === 0)
+        return { notes };
+    const nk = normalizeKey(input);
+    // Score entries: prefer name match, then reputation/benchmark/snippets.
+    const scored = entries.map((e) => {
+        const titleKey = e.title ? normalizeKey(e.title) : '';
+        const idKey = normalizeKey(e.id);
+        let match = 0;
+        if (titleKey && nk && titleKey === nk)
+            match = 3;
+        else if (titleKey && nk && (titleKey.includes(nk) || nk.includes(titleKey)))
+            match = 2;
+        else if (nk && idKey.includes(nk))
+            match = 1;
+        const score = match * 1_000_000 +
+            reputationWeight(e.sourceReputation) * 10_000 +
+            (e.benchmarkScore ?? 0) * 100 +
+            Math.min(e.codeSnippets ?? 0, 50_000) * 0.01;
+        return { e, match, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const best = scored[0];
+    if (!best)
+        return { notes };
+    const alternatives = scored.filter((s) => s.e.id !== best.e.id && s.match === best.match).slice(0, 3);
+    if (alternatives.length) {
+        notes.push(`resolve-library-id chose ${best.e.id}; alternatives: ${alternatives.map((a) => a.e.id).join(', ')}`);
+    }
+    // If we didn't get even a weak match, still proceed but note.
+    if (best.match === 0) {
+        notes.push(`resolve-library-id had no clear match for ${JSON.stringify(input)}; using ${best.e.id}`);
+    }
+    return { id: best.e.id, notes };
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function toPosix(p) {
+    return p.replaceAll('\\', '/');
+}
+function sha256Hex(text) {
+    return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+}
+function safeIdSegments(context7Id) {
+    const raw = context7Id.trim().replace(/^\/+/, '');
+    const parts = raw.split('/').filter(Boolean);
+    // Prevent any weird traversal segments.
+    return parts.filter((p) => p !== '.' && p !== '..');
+}
+function slug(s) {
+    return s
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .slice(0, 64);
+}
+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 };
+    // Cutting at a byte boundary may split a multi-byte codepoint; Node will replace invalid sequences.
+    const clipped = buf.subarray(0, maxBytes).toString('utf8');
+    return { text: `${clipped}\n\n[TRUNCATED]\n`, truncated: true };
+}
+async function ensureDir(p) {
+    await fs.mkdir(p, { recursive: true });
+}
+async function writeJson(targetPath, obj) {
+    await ensureDir(path.dirname(targetPath));
+    await fs.writeFile(targetPath, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+async function callOrThrow(client, name, args) {
+    const res = await client.callTool({ name, arguments: args });
+    if (res.isError) {
+        throw new Error(textFromToolResult(res) || `${name} failed`);
+    }
+    return {
+        text: textFromToolResult(res),
+        structured: res.structuredContent,
+    };
+}
+async function resolveContext7Id(client, input) {
+    const notes = [];
+    const trimmed = input.trim();
+    if (trimmed.startsWith('/')) {
+        return { id: trimmed, notes };
+    }
+    try {
+        const res = await client.callTool({
+            name: 'resolve-library-id',
+            arguments: { libraryName: trimmed },
+        });
+        if (res.isError) {
+            notes.push(`resolve-library-id error: ${textFromToolResult(res)}`);
+            return { notes };
+        }
+        const text = textFromToolResult(res);
+        // Prefer parsing the structured list output for better selection.
+        const parsed = parseResolveEntries(text);
+        const chosen = chooseBestEntry(parsed, trimmed);
+        if (chosen.id) {
+            notes.push(...chosen.notes);
+            return { id: chosen.id, notes };
+        }
+        // Fallback: regex/structured extraction.
+        const ids = extractContext7IdsFromResult(res);
+        if (ids.length === 0) {
+            notes.push('resolve-library-id returned no Context7 IDs');
+            return { notes };
+        }
+        if (ids.length > 1) {
+            notes.push(`resolve-library-id returned multiple IDs; using first: ${ids[0]}`);
+        }
+        return { id: ids[0], notes };
+    }
+    catch (err) {
+        notes.push(`resolve-library-id threw: ${err instanceof Error ? err.message : String(err)}`);
+        return { notes };
+    }
+}
+export async function ingestContext7Libraries(params) {
+    const libs = (params.libraries ?? []).map((s) => s.trim()).filter(Boolean);
+    if (libs.length === 0)
+        return { files: [], libraries: [] };
+    const topics = (params.topics ?? []).map((s) => s.trim()).filter(Boolean).slice(0, 10);
+    const maxLibraries = 20;
+    await ensureDir(params.bundlePaths.librariesDir);
+    let ctx = null;
+    try {
+        ctx = await connectContext7(params.cfg);
+    }
+    catch (err) {
+        // Best-effort: still write per-library meta.json so the bundle explains what failed.
+        const libraries = [];
+        for (const input of libs.slice(0, maxLibraries)) {
+            const fetchedAt = nowIso();
+            const notes = [`context7 connect failed: ${err instanceof Error ? err.message : String(err)}`];
+            const baseDir = path.join(params.bundlePaths.librariesDir, 'context7', '_unresolved', slug(input) || 'library');
+            await writeJson(path.join(baseDir, 'meta.json'), {
+                kind: 'context7',
+                input,
+                fetchedAt,
+                notes,
+            });
+            libraries.push({ kind: 'context7', input, fetchedAt, notes });
+        }
+        return { files: [], libraries };
+    }
+    const client = ctx.client;
+    const files = [];
+    const libraries = [];
+    try {
+        for (const input of libs.slice(0, maxLibraries)) {
+            const fetchedAt = nowIso();
+            const notes = [];
+            const fileRelPaths = [];
+            const resolved = await resolveContext7Id(client, input);
+            notes.push(...resolved.notes);
+            const id = resolved.id;
+            const baseDir = id
+                ? path.join(params.bundlePaths.librariesDir, 'context7', ...safeIdSegments(id))
+                : path.join(params.bundlePaths.librariesDir, 'context7', '_unresolved', slug(input) || 'library');
+            await ensureDir(baseDir);
+            if (id) {
+                const topicList = topics.length > 0 ? topics : [''];
+                for (const topic of topicList) {
+                    const topicLabel = topic || 'all';
+                    const fileName = topic
+                        ? `topic-${slug(topicLabel)}-page-1.md`
+                        : 'docs-page-1.md';
+                    try {
+                        const args = {
+                            context7CompatibleLibraryID: id,
+                            page: 1,
+                        };
+                        if (topic)
+                            args.topic = topic;
+                        const { text } = await callOrThrow(client, 'get-library-docs', args);
+                        if (!text.trim()) {
+                            notes.push(`get-library-docs returned empty text for topic=${JSON.stringify(topicLabel)}`);
+                            continue;
+                        }
+                        const clipped = clipUtf8(text, params.cfg.maxFileBytes);
+                        if (clipped.truncated) {
+                            notes.push(`docs truncated to maxFileBytes=${params.cfg.maxFileBytes} for topic=${JSON.stringify(topicLabel)}`);
+                        }
+                        const absDocPath = path.join(baseDir, fileName);
+                        await fs.writeFile(absDocPath, clipped.text, 'utf8');
+                        const bundleRelPosix = toPosix(path.relative(params.bundlePaths.rootDir, absDocPath));
+                        fileRelPaths.push(bundleRelPosix);
+                        files.push({
+                            repoId: `context7:${id}`,
+                            kind: 'doc',
+                            repoRelativePath: fileName,
+                            bundleNormRelativePath: bundleRelPosix,
+                            bundleNormAbsPath: absDocPath,
+                            sha256: sha256Hex(clipped.text),
+                            bytes: Buffer.byteLength(clipped.text, 'utf8'),
+                        });
+                    }
+                    catch (err) {
+                        notes.push(`get-library-docs failed for topic=${JSON.stringify(topicLabel)}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            else {
+                notes.push('Context7 ID unresolved; skipped get-library-docs');
+            }
+            await writeJson(path.join(baseDir, 'meta.json'), {
+                kind: 'context7',
+                input,
+                id,
+                fetchedAt,
+                topics: topics.length > 0 ? topics : undefined,
+                files: fileRelPaths,
+                notes: notes.length > 0 ? notes : undefined,
+            });
+            libraries.push({
+                kind: 'context7',
+                input,
+                id,
+                fetchedAt,
+                files: fileRelPaths.length > 0 ? fileRelPaths : undefined,
+                notes: notes.length > 0 ? notes.slice(0, 50) : undefined,
+            });
+        }
+    }
+    finally {
+        await ctx.close();
+    }
+    return { files, libraries };
+}

package/dist/bundle/deepwiki.js

@@ -0,0 +1,206 @@
+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.0',
+                '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,
+        },
+    };
+}