kodingo-cli 1.0.12 → 1.0.13

package/dist/cli.js

@@ -13,6 +13,7 @@ const ignore_1 = require("./commands/ignore");
 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 init_1 = require("./commands/init");
 const install_hook_1 = require("./commands/install-hook");
 const update_1 = require("./commands/update");
@@ -214,4 +215,15 @@ program
         payload.repo = String(options.repo);
     await (0, scan_claude_1.scanClaudeCommand)(payload);
 });
+// ── scan-repo ─────────────────────────────────────────────────────────────────
+program
+    .command("scan-repo")
+    .description("Bulk scan existing codebase and capture memory for functions not yet in Kortex")
+    .option("--repo <path>", "repo path to scan")
+    .action(async (options) => {
+    const payload = {};
+    if (options.repo)
+        payload.repo = String(options.repo);
+    await (0, scan_repo_1.scanRepoCommand)(payload);
+});
 program.parse(process.argv);

package/dist/commands/capture.js

@@ -78,3 +78,6 @@ async function readStdin() {
 }
 // review test
 // review test
+function testKodingoSaveWatcher() {
+    return false;
+}

package/dist/commands/init.js

@@ -47,6 +47,7 @@ exports.registerInitCommand = registerInitCommand;
 const readline = __importStar(require("node:readline"));
 const persistence_config_1 = require("../utils/persistence-config");
 const path_1 = __importDefault(require("path"));
+const scan_repo_1 = require("./scan-repo");
 const fs_1 = __importDefault(require("fs"));
 function findRepoRoot(startPath) {
     let current = startPath;
@@ -85,6 +86,18 @@ function ensureGitignoreEntry(repoRoot, entry) {
     }
 }
 // ── Command ───────────────────────────────────────────────────────────────────
+async function runInitialScan(repoRoot) {
+    try {
+        console.log("\n🔍 Scanning existing codebase for functions without memory...");
+        const captured = await (0, scan_repo_1.scanRepoCommand)({ repo: repoRoot, silent: false });
+        if (captured === 0) {
+            console.log("  No existing functions found — Kortex will capture them as you write and commit code.");
+        }
+    }
+    catch {
+        // Never fail init because of a scan error
+    }
+}
 function registerInitCommand(program) {
     program
         .command("init")
@@ -117,6 +130,8 @@ function registerInitCommand(program) {
                 const repoRoot = findRepoRoot(process.cwd());
                 ensureGitignoreEntry(repoRoot, ".kortex/");
                 console.log(`✔ Cloud mode configured. Config saved to ${persistence_config_1.CONFIG_PATH}`);
+                // Auto-scan existing codebase silently
+                await runInitialScan(repoRoot);
                 return;
             }
             // ── Interactive flow ──────────────────────────────────────────────────
@@ -161,6 +176,8 @@ function registerInitCommand(program) {
             console.log(`  API URL : ${apiUrl}`);
             console.log(`  Config  : ${persistence_config_1.CONFIG_PATH}`);
             console.log("\nYou're ready to use kodingo with the cloud API.");
+            // Auto-scan existing codebase for functions without memory
+            await runInitialScan(repoRoot);
         }
         catch (err) {
             console.error(`\n✖ Init failed: ${err.message}`);

package/dist/commands/scan-repo.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * kodingo scan-repo
+ *
+ * Bulk scans an entire repository for functions that have no Kortex memory yet.
+ * Designed to be run once on an existing codebase after `kodingo init`.
+ * Also triggered automatically at the end of `kodingo init` if existing code is found.
+ *
+ * Walks all supported files, extracts symbols, checks which ones have no memory,
+ * and submits them to the inference endpoint in batches.
+ *
+ * Caps at 50 symbols per run to avoid overwhelming the API.
+ * Safe to run multiple times — skips symbols that already have memory.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRepoCommand = scanRepoCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+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",
+];
+const MAX_SYMBOLS = 50;
+const BATCH_SIZE = 5;
+const BATCH_DELAY_MS = 1200;
+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;
+    }
+}
+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 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;
+    }
+    catch {
+        return [];
+    }
+}
+async function hasExistingMemory(token, symbol, repo) {
+    try {
+        const res = await fetch(`${API_BASE}/memory?symbol=${encodeURIComponent(symbol)}&repo=${encodeURIComponent(repo)}&limit=1`, { headers: { "X-Kodingo-Token": token } });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        return (data.total ?? 0) > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function inferAndCapture(token, symbol, repo) {
+    try {
+        const inferRes = await fetch(`${API_BASE}/infer`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+            body: JSON.stringify({ symbol: symbol.name, code: symbol.code }),
+        });
+        if (!inferRes.ok)
+            return false;
+        const inferred = await inferRes.json();
+        const saveRes = await fetch(`${API_BASE}/memory`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+            body: JSON.stringify({
+                type: inferred.type ?? "context",
+                title: inferred.title ?? `${symbol.name} — scanned`,
+                content: inferred.content ?? `Function \`${symbol.name}\` detected during repo scan.`,
+                symbol: symbol.name,
+                repo,
+                tags: [...(inferred.tags ?? []), "scan-repo"],
+                status: "proposed",
+                confidence: 0.35,
+            }),
+        });
+        return saveRes.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function scanRepoCommand(options = {}) {
+    const config = (0, persistence_config_1.readConfig)();
+    if (config.mode !== "cloud" || !config.token) {
+        if (!options.silent)
+            console.error("✖ scan-repo requires cloud mode. Run `kodingo init` first.");
+        return 0;
+    }
+    const repoRoot = options.repo
+        ? path_1.default.resolve(options.repo)
+        : findRepoRoot(process.cwd());
+    const repoName = path_1.default.basename(repoRoot);
+    if (!options.silent) {
+        console.log(`\n🔍 Kortex — scanning ${repoName} for existing functions...\n`);
+    }
+    // Walk all files and extract symbols
+    const files = walkFiles(repoRoot);
+    const allSymbols = [];
+    for (const file of files) {
+        allSymbols.push(...extractSymbols(file));
+    }
+    if (allSymbols.length === 0) {
+        if (!options.silent)
+            console.log("  No functions found — repo appears empty. Nothing to scan.");
+        return 0;
+    }
+    if (!options.silent) {
+        console.log(`  Found ${allSymbols.length} functions across ${files.length} files`);
+        console.log(`  Checking which ones need memory...\n`);
+    }
+    // Filter to symbols without existing memory, cap at MAX_SYMBOLS
+    const toCapture = [];
+    for (const sym of allSymbols) {
+        if (toCapture.length >= MAX_SYMBOLS)
+            break;
+        const exists = await hasExistingMemory(config.token, sym.name, repoName);
+        if (!exists)
+            toCapture.push(sym);
+    }
+    if (toCapture.length === 0) {
+        if (!options.silent)
+            console.log("  ✔ All functions already have Kortex memory. Nothing to capture.");
+        return 0;
+    }
+    if (!options.silent) {
+        console.log(`  Capturing memory for ${toCapture.length} functions...\n`);
+    }
+    // Process in batches
+    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(config.token, sym, repoName)));
+        const batchCaptured = results.filter(Boolean).length;
+        captured += batchCaptured;
+        if (!options.silent) {
+            const progress = Math.min(i + BATCH_SIZE, toCapture.length);
+            process.stdout.write(`\r  Progress: ${progress}/${toCapture.length} functions processed`);
+        }
+        if (i + BATCH_SIZE < toCapture.length) {
+            await new Promise(r => setTimeout(r, BATCH_DELAY_MS));
+        }
+    }
+    if (!options.silent) {
+        console.log(`\n\n✔ Scan complete — ${captured} memories captured for ${repoName}`);
+        if (allSymbols.length > MAX_SYMBOLS) {
+            console.log(`  Note: ${allSymbols.length - MAX_SYMBOLS} additional functions will be captured automatically as you open files.`);
+        }
+    }
+    return captured;
+}

package/package.json

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