preflight-mcp 0.1.2 → 0.1.4

package/dist/ast/treeSitter.js

@@ -0,0 +1,588 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { Language, Parser } from 'web-tree-sitter';
+const require = createRequire(import.meta.url);
+let initPromise;
+const languageCache = new Map();
+function normalizeExt(p) {
+    return path.extname(p).toLowerCase();
+}
+export function languageForFile(filePath) {
+    const ext = normalizeExt(filePath);
+    if (['.ts'].includes(ext))
+        return 'typescript';
+    if (['.tsx'].includes(ext))
+        return 'tsx';
+    if (['.js', '.jsx', '.mjs', '.cjs'].includes(ext))
+        return 'javascript';
+    if (ext === '.py')
+        return 'python';
+    if (ext === '.go')
+        return 'go';
+    if (ext === '.java')
+        return 'java';
+    if (ext === '.rs')
+        return 'rust';
+    return null;
+}
+async function ensureInit() {
+    initPromise ??= Parser.init();
+    await initPromise;
+}
+function wasmPathForLanguage(lang) {
+    const name = (() => {
+        switch (lang) {
+            case 'javascript':
+                return 'tree-sitter-javascript.wasm';
+            case 'typescript':
+                return 'tree-sitter-typescript.wasm';
+            case 'tsx':
+                return 'tree-sitter-tsx.wasm';
+            case 'python':
+                return 'tree-sitter-python.wasm';
+            case 'go':
+                return 'tree-sitter-go.wasm';
+            case 'java':
+                return 'tree-sitter-java.wasm';
+            case 'rust':
+                return 'tree-sitter-rust.wasm';
+        }
+    })();
+    return require.resolve(`@vscode/tree-sitter-wasm/wasm/${name}`);
+}
+async function loadLanguage(lang) {
+    const cached = languageCache.get(lang);
+    if (cached)
+        return cached;
+    const promise = (async () => {
+        await ensureInit();
+        const wasmPath = wasmPathForLanguage(lang);
+        return Language.load(wasmPath);
+    })();
+    languageCache.set(lang, promise);
+    return promise;
+}
+function rangeFromNode(n) {
+    return {
+        startLine: n.startPosition.row + 1,
+        startCol: n.startPosition.column + 1,
+        endLine: n.endPosition.row + 1,
+        endCol: n.endPosition.column + 1,
+    };
+}
+function firstStringFragment(node) {
+    const frags = node.descendantsOfType('string_fragment');
+    return frags[0] ?? null;
+}
+function firstOfTypes(node, types) {
+    for (const t of types) {
+        const found = node.descendantsOfType(t);
+        if (found[0])
+            return found[0];
+    }
+    return null;
+}
+function extractImportsJsTs(root, lang) {
+    const out = [];
+    for (const st of root.descendantsOfType(['import_statement', 'export_statement'])) {
+        const source = st.childForFieldName('source');
+        if (!source)
+            continue;
+        const frag = firstStringFragment(source);
+        if (!frag)
+            continue;
+        out.push({
+            language: lang,
+            kind: st.type === 'export_statement' ? 'exportFrom' : 'import',
+            module: frag.text,
+            range: rangeFromNode(frag),
+        });
+    }
+    for (const call of root.descendantsOfType('call_expression')) {
+        const fn = call.childForFieldName('function');
+        if (!fn)
+            continue;
+        const args = call.childForFieldName('arguments');
+        const arg0 = args?.namedChild(0);
+        if (!arg0 || arg0.type !== 'string')
+            continue;
+        const frag = firstStringFragment(arg0);
+        if (!frag)
+            continue;
+        // Dynamic import: import("x")
+        if (fn.type === 'import') {
+            out.push({
+                language: lang,
+                kind: 'dynamicImport',
+                module: frag.text,
+                range: rangeFromNode(frag),
+            });
+            continue;
+        }
+        // CommonJS require: require("x")
+        if (fn.type === 'identifier' && fn.text === 'require') {
+            out.push({
+                language: lang,
+                kind: 'require',
+                module: frag.text,
+                range: rangeFromNode(frag),
+            });
+        }
+    }
+    return out;
+}
+function extractImportsPython(root) {
+    const out = [];
+    for (const st of root.descendantsOfType('import_statement')) {
+        const name = st.childForFieldName('name');
+        if (!name)
+            continue;
+        const dotted = name.type === 'aliased_import' ? name.childForFieldName('name') : name;
+        if (!dotted)
+            continue;
+        out.push({
+            language: 'python',
+            kind: 'pythonImport',
+            module: dotted.text,
+            range: rangeFromNode(dotted),
+        });
+    }
+    for (const st of root.descendantsOfType('import_from_statement')) {
+        const modName = st.childForFieldName('module_name');
+        if (!modName)
+            continue;
+        // For relative imports like `from . import foo`, tree-sitter gives module_name = `.` (relative_import)
+        // and then repeats `name:` fields for each imported identifier. Expand these into `.foo` so downstream
+        // consumers can resolve local imports.
+        if (modName.type === 'relative_import') {
+            const hasExplicitModule = modName.descendantsOfType('dotted_name')[0] != null;
+            if (!hasExplicitModule) {
+                const prefix = modName.text;
+                const names = st.childrenForFieldName('name');
+                let expanded = false;
+                for (const n of names) {
+                    const base = n.type === 'aliased_import' ? n.childForFieldName('name') : n;
+                    if (!base)
+                        continue;
+                    // `from . import *`
+                    if (base.text === '*')
+                        continue;
+                    expanded = true;
+                    out.push({
+                        language: 'python',
+                        kind: 'pythonFrom',
+                        module: `${prefix}${base.text}`,
+                        range: rangeFromNode(base),
+                    });
+                }
+                if (expanded)
+                    continue;
+            }
+        }
+        out.push({
+            language: 'python',
+            kind: 'pythonFrom',
+            module: modName.text,
+            range: rangeFromNode(modName),
+        });
+    }
+    return out;
+}
+function extractImportsGo(root) {
+    const out = [];
+    for (const spec of root.descendantsOfType('import_spec')) {
+        const p = spec.childForFieldName('path');
+        if (!p)
+            continue;
+        const content = firstOfTypes(p, [
+            'interpreted_string_literal_content',
+            'raw_string_literal_content',
+        ]);
+        if (!content)
+            continue;
+        out.push({
+            language: 'go',
+            kind: 'goImport',
+            module: content.text,
+            range: rangeFromNode(content),
+        });
+    }
+    return out;
+}
+function extractImportsJava(root) {
+    const out = [];
+    for (const decl of root.descendantsOfType('import_declaration')) {
+        const scoped = decl.namedChild(0);
+        if (!scoped || scoped.type !== 'scoped_identifier')
+            continue;
+        const asterisk = decl.descendantsOfType('asterisk')[0];
+        if (asterisk) {
+            out.push({
+                language: 'java',
+                kind: 'javaImport',
+                module: `${scoped.text}.*`,
+                range: {
+                    startLine: scoped.startPosition.row + 1,
+                    startCol: scoped.startPosition.column + 1,
+                    endLine: asterisk.endPosition.row + 1,
+                    endCol: asterisk.endPosition.column + 1,
+                },
+            });
+        }
+        else {
+            out.push({
+                language: 'java',
+                kind: 'javaImport',
+                module: scoped.text,
+                range: rangeFromNode(scoped),
+            });
+        }
+    }
+    return out;
+}
+function extractImportsRust(root) {
+    const out = [];
+    const unwrapUseAsClause = (n) => {
+        if (n.type !== 'use_as_clause')
+            return n;
+        return (n.childForFieldName('path') ?? n.namedChild(0) ?? n);
+    };
+    const rootNodeForUseListItem = (n) => {
+        const unwrapped = unwrapUseAsClause(n);
+        if (unwrapped.type === 'scoped_use_list') {
+            return unwrapped.childForFieldName('path') ?? null;
+        }
+        if (unwrapped.type === 'identifier' ||
+            unwrapped.type === 'scoped_identifier' ||
+            unwrapped.type === 'crate' ||
+            unwrapped.type === 'self' ||
+            unwrapped.type === 'super') {
+            return unwrapped;
+        }
+        return null;
+    };
+    for (const decl of root.descendantsOfType('use_declaration')) {
+        const arg = decl.childForFieldName('argument');
+        if (!arg)
+            continue;
+        if (arg.type === 'scoped_use_list') {
+            const p = arg.childForFieldName('path') ?? arg;
+            const list = arg.childForFieldName('list');
+            // Special-case: `use crate::{foo, bar};` / `use super::{foo, bar};` / `use self::{foo, bar};`
+            // These are very common for local module imports and should be expanded.
+            if (list && (p.type === 'crate' || p.type === 'super' || p.type === 'self')) {
+                for (const item of list.namedChildren) {
+                    const rootNode = rootNodeForUseListItem(item);
+                    if (!rootNode)
+                        continue;
+                    // `use crate::{self, foo};` doesn't add a meaningful module target for our purposes.
+                    if (rootNode.type === 'self')
+                        continue;
+                    out.push({
+                        language: 'rust',
+                        kind: 'rustUse',
+                        module: `${p.text}::${rootNode.text}`,
+                        range: rangeFromNode(rootNode),
+                    });
+                }
+                continue;
+            }
+            // Default behavior: treat the `path` as the imported module.
+            out.push({
+                language: 'rust',
+                kind: 'rustUse',
+                module: p.text,
+                range: rangeFromNode(p),
+            });
+            continue;
+        }
+        out.push({
+            language: 'rust',
+            kind: 'rustUse',
+            module: arg.text,
+            range: rangeFromNode(arg),
+        });
+    }
+    for (const decl of root.descendantsOfType('extern_crate_declaration')) {
+        const name = decl.childForFieldName('name');
+        if (!name)
+            continue;
+        out.push({
+            language: 'rust',
+            kind: 'rustExternCrate',
+            module: name.text,
+            range: rangeFromNode(name),
+        });
+    }
+    return out;
+}
+function extractImports(root, lang) {
+    switch (lang) {
+        case 'javascript':
+        case 'typescript':
+        case 'tsx':
+            return extractImportsJsTs(root, lang);
+        case 'python':
+            return extractImportsPython(root);
+        case 'go':
+            return extractImportsGo(root);
+        case 'java':
+            return extractImportsJava(root);
+        case 'rust':
+            return extractImportsRust(root);
+    }
+}
+function extractExportsJsTs(root) {
+    const out = new Set();
+    // ES module exports
+    for (const st of root.descendantsOfType('export_statement')) {
+        if (/^\s*export\s+default\b/.test(st.text)) {
+            out.add('default');
+        }
+        const clause = st.descendantsOfType('export_clause')[0];
+        if (clause) {
+            for (const spec of clause.descendantsOfType('export_specifier')) {
+                const alias = spec.childForFieldName('alias');
+                const name = (alias ?? spec.childForFieldName('name'));
+                if (name)
+                    out.add(name.text);
+            }
+            continue;
+        }
+        // export function/class/type/interface/enum ...
+        const direct = st.namedChildren;
+        for (const child of direct) {
+            if (child.type === 'function_declaration' ||
+                child.type === 'class_declaration' ||
+                child.type === 'interface_declaration' ||
+                child.type === 'type_alias_declaration' ||
+                child.type === 'enum_declaration') {
+                const name = child.childForFieldName('name');
+                if (name)
+                    out.add(name.text);
+            }
+            if (child.type === 'lexical_declaration' || child.type === 'variable_declaration') {
+                for (const decl of child.descendantsOfType('variable_declarator')) {
+                    const name = decl.childForFieldName('name');
+                    if (name && name.type === 'identifier')
+                        out.add(name.text);
+                }
+            }
+        }
+    }
+    // CommonJS exports (best-effort): module.exports / exports.foo
+    for (const asn of root.descendantsOfType('assignment_expression')) {
+        const left = asn.childForFieldName('left');
+        if (!left)
+            continue;
+        // exports.foo = ...
+        if (left.type === 'member_expression') {
+            const obj = left.childForFieldName('object');
+            const prop = left.childForFieldName('property');
+            if (obj?.type === 'identifier' && obj.text === 'exports' && prop) {
+                out.add(prop.text);
+                continue;
+            }
+            // module.exports = ...
+            if (obj?.type === 'identifier' && obj.text === 'module' && prop && prop.text === 'exports') {
+                out.add('default');
+                continue;
+            }
+            // module.exports.foo = ...
+            if (obj?.type === 'member_expression' && prop) {
+                const obj2 = obj.childForFieldName('object');
+                const prop2 = obj.childForFieldName('property');
+                if (obj2?.type === 'identifier' && obj2.text === 'module' && prop2?.text === 'exports') {
+                    out.add(prop.text);
+                }
+            }
+        }
+    }
+    return Array.from(out);
+}
+function unquoteStringLiteral(raw) {
+    let t = raw.trim();
+    // Handles prefixes like r"..", f'..', etc.
+    t = t.replace(/^[rRuUbBfF]+/, '');
+    const q = t[0];
+    if (q !== '"' && q !== "'")
+        return null;
+    if (t.length < 2 || t[t.length - 1] !== q)
+        return null;
+    return t.slice(1, -1);
+}
+function extractExportsPython(root) {
+    const out = new Set();
+    // __all__ = ['a', 'b'] (literal only)
+    for (const asn of root.descendantsOfType(['assignment', 'assignment_statement'])) {
+        // Keep this conservative: only accept module-level assignments.
+        // NOTE: web-tree-sitter node wrappers are not guaranteed to be referentially stable,
+        // so avoid `=== root` checks.
+        const parent = asn.parent;
+        const grandParent = parent?.parent;
+        const isTopLevel = (parent !== null && parent.parent === null) ||
+            (grandParent !== null && grandParent?.parent === null);
+        if (!isTopLevel)
+            continue;
+        const left = asn.childForFieldName('left') ?? asn.namedChild(0);
+        if (!left || left.text !== '__all__')
+            continue;
+        const right = asn.childForFieldName('right') ?? asn.namedChild(asn.namedChildCount - 1);
+        let listOrTuple = null;
+        if (right) {
+            listOrTuple =
+                right.type === 'list' || right.type === 'tuple'
+                    ? right
+                    : right.type === 'parenthesized_expression'
+                        ? (right.descendantsOfType('list')[0] ?? right.descendantsOfType('tuple')[0] ?? null)
+                        : null;
+        }
+        // Fallback: different python grammars may not expose assignment fields consistently.
+        if (!listOrTuple) {
+            listOrTuple = firstOfTypes(asn, ['list', 'tuple']);
+        }
+        if (!listOrTuple)
+            continue;
+        for (const s of listOrTuple.descendantsOfType('string')) {
+            const inner = unquoteStringLiteral(s.text);
+            if (inner)
+                out.add(inner);
+        }
+    }
+    // Top-level defs/classes (heuristic for public API)
+    for (const child of root.namedChildren) {
+        if (child.type === 'function_definition' || child.type === 'class_definition') {
+            const name = child.childForFieldName('name');
+            const n = name?.text ?? '';
+            if (n && !n.startsWith('_'))
+                out.add(n);
+        }
+    }
+    return Array.from(out);
+}
+function extractExportsGo(root) {
+    const out = new Set();
+    const topLevel = root.namedChildren;
+    for (const n of topLevel) {
+        if (n.type === 'function_declaration' || n.type === 'method_declaration') {
+            const name = n.childForFieldName('name') ?? n.descendantsOfType('identifier')[0];
+            const t = name?.text ?? '';
+            if (t && /^[A-Z]/.test(t))
+                out.add(t);
+        }
+        if (n.type === 'type_declaration') {
+            for (const spec of n.descendantsOfType('type_spec')) {
+                const name = spec.childForFieldName('name') ?? spec.descendantsOfType('type_identifier')[0];
+                const t = name?.text ?? '';
+                if (t && /^[A-Z]/.test(t))
+                    out.add(t);
+            }
+        }
+    }
+    return Array.from(out);
+}
+function extractExportsJava(root) {
+    const out = new Set();
+    for (const n of root.namedChildren) {
+        if (n.type !== 'class_declaration' &&
+            n.type !== 'interface_declaration' &&
+            n.type !== 'enum_declaration' &&
+            n.type !== 'record_declaration') {
+            continue;
+        }
+        const mods = n.childForFieldName('modifiers') ?? n.namedChild(0);
+        if (mods && !mods.text.includes('public'))
+            continue;
+        const name = n.childForFieldName('name');
+        if (name)
+            out.add(name.text);
+    }
+    return Array.from(out);
+}
+function hasRustPubVisibility(n) {
+    const first = n.namedChild(0);
+    if (first?.type === 'visibility_modifier' && first.text.startsWith('pub'))
+        return true;
+    const vis = n.childForFieldName('visibility');
+    if (vis?.type === 'visibility_modifier' && vis.text.startsWith('pub'))
+        return true;
+    return false;
+}
+function extractExportsRust(root) {
+    const out = new Set();
+    const candidates = [
+        'function_item',
+        'struct_item',
+        'enum_item',
+        'trait_item',
+        'type_item',
+        'const_item',
+        'static_item',
+        'mod_item',
+    ];
+    for (const n of root.namedChildren) {
+        if (!candidates.includes(n.type))
+            continue;
+        if (!hasRustPubVisibility(n))
+            continue;
+        const name = n.childForFieldName('name');
+        if (name)
+            out.add(name.text);
+    }
+    return Array.from(out);
+}
+function extractExports(root, lang) {
+    switch (lang) {
+        case 'javascript':
+        case 'typescript':
+        case 'tsx':
+            return extractExportsJsTs(root);
+        case 'python':
+            return extractExportsPython(root);
+        case 'go':
+            return extractExportsGo(root);
+        case 'java':
+            return extractExportsJava(root);
+        case 'rust':
+            return extractExportsRust(root);
+    }
+}
+export async function extractModuleSyntaxWasm(filePath, normalizedContent) {
+    const lang = languageForFile(filePath);
+    if (!lang)
+        return null;
+    const language = await loadLanguage(lang);
+    const parser = new Parser();
+    try {
+        parser.setLanguage(language);
+        const tree = parser.parse(normalizedContent);
+        if (!tree)
+            return { language: lang, imports: [], exports: [] };
+        try {
+            const root = tree.rootNode;
+            return {
+                language: lang,
+                imports: extractImports(root, lang),
+                exports: extractExports(root, lang),
+            };
+        }
+        finally {
+            tree.delete();
+        }
+    }
+    finally {
+        parser.delete();
+    }
+}
+export async function extractImportRefsWasm(filePath, normalizedContent) {
+    const res = await extractModuleSyntaxWasm(filePath, normalizedContent);
+    if (!res)
+        return null;
+    return { language: res.language, imports: res.imports };
+}
+export async function extractExportedSymbolsWasm(filePath, normalizedContent) {
+    const res = await extractModuleSyntaxWasm(filePath, normalizedContent);
+    if (!res)
+        return null;
+    return { language: res.language, exports: res.exports };
+}

package/dist/bundle/analysis.js

@@ -12,6 +12,7 @@ export async function analyzeBundleStatic(params) {
         const facts = await extractBundleFacts({
             bundleRoot: params.bundleRoot,
             repos: params.repos,
+            enablePhase2: params.mode === 'full', // Enable Phase 2 module analysis for 'full' mode
         });
         const factsPath = path.join(params.bundleRoot, 'analysis', 'FACTS.json');
         await writeFacts(factsPath, facts);
@@ -87,5 +88,51 @@ export function generateQuickSummary(facts) {
     if (facts.fileStructure.topLevelDirs.length > 0) {
         sections.push(`- Top-level directories: ${facts.fileStructure.topLevelDirs.join(', ')}`);
     }
+    sections.push('');
+    // Phase 2: Modules (if available)
+    if (facts.modules && facts.modules.length > 0) {
+        sections.push('## Module Analysis');
+        sections.push(`- Total modules: ${facts.modules.length}`);
+        const roleCount = facts.modules.reduce((acc, m) => {
+            acc[m.role] = (acc[m.role] || 0) + 1;
+            return acc;
+        }, {});
+        sections.push(`- Core modules: ${roleCount['core'] || 0}`);
+        sections.push(`- Utility modules: ${roleCount['utility'] || 0}`);
+        sections.push(`- Test modules: ${roleCount['test'] || 0}`);
+        sections.push(`- Config modules: ${roleCount['config'] || 0}`);
+        const coreModules = facts.modules.filter(m => m.role === 'core').slice(0, 5);
+        if (coreModules.length > 0) {
+            sections.push('\n### Top Core Modules');
+            for (const mod of coreModules) {
+                sections.push(`- ${mod.path} (${mod.exports.length} exports, ${mod.loc} LOC)`);
+            }
+        }
+        sections.push('');
+    }
+    // Phase 2: Architecture patterns (if available)
+    if (facts.patterns && facts.patterns.length > 0) {
+        sections.push('## Architecture Patterns');
+        sections.push(facts.patterns.map(p => `- ${p}`).join('\n'));
+        sections.push('');
+    }
+    // Phase 2: Tech stack (if available)
+    if (facts.techStack) {
+        sections.push('## Technology Stack');
+        sections.push(`- Language: ${facts.techStack.language}`);
+        if (facts.techStack.runtime) {
+            sections.push(`- Runtime: ${facts.techStack.runtime}`);
+        }
+        if (facts.techStack.packageManager) {
+            sections.push(`- Package Manager: ${facts.techStack.packageManager}`);
+        }
+        if (facts.techStack.buildTools) {
+            sections.push(`- Build Tools: ${facts.techStack.buildTools.join(', ')}`);
+        }
+        if (facts.techStack.testFrameworks) {
+            sections.push(`- Test Frameworks: ${facts.techStack.testFrameworks.join(', ')}`);
+        }
+        sections.push('');
+    }
     return sections.join('\n') + '\n';
 }