kodingo-cli 1.0.7 → 1.0.9

package/dist/adapters/git-adapter/git-listener.js

@@ -145,41 +145,130 @@ class GitListenerAdapter {
         this.lastProcessedCommit = latestCommit.hash;
     }
     /**
-     * Extract touched function/class names for JS/TS files (best effort).
-     * NOTE: Parses working tree file, not historical snapshot (acceptable for MVP).
+    /**
+     * Extract touched function/class/method names from changed files.
+     * Supports: JS, TS, JSX, TSX (AST), PHP, Python, Go, Rust, Java, Kotlin, Ruby, C/C++ (regex).
      */
     extractTouchedSymbols(diffFiles) {
         const symbols = [];
         for (const file of diffFiles) {
             if (file.binary)
                 continue;
-            const isTsOrJs = file.file.endsWith(".ts") || file.file.endsWith(".js");
-            if (!isTsOrJs)
-                continue;
             const absFilePath = path_1.default.join(this.repoPath, file.file);
             if (!fs_1.default.existsSync(absFilePath))
                 continue;
-            const content = fs_1.default.readFileSync(absFilePath, "utf-8");
-            try {
-                const ast = (0, parser_1.parse)(content, {
-                    sourceType: "module",
-                    plugins: ["typescript", "classProperties"],
-                });
-                (0, traverse_1.default)(ast, {
-                    FunctionDeclaration(p) {
-                        const name = p?.node?.id?.name;
+            const src = fs_1.default.readFileSync(absFilePath, "utf-8");
+            const ext = file.file.split(".").pop()?.toLowerCase() ?? "";
+            // JS / TS / JSX / TSX — AST parser
+            if (["ts", "tsx", "js", "jsx", "mjs", "cjs"].includes(ext)) {
+                try {
+                    const ast = (0, parser_1.parse)(src, {
+                        sourceType: "module",
+                        plugins: ["typescript", "classProperties", "jsx", "decorators-legacy", "classStaticBlock"],
+                    });
+                    (0, traverse_1.default)(ast, {
+                        FunctionDeclaration(p) {
+                            const name = p?.node?.id?.name;
+                            if (name)
+                                symbols.push(`function:${name}`);
+                        },
+                        ArrowFunctionExpression(p) {
+                            const parent = p?.parent;
+                            if (parent?.type === "VariableDeclarator" && parent?.id?.name) {
+                                symbols.push(`function:${parent.id.name}`);
+                            }
+                        },
+                        ClassDeclaration(p) {
+                            const name = p?.node?.id?.name;
+                            if (name)
+                                symbols.push(`class:${name}`);
+                        },
+                        ClassMethod(p) {
+                            const name = p?.node?.key?.name;
+                            if (name && name !== "constructor")
+                                symbols.push(`method:${name}`);
+                        },
+                    });
+                }
+                catch {
+                    for (const m of src.matchAll(/(?:function\s+(\w+)|const\s+(\w+)\s*=\s*(?:async\s*)?\()/g)) {
+                        const name = m[1] || m[2];
                         if (name)
                             symbols.push(`function:${name}`);
-                    },
-                    ClassDeclaration(p) {
-                        const name = p?.node?.id?.name;
-                        if (name)
-                            symbols.push(`class:${name}`);
-                    },
-                });
+                    }
+                }
+                continue;
+            }
+            // PHP
+            if (ext === "php") {
+                for (const m of src.matchAll(/(?:function\s+(\w+)\s*\(|class\s+(\w+)(?:\s+extends|\s+implements|\s*\{))/g)) {
+                    const name = m[1] || m[2];
+                    if (name)
+                        symbols.push(m[1] ? `function:${name}` : `class:${name}`);
+                }
+                continue;
+            }
+            // Python
+            if (ext === "py") {
+                for (const m of src.matchAll(/^(?:async\s+)?def\s+(\w+)\s*\(|^class\s+(\w+)/gm)) {
+                    const name = m[1] || m[2];
+                    if (name)
+                        symbols.push(m[1] ? `function:${name}` : `class:${name}`);
+                }
+                continue;
+            }
+            // Go
+            if (ext === "go") {
+                for (const m of src.matchAll(/^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(/gm)) {
+                    if (m[1])
+                        symbols.push(`function:${m[1]}`);
+                }
+                continue;
             }
-            catch {
-                // Ignore parse errors for MVP
+            // Rust
+            if (ext === "rs") {
+                for (const m of src.matchAll(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)|^(?:pub\s+)?struct\s+(\w+)|^(?:pub\s+)?impl\s+(\w+)/gm)) {
+                    const name = m[1] || m[2] || m[3];
+                    if (name)
+                        symbols.push(m[1] ? `function:${name}` : m[2] ? `struct:${name}` : `impl:${name}`);
+                }
+                continue;
+            }
+            // Java
+            if (ext === "java") {
+                for (const m of src.matchAll(/(?:public|private|protected|static|\s)+[\w<>\[\]]+\s+(\w+)\s*\([^)]*\)\s*(?:throws\s+\w+\s*)?\{|(?:public|private|protected)?\s*(?:abstract\s+)?class\s+(\w+)/g)) {
+                    const name = m[1] || m[2];
+                    if (name)
+                        symbols.push(m[1] ? `method:${name}` : `class:${name}`);
+                }
+                continue;
+            }
+            // Kotlin
+            if (ext === "kt" || ext === "kts") {
+                for (const m of src.matchAll(/(?:fun\s+(\w+)\s*\(|class\s+(\w+)|object\s+(\w+))/g)) {
+                    const name = m[1] || m[2] || m[3];
+                    if (name)
+                        symbols.push(m[1] ? `function:${name}` : `class:${name}`);
+                }
+                continue;
+            }
+            // Ruby
+            if (ext === "rb") {
+                for (const m of src.matchAll(/^(?:def\s+(\w+)|class\s+(\w+))/gm)) {
+                    const name = m[1] || m[2];
+                    if (name)
+                        symbols.push(m[1] ? `function:${name}` : `class:${name}`);
+                }
+                continue;
+            }
+            // C / C++
+            if (["c", "cpp", "cc", "cxx", "h", "hpp"].includes(ext)) {
+                for (const m of src.matchAll(/^[\w:*&<>\s]+\s+(\w+)\s*\([^)]*\)\s*(?:const\s*)?\{/gm)) {
+                    if (m[1] && !["if", "for", "while", "switch", "catch"].includes(m[1])) {
+                        symbols.push(`function:${m[1]}`);
+                    }
+                }
+                continue;
             }
         }
         return Array.from(new Set(symbols));

package/dist/commands/init.js

@@ -38,10 +38,26 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInitCommand = registerInitCommand;
 const readline = __importStar(require("node:readline"));
 const persistence_config_1 = require("../utils/persistence-config");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        if (fs_1.default.existsSync(path_1.default.join(current, ".git")))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}
 // ── Prompt helper ─────────────────────────────────────────────────────────────
 function prompt(rl, question) {
     return new Promise((resolve) => rl.question(question, (ans) => resolve(ans.trim())));
@@ -119,6 +135,9 @@ function registerInitCommand(program) {
             await verifyCloudConnection(apiUrl, token);
             const config = { mode: "cloud", apiUrl, token };
             (0, persistence_config_1.writeConfig)(config);
+            // Also save workspace-specific config scoped to this repo
+            const repoRoot = findRepoRoot(process.cwd());
+            (0, persistence_config_1.writeWorkspaceConfig)(repoRoot, { mode: "cloud", apiUrl, token });
             console.log(`\n✔ Cloud mode configured successfully.`);
             console.log(`  API URL : ${apiUrl}`);
             console.log(`  Config  : ${persistence_config_1.CONFIG_PATH}`);

package/dist/utils/persistence-config.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONFIG_PATH = void 0;
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
+exports.writeWorkspaceConfig = writeWorkspaceConfig;
+exports.readWorkspaceConfig = readWorkspaceConfig;
 exports.isCloudMode = isCloudMode;
 exports.getPersistence = getPersistence;
 /**
@@ -46,6 +48,16 @@ function writeConfig(config) {
     }
     node_fs_1.default.writeFileSync(exports.CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
 }
+function writeWorkspaceConfig(repoPath, wsConfig) {
+    const existing = readConfig();
+    const workspaces = existing.workspaces ?? {};
+    workspaces[repoPath] = wsConfig;
+    writeConfig({ ...existing, workspaces });
+}
+function readWorkspaceConfig(repoPath) {
+    const config = readConfig();
+    return config.workspaces?.[repoPath] ?? null;
+}
 function isCloudMode() {
     return readConfig().mode === "cloud";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodingo-cli",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,