kodingo-cli 1.0.12 → 1.0.14

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

@@ -2,9 +2,11 @@
 /**
  * kodingo init
  *
- * Interactively configures ~/.kodingo/config.json.
- * Supports both local (psql) and cloud (kodingo-api) modes.
- * On successful cloud init, ensures .kortex/ is in .gitignore.
+ * GitHub-style browser-based authentication and project connection.
+ * - First time on a machine: opens browser to login, saves auth token globally
+ * - Subsequent runs: skips login, goes straight to project selection
+ * - Project selection: type project name, case-insensitive match
+ * - Create new project if name not found
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -45,125 +47,232 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInitCommand = registerInitCommand;
 const readline = __importStar(require("node:readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const open_1 = __importDefault(require("open"));
 const persistence_config_1 = require("../utils/persistence-config");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
+const API_BASE = "https://kodingo-api.onrender.com";
+const APP_URL = "https://kodingo.xyz";
+const CONFIG_DIR = path.join(os.homedir(), ".kodingo");
+const AUTH_TOKEN_PATH = path.join(CONFIG_DIR, "auth.json");
+// ── Auth token storage ────────────────────────────────────────────────────────
+function readAuthToken() {
+    try {
+        if (fs.existsSync(AUTH_TOKEN_PATH)) {
+            const data = JSON.parse(fs.readFileSync(AUTH_TOKEN_PATH, "utf-8"));
+            return data.token ?? null;
+        }
+    }
+    catch { }
+    return null;
+}
+function saveAuthToken(token, email) {
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(AUTH_TOKEN_PATH, JSON.stringify({ token, email }, null, 2), "utf-8");
+}
+function readAuthEmail() {
+    try {
+        if (fs.existsSync(AUTH_TOKEN_PATH)) {
+            const data = JSON.parse(fs.readFileSync(AUTH_TOKEN_PATH, "utf-8"));
+            return data.email ?? '';
+        }
+    }
+    catch { }
+    return '';
+}
+// ── Prompt helper ─────────────────────────────────────────────────────────────
+function prompt(rl, question) {
+    return new Promise(resolve => rl.question(question, ans => resolve(ans.trim())));
+}
+// ── Repo root finder ──────────────────────────────────────────────────────────
 function findRepoRoot(startPath) {
     let current = startPath;
     while (true) {
-        if (fs_1.default.existsSync(path_1.default.join(current, ".git")))
+        if (fs.existsSync(path.join(current, ".git")))
             return current;
-        const parent = path_1.default.dirname(current);
+        const parent = path.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())));
-}
-// ── Health check ──────────────────────────────────────────────────────────────
-async function verifyCloudConnection(apiUrl, token) {
-    const url = `${apiUrl.replace(/\/$/, "")}/health`;
-    const res = await fetch(url, { headers: { "X-Kodingo-Token": token } });
-    if (!res.ok)
-        throw new Error(`Health check failed (${res.status}) — check your API URL`);
-}
 // ── .gitignore helper ─────────────────────────────────────────────────────────
 function ensureGitignoreEntry(repoRoot, entry) {
-    const gitignorePath = path_1.default.join(repoRoot, ".gitignore");
+    const gitignorePath = path.join(repoRoot, ".gitignore");
     const line = entry.endsWith("\n") ? entry : `${entry}\n`;
-    if (fs_1.default.existsSync(gitignorePath)) {
-        const contents = fs_1.default.readFileSync(gitignorePath, "utf-8");
-        if (contents.split("\n").some((l) => l.trim() === entry.trim()))
+    if (fs.existsSync(gitignorePath)) {
+        const contents = fs.readFileSync(gitignorePath, "utf-8");
+        if (contents.split("\n").some(l => l.trim() === entry.trim()))
             return;
-        fs_1.default.appendFileSync(gitignorePath, `\n# Kortex — auto-generated context file\n${line}`, "utf-8");
+        fs.appendFileSync(gitignorePath, `\n# Kortex\n${line}`, "utf-8");
     }
     else {
-        fs_1.default.writeFileSync(gitignorePath, `# Kortex — auto-generated context file\n${line}`, "utf-8");
+        fs.writeFileSync(gitignorePath, `# Kortex\n${line}`, "utf-8");
+    }
+}
+// ── Browser login flow ────────────────────────────────────────────────────────
+async function browserLogin() {
+    // Request a state token from the API
+    const initRes = await fetch(`${API_BASE}/cli/auth/init`, { method: "POST" });
+    if (!initRes.ok)
+        throw new Error("Failed to start login flow");
+    const { state, loginUrl } = await initRes.json();
+    console.log("\nPress Enter to open kodingo.xyz in your browser...");
+    console.log(`Or open this URL manually: ${loginUrl}\n`);
+    await new Promise(resolve => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question("", () => { rl.close(); resolve(); });
+    });
+    // Open browser
+    try {
+        await (0, open_1.default)(loginUrl);
+    }
+    catch { }
+    console.log("Waiting for login...");
+    // Poll for completion
+    const start = Date.now();
+    while (Date.now() - start < 5 * 60 * 1000) {
+        await new Promise(r => setTimeout(r, 2000));
+        const pollRes = await fetch(`${API_BASE}/cli/auth/poll/${state}`);
+        if (!pollRes.ok)
+            continue;
+        const data = await pollRes.json();
+        if (data.status === "complete" && data.token) {
+            return { token: data.token, email: data.email ?? "" };
+        }
     }
+    throw new Error("Login timed out. Please try again.");
+}
+// ── Fetch accessible projects ─────────────────────────────────────────────────
+async function fetchProjects(authToken) {
+    const res = await fetch(`${API_BASE}/cli/projects`, {
+        headers: { Authorization: `Bearer ${authToken}` },
+    });
+    if (!res.ok)
+        throw new Error("Failed to fetch projects. Please run `kodingo init` again.");
+    const data = await res.json();
+    return data.projects ?? [];
+}
+// ── Create a new project ──────────────────────────────────────────────────────
+async function createProject(authToken, name, orgId) {
+    const res = await fetch(`${API_BASE}/cli/projects`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${authToken}` },
+        body: JSON.stringify({ name, orgId }),
+    });
+    const data = await res.json();
+    if (!res.ok)
+        throw new Error(data.error ?? "Failed to create project");
+    return data;
 }
 // ── Command ───────────────────────────────────────────────────────────────────
 function registerInitCommand(program) {
     program
         .command("init")
-        .description("Configure kodingo CLI (local psql or cloud API)")
-        .option("--local", "Switch to local mode (psql)")
-        .option("--cloud", "Switch to cloud mode (kodingo-api)")
-        .option("--api-url <url>", "Cloud API URL (skips prompt)")
-        .option("--token <token>", "Cloud API token (skips prompt)")
+        .description("Connect this repository to a Kodingo project")
+        .option("--logout", "Log out and clear saved credentials")
         .action(async (opts) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         try {
-            const current = (0, persistence_config_1.readConfig)();
-            // ── Non-interactive flags ─────────────────────────────────────────────
-            if (opts.local) {
-                (0, persistence_config_1.writeConfig)({ mode: "local" });
-                console.log("✔ Switched to local mode — using local psql database.");
+            // ── Logout ──────────────────────────────────────────────────────────
+            if (opts.logout) {
+                if (fs.existsSync(AUTH_TOKEN_PATH))
+                    fs.unlinkSync(AUTH_TOKEN_PATH);
+                console.log("✔ Logged out of Kodingo.");
                 return;
             }
-            if (opts.cloud && opts.apiUrl && opts.token) {
-                console.log("Verifying connection to kodingo-api...");
-                await verifyCloudConnection(opts.apiUrl, opts.token);
-                (0, persistence_config_1.writeConfig)({
-                    mode: "cloud",
-                    apiUrl: opts.apiUrl,
-                    token: opts.token,
-                });
-                const repoRoot = findRepoRoot(process.cwd());
-                ensureGitignoreEntry(repoRoot, ".kortex/");
-                console.log(`✔ Cloud mode configured. Config saved to ${persistence_config_1.CONFIG_PATH}`);
-                return;
+            // ── Check if already logged in ───────────────────────────────────────
+            let authToken = readAuthToken();
+            let email = readAuthEmail();
+            if (authToken) {
+                console.log(`\n✔ Already logged in as ${email || "your Kodingo account"}\n`);
             }
-            // ── Interactive flow ──────────────────────────────────────────────────
-            console.log("\nKodingo CLI Setup\n");
-            console.log(`Current mode: ${current.mode}`);
-            if (current.apiUrl)
-                console.log(`Current API URL: ${current.apiUrl}`);
-            console.log();
-            const modeInput = await prompt(rl, "Choose mode — (l)ocal or (c)loud [default: local]: ");
-            const mode = modeInput.toLowerCase().startsWith("c")
-                ? "cloud"
-                : "local";
-            if (mode === "local") {
-                (0, persistence_config_1.writeConfig)({ mode: "local" });
-                console.log("\n✔ Local mode configured. Using local psql database.");
-                return;
+            else {
+                console.log("\nKodingo — Connect this repository\n");
+                const result = await browserLogin();
+                authToken = result.token;
+                email = result.email;
+                saveAuthToken(authToken, email);
+                console.log(`\n✔ Logged in as ${email}\n`);
             }
-            // Cloud mode — collect API URL and token
-            const defaultUrl = current.apiUrl ?? "";
-            const apiUrlInput = await prompt(rl, `API URL${defaultUrl ? ` [${defaultUrl}]` : ""}: `);
-            const apiUrl = apiUrlInput || defaultUrl;
-            if (!apiUrl) {
-                console.error("✖ API URL is required for cloud mode.");
+            // ── Fetch projects ───────────────────────────────────────────────────
+            const projects = await fetchProjects(authToken);
+            // ── Ask for project name ─────────────────────────────────────────────
+            const projectName = await prompt(rl, "Enter the project name to connect to this repo: ");
+            if (!projectName) {
+                console.error("✖ Project name is required.");
                 process.exit(1);
             }
-            const tokenInput = await prompt(rl, "API Token (X-Kodingo-Token): ");
-            const token = tokenInput || current.token || "";
-            if (!token) {
-                console.error("✖ API token is required for cloud mode.");
-                process.exit(1);
+            // ── Case-insensitive search ──────────────────────────────────────────
+            const normalised = projectName.toLowerCase().trim();
+            const matches = projects.filter(p => p.name.toLowerCase().trim() === normalised);
+            let selectedProject = null;
+            if (matches.length === 1) {
+                selectedProject = matches[0];
+                console.log(`\n✔ Found project: ${selectedProject.name} (${matches[0].org_name} · ${matches[0].plan} plan)\n`);
+            }
+            else if (matches.length > 1) {
+                // Multiple orgs with same project name — ask which one
+                console.log("\nMultiple projects found with that name:");
+                matches.forEach((p, i) => console.log(`  ${i + 1}. ${p.name} — ${p.org_name}`));
+                const choice = await prompt(rl, "Enter number: ");
+                const idx = parseInt(choice) - 1;
+                if (idx < 0 || idx >= matches.length) {
+                    console.error("✖ Invalid choice.");
+                    process.exit(1);
+                }
+                selectedProject = matches[idx];
             }
-            console.log("\nVerifying connection to kodingo-api...");
-            await verifyCloudConnection(apiUrl, token);
-            const config = { mode: "cloud", apiUrl, token };
-            (0, persistence_config_1.writeConfig)(config);
-            // Save workspace-specific config scoped to this repo
+            else {
+                // No match — offer to create
+                console.log(`\n  No project named "${projectName}" found in your account.`);
+                const create = await prompt(rl, "Would you like to create it? (y/n): ");
+                if (!create.toLowerCase().startsWith("y")) {
+                    console.log("✖ Cancelled.");
+                    process.exit(0);
+                }
+                // If user has multiple orgs, ask which one
+                const orgs = [...new Map(projects.map(p => [p.org_id, { id: p.org_id, name: p.org_name }])).values()];
+                let orgId = orgs[0]?.id;
+                if (orgs.length > 1) {
+                    console.log("\nSelect an organisation:");
+                    orgs.forEach((o, i) => console.log(`  ${i + 1}. ${o.name}`));
+                    const orgChoice = await prompt(rl, "Enter number: ");
+                    const orgIdx = parseInt(orgChoice) - 1;
+                    if (orgIdx < 0 || orgIdx >= orgs.length) {
+                        console.error("✖ Invalid choice.");
+                        process.exit(1);
+                    }
+                    orgId = orgs[orgIdx].id;
+                }
+                const created = await createProject(authToken, projectName, orgId);
+                selectedProject = created;
+                console.log(`\n✔ Project "${created.name}" created\n`);
+            }
+            // ── Save config ──────────────────────────────────────────────────────
             const repoRoot = findRepoRoot(process.cwd());
-            (0, persistence_config_1.writeWorkspaceConfig)(repoRoot, { mode: "cloud", apiUrl, token });
-            // Ensure .kortex/ is gitignored — it's a generated file, not source
+            const apiUrl = API_BASE;
+            (0, persistence_config_1.writeConfig)({ mode: "cloud", apiUrl, token: selectedProject.token });
+            (0, persistence_config_1.writeWorkspaceConfig)(repoRoot, { mode: "cloud", apiUrl, token: selectedProject.token });
             ensureGitignoreEntry(repoRoot, ".kortex/");
-            console.log(`\n✔ Cloud mode configured successfully.`);
-            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.");
+            console.log(`✔ Connected. Token saved to ${persistence_config_1.CONFIG_PATH}`);
+            console.log("\nKortex is now watching this repo.");
+            console.log("Run `kodingo install-hook` to capture memories on every commit.\n");
+            // Auto-scan existing codebase
+            try {
+                const { scanRepoCommand } = await Promise.resolve().then(() => __importStar(require("./scan-repo")));
+                console.log("🔍 Scanning existing codebase for functions without memory...");
+                const captured = await 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 { }
         }
         catch (err) {
-            console.error(`\n✖ Init failed: ${err.message}`);
+            console.error(`\n✖ ${err.message}`);
             process.exit(1);
         }
         finally {

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.14",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,
@@ -24,12 +24,13 @@
     "@babel/traverse": "^7.29.0",
     "commander": "^12.1.0",
     "kodingo-core": "^0.1.0",
+    "open": "^11.0.0",
     "simple-git": "^3.30.0",
     "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@types/babel__traverse": "^7.28.0",
-    "@types/node": "^22.0.0",
+    "@types/node": "^22.19.20",
     "@types/uuid": "^10.0.0",
     "typescript": "^5.6.0"
   }