lat.md 0.5.0 → 0.7.0

package/dist/src/source-parser.js

@@ -0,0 +1,720 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { Parser, Language, } from 'web-tree-sitter';
+// Lazy singleton for the parser
+let parserReady = null;
+let parserInstance = null;
+const languages = new Map();
+function wasmDir() {
+    const require = createRequire(import.meta.url);
+    const pkgPath = require.resolve('@repomix/tree-sitter-wasms/package.json');
+    return join(dirname(pkgPath), 'out');
+}
+async function ensureParser() {
+    if (!parserReady) {
+        parserReady = Parser.init();
+    }
+    await parserReady;
+    if (!parserInstance) {
+        parserInstance = new Parser();
+    }
+    return parserInstance;
+}
+async function getLanguage(ext) {
+    const grammarMap = {
+        '.ts': 'tree-sitter-typescript.wasm',
+        '.tsx': 'tree-sitter-tsx.wasm',
+        '.js': 'tree-sitter-javascript.wasm',
+        '.jsx': 'tree-sitter-javascript.wasm',
+        '.py': 'tree-sitter-python.wasm',
+        '.rs': 'tree-sitter-rust.wasm',
+        '.go': 'tree-sitter-go.wasm',
+        '.c': 'tree-sitter-c.wasm',
+        '.h': 'tree-sitter-c.wasm',
+    };
+    const wasmFile = grammarMap[ext];
+    if (!wasmFile)
+        return null;
+    // Ensure WASM runtime is initialized before loading languages
+    await ensureParser();
+    if (!languages.has(wasmFile)) {
+        const wasmPath = join(wasmDir(), wasmFile);
+        const lang = await Language.load(wasmPath);
+        languages.set(wasmFile, lang);
+    }
+    return languages.get(wasmFile);
+}
+function extractName(node) {
+    const nameNode = node.childForFieldName('name');
+    return nameNode ? nameNode.text : null;
+}
+function extractTsSymbols(tree) {
+    const symbols = [];
+    const root = tree.rootNode;
+    for (let i = 0; i < root.childCount; i++) {
+        let node = root.child(i);
+        // Unwrap export_statement to get the inner declaration
+        const isExport = node.type === 'export_statement';
+        if (isExport) {
+            const inner = node.namedChildren.find((c) => c.type === 'function_declaration' ||
+                c.type === 'class_declaration' ||
+                c.type === 'lexical_declaration' ||
+                c.type === 'type_alias_declaration' ||
+                c.type === 'interface_declaration' ||
+                c.type === 'abstract_class_declaration');
+            if (inner)
+                node = inner;
+        }
+        const startLine = node.startPosition.row + 1;
+        const endLine = node.endPosition.row + 1;
+        if (node.type === 'function_declaration' ||
+            node.type === 'generator_function_declaration') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'function',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'class_declaration' ||
+            node.type === 'abstract_class_declaration') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+                // Extract methods
+                const body = node.childForFieldName('body');
+                if (body) {
+                    extractClassMethods(body, name, symbols);
+                }
+            }
+        }
+        else if (node.type === 'lexical_declaration') {
+            // const/let declarations
+            for (const decl of node.namedChildren) {
+                if (decl.type === 'variable_declarator') {
+                    const name = extractName(decl);
+                    if (name) {
+                        symbols.push({
+                            name,
+                            kind: 'const',
+                            startLine,
+                            endLine,
+                            signature: firstLine(node.text),
+                        });
+                    }
+                }
+            }
+        }
+        else if (node.type === 'type_alias_declaration') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'type',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'interface_declaration') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'interface',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+    }
+    return symbols;
+}
+function extractClassMethods(body, className, symbols) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+        const member = body.namedChild(i);
+        if (member.type === 'method_definition' ||
+            member.type === 'public_field_definition') {
+            const name = extractName(member);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'method',
+                    parent: className,
+                    startLine: member.startPosition.row + 1,
+                    endLine: member.endPosition.row + 1,
+                    signature: firstLine(member.text),
+                });
+            }
+        }
+    }
+}
+function extractPySymbols(tree) {
+    const symbols = [];
+    const root = tree.rootNode;
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        const startLine = node.startPosition.row + 1;
+        const endLine = node.endPosition.row + 1;
+        if (node.type === 'function_definition') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'function',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'class_definition') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+                // Extract methods
+                const body = node.childForFieldName('body');
+                if (body) {
+                    for (let j = 0; j < body.namedChildCount; j++) {
+                        const member = body.namedChild(j);
+                        if (member.type === 'function_definition') {
+                            const methodName = extractName(member);
+                            if (methodName) {
+                                symbols.push({
+                                    name: methodName,
+                                    kind: 'method',
+                                    parent: name,
+                                    startLine: member.startPosition.row + 1,
+                                    endLine: member.endPosition.row + 1,
+                                    signature: firstLine(member.text),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else if (node.type === 'expression_statement' &&
+            node.namedChildCount === 1 &&
+            node.namedChild(0).type === 'assignment') {
+            // Top-level assignment: FOO = ...
+            const assign = node.namedChild(0);
+            const left = assign.childForFieldName('left');
+            if (left && left.type === 'identifier') {
+                symbols.push({
+                    name: left.text,
+                    kind: 'variable',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+    }
+    return symbols;
+}
+function extractRustSymbols(tree) {
+    const symbols = [];
+    const root = tree.rootNode;
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        const startLine = node.startPosition.row + 1;
+        const endLine = node.endPosition.row + 1;
+        if (node.type === 'function_item') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'function',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'struct_item') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'enum_item') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'trait_item') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'interface',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'impl_item') {
+            // impl Type { ... } or impl Trait for Type { ... }
+            const typeName = node.childForFieldName('type')?.text;
+            if (!typeName)
+                continue;
+            const body = node.childForFieldName('body');
+            if (!body)
+                continue;
+            for (let j = 0; j < body.namedChildCount; j++) {
+                const member = body.namedChild(j);
+                if (member.type === 'function_item') {
+                    const name = extractName(member);
+                    if (name) {
+                        symbols.push({
+                            name,
+                            kind: 'method',
+                            parent: typeName,
+                            startLine: member.startPosition.row + 1,
+                            endLine: member.endPosition.row + 1,
+                            signature: firstLine(member.text),
+                        });
+                    }
+                }
+            }
+        }
+        else if (node.type === 'const_item') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'const',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'static_item') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'variable',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'type_item') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'type',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+    }
+    return symbols;
+}
+/**
+ * Extract the receiver type name from a Go method declaration's receiver node.
+ * Handles both value receivers (Greeter) and pointer receivers (*Greeter).
+ */
+function goReceiverType(receiverNode) {
+    const param = receiverNode.namedChild(0);
+    if (!param)
+        return null;
+    const typeNode = param.childForFieldName('type');
+    if (!typeNode)
+        return null;
+    // pointer_type -> child is the actual type name
+    if (typeNode.type === 'pointer_type') {
+        return typeNode.namedChild(0)?.text ?? null;
+    }
+    return typeNode.text;
+}
+function extractGoSymbols(tree) {
+    const symbols = [];
+    const root = tree.rootNode;
+    for (let i = 0; i < root.childCount; i++) {
+        const node = root.child(i);
+        const startLine = node.startPosition.row + 1;
+        const endLine = node.endPosition.row + 1;
+        if (node.type === 'function_declaration') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'function',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'method_declaration') {
+            const name = extractName(node);
+            const receiver = node.childForFieldName('receiver');
+            const typeName = receiver ? goReceiverType(receiver) : null;
+            if (name && typeName) {
+                symbols.push({
+                    name,
+                    kind: 'method',
+                    parent: typeName,
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'type_declaration') {
+            for (let j = 0; j < node.namedChildCount; j++) {
+                const spec = node.namedChild(j);
+                if (spec.type !== 'type_spec')
+                    continue;
+                const name = spec.childForFieldName('name')?.text;
+                if (!name)
+                    continue;
+                const typeNode = spec.childForFieldName('type');
+                const kind = typeNode?.type === 'interface_type' ? 'interface' : 'class';
+                symbols.push({
+                    name,
+                    kind,
+                    startLine: spec.startPosition.row + 1,
+                    endLine: spec.endPosition.row + 1,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'const_declaration') {
+            for (let j = 0; j < node.namedChildCount; j++) {
+                const spec = node.namedChild(j);
+                if (spec.type !== 'const_spec')
+                    continue;
+                const name = spec.childForFieldName('name')?.text;
+                if (name) {
+                    symbols.push({
+                        name,
+                        kind: 'const',
+                        startLine: spec.startPosition.row + 1,
+                        endLine: spec.endPosition.row + 1,
+                        signature: firstLine(node.text),
+                    });
+                }
+            }
+        }
+        else if (node.type === 'var_declaration') {
+            for (let j = 0; j < node.namedChildCount; j++) {
+                const spec = node.namedChild(j);
+                if (spec.type !== 'var_spec')
+                    continue;
+                const name = spec.childForFieldName('name')?.text;
+                if (name) {
+                    symbols.push({
+                        name,
+                        kind: 'variable',
+                        startLine: spec.startPosition.row + 1,
+                        endLine: spec.endPosition.row + 1,
+                        signature: firstLine(node.text),
+                    });
+                }
+            }
+        }
+    }
+    return symbols;
+}
+/**
+ * Extract the declarator name from a C function_declarator node.
+ * Handles plain identifiers and pointer declarators (*name).
+ */
+function cFuncName(declarator) {
+    if (declarator.type === 'function_declarator') {
+        const inner = declarator.childForFieldName('declarator');
+        if (!inner)
+            return null;
+        if (inner.type === 'identifier')
+            return inner.text;
+        if (inner.type === 'pointer_declarator') {
+            // *name — dig through pointer layers
+            let cur = inner;
+            while (cur.type === 'pointer_declarator') {
+                const child = cur.childForFieldName('declarator');
+                if (!child)
+                    return null;
+                cur = child;
+            }
+            return cur.type === 'identifier' ? cur.text : null;
+        }
+    }
+    return null;
+}
+/**
+ * Extract the variable name from a C init_declarator or plain declarator.
+ * Handles pointers like `*DEFAULT_NAME = "World"`.
+ */
+function cVarName(declarator) {
+    let node = declarator;
+    // Unwrap init_declarator to get the declarator part
+    if (node.type === 'init_declarator') {
+        const inner = node.childForFieldName('declarator');
+        if (!inner)
+            return null;
+        node = inner;
+    }
+    if (node.type === 'identifier')
+        return node.text;
+    if (node.type === 'pointer_declarator') {
+        let cur = node;
+        while (cur.type === 'pointer_declarator') {
+            const child = cur.childForFieldName('declarator');
+            if (!child)
+                return null;
+            cur = child;
+        }
+        return cur.type === 'identifier' ? cur.text : null;
+    }
+    return null;
+}
+function extractCSymbols(tree) {
+    const symbols = [];
+    collectCNodes(tree.rootNode, symbols);
+    return symbols;
+}
+/**
+ * Walk C AST nodes, collecting symbols. Recurses into preproc_ifdef /
+ * preproc_ifndef blocks so header include guards don't hide declarations.
+ */
+function collectCNodes(parent, symbols) {
+    for (let i = 0; i < parent.childCount; i++) {
+        const node = parent.child(i);
+        const startLine = node.startPosition.row + 1;
+        const endLine = node.endPosition.row + 1;
+        if (node.type === 'function_definition') {
+            const declarator = node.childForFieldName('declarator');
+            const name = declarator ? cFuncName(declarator) : null;
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'function',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'struct_specifier') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'enum_specifier') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'class',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'type_definition') {
+            const declarator = node.childForFieldName('declarator');
+            const name = declarator?.type === 'type_identifier' ? declarator.text : null;
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'type',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'declaration') {
+            const declarator = node.childForFieldName('declarator');
+            const name = declarator ? cVarName(declarator) : null;
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'variable',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'preproc_def') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: 'const',
+                    startLine,
+                    endLine,
+                    signature: firstLine(node.text),
+                });
+            }
+        }
+        else if (node.type === 'preproc_ifdef' ||
+            node.type === 'preproc_ifndef') {
+            // Recurse into include guard / conditional blocks
+            collectCNodes(node, symbols);
+        }
+    }
+}
+function firstLine(text) {
+    const nl = text.indexOf('\n');
+    return nl === -1 ? text : text.slice(0, nl);
+}
+export async function parseSourceSymbols(filePath, content) {
+    const ext = filePath.match(/\.[^.]+$/)?.[0] ?? '';
+    const lang = await getLanguage(ext);
+    if (!lang)
+        return [];
+    const p = await ensureParser();
+    p.setLanguage(lang);
+    const tree = p.parse(content);
+    if (!tree)
+        return [];
+    if (ext === '.py') {
+        return extractPySymbols(tree);
+    }
+    if (ext === '.rs') {
+        return extractRustSymbols(tree);
+    }
+    if (ext === '.go') {
+        return extractGoSymbols(tree);
+    }
+    if (ext === '.c' || ext === '.h') {
+        return extractCSymbols(tree);
+    }
+    return extractTsSymbols(tree);
+}
+/**
+ * Check whether a source file path (relative to projectRoot) has a given symbol.
+ * Used by lat check to validate source code wiki links lazily.
+ */
+export async function resolveSourceSymbol(filePath, symbolPath, projectRoot) {
+    const absPath = join(projectRoot, filePath);
+    let content;
+    try {
+        content = readFileSync(absPath, 'utf-8');
+    }
+    catch {
+        return { found: false, symbols: [] };
+    }
+    let symbols;
+    try {
+        symbols = await parseSourceSymbols(filePath, content);
+    }
+    catch (err) {
+        return {
+            found: false,
+            symbols: [],
+            error: `failed to parse "${filePath}": ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const parts = symbolPath.split('#');
+    if (parts.length === 1) {
+        // Simple symbol: getConfigDir
+        const found = symbols.some((s) => s.name === parts[0] && !s.parent);
+        return { found, symbols };
+    }
+    if (parts.length === 2) {
+        // Nested symbol: MyClass#myMethod
+        const found = symbols.some((s) => s.name === parts[1] && s.parent === parts[0]);
+        return { found, symbols };
+    }
+    return { found: false, symbols };
+}
+/**
+ * Convert source symbols to Section objects for uniform handling.
+ */
+export function sourceSymbolsToSections(symbols, filePath) {
+    const sections = [];
+    const classMap = new Map();
+    for (const sym of symbols) {
+        if (sym.parent)
+            continue; // Handle methods after their class
+        const section = {
+            id: `${filePath}#${sym.name}`,
+            heading: sym.name,
+            depth: 1,
+            file: filePath,
+            filePath,
+            children: [],
+            startLine: sym.startLine,
+            endLine: sym.endLine,
+            firstParagraph: sym.signature,
+        };
+        sections.push(section);
+        if (sym.kind === 'class') {
+            classMap.set(sym.name, section);
+        }
+    }
+    // Add methods as children
+    for (const sym of symbols) {
+        if (!sym.parent)
+            continue;
+        const parentSection = classMap.get(sym.parent);
+        if (!parentSection)
+            continue;
+        const section = {
+            id: `${filePath}#${sym.parent}#${sym.name}`,
+            heading: sym.name,
+            depth: 2,
+            file: filePath,
+            filePath,
+            children: [],
+            startLine: sym.startLine,
+            endLine: sym.endLine,
+            firstParagraph: sym.signature,
+        };
+        parentSection.children.push(section);
+    }
+    return sections;
+}