kodingo-cli 1.0.27 → 1.0.29

package/dist/commands/scan-git.js

@@ -7,13 +7,81 @@ exports.scanGitCommand = scanGitCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+const ast_parser_1 = require("../utils/ast-parser");
+const persistence_config_1 = require("../utils/persistence-config");
 const simple_git_1 = __importDefault(require("simple-git"));
 const git_listener_1 = require("../adapters/git-adapter/git-listener");
 const db_event_port_1 = require("../ports/db-event-port");
 const cloud_event_port_1 = require("../ports/cloud-event-port");
-const persistence_config_1 = require("../utils/persistence-config");
+const persistence_config_2 = require("../utils/persistence-config");
+const API_BASE_DEFAULT = "https://kodingo-api.onrender.com";
+function getCredentials(repoRoot) {
+    const config = (0, persistence_config_1.readConfig)();
+    const normRoot = repoRoot.replace(/\/+$/, "");
+    let wsEntry = config.workspaces?.[normRoot] ?? config.workspaces?.[normRoot + "/"];
+    // Walk parent directories
+    let current = normRoot;
+    while (!wsEntry && current !== path_1.default.dirname(current)) {
+        current = path_1.default.dirname(current);
+        wsEntry = config.workspaces?.[current] ?? config.workspaces?.[current + "/"];
+    }
+    const token = wsEntry?.token ?? config.token ?? "";
+    const apiUrl = wsEntry?.apiUrl ?? config.apiUrl ?? API_BASE_DEFAULT;
+    return { token, apiUrl };
+}
+async function detectContextDecay(repoRoot, changedFiles) {
+    const { token, apiUrl } = getCredentials(repoRoot);
+    if (!token)
+        return;
+    const repoName = path_1.default.basename(repoRoot);
+    for (const filePath of changedFiles) {
+        if (!fs_1.default.existsSync(filePath))
+            continue;
+        try {
+            const source = fs_1.default.readFileSync(filePath, "utf-8");
+            const nodes = await (0, ast_parser_1.parseFile)(filePath, source);
+            for (const node of nodes) {
+                if (!node.fingerprint)
+                    continue;
+                // Check if this fingerprint exists under a DIFFERENT symbol/repo
+                const res = await fetch(`${apiUrl}/memory?fingerprint=${encodeURIComponent(node.fingerprint)}&limit=5`, { headers: { "X-Kodingo-Token": token } });
+                if (!res.ok)
+                    continue;
+                const data = await res.json();
+                const memories = data.data ?? [];
+                for (const m of memories) {
+                    const sameSymbol = m.symbol === node.name;
+                    const sameRepo = m.repo === repoName;
+                    if (!sameSymbol || !sameRepo) {
+                        // Fingerprint match but different identity — this is a rename/move
+                        const migrateRes = await fetch(`${apiUrl}/memory/migrate`, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                            body: JSON.stringify({
+                                fingerprint: node.fingerprint,
+                                oldSymbol: m.symbol,
+                                newSymbol: node.name,
+                                oldRepo: m.repo ?? repoName,
+                                newRepo: repoName,
+                            }),
+                        });
+                        if (migrateRes.ok) {
+                            const result = await migrateRes.json();
+                            if (result.migrated > 0) {
+                                console.log(`  ↳ Kortex: ${result.migrated} memor${result.migrated === 1 ? "y" : "ies"} followed rename: ${m.symbol} → ${node.name}`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // silent — never block the commit flow
+        }
+    }
+}
 async function scanGitCommand(options) {
-    const { initDb, getMemoryByExternalId } = (0, persistence_config_1.getPersistence)();
+    const { initDb, getMemoryByExternalId } = (0, persistence_config_2.getPersistence)();
     const repoRoot = resolveRepoRoot(options);
     await initDb();
     const git = (0, simple_git_1.default)(repoRoot);
@@ -30,7 +98,7 @@ async function scanGitCommand(options) {
         console.log(`Git scan skipped (already stored) for repo: ${repoRoot} commit: ${commitHash.slice(0, 8)}`);
         return;
     }
-    const eventPort = (0, persistence_config_1.isCloudMode)()
+    const eventPort = (0, persistence_config_2.isCloudMode)()
         ? new cloud_event_port_1.CloudEventPort(repoRoot)
         : new db_event_port_1.DbEventPort(repoRoot);
     const adapter = new git_listener_1.GitListenerAdapter(repoRoot, eventPort, 5000);

package/dist/commands/scan-repo.js

@@ -54,20 +54,13 @@ const fs_1 = __importDefault(require("fs"));
 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 API_BASE = "https://kodingo-api.onrender.com";
 const SUPPORTED_EXTENSIONS = [
     ".ts", ".tsx", ".js", ".jsx",
     ".py", ".go", ".rs", ".php",
     ".java", ".kt", ".rb", ".c", ".cpp",
 ];
-const SYMBOL_PATTERNS = [
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
-    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/,
-    /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\(/,
-    /^def\s+(\w+)\s*\(/,
-    /^func\s+(\w+)\s*\(/,
-    /^(?:pub\s+)?fn\s+(\w+)\s*\(/,
-];
 const IGNORED_DIRS = [
     "node_modules", ".git", ".kortex", "dist", "build",
     "out", ".next", "coverage", "__pycache__", "vendor",
@@ -105,26 +98,16 @@ function walkFiles(dir) {
     catch { }
     return results;
 }
-function extractSymbols(filePath) {
+async function extractSymbols(filePath) {
     try {
-        const text = fs_1.default.readFileSync(filePath, "utf-8");
-        const lines = text.split("\n");
-        const entries = [];
-        for (let i = 0; i < lines.length; i++) {
-            const trimmed = lines[i].trim();
-            for (const pat of SYMBOL_PATTERNS) {
-                const m = trimmed.match(pat);
-                if (m?.[1]) {
-                    entries.push({
-                        name: m[1],
-                        code: lines.slice(i, i + 40).join("\n"),
-                        file: filePath,
-                    });
-                    break;
-                }
-            }
-        }
-        return entries;
+        const source = fs_1.default.readFileSync(filePath, "utf-8");
+        const nodes = await (0, ast_parser_1.parseFile)(filePath, source);
+        return nodes.map(n => ({
+            name: n.name,
+            code: n.body.slice(0, 2000), // cap to avoid huge payloads
+            file: filePath,
+            fingerprint: n.fingerprint,
+        }));
     }
     catch {
         return [];
@@ -180,6 +163,7 @@ async function inferAndCapture(token, symbol, repo) {
                 confidence: 0.35,
                 machineId: (0, persistence_config_1.readConfig)().machineId ?? undefined,
                 displayName: os.hostname(),
+                fingerprint: symbol.fingerprint ?? undefined,
             }),
         });
         return saveRes.ok;
@@ -210,7 +194,7 @@ async function scanRepoCommand(options = {}) {
     const files = walkFiles(repoRoot);
     const allSymbols = [];
     for (const file of files) {
-        allSymbols.push(...extractSymbols(file));
+        allSymbols.push(...(await extractSymbols(file)));
     }
     if (allSymbols.length === 0) {
         if (!options.silent)

package/dist/utils/ast-parser.js

@@ -0,0 +1,313 @@
+"use strict";
+/**
+ * ast-parser.ts
+ *
+ * Extracts symbol nodes from source files using proper AST parsing for
+ * TypeScript/JavaScript and improved structural parsing for other languages.
+ *
+ * Returns SymbolNode objects with stable fingerprints that survive renames.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeFingerprint = computeFingerprint;
+exports.parseFile = parseFile;
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+// ── Fingerprint ───────────────────────────────────────────────────────────────
+/**
+ * Normalise function body and hash it.
+ * Strips: whitespace, comments, string literals.
+ * Survives: renames, variable name changes, log additions, typo fixes.
+ * Breaks on: structural logic changes (intentional).
+ */
+function computeFingerprint(body) {
+    const normalised = body
+        .replace(/\/\/.*$/gm, "") // remove single-line comments
+        .replace(/\/\*[\s\S]*?\*\//g, "") // remove multi-line comments
+        .replace(/#.*$/gm, "") // remove Python comments
+        .replace(/(["\`\'])(?:(?!\1)[\s\S])*?\1/g, "STR") // replace string literals
+        .replace(/\b\d+\b/g, "NUM") // replace numeric literals
+        .replace(/\s+/g, " ") // collapse whitespace
+        .trim();
+    return (0, crypto_1.createHash)("sha256").update(normalised).digest("hex").slice(0, 16);
+}
+// ── TypeScript / JavaScript parser ───────────────────────────────────────────
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { parse: tsParse } = require("@typescript-eslint/typescript-estree");
+async function parseTypeScript(filePath, source) {
+    try {
+        const parse = tsParse;
+        const isTs = /\.(ts|tsx)$/.test(filePath);
+        const ast = parse(source, {
+            jsx: true,
+            loc: true,
+            range: true,
+            errorRecovery: true,
+            ...(isTs ? { filePath } : {}),
+        });
+        const symbols = [];
+        const lines = source.split("\n");
+        function getBody(start, end) {
+            return source.slice(start, end);
+        }
+        function visit(node, className) {
+            if (!node || typeof node !== "object")
+                return;
+            if (node.type === "FunctionDeclaration" && node.id?.name) {
+                const body = getBody(node.range[0], node.range[1]);
+                symbols.push({
+                    name: node.id.name,
+                    type: "function",
+                    file: filePath,
+                    startLine: node.loc.start.line,
+                    endLine: node.loc.end.line,
+                    body,
+                    fingerprint: computeFingerprint(body),
+                });
+            }
+            if ((node.type === "VariableDeclarator") &&
+                node.id?.name &&
+                node.init &&
+                (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression")) {
+                const body = getBody(node.init.range[0], node.init.range[1]);
+                symbols.push({
+                    name: node.id.name,
+                    type: "arrow_function",
+                    file: filePath,
+                    startLine: node.loc.start.line,
+                    endLine: node.loc.end.line,
+                    body,
+                    fingerprint: computeFingerprint(body),
+                });
+            }
+            if (node.type === "ClassDeclaration" ||
+                node.type === "ClassExpression") {
+                const name = node.id?.name;
+                if (name) {
+                    const body = getBody(node.range[0], node.range[1]);
+                    symbols.push({
+                        name,
+                        type: "class",
+                        file: filePath,
+                        startLine: node.loc.start.line,
+                        endLine: node.loc.end.line,
+                        body,
+                        fingerprint: computeFingerprint(body),
+                    });
+                    // Visit methods inside the class
+                    if (node.body?.body) {
+                        for (const member of node.body.body) {
+                            if ((member.type === "MethodDefinition" || member.type === "PropertyDefinition") &&
+                                member.key?.name &&
+                                member.value?.type === "FunctionExpression") {
+                                const mBody = getBody(member.range[0], member.range[1]);
+                                symbols.push({
+                                    name: `${name}.${member.key.name}`,
+                                    type: "method",
+                                    file: filePath,
+                                    startLine: member.loc.start.line,
+                                    endLine: member.loc.end.line,
+                                    body: mBody,
+                                    fingerprint: computeFingerprint(mBody),
+                                });
+                            }
+                        }
+                    }
+                }
+                return; // already handled children
+            }
+            // Recurse
+            for (const key of Object.keys(node)) {
+                if (key === "parent")
+                    continue;
+                const child = node[key];
+                if (Array.isArray(child)) {
+                    for (const c of child)
+                        visit(c, className);
+                }
+                else if (child && typeof child === "object" && child.type) {
+                    visit(child, className);
+                }
+            }
+        }
+        visit(ast);
+        return symbols;
+    }
+    catch {
+        return [];
+    }
+}
+// ── Structural parser for other languages ────────────────────────────────────
+/**
+ * Extracts symbols using brace-depth tracking.
+ * Works for Go, Rust, Java, Kotlin, PHP, Ruby, C/C++.
+ */
+function parseStructural(filePath, source, patterns) {
+    const symbols = [];
+    const lines = source.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        for (const pattern of patterns) {
+            const match = line.match(pattern);
+            if (!match?.[1])
+                continue;
+            const name = match[1];
+            const startLine = i + 1;
+            // Find the matching closing brace
+            let depth = 0;
+            let endLine = startLine;
+            let started = false;
+            for (let j = i; j < lines.length; j++) {
+                for (const ch of lines[j]) {
+                    if (ch === "{") {
+                        depth++;
+                        started = true;
+                    }
+                    if (ch === "}") {
+                        depth--;
+                    }
+                }
+                if (started && depth === 0) {
+                    endLine = j + 1;
+                    break;
+                }
+            }
+            const body = lines.slice(i, endLine).join("\n");
+            symbols.push({
+                name,
+                type: line.match(/class\s/) ? "class" : "function",
+                file: filePath,
+                startLine,
+                endLine,
+                body,
+                fingerprint: computeFingerprint(body),
+            });
+            break;
+        }
+    }
+    return symbols;
+}
+/** Python uses indentation-based scoping */
+function parsePython(filePath, source) {
+    const symbols = [];
+    const lines = source.split("\n");
+    const defPattern = /^(async\s+)?def\s+(\w+)\s*\(/;
+    const classPattern = /^class\s+(\w+)/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const defMatch = line.match(defPattern);
+        const classMatch = line.match(classPattern);
+        const match = defMatch || classMatch;
+        if (!match)
+            continue;
+        const name = defMatch ? match[2] : match[1];
+        const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+        const startLine = i + 1;
+        let endLine = startLine;
+        for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j];
+            if (nextLine.trim() === "")
+                continue;
+            const nextIndent = nextLine.match(/^(\s*)/)?.[1].length ?? 0;
+            if (nextIndent <= indent && nextLine.trim() !== "") {
+                endLine = j;
+                break;
+            }
+            endLine = j + 1;
+        }
+        const body = lines.slice(i, endLine).join("\n");
+        symbols.push({
+            name,
+            type: classMatch ? "class" : "function",
+            file: filePath,
+            startLine,
+            endLine,
+            body,
+            fingerprint: computeFingerprint(body),
+        });
+    }
+    return symbols;
+}
+// ── Language dispatch ─────────────────────────────────────────────────────────
+const GO_PATTERNS = [
+    /^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(/,
+];
+const RUST_PATTERNS = [
+    /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+];
+const JAVA_PATTERNS = [
+    /^(?:public|private|protected|static|\s)+[\w<>\[\]]+\s+(\w+)\s*\(/,
+    /^(?:public|private|protected|abstract|\s)*class\s+(\w+)/,
+];
+const PHP_PATTERNS = [
+    /^(?:public|private|protected|static|\s)*function\s+(\w+)\s*\(/,
+    /^(?:abstract\s+)?class\s+(\w+)/,
+];
+const RUBY_PATTERNS = [
+    /^def\s+(\w+)/,
+    /^class\s+(\w+)/,
+];
+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+)/,
+];
+async function parseFile(filePath, source) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case ".ts":
+        case ".tsx":
+        case ".js":
+        case ".jsx":
+        case ".mjs":
+        case ".cjs":
+            return parseTypeScript(filePath, source);
+        case ".py":
+            return parsePython(filePath, source);
+        case ".go":
+            return parseStructural(filePath, source, GO_PATTERNS);
+        case ".rs":
+            return parseStructural(filePath, source, RUST_PATTERNS);
+        case ".java":
+            return parseStructural(filePath, source, JAVA_PATTERNS);
+        case ".php":
+            return parseStructural(filePath, source, PHP_PATTERNS);
+        case ".rb":
+            return parseStructural(filePath, source, RUBY_PATTERNS);
+        case ".kt":
+            return parseStructural(filePath, source, KOTLIN_PATTERNS);
+        default:
+            return [];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodingo-cli",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,
@@ -22,6 +22,8 @@
   "dependencies": {
     "@babel/parser": "^7.29.0",
     "@babel/traverse": "^7.29.0",
+    "@typescript-eslint/types": "^8.61.1",
+    "@typescript-eslint/typescript-estree": "^8.61.1",
     "commander": "^12.1.0",
     "kodingo-core": "^0.1.0",
     "open": "^11.0.0",