kodingo-cli 1.0.38 → 1.1.0

package/dist/cli.js

@@ -14,6 +14,7 @@ const deny_1 = require("./commands/deny");
 const scan_git_1 = require("./commands/scan-git");
 const scan_claude_1 = require("./commands/scan-claude");
 const scan_repo_1 = require("./commands/scan-repo");
+const sync_graph_1 = require("./commands/sync-graph");
 const init_1 = require("./commands/init");
 const install_hook_1 = require("./commands/install-hook");
 const update_1 = require("./commands/update");
@@ -231,6 +232,16 @@ program
         payload.repo = String(options.repo);
     await (0, scan_repo_1.scanRepoCommand)(payload);
 });
+program
+    .command("sync-graph")
+    .description("Build and sync the structural relationship graph for the current repo")
+    .option("--repo <path>", "repo path to scan")
+    .action(async (options) => {
+    const payload = {};
+    if (options.repo)
+        payload.repo = String(options.repo);
+    await (0, sync_graph_1.syncGraphCommand)(payload);
+});
 program
     .command("context")
     .description("Get affirmed memories for a file — designed for AI agents")

package/dist/commands/scan-repo.js

@@ -55,6 +55,8 @@ const path_1 = __importDefault(require("path"));
 const persistence_config_1 = require("../utils/persistence-config");
 const os = __importStar(require("os"));
 const ast_parser_1 = require("../utils/ast-parser");
+const graph_builder_1 = require("../utils/graph-builder");
+const context_assembler_1 = require("../utils/context-assembler");
 const API_BASE = "https://kodingo-api.onrender.com";
 const SUPPORTED_EXTENSIONS = [
     ".ts", ".tsx", ".js", ".jsx",
@@ -124,7 +126,8 @@ async function fetchExistingSymbols(token, repo, apiUrl) {
             if (!res.ok)
                 break;
             const data = await res.json();
-            for (const m of data.memories ?? []) {
+            const page = data.data ?? [];
+            for (const m of page) {
                 if (m.symbol) {
                     // Store both symbol-only and symbol::repo keys for accurate matching
                     known.add(m.symbol);
@@ -133,8 +136,8 @@ async function fetchExistingSymbols(token, repo, apiUrl) {
                 }
             }
             offset += limit;
-            if (offset >= (data.total ?? 0))
-                break;
+            if (page.length < limit)
+                break; // fewer than a full page means we've reached the end
         }
     }
     catch { }
@@ -150,12 +153,29 @@ async function sendSignal(token, apiUrl, memoryId, weightClass) {
     }
     catch { }
 }
-async function inferAndCapture(token, symbol, repo) {
+async function inferAndCapture(token, symbol, repo, graph, repoRoot) {
     try {
-        const inferRes = await fetch(`${API_BASE}/infer`, {
+        // Use contextual inference when the graph knows this symbol — richer, structure-grounded reasoning.
+        // Falls back to isolated /infer for symbols the graph didn't resolve (e.g. parse failures).
+        const useContextual = graph && symbol.fingerprint && graph.nodes[symbol.fingerprint];
+        const endpoint = useContextual ? "/infer/contextual" : "/infer";
+        let body = { symbol: symbol.name, code: symbol.code };
+        if (useContextual && graph && symbol.fingerprint) {
+            const assembled = (0, context_assembler_1.assembleContext)(repoRoot, graph, symbol.fingerprint);
+            if (assembled) {
+                body = {
+                    symbol: symbol.name,
+                    code: symbol.code,
+                    callers: assembled.callers.map(c => ({ name: c.name, snippet: c.snippet, confidence: c.confidence })),
+                    callees: assembled.callees.map(c => ({ name: c.name, snippet: c.snippet, confidence: c.confidence })),
+                    weakestConfidence: assembled.weakestConfidence,
+                };
+            }
+        }
+        const inferRes = await fetch(`${API_BASE}${endpoint}`, {
             method: "POST",
             headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
-            body: JSON.stringify({ symbol: symbol.name, code: symbol.code }),
+            body: JSON.stringify(body),
         });
         if (!inferRes.ok)
             return false;
@@ -217,8 +237,27 @@ async function scanRepoCommand(options = {}) {
     }
     // Fetch all existing memory symbols in one bulk call
     const { known: existingSymbols, idMap: existingIds } = await fetchExistingSymbols(token, repoName, apiUrl);
-    // Shuffle so repeated runs cover different parts of the codebase
-    const shuffled = [...allSymbols].sort(() => Math.random() - 0.5);
+    // Build (or reuse) the structural graph — used to order symbols by
+    // centrality (most structurally critical first) instead of randomly,
+    // and to assemble context for richer, structure-grounded inference.
+    let graph = null;
+    try {
+        graph = await (0, graph_builder_1.buildGraph)(repoRoot);
+        (0, graph_builder_1.saveGraph)(repoRoot, graph);
+    }
+    catch {
+        graph = null;
+    }
+    const ordered = graph
+        ? [...allSymbols].sort((a, b) => {
+            const centralityA = a.fingerprint && graph.nodes[a.fingerprint] ? graph.nodes[a.fingerprint].centrality : -1;
+            const centralityB = b.fingerprint && graph.nodes[b.fingerprint] ? graph.nodes[b.fingerprint].centrality : -1;
+            if (centralityA !== centralityB)
+                return centralityB - centralityA;
+            return Math.random() - 0.5;
+        })
+        : [...allSymbols].sort(() => Math.random() - 0.5);
+    const shuffled = ordered;
     // Filter locally — no per-symbol API calls needed
     const toCapture = [];
     const seen = new Set();
@@ -253,7 +292,7 @@ async function scanRepoCommand(options = {}) {
     let captured = 0;
     for (let i = 0; i < toCapture.length; i += BATCH_SIZE) {
         const batch = toCapture.slice(i, i + BATCH_SIZE);
-        const results = await Promise.all(batch.map(sym => inferAndCapture(token, sym, repoName)));
+        const results = await Promise.all(batch.map(sym => inferAndCapture(token, sym, repoName, graph, repoRoot)));
         const batchCaptured = results.filter(Boolean).length;
         captured += batchCaptured;
         if (!options.silent) {

package/dist/commands/sync-graph.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * kodingo sync-graph
+ *
+ * Builds the structural relationship graph for the current repo, diffs it
+ * against the previously saved local graph, and syncs only the diff to the
+ * server. Safe to run repeatedly — nodes are upserted, edges are additive
+ * with soft-delete on removal.
+ *
+ * Designed to be fast on repeat runs since only changed files need re-parsing
+ * in a future incremental version; for now it does a full local rebuild but
+ * only transmits the diff over the network.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncGraphCommand = syncGraphCommand;
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+const repo_scope_1 = require("../utils/repo-scope");
+const graph_builder_1 = require("../utils/graph-builder");
+async function syncGraphCommand(options = {}) {
+    const repoRoot = (0, repo_scope_1.resolveRepoScope)(options.repo ? { repo: options.repo } : {}) ?? process.cwd();
+    const config = (0, persistence_config_1.readConfig)();
+    const wsConfig = (0, persistence_config_1.readWorkspaceConfig)(repoRoot);
+    const token = wsConfig?.token ?? "";
+    const apiUrl = wsConfig?.apiUrl ?? config.apiUrl ?? "https://kodingo-api.onrender.com";
+    if (!token) {
+        if (!options.silent)
+            console.error("✖ This repo is not connected to Kodingo. Run `kodingo init` first.");
+        return false;
+    }
+    const repoName = path_1.default.basename(repoRoot);
+    if (!options.silent)
+        console.log(`\n🧠 Kortex — building structural graph for ${repoName}...\n`);
+    const previous = (0, graph_builder_1.loadGraph)(repoRoot);
+    const current = await (0, graph_builder_1.buildGraph)(repoRoot);
+    const diff = (0, graph_builder_1.diffGraphs)(previous, current);
+    if (diff.added.length === 0 && diff.removed.length === 0 && diff.edgesAdded.length === 0 && diff.edgesRemoved.length === 0) {
+        if (!options.silent)
+            console.log("  ✔ No structural changes detected. Graph is up to date.");
+        return true;
+    }
+    if (!options.silent) {
+        console.log(`  ${diff.added.length} symbols, ${diff.edgesAdded.length} new relationships detected`);
+    }
+    // Chunk large syncs to respect the server's per-request caps (2000 nodes / 10000 edges)
+    const NODE_CHUNK = 1500;
+    const EDGE_CHUNK = 8000;
+    try {
+        for (let i = 0; i < diff.added.length || i === 0; i += NODE_CHUNK) {
+            const nodeChunk = diff.added.slice(i, i + NODE_CHUNK);
+            const edgeChunk = i === 0 ? diff.edgesAdded.slice(0, EDGE_CHUNK) : [];
+            const res = await fetch(`${apiUrl}/graph/sync`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                body: JSON.stringify({
+                    repo: repoName,
+                    added: nodeChunk.map(n => ({
+                        fingerprint: n.fingerprint,
+                        name: n.name,
+                        file: path_1.default.relative(repoRoot, n.file),
+                        type: n.type,
+                        language: n.language,
+                        startLine: n.startLine,
+                        endLine: n.endLine,
+                        resolutionTier: n.resolutionTier,
+                        fanIn: n.fanIn,
+                        fanOut: n.fanOut,
+                        centrality: n.centrality,
+                    })),
+                    removed: i === 0 ? diff.removed : [],
+                    edgesAdded: edgeChunk.map(e => ({
+                        fromFingerprint: e.from,
+                        toFingerprint: e.to,
+                        edgeType: e.type,
+                        confidence: e.confidence,
+                        file: path_1.default.relative(repoRoot, e.file),
+                        line: e.line,
+                    })),
+                    edgesRemoved: i === 0 ? diff.edgesRemoved.map(e => ({ fromFingerprint: e.from, toFingerprint: e.to })) : [],
+                }),
+            });
+            if (!res.ok) {
+                if (!options.silent)
+                    console.error(`  ✖ Sync failed: ${res.status} ${await res.text()}`);
+                return false;
+            }
+            if (diff.added.length === 0)
+                break; // ensure single-iteration exit when nothing to chunk
+        }
+    }
+    catch (err) {
+        if (!options.silent)
+            console.error(`  ✖ Sync failed: ${err.message}`);
+        return false;
+    }
+    (0, graph_builder_1.saveGraph)(repoRoot, current);
+    if (!options.silent) {
+        console.log(`\n✔ Graph synced — ${Object.keys(current.nodes).length} symbols, ${current.edges.length} relationships tracked for ${repoName}`);
+    }
+    return true;
+}

package/dist/utils/ast-parser.js

@@ -63,9 +63,73 @@ function computeFingerprint(body) {
         .trim();
     return (0, crypto_1.createHash)("sha256").update(normalised).digest("hex").slice(0, 16);
 }
+// ── Lightweight call extraction for non-TS languages (heuristic, Tier 2) ─────
+/** Regex-based call-site extraction: matches `identifier(` patterns. Not scope-resolved. */
+function extractCallNamesRegex(body) {
+    const calls = new Set();
+    const pattern = /\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+    let match;
+    while ((match = pattern.exec(body)) !== null) {
+        calls.add(match[1]);
+    }
+    return Array.from(calls);
+}
 // ── TypeScript / JavaScript parser ───────────────────────────────────────────
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { parse: tsParse } = require("@typescript-eslint/typescript-estree");
+// ── Import extraction ────────────────────────────────────────────────────────
+function extractImports(ast) {
+    const imports = [];
+    const body = ast.body ?? [];
+    for (const node of body) {
+        if (node.type !== "ImportDeclaration" || !node.source?.value)
+            continue;
+        const source = node.source.value;
+        for (const spec of node.specifiers ?? []) {
+            if (spec.type === "ImportDefaultSpecifier" && spec.local?.name) {
+                imports.push({ imported: spec.local.name, source, isDefault: true });
+            }
+            else if (spec.type === "ImportSpecifier" && spec.local?.name) {
+                imports.push({ imported: spec.local.name, source, isDefault: false });
+            }
+            else if (spec.type === "ImportNamespaceSpecifier" && spec.local?.name) {
+                imports.push({ imported: spec.local.name, source, isDefault: false });
+            }
+        }
+    }
+    return imports;
+}
+// ── Call-site extraction ──────────────────────────────────────────────────────
+/** Walks a symbol's body subtree and collects callee identifier names. Heuristic — not scope-resolved. */
+function extractCallNames(node, acc = new Set()) {
+    function walk(n) {
+        if (!n || typeof n !== "object")
+            return;
+        if (n.type === "CallExpression") {
+            const callee = n.callee;
+            if (callee?.type === "Identifier" && callee.name) {
+                acc.add(callee.name);
+            }
+            else if (callee?.type === "MemberExpression" && callee.property?.name) {
+                acc.add(callee.property.name);
+            }
+        }
+        for (const key of Object.keys(n)) {
+            if (key === "parent")
+                continue;
+            const child = n[key];
+            if (Array.isArray(child)) {
+                for (const c of child)
+                    walk(c);
+            }
+            else if (child && typeof child === "object" && child.type) {
+                walk(child);
+            }
+        }
+    }
+    walk(node);
+    return Array.from(acc);
+}
 async function parseTypeScript(filePath, source) {
     try {
         const parse = tsParse;
@@ -79,6 +143,7 @@ async function parseTypeScript(filePath, source) {
         });
         const symbols = [];
         const lines = source.split("\n");
+        const fileImports = extractImports(ast);
         function getBody(start, end) {
             return source.slice(start, end);
         }
@@ -95,6 +160,8 @@ async function parseTypeScript(filePath, source) {
                     endLine: node.loc.end.line,
                     body,
                     fingerprint: computeFingerprint(body),
+                    calls: extractCallNames(node.body),
+                    imports: fileImports,
                 });
             }
             if ((node.type === "VariableDeclarator") &&
@@ -110,6 +177,8 @@ async function parseTypeScript(filePath, source) {
                     endLine: node.loc.end.line,
                     body,
                     fingerprint: computeFingerprint(body),
+                    calls: extractCallNames(node.init.body),
+                    imports: fileImports,
                 });
             }
             if (node.type === "ClassDeclaration" ||
@@ -125,6 +194,8 @@ async function parseTypeScript(filePath, source) {
                         endLine: node.loc.end.line,
                         body,
                         fingerprint: computeFingerprint(body),
+                        calls: extractCallNames(node.body),
+                        imports: fileImports,
                     });
                     // Visit methods inside the class
                     if (node.body?.body) {
@@ -141,6 +212,8 @@ async function parseTypeScript(filePath, source) {
                                     endLine: member.loc.end.line,
                                     body: mBody,
                                     fingerprint: computeFingerprint(mBody),
+                                    calls: extractCallNames(member.value?.body),
+                                    imports: fileImports,
                                 });
                             }
                         }
@@ -213,6 +286,8 @@ function parseStructural(filePath, source, patterns) {
                 endLine,
                 body,
                 fingerprint: computeFingerprint(body),
+                calls: extractCallNamesRegex(body),
+                imports: [],
             });
             break;
         }
@@ -256,6 +331,8 @@ function parsePython(filePath, source) {
             endLine,
             body,
             fingerprint: computeFingerprint(body),
+            calls: extractCallNamesRegex(body),
+            imports: [],
         });
     }
     return symbols;
@@ -283,6 +360,7 @@ const KOTLIN_PATTERNS = [
     /^(?:fun|override\s+fun|suspend\s+fun|private\s+fun|public\s+fun)\s+(\w+)/,
     /^(?:class|data class|object|interface)\s+(\w+)/,
 ];
+const TREE_SITTER_EXTENSIONS = new Set([".py", ".go", ".rs", ".java", ".kt", ".rb", ".php", ".c", ".cpp"]);
 async function parseFile(filePath, source) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
@@ -293,6 +371,21 @@ async function parseFile(filePath, source) {
         case ".mjs":
         case ".cjs":
             return parseTypeScript(filePath, source);
+        default:
+            break;
+    }
+    if (TREE_SITTER_EXTENSIONS.has(ext)) {
+        try {
+            const { parseWithTreeSitter } = require("./tree-sitter-parser");
+            const result = await parseWithTreeSitter(filePath, source);
+            if (result.length > 0)
+                return result;
+        }
+        catch {
+            // fall through to legacy heuristic parsers below
+        }
+    }
+    switch (ext) {
         case ".py":
             return parsePython(filePath, source);
         case ".go":

package/dist/utils/context-assembler.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * context-assembler.ts
+ *
+ * Given a target symbol's fingerprint and the repo's structural graph,
+ * assembles a bounded 1-hop neighborhood: what it calls, what calls it,
+ * and its imports. This is the context sent to /infer/contextual instead
+ * of reasoning about a function in total isolation.
+ *
+ * Token budget is enforced by truncating the lowest-confidence neighbors
+ * first — never sends unbounded context.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleContext = assembleContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DEFAULT_TOKEN_BUDGET = 3000;
+const CHARS_PER_TOKEN_ESTIMATE = 4;
+const MAX_SNIPPET_CHARS = 500; // per-neighbor cap before budget truncation
+function readSnippet(repoRoot, file, startLine, endLine) {
+    try {
+        const absPath = path_1.default.isAbsolute(file) ? file : path_1.default.join(repoRoot, file);
+        const source = fs_1.default.readFileSync(absPath, "utf-8");
+        const lines = source.split("\n");
+        const snippet = lines.slice(Math.max(0, startLine - 1), endLine).join("\n");
+        return snippet.length > MAX_SNIPPET_CHARS ? snippet.slice(0, MAX_SNIPPET_CHARS) + "\n// ...truncated" : snippet;
+    }
+    catch {
+        return null;
+    }
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
+}
+function assembleContext(repoRoot, graph, targetFingerprint, tokenBudget = DEFAULT_TOKEN_BUDGET) {
+    const target = graph.nodes[targetFingerprint];
+    if (!target)
+        return null;
+    const targetBody = readSnippet(repoRoot, target.file, target.startLine, target.endLine);
+    if (targetBody === null)
+        return null;
+    let usedTokens = estimateTokens(targetBody);
+    // Callees: edges where this symbol is the source
+    const calleeEdges = graph.edges
+        .filter(e => e.from === targetFingerprint)
+        .sort((a, b) => b.confidence - a.confidence);
+    // Callers: edges where this symbol is the target
+    const callerEdges = graph.edges
+        .filter(e => e.to === targetFingerprint)
+        .sort((a, b) => b.confidence - a.confidence);
+    function buildNeighbors(edges, direction) {
+        const neighbors = [];
+        for (const edge of edges) {
+            const neighborFingerprint = direction === "from" ? edge.to : edge.from;
+            const neighborNode = graph.nodes[neighborFingerprint];
+            if (!neighborNode)
+                continue;
+            const snippet = readSnippet(repoRoot, neighborNode.file, neighborNode.startLine, neighborNode.endLine);
+            if (snippet === null)
+                continue;
+            const projected = usedTokens + estimateTokens(snippet);
+            if (projected > tokenBudget)
+                break; // budget exhausted — remaining lower-confidence neighbors are dropped
+            usedTokens = projected;
+            neighbors.push({
+                name: neighborNode.name,
+                file: neighborNode.file,
+                snippet,
+                confidence: edge.confidence,
+                edgeType: edge.type,
+            });
+        }
+        return neighbors;
+    }
+    const callees = buildNeighbors(calleeEdges, "from");
+    const callers = buildNeighbors(callerEdges, "to");
+    const allConfidences = [...callees, ...callers].map(n => n.confidence);
+    const weakestConfidence = allConfidences.length > 0 ? Math.min(...allConfidences) : 1.0;
+    return {
+        targetName: target.name,
+        targetFile: target.file,
+        targetBody,
+        callers,
+        callees,
+        imports: [], // populated by caller if needed — graph doesn't currently store per-node imports
+        weakestConfidence,
+    };
+}

package/dist/utils/graph-builder.js

@@ -0,0 +1,384 @@
+"use strict";
+/**
+ * graph-builder.ts
+ *
+ * Builds a structural relationship graph (KortexGraph) for a repository.
+ *
+ * Nodes are keyed by fingerprint (stable across renames/moves — same mechanism
+ * used for memory symbols). Edges represent "calls" relationships between symbols.
+ *
+ * Resolution has two tiers:
+ *  - Tier 1 (TypeScript/JavaScript): uses the TypeScript compiler's type checker
+ *    to resolve call expressions to their actual declaration, giving near-100%
+ *    accurate edges. Confidence = 1.0.
+ *  - Tier 2 (all other languages): heuristic name-based matching against the
+ *    repo-wide symbol table. Confidence is scored by name uniqueness.
+ *
+ * This module performs zero LLM calls. Pure static analysis.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraph = buildGraph;
+exports.diffGraphs = diffGraphs;
+exports.saveGraph = saveGraph;
+exports.loadGraph = loadGraph;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ts = __importStar(require("typescript"));
+const ast_parser_1 = require("./ast-parser");
+const SUPPORTED_EXTENSIONS = [
+    ".ts", ".tsx", ".js", ".jsx",
+    ".py", ".go", ".rs", ".php",
+    ".java", ".kt", ".rb", ".c", ".cpp",
+];
+const TS_JS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
+const IGNORED_DIRS = [
+    "node_modules", ".git", ".kortex", "dist", "build",
+    "out", ".next", "coverage", "__pycache__", "vendor",
+];
+function walkFiles(dir) {
+    const results = [];
+    try {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (IGNORED_DIRS.includes(entry.name))
+                continue;
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...walkFiles(fullPath));
+            }
+            else if (entry.isFile() && SUPPORTED_EXTENSIONS.includes(path_1.default.extname(entry.name))) {
+                results.push(fullPath);
+            }
+        }
+    }
+    catch { }
+    return results;
+}
+function languageForFile(file) {
+    const ext = path_1.default.extname(file).toLowerCase();
+    const map = {
+        ".ts": "typescript", ".tsx": "typescript",
+        ".js": "javascript", ".jsx": "javascript",
+        ".py": "python", ".go": "go", ".rs": "rust",
+        ".php": "php", ".java": "java", ".kt": "kotlin",
+        ".rb": "ruby", ".c": "c", ".cpp": "cpp",
+    };
+    return map[ext] ?? "unknown";
+}
+async function collectAllSymbols(repoRoot) {
+    const files = walkFiles(repoRoot);
+    const all = [];
+    for (const file of files) {
+        try {
+            const source = fs_1.default.readFileSync(file, "utf-8");
+            const nodes = await (0, ast_parser_1.parseFile)(file, source);
+            for (const n of nodes) {
+                all.push({ ...n, language: languageForFile(file) });
+            }
+        }
+        catch { }
+    }
+    return all;
+}
+function buildNameIndex(symbols) {
+    const index = new Map();
+    for (const sym of symbols) {
+        const shortName = sym.name.includes(".") ? sym.name.split(".").pop() : sym.name;
+        const existing = index.get(shortName) ?? [];
+        existing.push(sym.fingerprint);
+        index.set(shortName, existing);
+    }
+    return index;
+}
+function resolveTier2Edges(symbols, nameIndex) {
+    const edges = [];
+    for (const sym of symbols) {
+        if (TS_JS_EXTENSIONS.has(path_1.default.extname(sym.file)))
+            continue;
+        for (const calledName of sym.calls) {
+            const candidates = nameIndex.get(calledName);
+            if (!candidates || candidates.length === 0)
+                continue;
+            const uniqueCandidates = Array.from(new Set(candidates));
+            const confidence = uniqueCandidates.length === 1 ? 0.8 : Math.max(0.2, 0.6 / uniqueCandidates.length);
+            for (const targetFingerprint of uniqueCandidates) {
+                if (targetFingerprint === sym.fingerprint)
+                    continue;
+                edges.push({
+                    from: sym.fingerprint,
+                    to: targetFingerprint,
+                    type: "calls",
+                    confidence,
+                    file: sym.file,
+                    line: sym.startLine,
+                });
+            }
+        }
+    }
+    return edges;
+}
+function resolveTier1Edges(repoRoot, tsFiles, symbols) {
+    if (tsFiles.length === 0)
+        return [];
+    const edges = [];
+    const symbolsByFile = new Map();
+    for (const sym of symbols) {
+        if (!TS_JS_EXTENSIONS.has(path_1.default.extname(sym.file)))
+            continue;
+        const list = symbolsByFile.get(sym.file) ?? [];
+        list.push(sym);
+        symbolsByFile.set(sym.file, list);
+    }
+    function findEnclosingSymbol(file, line) {
+        const candidates = symbolsByFile.get(file);
+        if (!candidates)
+            return null;
+        let best = null;
+        for (const c of candidates) {
+            if (line >= c.startLine && line <= c.endLine) {
+                if (!best || (c.endLine - c.startLine) < (best.endLine - best.startLine)) {
+                    best = c;
+                }
+            }
+        }
+        return best;
+    }
+    let tsconfigPath;
+    try {
+        tsconfigPath = ts.findConfigFile(repoRoot, ts.sys.fileExists, "tsconfig.json") ?? undefined;
+    }
+    catch {
+        tsconfigPath = undefined;
+    }
+    let compilerOptions = {
+        allowJs: true,
+        jsx: ts.JsxEmit.Preserve,
+        module: ts.ModuleKind.CommonJS,
+        target: ts.ScriptTarget.ES2020,
+        noEmit: true,
+    };
+    if (tsconfigPath) {
+        try {
+            const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+            const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path_1.default.dirname(tsconfigPath));
+            compilerOptions = { ...compilerOptions, ...parsed.options, noEmit: true };
+        }
+        catch { }
+    }
+    let program;
+    try {
+        program = ts.createProgram(tsFiles, compilerOptions);
+    }
+    catch {
+        return [];
+    }
+    const checker = program.getTypeChecker();
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile)
+            continue;
+        if (!tsFiles.includes(sourceFile.fileName))
+            continue;
+        function recordEdge(identifierNode, edgeType) {
+            try {
+                let symbol = checker.getSymbolAtLocation(identifierNode);
+                // Resolve import aliases to the real declaration — otherwise imported
+                // symbols point at the import statement itself, not the function body.
+                if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {
+                    symbol = checker.getAliasedSymbol(symbol);
+                }
+                const declarations = symbol?.getDeclarations();
+                if (!declarations || declarations.length === 0)
+                    return;
+                const decl = declarations[0];
+                const declFile = decl.getSourceFile().fileName;
+                const declLine = decl.getSourceFile().getLineAndCharacterOfPosition(decl.getStart()).line + 1;
+                const targetSymbol = findEnclosingSymbol(declFile, declLine);
+                const refLine = sourceFile.getLineAndCharacterOfPosition(identifierNode.getStart()).line + 1;
+                const callerSymbol = findEnclosingSymbol(sourceFile.fileName, refLine);
+                if (targetSymbol && callerSymbol && targetSymbol.fingerprint !== callerSymbol.fingerprint) {
+                    edges.push({
+                        from: callerSymbol.fingerprint,
+                        to: targetSymbol.fingerprint,
+                        type: edgeType,
+                        confidence: edgeType === "calls" ? 1.0 : 0.9,
+                        file: sourceFile.fileName,
+                        line: refLine,
+                    });
+                }
+            }
+            catch { }
+        }
+        function visit(node) {
+            if (ts.isCallExpression(node)) {
+                // The call target itself — e.g. authMiddleware() — direct invocation
+                recordEdge(node.expression, "calls");
+                // Arguments passed to this call that resolve to known function symbols —
+                // e.g. app.addHook("preHandler", authMiddleware) — registration/callback pattern.
+                // This is where middleware, event handlers, and hooks get missed if we only
+                // look at direct calls.
+                for (const arg of node.arguments) {
+                    if (ts.isIdentifier(arg)) {
+                        recordEdge(arg, "references");
+                    }
+                }
+            }
+            // Also catch bare identifier references outside call arguments —
+            // e.g. `export const handler = someFunction;` or object literal values
+            // like `{ preHandler: authMiddleware }`.
+            if (ts.isIdentifier(node) &&
+                !ts.isCallExpression(node.parent) &&
+                node.parent &&
+                (ts.isPropertyAssignment(node.parent) || ts.isVariableDeclaration(node.parent) || ts.isBinaryExpression(node.parent))) {
+                recordEdge(node, "references");
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+    }
+    return edges;
+}
+function computeCentrality(nodes, edges) {
+    for (const edge of edges) {
+        if (nodes[edge.to])
+            nodes[edge.to].fanIn += edge.confidence;
+        if (nodes[edge.from])
+            nodes[edge.from].fanOut += edge.confidence;
+    }
+    for (const node of Object.values(nodes)) {
+        node.centrality = node.fanIn * 2 + node.fanOut;
+    }
+}
+async function buildGraph(repoRoot) {
+    const symbols = await collectAllSymbols(repoRoot);
+    const nodes = {};
+    for (const sym of symbols) {
+        const isTsJs = TS_JS_EXTENSIONS.has(path_1.default.extname(sym.file));
+        nodes[sym.fingerprint] = {
+            fingerprint: sym.fingerprint,
+            name: sym.name,
+            file: sym.file,
+            type: sym.type,
+            startLine: sym.startLine,
+            endLine: sym.endLine,
+            language: sym.language,
+            resolutionTier: isTsJs ? 1 : 2,
+            fanIn: 0,
+            fanOut: 0,
+            centrality: 0,
+        };
+    }
+    const tsFiles = symbols
+        .map(s => s.file)
+        .filter(f => TS_JS_EXTENSIONS.has(path_1.default.extname(f)))
+        .filter((f, i, arr) => arr.indexOf(f) === i);
+    const tier1Edges = resolveTier1Edges(repoRoot, tsFiles, symbols);
+    const nameIndex = buildNameIndex(symbols);
+    const tier2Edges = resolveTier2Edges(symbols, nameIndex);
+    const edges = [...tier1Edges, ...tier2Edges];
+    computeCentrality(nodes, edges);
+    return {
+        builtAt: new Date().toISOString(),
+        repoRoot,
+        nodes,
+        edges,
+    };
+}
+function edgeKey(e) {
+    return `${e.from}::${e.to}::${e.type}`;
+}
+/**
+ * Diffs the freshly built graph against the previously saved one.
+ * Nodes are compared by fingerprint. Edges are compared by (from, to, type) —
+ * this prevents re-inserting the same edge on every sync while still allowing
+ * confidence values to be refreshed via the "added" path (upsert semantics).
+ */
+function diffGraphs(previous, current) {
+    const prevNodeKeys = new Set(previous ? Object.keys(previous.nodes) : []);
+    const currNodeKeys = new Set(Object.keys(current.nodes));
+    const added = [];
+    for (const key of currNodeKeys) {
+        // Always include changed nodes — cheap to upsert, and centrality/fanIn/fanOut
+        // change frequently even when the symbol itself hasn't moved.
+        added.push(current.nodes[key]);
+    }
+    const removed = [];
+    for (const key of prevNodeKeys) {
+        if (!currNodeKeys.has(key))
+            removed.push(key);
+    }
+    const prevEdgeMap = new Map();
+    for (const e of previous?.edges ?? []) {
+        prevEdgeMap.set(edgeKey(e), e);
+    }
+    const currEdgeMap = new Map();
+    for (const e of current.edges) {
+        currEdgeMap.set(edgeKey(e), e);
+    }
+    const edgesAdded = [];
+    for (const [key, edge] of currEdgeMap) {
+        if (!prevEdgeMap.has(key))
+            edgesAdded.push(edge);
+    }
+    const edgesRemoved = [];
+    for (const [key, edge] of prevEdgeMap) {
+        if (!currEdgeMap.has(key)) {
+            edgesRemoved.push({ from: edge.from, to: edge.to, type: edge.type });
+        }
+    }
+    return { added, removed, edgesAdded, edgesRemoved };
+}
+function saveGraph(repoRoot, graph) {
+    const kortexDir = path_1.default.join(repoRoot, ".kortex");
+    if (!fs_1.default.existsSync(kortexDir)) {
+        fs_1.default.mkdirSync(kortexDir, { recursive: true });
+    }
+    const graphPath = path_1.default.join(kortexDir, "graph.json");
+    fs_1.default.writeFileSync(graphPath, JSON.stringify(graph, null, 2), "utf-8");
+}
+function loadGraph(repoRoot) {
+    const graphPath = path_1.default.join(repoRoot, ".kortex", "graph.json");
+    if (!fs_1.default.existsSync(graphPath))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(graphPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/tree-sitter-parser.js

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * tree-sitter-parser.ts
+ *
+ * Real AST-based symbol extraction for non-TS/JS languages, using web-tree-sitter
+ * with prebuilt WASM grammars (tree-sitter-wasms) — no native compilation required,
+ * works identically on any developer machine.
+ *
+ * This replaces regex/brace-counting heuristics (parseStructural, parsePython in
+ * ast-parser.ts) with genuine parse trees. Call and declaration extraction is still
+ * heuristic in the sense that it isn't type-checked (that's Tier 1, TS/JS only via
+ * the compiler), but it is now grounded in a real AST rather than pattern matching
+ * over raw text — eliminating false positives from strings/comments that merely
+ * look like declarations or calls.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWithTreeSitter = parseWithTreeSitter;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const web_tree_sitter_1 = __importDefault(require("web-tree-sitter"));
+const ast_parser_1 = require("./ast-parser");
+const LANGUAGE_CONFIGS = {
+    python: {
+        wasmFile: "tree-sitter-python.wasm",
+        functionTypes: ["function_definition"],
+        classTypes: ["class_definition"],
+        callTypes: ["call"],
+        calleeFieldCandidates: ["function"],
+        nameFieldCandidates: ["name"],
+        importTypes: ["import_statement", "import_from_statement"],
+    },
+    go: {
+        wasmFile: "tree-sitter-go.wasm",
+        functionTypes: ["function_declaration", "method_declaration"],
+        classTypes: [],
+        callTypes: ["call_expression"],
+        calleeFieldCandidates: ["function"],
+        nameFieldCandidates: ["name"],
+        importTypes: ["import_spec"],
+    },
+    rust: {
+        wasmFile: "tree-sitter-rust.wasm",
+        functionTypes: ["function_item"],
+        classTypes: ["impl_item"],
+        callTypes: ["call_expression"],
+        calleeFieldCandidates: ["function"],
+        nameFieldCandidates: ["name", "type"],
+        importTypes: ["use_declaration"],
+    },
+    java: {
+        wasmFile: "tree-sitter-java.wasm",
+        functionTypes: ["method_declaration", "constructor_declaration"],
+        classTypes: ["class_declaration", "interface_declaration"],
+        callTypes: ["method_invocation"],
+        calleeFieldCandidates: ["name"],
+        nameFieldCandidates: ["name"],
+        importTypes: ["import_declaration"],
+    },
+    kotlin: {
+        wasmFile: "tree-sitter-kotlin.wasm",
+        functionTypes: ["function_declaration"],
+        classTypes: ["class_declaration"],
+        callTypes: ["call_expression"],
+        calleeFieldCandidates: ["function"],
+        nameFieldCandidates: ["name"],
+        importTypes: ["import_header"],
+    },
+    ruby: {
+        wasmFile: "tree-sitter-ruby.wasm",
+        functionTypes: ["method", "singleton_method"],
+        classTypes: ["class", "module"],
+        callTypes: ["call", "method_call"],
+        calleeFieldCandidates: ["method"],
+        nameFieldCandidates: ["name"],
+        importTypes: [],
+    },
+    php: {
+        wasmFile: "tree-sitter-php.wasm",
+        functionTypes: ["function_definition", "method_declaration"],
+        classTypes: ["class_declaration"],
+        callTypes: ["function_call_expression", "member_call_expression", "scoped_call_expression"],
+        calleeFieldCandidates: ["function", "name"],
+        nameFieldCandidates: ["name"],
+        importTypes: ["namespace_use_declaration"],
+    },
+    c: {
+        wasmFile: "tree-sitter-c.wasm",
+        functionTypes: ["function_definition"],
+        classTypes: [],
+        callTypes: ["call_expression"],
+        calleeFieldCandidates: ["function"],
+        nameFieldCandidates: [], // handled via declarator fallback
+        importTypes: ["preproc_include"],
+    },
+    cpp: {
+        wasmFile: "tree-sitter-cpp.wasm",
+        functionTypes: ["function_definition"],
+        classTypes: ["class_specifier", "struct_specifier"],
+        callTypes: ["call_expression"],
+        calleeFieldCandidates: ["function"],
+        nameFieldCandidates: [], // handled via declarator fallback
+        importTypes: ["preproc_include"],
+    },
+};
+const EXT_TO_LANGUAGE = {
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".rb": "ruby",
+    ".php": "php",
+    ".c": "c",
+    ".cpp": "cpp",
+};
+let initialised = false;
+const languageCache = new Map();
+async function ensureInit() {
+    if (!initialised) {
+        await web_tree_sitter_1.default.init();
+        initialised = true;
+    }
+}
+async function loadLanguage(key, config) {
+    const cached = languageCache.get(key);
+    if (cached)
+        return cached;
+    const wasmDir = path_1.default.join(path_1.default.dirname(require.resolve("tree-sitter-wasms/package.json")), "out");
+    const wasmPath = path_1.default.join(wasmDir, config.wasmFile);
+    const wasmBuffer = fs_1.default.readFileSync(wasmPath);
+    const lang = await web_tree_sitter_1.default.Language.load(wasmBuffer);
+    languageCache.set(key, lang);
+    return lang;
+}
+// ── Node helpers ──────────────────────────────────────────────────────────────
+function getFieldOrFallback(node, candidates) {
+    for (const field of candidates) {
+        const child = node.childForFieldName(field);
+        if (child)
+            return child;
+    }
+    return null;
+}
+/** Descends through nested declarators (C/C++ function name pattern) to find the innermost identifier. */
+function extractDeclaratorName(node) {
+    let current = node.childForFieldName("declarator");
+    let guard = 0;
+    while (current && guard < 10) {
+        guard++;
+        if (current.type === "identifier" || current.type === "field_identifier") {
+            return current.text;
+        }
+        const nested = current.childForFieldName("declarator");
+        if (!nested)
+            break;
+        current = nested;
+    }
+    return null;
+}
+function getNodeName(node, config) {
+    const viaField = getFieldOrFallback(node, config.nameFieldCandidates);
+    if (viaField)
+        return viaField.text;
+    const viaDeclarator = extractDeclaratorName(node);
+    if (viaDeclarator)
+        return viaDeclarator;
+    // Last resort: first identifier-like named child
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && (child.type === "identifier" || child.type === "type_identifier" || child.type === "simple_identifier")) {
+            return child.text;
+        }
+    }
+    return null;
+}
+/** Extracts a trailing identifier from a callee expression (e.g. "$this->service->method" -> "method"). */
+function extractTrailingIdentifier(text) {
+    const match = text.match(/([A-Za-z_][A-Za-z0-9_]*)$/);
+    return match ? match[1] : null;
+}
+function extractCallNamesTs(node, config) {
+    const calls = new Set();
+    function walk(n) {
+        if (config.callTypes.includes(n.type)) {
+            const calleeNode = getFieldOrFallback(n, config.calleeFieldCandidates) ?? n.namedChild(0);
+            if (calleeNode) {
+                const name = extractTrailingIdentifier(calleeNode.text);
+                if (name)
+                    calls.add(name);
+            }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+            const child = n.namedChild(i);
+            if (child)
+                walk(child);
+        }
+    }
+    walk(node);
+    return Array.from(calls);
+}
+function extractImportsTs(root, config) {
+    const imports = [];
+    if (config.importTypes.length === 0)
+        return imports;
+    function walk(n) {
+        if (config.importTypes.includes(n.type)) {
+            imports.push({ imported: "", source: n.text.trim(), isDefault: false });
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+            const child = n.namedChild(i);
+            if (child)
+                walk(child);
+        }
+    }
+    walk(root);
+    return imports;
+}
+// ── Main extraction ───────────────────────────────────────────────────────────
+async function parseWithTreeSitter(filePath, source) {
+    const ext = path_1.default.extname(filePath).toLowerCase();
+    const langKey = EXT_TO_LANGUAGE[ext];
+    if (!langKey)
+        return [];
+    const config = LANGUAGE_CONFIGS[langKey];
+    if (!config)
+        return [];
+    try {
+        await ensureInit();
+        const language = await loadLanguage(langKey, config);
+        const parser = new web_tree_sitter_1.default();
+        parser.setLanguage(language);
+        const tree = parser.parse(source);
+        const root = tree.rootNode;
+        const fileImports = extractImportsTs(root, config);
+        const symbols = [];
+        function visit(node, enclosingClassName) {
+            if (config.classTypes.includes(node.type)) {
+                const className = getNodeName(node, config);
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const child = node.namedChild(i);
+                    if (child)
+                        visit(child, className ?? undefined);
+                }
+                return;
+            }
+            if (config.functionTypes.includes(node.type)) {
+                const rawName = getNodeName(node, config);
+                if (rawName) {
+                    const qualifiedName = enclosingClassName ? enclosingClassName + "." + rawName : rawName;
+                    const body = node.text;
+                    symbols.push({
+                        name: qualifiedName,
+                        type: enclosingClassName ? "method" : "function",
+                        file: filePath,
+                        startLine: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        body,
+                        fingerprint: (0, ast_parser_1.computeFingerprint)(body),
+                        calls: extractCallNamesTs(node, config),
+                        imports: fileImports,
+                    });
+                }
+                // still recurse in case of nested closures/functions
+            }
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child)
+                    visit(child, enclosingClassName);
+            }
+        }
+        visit(root);
+        return symbols;
+    }
+    catch {
+        // Parsing failures must never crash a full-repo scan — return empty for this file
+        return [];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodingo-cli",
-  "version": "1.0.38",
+  "version": "1.1.0",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,
@@ -28,12 +28,14 @@
     "kodingo-core": "^0.2.1",
     "open": "^11.0.0",
     "simple-git": "^3.30.0",
-    "uuid": "^10.0.0"
+    "tree-sitter-wasms": "^0.1.13",
+    "typescript": "^5.9.3",
+    "uuid": "^10.0.0",
+    "web-tree-sitter": "^0.20.8"
   },
   "devDependencies": {
     "@types/babel__traverse": "^7.28.0",
     "@types/node": "^22.19.20",
-    "@types/uuid": "^10.0.0",
-    "typescript": "^5.6.0"
+    "@types/uuid": "^10.0.0"
   }
 }