kodingo-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const capture_1 = require("./commands/capture");
+const doctor_1 = require("./commands/doctor");
+const query_memory_1 = require("./commands/query-memory");
+const query_symbol_1 = require("./commands/query-symbol");
+const explain_symbol_1 = require("./commands/explain-symbol");
+const canonicalize_symbol_1 = require("./commands/canonicalize-symbol");
+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 init_1 = require("./commands/init");
+const install_hook_1 = require("./commands/install-hook");
+const program = new commander_1.Command();
+program.name("kodingo").description("Kodingo CLI");
+// ── init ──────────────────────────────────────────────────────────────────────
+(0, init_1.registerInitCommand)(program);
+// ── capture ───────────────────────────────────────────────────────────────────
+program
+    .command("capture")
+    .description("Capture a memory record and persist it")
+    .option("--type <type>", "decision | note | context", "note")
+    .option("--title <title>", "optional title")
+    .option("--tags <tags>", "comma-separated tags")
+    .option("--content <content>", "content body")
+    .action(async (options) => {
+    await (0, capture_1.captureCommand)({
+        type: options.type,
+        title: options.title,
+        tags: options.tags,
+        content: options.content,
+    });
+});
+// ── query-memory ──────────────────────────────────────────────────────────────
+program
+    .command("query-memory")
+    .description("Query stored memory records")
+    .argument("<text>", "text to search")
+    .option("--limit <number>", "max results", "10")
+    .option("--global", "search across all repos (ignore repo scope)")
+    .option("--repo <path>", "explicit repo path to scope results")
+    .option("--dedupe-by-symbol", "return only the best record per symbol")
+    .option("--include-non-canonical", "include denied records in results")
+    .action(async (text, options) => {
+    const parsed = Number.parseInt(String(options.limit), 10);
+    const limit = Number.isNaN(parsed) ? 10 : parsed;
+    const queryOptions = { limit };
+    if (options.global === true)
+        queryOptions.global = true;
+    if (options.repo)
+        queryOptions.repo = String(options.repo);
+    if (options.dedupeBySymbol === true)
+        queryOptions.dedupeBySymbol = true;
+    if (options.includeNonCanonical === true)
+        queryOptions.includeNonCanonical = true;
+    await (0, query_memory_1.queryMemoryCommand)(String(text), queryOptions);
+});
+// ── query-symbol ──────────────────────────────────────────────────────────────
+program
+    .command("query-symbol")
+    .description("Query stored memory records by exact symbol")
+    .argument("<symbol>", "symbol to search")
+    .option("--limit <number>", "max results", "1")
+    .option("--global", "search across all repos (ignore repo scope)")
+    .option("--repo <path>", "explicit repo path to scope results")
+    .option("--include-denied", "include denied records")
+    .option("--only-canonical", "only return affirmed records")
+    .action(async (symbol, options) => {
+    const parsed = Number.parseInt(String(options.limit), 10);
+    const limit = Number.isNaN(parsed) ? 1 : parsed;
+    const queryOptions = {
+        limit,
+        includeDenied: options.includeDenied === true,
+        onlyCanonical: options.onlyCanonical === true,
+    };
+    if (options.global === true)
+        queryOptions.global = true;
+    if (options.repo)
+        queryOptions.repo = String(options.repo);
+    await (0, query_symbol_1.querySymbolCommand)(String(symbol), queryOptions);
+});
+// ── explain-symbol ────────────────────────────────────────────────────────────
+program
+    .command("explain-symbol")
+    .description("Explain what a symbol is and why it exists (canonical answer)")
+    .argument("<symbol>", "symbol to explain")
+    .option("--global", "search across all repos (ignore repo scope)")
+    .option("--repo <path>", "explicit repo path to scope results")
+    .action(async (symbol, options) => {
+    const queryOptions = {};
+    if (options.global === true)
+        queryOptions.global = true;
+    if (options.repo)
+        queryOptions.repo = String(options.repo);
+    await (0, explain_symbol_1.explainSymbolCommand)(String(symbol), queryOptions);
+});
+// ── canonicalize-symbol ───────────────────────────────────────────────────────
+program
+    .command("canonicalize-symbol")
+    .description("Suppress stale proposed siblings for a symbol, keeping affirmed record as canonical truth")
+    .argument("<symbol>", "symbol to canonicalize")
+    .option("--global", "search across all repos (ignore repo scope)")
+    .option("--repo <path>", "explicit repo path to scope results")
+    .option("--dry-run", "show what would be suppressed without making changes")
+    .action(async (symbol, options) => {
+    const queryOptions = {};
+    if (options.global === true)
+        queryOptions.global = true;
+    if (options.repo)
+        queryOptions.repo = String(options.repo);
+    if (options.dryRun === true)
+        queryOptions.dryRun = true;
+    await (0, canonicalize_symbol_1.canonicalizeSymbolCommand)(String(symbol), queryOptions);
+});
+// ── affirm ────────────────────────────────────────────────────────────────────
+program
+    .command("affirm")
+    .description("Affirm a memory record (promote to canonical)")
+    .argument("<id>", "memory id")
+    .action(async (id) => {
+    await (0, affirm_1.affirmCommand)({ id: String(id) });
+});
+// ── ignore ────────────────────────────────────────────────────────────────────
+program
+    .command("ignore")
+    .description("Ignore a memory record (retain as non-canonical)")
+    .argument("<id>", "memory id")
+    .action(async (id) => {
+    await (0, ignore_1.ignoreCommand)({ id: String(id) });
+});
+// ── deny ──────────────────────────────────────────────────────────────────────
+program
+    .command("deny")
+    .description("Deny a memory record and create a corrected replacement proposal")
+    .argument("<id>", "memory id")
+    .option("--title <title>", "optional title for corrected record")
+    .option("--tags <tags>", "comma-separated tags for corrected record")
+    .option("--content <content>", "corrected truth content")
+    .action(async (id, options) => {
+    const payload = { id: String(id) };
+    if (options.title)
+        payload.title = String(options.title);
+    if (options.tags)
+        payload.tags = String(options.tags);
+    if (options.content)
+        payload.content = String(options.content);
+    await (0, deny_1.denyCommand)(payload);
+});
+// ── scan-git ──────────────────────────────────────────────────────────────────
+program
+    .command("scan-git")
+    .description("Scan latest git commit and store an inferred proposed decision")
+    .option("--repo <path>", "repo path to scan")
+    .action(async (options) => {
+    const payload = {};
+    if (options.repo)
+        payload.repo = String(options.repo);
+    await (0, scan_git_1.scanGitCommand)(payload);
+});
+// ── doctor ────────────────────────────────────────────────────────────────────
+program
+    .command("doctor")
+    .description("Run environment and database health checks")
+    .action(async () => {
+    await (0, doctor_1.doctorCommand)();
+});
+// ── install-hook ──────────────────────────────────────────────────────────────
+program
+    .command("install-hook")
+    .description("Install kodingo post-commit git hook in the current repo")
+    .option("--repo <path>", "repo path to install hook into")
+    .action(async (options) => {
+    const payload = {};
+    if (options.repo)
+        payload.repo = String(options.repo);
+    await (0, install_hook_1.installHookCommand)(payload);
+});
+program.parse(process.argv);

package/dist/commands/add-decision.js

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

package/dist/commands/affirm.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.affirmCommand = affirmCommand;
+const persistence_config_1 = require("../utils/persistence-config");
+function clamp01(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(0, Math.min(1, n));
+}
+async function affirmCommand(options) {
+    const { initDb, getMemoryById, updateMemoryLifecycle, suppressProposedSiblings, } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const existing = await getMemoryById(options.id);
+    if (!existing) {
+        throw new Error(`Memory not found: ${options.id}`);
+    }
+    let nextConfidence = existing.confidence;
+    if (existing.status !== "affirmed") {
+        nextConfidence = Math.max(nextConfidence, 0.8);
+        nextConfidence = clamp01(nextConfidence + 0.1);
+    }
+    else {
+        nextConfidence = clamp01(nextConfidence + 0.05);
+    }
+    const updated = await updateMemoryLifecycle({
+        id: existing.id,
+        status: "affirmed",
+        confidence: nextConfidence,
+    });
+    console.log(`Affirmed memory: ${updated.id} (status=${updated.status}, confidence=${updated.confidence.toFixed(2)})`);
+    if (existing.symbol) {
+        const suppressed = await suppressProposedSiblings({
+            symbol: existing.symbol,
+            repoPath: existing.repo ?? null,
+            excludeId: existing.id,
+        });
+        if (suppressed > 0) {
+            console.log(`  Suppressed ${suppressed} stale proposed sibling(s) for symbol: ${existing.symbol}`);
+        }
+    }
+}

package/dist/commands/canonicalize-symbol.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalizeSymbolCommand = canonicalizeSymbolCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+async function canonicalizeSymbolCommand(symbol, options) {
+    const { initDb, queryMemoryBySymbol, suppressProposedSiblings } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const repoPath = resolveRepoScope(options);
+    const canonicalParams = {
+        symbol,
+        limit: 1,
+        onlyCanonical: true,
+    };
+    if (repoPath)
+        canonicalParams.repoPath = repoPath;
+    const canonical = await queryMemoryBySymbol(canonicalParams);
+    const canonicalRecord = canonical[0];
+    if (!canonicalRecord) {
+        console.log(`No affirmed record found for symbol: ${symbol}`);
+        console.log(`Tip: run "kodingo affirm <id>" to promote a record to canonical truth first.`);
+        return;
+    }
+    const allParams = {
+        symbol,
+        limit: 100,
+        onlyCanonical: false,
+        includeDenied: false,
+    };
+    if (repoPath)
+        allParams.repoPath = repoPath;
+    const all = await queryMemoryBySymbol(allParams);
+    const proposedSiblings = all.filter((r) => r.status === "proposed" && r.id !== canonicalRecord.id);
+    const ignoredCount = all.filter((r) => r.status === "ignored" && r.id !== canonicalRecord.id).length;
+    const contentPreview = canonicalRecord.content.length > 80
+        ? canonicalRecord.content.slice(0, 80) + "..."
+        : canonicalRecord.content;
+    console.log(`Symbol: ${symbol}`);
+    console.log(`${"─".repeat(60)}`);
+    console.log(`✓ Canonical record: ${canonicalRecord.id} (confidence ${Math.round(canonicalRecord.confidence * 100)}%)`);
+    console.log(`  ${contentPreview}`);
+    console.log("");
+    if (proposedSiblings.length === 0) {
+        console.log(`Already clean — no stale proposed siblings found.`);
+        if (ignoredCount > 0) {
+            console.log(`  ${ignoredCount} ignored record(s) retained (not canonical, not false).`);
+        }
+        return;
+    }
+    console.log(`Found ${proposedSiblings.length} stale proposed sibling(s) to suppress:`);
+    for (const r of proposedSiblings) {
+        const preview = r.content.length > 60 ? r.content.slice(0, 60) + "..." : r.content;
+        console.log(`  - ${r.id} (confidence ${Math.round(r.confidence * 100)}%)`);
+        console.log(`    ${preview}`);
+    }
+    console.log("");
+    if (options.dryRun) {
+        console.log(`Dry run — no changes made. Remove --dry-run to apply suppression.`);
+        return;
+    }
+    const suppressed = await suppressProposedSiblings({
+        symbol,
+        repoPath: repoPath ?? null,
+        excludeId: canonicalRecord.id,
+    });
+    console.log(`Suppressed ${suppressed} proposed sibling(s) → marked ignored.`);
+    if (ignoredCount > 0) {
+        console.log(`  ${ignoredCount} previously ignored record(s) left untouched.`);
+    }
+    console.log(`Symbol memory is now clean.`);
+}
+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/capture.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureCommand = captureCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+async function captureCommand(options) {
+    const { initDb, saveMemory } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const content = options.content ?? (await readStdin());
+    if (!content) {
+        throw new Error("Content is required. Provide --content or stdin input.");
+    }
+    const tags = parseTags(options.tags);
+    const repoPath = findRepoRoot(process.cwd());
+    const input = {
+        type: options.type,
+        content,
+        repoPath,
+    };
+    if (options.title)
+        input.title = options.title;
+    if (tags)
+        input.tags = tags;
+    const record = await saveMemory(input);
+    console.log(`Saved memory: ${record.id} (type=${record.type})`);
+}
+function parseTags(tags) {
+    if (!tags)
+        return undefined;
+    const parsed = tags
+        .split(",")
+        .map((t) => t.trim())
+        .filter(Boolean);
+    return parsed.length ? parsed : undefined;
+}
+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;
+    }
+}
+async function readStdin() {
+    if (process.stdin.isTTY) {
+        console.log("Enter content, then press Ctrl+D when finished:");
+    }
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => {
+            resolve(data.trim());
+        });
+        process.stdin.on("error", reject);
+    });
+}

package/dist/commands/deny.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.denyCommand = denyCommand;
+const persistence_config_1 = require("../utils/persistence-config");
+function parseTags(tags) {
+    if (!tags)
+        return undefined;
+    const parsed = tags
+        .split(",")
+        .map((t) => t.trim())
+        .filter(Boolean);
+    return parsed.length ? parsed : undefined;
+}
+function mergeTags(existing, override) {
+    if (override && override.length) {
+        const base = new Set(override);
+        for (const t of existing ?? []) {
+            if (t.startsWith("signal:") || t.startsWith("kind:"))
+                base.add(t);
+        }
+        return Array.from(base);
+    }
+    if (existing && existing.length)
+        return existing;
+    return undefined;
+}
+async function denyCommand(options) {
+    const { initDb, getMemoryById, saveMemory, updateMemoryLifecycle } = (0, persistence_config_1.getPersistence)();
+    await initDb();
+    const existing = await getMemoryById(options.id);
+    if (!existing) {
+        throw new Error(`Memory not found: ${options.id}`);
+    }
+    const correctionContent = options.content?.trim();
+    if (!correctionContent) {
+        throw new Error("Correction content is required. Provide --content with the corrected truth.");
+    }
+    const userTags = parseTags(options.tags);
+    const tags = mergeTags(existing.tags, userTags);
+    const input = {
+        type: existing.type,
+        content: correctionContent,
+        status: "proposed",
+        confidence: 0.7,
+        correctsId: existing.id,
+    };
+    if (existing.repo)
+        input.repoPath = existing.repo;
+    if (existing.symbol)
+        input.symbol = existing.symbol;
+    const nextTitle = options.title?.trim();
+    if (nextTitle)
+        input.title = nextTitle;
+    if (tags && tags.length > 0)
+        input.tags = tags;
+    const corrected = await saveMemory(input);
+    const denied = await updateMemoryLifecycle({
+        id: existing.id,
+        status: "denied",
+        confidence: Math.min(existing.confidence, 0.2),
+        correctedById: corrected.id,
+    });
+    console.log(`Denied memory: ${denied.id} (status=${denied.status}, confidence=${denied.confidence.toFixed(2)})`);
+    console.log(`  corrected_by_id: ${denied.correctedById}`);
+    console.log(`Created corrected memory: ${corrected.id} (status=${corrected.status}, confidence=${corrected.confidence.toFixed(2)})`);
+    console.log(`  corrects_id: ${corrected.correctsId}`);
+}

package/dist/commands/doctor.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = doctorCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+// checkDatabaseConnection is local-only — only used in local mode checks.
+const memory_persistence_1 = require("../adapters/db-adapter/memory-persistence");
+async function doctorCommand() {
+    const results = [];
+    const recordId = await runDoctor(results);
+    const hasFail = results.some((r) => r.ok === false);
+    const overallLabel = hasFail ? "FAILED" : "OK";
+    console.log(`Kodingo doctor report: ${overallLabel}`);
+    for (const r of results) {
+        if (r.ok === true)
+            console.log(`- OK: ${r.name}`);
+        else if (r.ok === "warn")
+            console.log(`- WARN: ${r.name} (${r.message})`);
+        else
+            console.log(`- FAIL: ${r.name} (${r.error})`);
+    }
+    // Clean up smoke test record if one was created
+    if (recordId) {
+        try {
+            const { deleteMemoryById } = (0, persistence_config_1.getPersistence)();
+            await deleteMemoryById(recordId);
+        }
+        catch {
+            // ignore cleanup errors in doctor
+        }
+    }
+    if (hasFail)
+        process.exitCode = 1;
+}
+async function runDoctor(results) {
+    const { initDb, saveMemory, queryMemory } = (0, persistence_config_1.getPersistence)();
+    const cloudMode = (0, persistence_config_1.isCloudMode)();
+    // ── Mode-specific connectivity checks ──────────────────────────────────────
+    if (cloudMode) {
+        await runCloudChecks(results);
+    }
+    else {
+        await runLocalChecks(results);
+    }
+    // ── Shared: init + smoke test ───────────────────────────────────────────────
+    let tempId = null;
+    await runStep("Initialize database", async () => {
+        await initDb();
+    }, results);
+    await runStep("Insert temporary memory record", async () => {
+        const inserted = await saveMemory({
+            type: "note",
+            title: "smoke: doctor",
+            content: "doctor saved",
+            tags: ["smoke", "doctor"],
+            repoPath: process.cwd(),
+        });
+        tempId = inserted.id;
+    }, results);
+    await runStep("Query temporary memory record", async () => {
+        const found = await queryMemory("smoke: doctor", 5);
+        if (!found.some((r) => r.id === tempId)) {
+            throw new Error("Temporary record not found in query results");
+        }
+    }, results);
+    await runStep("Delete temporary memory record", async () => {
+        if (!tempId)
+            throw new Error("No temporary record id available");
+        const { deleteMemoryById } = (0, persistence_config_1.getPersistence)();
+        await deleteMemoryById(tempId);
+        tempId = null; // already deleted — skip outer cleanup
+    }, results);
+    // ── Shared: environment checks ──────────────────────────────────────────────
+    if (process.env.ANTHROPIC_API_KEY) {
+        results.push({ name: "ANTHROPIC_API_KEY is set", ok: true });
+    }
+    else {
+        results.push({
+            name: "ANTHROPIC_API_KEY is not set",
+            ok: "warn",
+            message: "git inference will use fallback summaries",
+        });
+    }
+    const repoRoot = findRepoRoot(process.cwd());
+    const hookPath = path_1.default.join(repoRoot, ".git", "hooks", "post-commit");
+    if (fs_1.default.existsSync(hookPath) &&
+        fs_1.default.readFileSync(hookPath, "utf-8").includes("# <kodingo>")) {
+        results.push({ name: "Git hook installed", ok: true });
+    }
+    else {
+        results.push({
+            name: "Git hook not installed",
+            ok: "warn",
+            message: "run kodingo install-hook to enable automatic memory ingestion",
+        });
+    }
+    return tempId;
+}
+// ── Local mode checks ─────────────────────────────────────────────────────────
+async function runLocalChecks(results) {
+    await runStep("DATABASE_URL is set", async () => {
+        if (!process.env.DATABASE_URL) {
+            throw new Error("DATABASE_URL is not set");
+        }
+    }, results);
+    await runStep("Postgres connection", async () => {
+        await (0, memory_persistence_1.checkDatabaseConnection)();
+    }, results);
+}
+// ── Cloud mode checks ─────────────────────────────────────────────────────────
+async function runCloudChecks(results) {
+    const config = (0, persistence_config_1.readConfig)();
+    await runStep("KODINGO_API_URL is configured", async () => {
+        if (!config.apiUrl) {
+            throw new Error("apiUrl is not set in ~/.kodingo/config.json");
+        }
+    }, results);
+    await runStep("KODINGO_API_TOKEN is configured", async () => {
+        if (!config.token) {
+            throw new Error("token is not set in ~/.kodingo/config.json");
+        }
+    }, results);
+    await runStep("kodingo-api reachable", async () => {
+        const apiUrl = config.apiUrl.replace(/\/$/, "");
+        const res = await fetch(`${apiUrl}/health`);
+        if (!res.ok) {
+            throw new Error(`Health check failed: HTTP ${res.status}`);
+        }
+    }, results);
+    await runStep("kodingo-api token valid", async () => {
+        const apiUrl = config.apiUrl.replace(/\/$/, "");
+        const res = await fetch(`${apiUrl}/memory?limit=1`, {
+            headers: { "X-Kodingo-Token": config.token },
+        });
+        if (res.status === 401) {
+            throw new Error("Token is invalid or expired");
+        }
+        if (!res.ok) {
+            throw new Error(`Unexpected response: HTTP ${res.status}`);
+        }
+    }, results);
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+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;
+    }
+}
+async function runStep(name, fn, results) {
+    try {
+        await fn();
+        results.push({ name, ok: true });
+    }
+    catch (err) {
+        results.push({ name, ok: false, error: String(err?.message ?? err) });
+    }
+}