kodingo-cli 1.0.0

package/dist/commands/explain-symbol.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explainSymbolCommand = explainSymbolCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+async function explainSymbolCommand(symbol, options) {
+    const { initDb, queryMemoryBySymbol } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const repoPath = resolveRepoScope(options);
+    const params = {
+        symbol,
+        limit: 1,
+        onlyCanonical: true,
+    };
+    if (repoPath)
+        params.repoPath = repoPath;
+    const results = await queryMemoryBySymbol(params);
+    // Fallback: if no affirmed record exists, surface best non-denied candidate.
+    let record = results[0];
+    if (!record) {
+        const fallbackParams = {
+            symbol,
+            limit: 1,
+            onlyCanonical: false,
+            includeDenied: false,
+        };
+        if (repoPath)
+            fallbackParams.repoPath = repoPath;
+        const fallback = await queryMemoryBySymbol(fallbackParams);
+        record = fallback[0];
+    }
+    if (!record) {
+        console.log(`No memory found for symbol: ${symbol}`);
+        console.log(`Tip: run "kodingo scan-git --repo <path>" to infer decisions from git history.`);
+        return;
+    }
+    const isCanonical = record.status === "affirmed";
+    const confidencePct = Math.round(record.confidence * 100);
+    console.log(`Symbol: ${symbol}`);
+    console.log(`${"─".repeat(60)}`);
+    if (record.title) {
+        console.log(`${record.title}`);
+        console.log("");
+    }
+    console.log(record.content);
+    console.log("");
+    const statusLabel = isCanonical
+        ? `✓ affirmed`
+        : `~ ${record.status} (not yet affirmed)`;
+    console.log(`${statusLabel} · confidence ${confidencePct}% · ${record.type}`);
+    if (record.tags?.length) {
+        console.log(`tags: ${record.tags.join(", ")}`);
+    }
+    console.log(`id: ${record.id}`);
+    if (!isCanonical) {
+        console.log("");
+        console.log(`Note: No affirmed record exists for this symbol. Showing best available candidate.`);
+        console.log(`Run "kodingo affirm ${record.id}" to promote this to canonical truth.`);
+    }
+}
+function resolveRepoScope(options) {
+    if (options.global === true)
+        return undefined;
+    if (options.repo && options.repo.trim()) {
+        return path_1.default.resolve(options.repo.trim());
+    }
+    return findRepoRoot(process.cwd());
+}
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        const gitPath = path_1.default.join(current, ".git");
+        if (fs_1.default.existsSync(gitPath))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}

package/dist/commands/ignore.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreCommand = ignoreCommand;
+const persistence_config_1 = require("../utils/persistence-config");
+async function ignoreCommand(options) {
+    const { initDb, getMemoryById, updateMemoryLifecycle } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const existing = await getMemoryById(options.id);
+    if (!existing) {
+        throw new Error(`Memory not found: ${options.id}`);
+    }
+    // Domain contract: ignore does not change confidence.
+    const updated = await updateMemoryLifecycle({
+        id: existing.id,
+        status: "ignored",
+        confidence: existing.confidence,
+    });
+    console.log(`Ignored memory: ${updated.id} (status=${updated.status}, confidence=${updated.confidence.toFixed(2)})`);
+}

package/dist/commands/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/commands/init.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * kodingo init
+ *
+ * Interactively configures ~/.kodingo/config.json.
+ * Supports both local (psql) and cloud (kodingo-api) modes.
+ */
+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.registerInitCommand = registerInitCommand;
+const readline = __importStar(require("node:readline"));
+const persistence_config_1 = require("../utils/persistence-config");
+// ── 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`);
+}
+// ── 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)")
+        .action(async (opts) => {
+        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.");
+                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,
+                });
+                console.log(`✔ Cloud mode configured. Config saved to ${persistence_config_1.CONFIG_PATH}`);
+                return;
+            }
+            // ── 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;
+            }
+            // 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.");
+                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);
+            }
+            console.log("\nVerifying connection to kodingo-api...");
+            await verifyCloudConnection(apiUrl, token);
+            const config = { mode: "cloud", apiUrl, token };
+            (0, persistence_config_1.writeConfig)(config);
+            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.");
+        }
+        catch (err) {
+            console.error(`\n✖ Init failed: ${err.message}`);
+            process.exit(1);
+        }
+        finally {
+            rl.close();
+        }
+    });
+}

package/dist/commands/install-hook.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installHookCommand = installHookCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function installHookCommand(options) {
+    const repoRoot = resolveRepoRoot(options);
+    const hooksDir = path_1.default.join(repoRoot, ".git", "hooks");
+    if (!fs_1.default.existsSync(hooksDir)) {
+        throw new Error(`Hooks directory does not exist: ${hooksDir}. Is this a valid git repository?`);
+    }
+    const kodingoBin = process.argv[1];
+    const hookPath = path_1.default.join(hooksDir, "post-commit");
+    const hookBlock = [
+        "# <kodingo>",
+        "# Kodingo: auto-infer decision memory from git commits",
+        `"${kodingoBin}" scan-git --repo "$(git rev-parse --show-toplevel)" &`,
+        "# </kodingo>",
+    ].join("\n");
+    if (fs_1.default.existsSync(hookPath)) {
+        const existing = fs_1.default.readFileSync(hookPath, "utf-8");
+        if (existing.includes("# <kodingo>")) {
+            console.log("Hook already installed");
+            return;
+        }
+        // Append to existing hook
+        const updated = existing.endsWith("\n")
+            ? existing + "\n" + hookBlock + "\n"
+            : existing + "\n\n" + hookBlock + "\n";
+        fs_1.default.writeFileSync(hookPath, updated, "utf-8");
+    }
+    else {
+        // Create new hook file
+        const content = "#!/bin/sh\n\n" + hookBlock + "\n";
+        fs_1.default.writeFileSync(hookPath, content, "utf-8");
+    }
+    fs_1.default.chmodSync(hookPath, 0o755);
+    console.log(`Kodingo hook installed for repo: ${repoRoot}`);
+}
+function resolveRepoRoot(options) {
+    if (options.repo && options.repo.trim()) {
+        const resolved = path_1.default.resolve(options.repo.trim());
+        return findRepoRoot(resolved);
+    }
+    return findRepoRoot(process.cwd());
+}
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        const gitPath = path_1.default.join(current, ".git");
+        if (fs_1.default.existsSync(gitPath))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}

package/dist/commands/query-memory.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryMemoryCommand = queryMemoryCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+async function queryMemoryCommand(text, options) {
+    const { initDb, queryMemory } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const limit = options.limit ?? 10;
+    const repoPath = resolveRepoScope(options);
+    const results = await queryMemory(text, limit, repoPath, {
+        dedupeBySymbol: options.dedupeBySymbol === true,
+        includeNonCanonical: options.includeNonCanonical === true,
+    });
+    if (results.length === 0) {
+        console.log("No results.");
+        return;
+    }
+    for (const r of results) {
+        const createdAt = r.createdAt instanceof Date
+            ? r.createdAt.toISOString()
+            : String(r.createdAt);
+        console.log(`[${createdAt}] (${r.type}) ${r.title ?? "(untitled)"}`);
+        console.log(r.content);
+        if (r.tags?.length)
+            console.log(`tags: ${r.tags.join(", ")}`);
+        console.log(`status: ${r.status}`);
+        console.log(`confidence: ${r.confidence.toFixed(2)}`);
+        console.log(`repo: ${r.repo ?? "(unknown)"}`);
+        if (r.symbol)
+            console.log(`symbol: ${r.symbol}`);
+        if (r.externalId)
+            console.log(`externalId: ${r.externalId}`);
+        console.log(`id: ${r.id}`);
+        console.log("");
+    }
+}
+function resolveRepoScope(options) {
+    if (options.global === true)
+        return undefined;
+    if (options.repo && options.repo.trim()) {
+        return path_1.default.resolve(options.repo.trim());
+    }
+    return findRepoRoot(process.cwd());
+}
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        const gitPath = path_1.default.join(current, ".git");
+        if (fs_1.default.existsSync(gitPath))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}

package/dist/commands/query-symbol.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.querySymbolCommand = querySymbolCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+async function querySymbolCommand(symbol, options) {
+    const { initDb, queryMemoryBySymbol } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const limit = options.limit ?? 10;
+    const repoPath = resolveRepoScope(options);
+    const params = {
+        symbol,
+        limit,
+        includeDenied: options.includeDenied === true,
+        onlyCanonical: options.onlyCanonical === true,
+    };
+    if (repoPath)
+        params.repoPath = repoPath;
+    const results = await queryMemoryBySymbol(params);
+    if (results.length === 0) {
+        console.log("No results.");
+        return;
+    }
+    for (const r of results) {
+        console.log(`[${r.createdAt.toISOString()}] (${r.type}) ${r.title ?? "(untitled)"}`);
+        console.log(r.content);
+        if (r.tags?.length)
+            console.log(`tags: ${r.tags.join(", ")}`);
+        console.log(`status: ${r.status}`);
+        console.log(`confidence: ${r.confidence.toFixed(2)}`);
+        console.log(`repo: ${r.repo ?? "(unknown)"}`);
+        if (r.symbol)
+            console.log(`symbol: ${r.symbol}`);
+        if (r.externalId)
+            console.log(`externalId: ${r.externalId}`);
+        console.log(`id: ${r.id}`);
+        console.log("");
+    }
+}
+function resolveRepoScope(options) {
+    if (options.global === true)
+        return undefined;
+    if (options.repo && options.repo.trim()) {
+        return path_1.default.resolve(options.repo.trim());
+    }
+    return findRepoRoot(process.cwd());
+}
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        const gitPath = path_1.default.join(current, ".git");
+        if (fs_1.default.existsSync(gitPath))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}

package/dist/commands/scan-git.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanGitCommand = scanGitCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+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");
+async function scanGitCommand(options) {
+    const { initDb, getMemoryByExternalId } = (0, persistence_config_1.getPersistence)();
+    const repoRoot = resolveRepoRoot(options);
+    await initDb();
+    const git = (0, simple_git_1.default)(repoRoot);
+    const log = await git.log({ maxCount: 1 });
+    const latestCommit = log.all?.[0];
+    if (!latestCommit?.hash) {
+        console.log(`Git scan complete (no commits) for repo: ${repoRoot}`);
+        return;
+    }
+    const commitHash = String(latestCommit.hash);
+    const externalId = `git:${commitHash}`;
+    // Idempotency check via the active persistence adapter (local or cloud)
+    const existing = await getMemoryByExternalId(externalId, repoRoot);
+    if (existing) {
+        console.log(`Git scan skipped (already stored) for repo: ${repoRoot} commit: ${commitHash.slice(0, 8)}`);
+        return;
+    }
+    // Use the appropriate event port based on configured persistence mode
+    const eventPort = (0, persistence_config_1.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);
+    await adapter.runOnceLatest();
+    console.log(`Git scan complete (latest commit) for repo: ${repoRoot} commit: ${commitHash.slice(0, 8)}`);
+}
+function resolveRepoRoot(options) {
+    if (options.repo && options.repo.trim()) {
+        const resolved = path_1.default.resolve(options.repo.trim());
+        return findRepoRoot(resolved);
+    }
+    return findRepoRoot(process.cwd());
+}
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        const gitPath = path_1.default.join(current, ".git");
+        if (fs_1.default.existsSync(gitPath))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}

package/dist/commands/uninstall-hook.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallHookCommand = uninstallHookCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function uninstallHookCommand(options) {
+    const repoRoot = resolveRepoRoot(options);
+    const hookPath = path_1.default.join(repoRoot, ".git", "hooks", "post-commit");
+    if (!fs_1.default.existsSync(hookPath)) {
+        console.log("No hook found");
+        return;
+    }
+    const content = fs_1.default.readFileSync(hookPath, "utf-8");
+    if (!content.includes("# <kodingo>")) {
+        console.log("No hook found");
+        return;
+    }
+    // Remove the kodingo block and surrounding blank lines
+    const cleaned = content.replace(/\n*# <kodingo>\n[\s\S]*?# <\/kodingo>\n*/g, "\n");
+    const trimmed = cleaned.trim();
+    if (trimmed === "" || trimmed === "#!/bin/sh") {
+        fs_1.default.unlinkSync(hookPath);
+    }
+    else {
+        fs_1.default.writeFileSync(hookPath, trimmed + "\n", "utf-8");
+        fs_1.default.chmodSync(hookPath, 0o755);
+    }
+    console.log(`Kodingo hook uninstalled for repo: ${repoRoot}`);
+}
+function resolveRepoRoot(options) {
+    if (options.repo && options.repo.trim()) {
+        const resolved = path_1.default.resolve(options.repo.trim());
+        return findRepoRoot(resolved);
+    }
+    return findRepoRoot(process.cwd());
+}
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        const gitPath = path_1.default.join(current, ".git");
+        if (fs_1.default.existsSync(gitPath))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}