lat.md 0.10.1 → 0.10.3

package/dist/src/cli/check.js

@@ -3,7 +3,7 @@ import { existsSync } from 'node:fs';
 import { basename, dirname, extname, join, relative } from 'node:path';
 import { listLatticeFiles, loadAllSections, extractRefs, flattenSections, parseFrontmatter, parseSections, buildFileIndex, resolveRef, } from '../lattice.js';
 import { scanCodeRefs } from '../code-refs.js';
-import { SOURCE_EXTENSIONS } from '../source-parser.js';
+import { SOURCE_EXTENSIONS, clearSymbolCache } from '../source-parser.js';
 import { walkEntries } from '../walk.js';
 import { INIT_VERSION, readInitVersion } from '../init-version.js';
 function filePart(id) {
@@ -82,6 +82,7 @@ async function tryResolveSourceRef(target, projectRoot) {
     }
 }
 export async function checkMd(latticeDir) {
+    clearSymbolCache();
     const projectRoot = dirname(latticeDir);
     const files = await listLatticeFiles(latticeDir);
     const allSections = await loadAllSections(latticeDir);

package/dist/src/source-parser.d.ts

@@ -10,6 +10,8 @@ export type SourceSymbol = {
 /** All source file extensions that lat can parse (derived from grammarMap). */
 export declare const SOURCE_EXTENSIONS: ReadonlySet<string>;
 export declare function parseSourceSymbols(filePath: string, content: string): Promise<SourceSymbol[]>;
+/** Clear the symbol cache. Call between top-level operations. */
+export declare function clearSymbolCache(): void;
 /**
  * Check whether a source file path (relative to projectRoot) has a given symbol.
  * Used by lat check to validate source code wiki links lazily.

package/dist/src/source-parser.js

@@ -477,8 +477,17 @@ function extractGoSymbols(tree) {
  * Handles plain identifiers and pointer declarators (*name).
  */
 function cFuncName(declarator) {
-    if (declarator.type === 'function_declarator') {
-        const inner = declarator.childForFieldName('declarator');
+    // Unwrap pointer_declarator layers (for functions returning pointers,
+    // e.g. `JSRuntime *JS_NewRuntime(void)` → pointer_declarator > function_declarator)
+    let node = declarator;
+    while (node.type === 'pointer_declarator') {
+        const child = node.childForFieldName('declarator');
+        if (!child)
+            return null;
+        node = child;
+    }
+    if (node.type === 'function_declarator') {
+        const inner = node.childForFieldName('declarator');
         if (!inner)
             return null;
         if (inner.type === 'identifier')
@@ -510,6 +519,13 @@ function cVarName(declarator) {
             return null;
         node = inner;
     }
+    // Unwrap array_declarator (e.g. `char js_version[]`)
+    if (node.type === 'array_declarator') {
+        const inner = node.childForFieldName('declarator');
+        if (!inner)
+            return null;
+        node = inner;
+    }
     if (node.type === 'identifier')
         return node.text;
     if (node.type === 'pointer_declarator') {
@@ -530,8 +546,13 @@ function extractCSymbols(tree) {
     return symbols;
 }
 /**
- * Walk C AST nodes, collecting symbols. Recurses into preproc_ifdef /
- * preproc_ifndef blocks so header include guards don't hide declarations.
+ * Walk C AST nodes, collecting symbols. Recurses into preprocessor
+ * conditional blocks (ifdef/ifndef/if), linkage specifications
+ * (extern "C" { ... }), and declaration lists so that include guards
+ * and conditional compilation don't hide declarations.
+ *
+ * For #if/#ifdef/#ifndef, only the "then" branch is traversed —
+ * preproc_else and preproc_elif children are skipped.
  */
 function collectCNodes(parent, symbols) {
     for (let i = 0; i < parent.childCount; i++) {
@@ -576,7 +597,12 @@ function collectCNodes(parent, symbols) {
             }
         }
         else if (node.type === 'type_definition') {
-            const declarator = node.childForFieldName('declarator');
+            let declarator = node.childForFieldName('declarator');
+            // Unwrap pointer_declarator for pointer typedefs
+            // e.g. `typedef struct __JSValue *JSValue;`
+            while (declarator?.type === 'pointer_declarator') {
+                declarator = declarator.childForFieldName('declarator') ?? null;
+            }
             const name = declarator?.type === 'type_identifier' ? declarator.text : null;
             if (name) {
                 symbols.push({
@@ -590,18 +616,33 @@ function collectCNodes(parent, symbols) {
         }
         else if (node.type === 'declaration') {
             const declarator = node.childForFieldName('declarator');
-            const name = declarator ? cVarName(declarator) : null;
-            if (name) {
+            // Try as function declaration first (e.g. `void greet(const char *name);`
+            // in headers), then fall back to variable.
+            const funcName = declarator ? cFuncName(declarator) : null;
+            if (funcName) {
                 symbols.push({
-                    name,
-                    kind: 'variable',
+                    name: funcName,
+                    kind: 'function',
                     startLine,
                     endLine,
                     signature: firstLine(node.text),
                 });
             }
+            else {
+                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') {
+        else if (node.type === 'preproc_def' ||
+            node.type === 'preproc_function_def') {
             const name = extractName(node);
             if (name) {
                 symbols.push({
@@ -614,10 +655,21 @@ function collectCNodes(parent, symbols) {
             }
         }
         else if (node.type === 'preproc_ifdef' ||
-            node.type === 'preproc_ifndef') {
-            // Recurse into include guard / conditional blocks
+            node.type === 'preproc_ifndef' ||
+            node.type === 'preproc_if') {
+            // Recurse into conditional blocks (then-branch only).
+            // preproc_else / preproc_elif children are skipped.
+            collectCNodes(node, symbols);
+        }
+        else if (node.type === 'linkage_specification' ||
+            node.type === 'declaration_list') {
+            // extern "C" { ... } wraps declarations in linkage_specification
+            // containing a declaration_list — recurse through both.
             collectCNodes(node, symbols);
         }
+        else if (node.type === 'preproc_else' || node.type === 'preproc_elif') {
+            // Skip else/elif branches of preprocessor conditionals.
+        }
     }
 }
 function firstLine(text) {
@@ -634,19 +686,32 @@ export async function parseSourceSymbols(filePath, content) {
     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);
+    try {
+        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);
     }
-    if (ext === '.c' || ext === '.h') {
-        return extractCSymbols(tree);
+    finally {
+        tree.delete();
     }
-    return extractTsSymbols(tree);
+}
+// Per-invocation cache for parsed source symbols, keyed by absolute file path.
+// Prevents re-parsing the same file when multiple wiki links reference it
+// (e.g. 20+ links to quickjs.c would otherwise parse a 60K-line file 20 times).
+const symbolCache = new Map();
+/** Clear the symbol cache. Call between top-level operations. */
+export function clearSymbolCache() {
+    symbolCache.clear();
 }
 /**
  * Check whether a source file path (relative to projectRoot) has a given symbol.
@@ -654,24 +719,33 @@ export async function parseSourceSymbols(filePath, content) {
  */
 export async function resolveSourceSymbol(filePath, symbolPath, projectRoot) {
     const absPath = join(projectRoot, filePath);
-    let content;
-    try {
-        content = readFileSync(absPath, 'utf-8');
+    let cached = symbolCache.get(absPath);
+    if (!cached) {
+        let content;
+        try {
+            content = readFileSync(absPath, 'utf-8');
+        }
+        catch {
+            cached = { symbols: [] };
+            symbolCache.set(absPath, cached);
+            return { found: false, symbols: [] };
+        }
+        try {
+            const symbols = await parseSourceSymbols(filePath, content);
+            cached = { symbols };
+        }
+        catch (err) {
+            cached = {
+                symbols: [],
+                error: `failed to parse "${filePath}": ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        symbolCache.set(absPath, cached);
     }
-    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)}`,
-        };
+    if (cached.error) {
+        return { found: false, symbols: cached.symbols, error: cached.error };
     }
+    const { symbols } = cached;
     const parts = symbolPath.split('#');
     if (parts.length === 1) {
         // Simple symbol: getConfigDir

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lat.md",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "A knowledge graph for your codebase, written in markdown",
   "type": "module",
   "packageManager": "pnpm@10.30.2",