kodingo-cli 1.0.11 → 1.0.13

package/dist/cli.js

@@ -12,6 +12,8 @@ const affirm_1 = require("./commands/affirm");
 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");
@@ -202,4 +204,26 @@ program
         payload.repo = String(options.repo);
     await (0, install_hook_1.installHookCommand)(payload);
 });
+// ── scan-claude ──────────────────────────────────────────────────────────────
+program
+    .command("scan-claude")
+    .description("Scan Claude Code session files and extract decisions into Kortex memory")
+    .option("--repo <path>", "repo path to scan")
+    .action(async (options) => {
+    const payload = {};
+    if (options.repo)
+        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-claude.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * kodingo scan-claude
+ *
+ * Reads Claude Code session files from .claude/sessions/ in the repo root
+ * and extracts decisions, rationale, and rejected approaches that never
+ * made it into a commit — signal that would otherwise be lost forever.
+ *
+ * Claude Code writes JSONL session files at:
+ *   <repo>/.claude/sessions/<session-id>.jsonl
+ *
+ * Each line is a message in the conversation. We scan for:
+ *   - Assistant messages containing architectural decisions or tradeoffs
+ *   - Tool results showing code that was written then abandoned
+ *   - Explicit reasoning blocks
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanClaudeCommand = scanClaudeCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+// ── Heuristics for extracting decisions ──────────────────────────────────────
+const DECISION_PATTERNS = [
+    /\b(?:decided|decision|chose|choosing|going with|we['']ll use|using|opted for|approach is)\b/i,
+    /\b(?:tradeoff|trade-off|because|reason|rationale|the issue is|the problem is)\b/i,
+    /\b(?:instead of|rather than|alternative|we could|we should|don['']t use|avoid)\b/i,
+    /\b(?:architecture|pattern|design|structure|strategy|approach)\b/i,
+];
+const REJECTION_PATTERNS = [
+    /\b(?:rejected|abandoned|won['']t work|doesn['']t work|not going to|let['']s not|avoid this)\b/i,
+    /\b(?:tried|attempted|doesn['']t fit|too complex|too slow|bad idea)\b/i,
+];
+function scoreText(text) {
+    let score = 0;
+    for (const pat of DECISION_PATTERNS) {
+        if (pat.test(text))
+            score += 2;
+    }
+    for (const pat of REJECTION_PATTERNS) {
+        if (pat.test(text))
+            score += 1;
+    }
+    return score;
+}
+function extractTextFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter(b => b.type === "text" && b.text)
+        .map(b => b.text)
+        .join("\n");
+}
+// Split assistant message into paragraph-sized chunks
+function splitIntoParagraphs(text) {
+    return text
+        .split(/\n{2,}/)
+        .map(p => p.trim())
+        .filter(p => p.length > 80);
+}
+function buildTitle(text) {
+    const first = text.split(/[.\n]/)[0].trim();
+    return first.length > 100 ? first.slice(0, 97) + "..." : first;
+}
+// ── Session parser ────────────────────────────────────────────────────────────
+function parseSessionFile(filePath) {
+    const messages = [];
+    const lines = fs_1.default.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            // Claude Code JSONL format: { role, content, ... }
+            if (parsed.role && parsed.content !== undefined) {
+                messages.push(parsed);
+            }
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    return messages;
+}
+function extractMemoriesFromSession(messages, sessionId, repoPath) {
+    const memories = [];
+    for (const msg of messages) {
+        if (msg.role !== "assistant")
+            continue;
+        const text = extractTextFromContent(msg.content);
+        if (!text)
+            continue;
+        const paragraphs = splitIntoParagraphs(text);
+        for (const para of paragraphs) {
+            const score = scoreText(para);
+            if (score < 2)
+                continue;
+            const isRejection = REJECTION_PATTERNS.some(p => p.test(para));
+            memories.push({
+                type: isRejection ? "note" : "decision",
+                title: buildTitle(para),
+                content: para,
+                tags: ["claude-session", isRejection ? "rejected-approach" : "ai-reasoning"],
+                repoPath,
+                status: "proposed",
+                confidence: Math.min(0.3 + score * 0.05, 0.6),
+                externalId: `claude-session:${sessionId}:${Buffer.from(para.slice(0, 40)).toString("base64").slice(0, 16)}`,
+            });
+        }
+    }
+    return memories;
+}
+// ── Command ───────────────────────────────────────────────────────────────────
+async function scanClaudeCommand(options = {}) {
+    const repoRoot = resolveRepoRoot(options);
+    const sessionsDir = path_1.default.join(repoRoot, ".claude", "sessions");
+    if (!fs_1.default.existsSync(sessionsDir)) {
+        console.log(`No Claude Code sessions found at ${sessionsDir}`);
+        console.log("Claude Code sessions are created when you use Claude Code in this repo.");
+        return;
+    }
+    const sessionFiles = fs_1.default.readdirSync(sessionsDir)
+        .filter(f => f.endsWith(".jsonl"))
+        .map(f => path_1.default.join(sessionsDir, f));
+    if (!sessionFiles.length) {
+        console.log("No session files found.");
+        return;
+    }
+    const { initDb, saveMemory, getMemoryByExternalId } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    let totalSaved = 0;
+    let totalSkipped = 0;
+    for (const filePath of sessionFiles) {
+        const sessionId = path_1.default.basename(filePath, ".jsonl");
+        let messages;
+        try {
+            messages = parseSessionFile(filePath);
+        }
+        catch {
+            console.warn(`  Skipping unreadable session: ${sessionId}`);
+            continue;
+        }
+        const candidates = extractMemoriesFromSession(messages, sessionId, repoRoot);
+        for (const candidate of candidates) {
+            // Deduplicate by externalId
+            if (candidate.externalId) {
+                const existing = await getMemoryByExternalId(candidate.externalId, repoRoot);
+                if (existing) {
+                    totalSkipped++;
+                    continue;
+                }
+            }
+            await saveMemory(candidate);
+            totalSaved++;
+        }
+    }
+    console.log(`Claude session scan complete.`);
+    console.log(`  Sessions scanned : ${sessionFiles.length}`);
+    console.log(`  Memories saved   : ${totalSaved}`);
+    console.log(`  Already stored   : ${totalSkipped}`);
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function resolveRepoRoot(options) {
+    if (options.repo?.trim()) {
+        return findRepoRoot(path_1.default.resolve(options.repo.trim()));
+    }
+    return findRepoRoot(process.cwd());
+}
+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;
+    }
+}

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.11",
+  "version": "1.0.13",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,