kodingo-cli 1.0.0

package/dist/ports/cloud-event-port.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudEventPort = void 0;
+const kodingo_core_1 = require("kodingo-core");
+const persistence_config_1 = require("../utils/persistence-config");
+const inference_1 = require("../adapters/ai/inference");
+const path_1 = __importDefault(require("path"));
+/**
+ * EventPort implementation that persists via getPersistence().
+ * Used in cloud mode — drop-in replacement for DbEventPort.
+ * GitListenerAdapter only depends on EventPort, so it works with either.
+ */
+class CloudEventPort {
+    constructor(repoPath) {
+        this.repoPath = repoPath;
+        this.persistence = (0, persistence_config_1.getPersistence)();
+    }
+    async pushDecision(decision, _context) {
+        await this.persistence.initDb();
+        const { title, content, symbol, externalId } = await this.mapDecisionToMemory(decision);
+        // Confidence accumulation: if symbol is present, look for existing record
+        if (symbol) {
+            const existing = await this.getProposedOrIgnoredBySymbol(symbol);
+            if (existing) {
+                const domainRecord = {
+                    id: existing.id,
+                    projectId: existing.projectId,
+                    repo: this.repoPath,
+                    type: "decision",
+                    title: existing.title ?? "",
+                    content: existing.content,
+                    symbol: existing.symbol ?? "",
+                    tags: existing.tags ?? [],
+                    status: existing.status,
+                    confidence: existing.confidence,
+                    evidence: {
+                        strongCodeChangeCount: 0,
+                        structuralCount: 0,
+                        metadataCount: 0,
+                        evidenceGain: 0,
+                    },
+                    createdAt: existing.createdAt instanceof Date
+                        ? existing.createdAt
+                        : new Date(existing.createdAt),
+                    updatedAt: existing.updatedAt instanceof Date
+                        ? existing.updatedAt
+                        : new Date(existing.updatedAt),
+                };
+                const updated = (0, kodingo_core_1.applySignal)(domainRecord, {
+                    weightClass: "code_change",
+                });
+                await this.persistence.updateMemoryConfidence({
+                    id: existing.id,
+                    confidence: updated.confidence,
+                });
+                console.log(`Signal applied to existing memory: ${existing.id} (symbol=${symbol}, confidence=${updated.confidence.toFixed(2)})`);
+                return;
+            }
+        }
+        // No existing proposed/ignored record — insert new
+        const input = {
+            type: "decision",
+            content,
+            repoPath: this.repoPath,
+            status: "proposed",
+            confidence: 0.3,
+            externalId,
+            tags: ["signal:git", "kind:decision"],
+        };
+        if (title)
+            input.title = title;
+        if (symbol)
+            input.symbol = symbol;
+        await this.persistence.saveMemory(input);
+    }
+    /**
+     * Query for a proposed or ignored record by symbol, scoped to this repo.
+     * The cloud adapter exposes this via queryMemoryBySymbol — we replicate
+     * the same selection logic as getProposedOrIgnoredRecordBySymbol in db-adapter.
+     */
+    async getProposedOrIgnoredBySymbol(symbol) {
+        const results = await this.persistence.queryMemoryBySymbol({
+            symbol,
+            limit: 10,
+            repoPath: this.repoPath,
+            includeDenied: false,
+            onlyCanonical: false,
+        });
+        // Prefer proposed over ignored, then highest confidence
+        const candidates = results.filter((r) => r.status === "proposed" || r.status === "ignored");
+        if (candidates.length === 0)
+            return null;
+        return candidates.sort((a, b) => {
+            if (a.status === "proposed" && b.status !== "proposed")
+                return -1;
+            if (b.status === "proposed" && a.status !== "proposed")
+                return 1;
+            return b.confidence - a.confidence;
+        })[0];
+    }
+    async mapDecisionToMemory(decision) {
+        const summary = safeParseJson(decision.changeSummary);
+        const commitHash = typeof summary?.commitHash === "string"
+            ? summary.commitHash
+            : decision.id;
+        const filesChanged = Array.isArray(summary?.filesChanged)
+            ? summary.filesChanged
+            : [];
+        const symbolsTouched = Array.isArray(summary?.symbolsTouched)
+            ? summary.symbolsTouched
+            : [];
+        const symbol = this.pickBestSymbol(symbolsTouched, filesChanged);
+        const filePaths = extractFilePaths(filesChanged);
+        const repoName = path_1.default.basename(this.repoPath);
+        const shortHash = String(commitHash).slice(0, 8);
+        const content = await (0, inference_1.inferDecisionSummary)({
+            diff: typeof summary?.rawDiff === "string"
+                ? summary.rawDiff
+                : (decision.changeSummary ?? ""),
+            changedFiles: filePaths,
+            symbol: symbol ?? "unknown",
+            commitMessage: decision.rationale ?? "",
+            repoName,
+        });
+        const title = symbol
+            ? `Decision: changes to ${symbol}`
+            : `Decision: changes in commit ${shortHash}`;
+        const externalId = `git:${String(commitHash)}`;
+        return { title, content, symbol, externalId };
+    }
+    pickBestSymbol(symbolsTouched, filesChanged) {
+        const firstSymbol = typeof symbolsTouched?.[0] === "string"
+            ? symbolsTouched[0]
+            : null;
+        if (firstSymbol)
+            return firstSymbol;
+        const filePaths = extractFilePaths(filesChanged);
+        for (const p of filePaths) {
+            const feature = deriveFeatureSymbol(p);
+            if (feature)
+                return feature;
+        }
+        for (const p of filePaths) {
+            const folder = deriveTopFolderSymbol(p);
+            if (folder)
+                return folder;
+        }
+        return "repo";
+    }
+}
+exports.CloudEventPort = CloudEventPort;
+// ── Shared helpers (mirrored from DbEventPort) ────────────────────────────────
+function extractFilePaths(filesChanged) {
+    const out = [];
+    for (const item of filesChanged) {
+        if (item && typeof item === "object") {
+            const anyItem = item;
+            if (typeof anyItem.file === "string" && anyItem.file.trim()) {
+                out.push(normalizePath(anyItem.file.trim()));
+            }
+        }
+    }
+    return out;
+}
+function normalizePath(p) {
+    return p.replace(/\\/g, "/");
+}
+function deriveFeatureSymbol(filePath) {
+    const parts = filePath.split("/").filter(Boolean);
+    if (parts.length < 3)
+        return null;
+    if (parts[0] !== "lib")
+        return null;
+    if (parts[1] !== "features")
+        return null;
+    const featureName = parts[2];
+    if (!featureName)
+        return null;
+    return `feature:lib/features/${featureName}`;
+}
+function deriveTopFolderSymbol(filePath) {
+    const parts = filePath.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return null;
+    if (parts[0] === "lib") {
+        if (parts.length >= 2) {
+            if (parts.length === 2 && parts[1].includes("."))
+                return "module:lib";
+            return `module:lib/${parts[1]}`;
+        }
+        return "module:lib";
+    }
+    return `path:${parts[0]}`;
+}
+function safeParseJson(input) {
+    if (typeof input !== "string")
+        return null;
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/ports/db-event-port.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbEventPort = void 0;
+const kodingo_core_1 = require("kodingo-core");
+const memory_persistence_1 = require("../adapters/db-adapter/memory-persistence");
+const inference_1 = require("../adapters/ai/inference");
+const path_1 = __importDefault(require("path"));
+/**
+ * Minimal EventPort implementation for the CLI.
+ * Persists incoming Decisions as memory records using the DB adapter.
+ *
+ * MVP wiring:
+ * - status: proposed
+ * - confidence: 0.30 baseline (domain contract)
+ * - repoPath: provided at construction time
+ * - externalId: stable dedupe key (git:<commitHash>)
+ * - symbol:
+ *    1) first touched symbol if present (ts/js)
+ *    2) else derive folder symbol from changed files (flutter/dart etc.)
+ *
+ * Confidence accumulation:
+ * - When a symbol already has a proposed/ignored record, apply a code_change
+ *   signal to raise its confidence instead of inserting a duplicate.
+ * - Affirmed/denied records are never modified — insert a new proposed record.
+ */
+class DbEventPort {
+    constructor(repoPath) {
+        this.repoPath = repoPath;
+    }
+    async pushDecision(decision, _context) {
+        await (0, memory_persistence_1.initDb)();
+        const { title, content, symbol, externalId } = await this.mapDecisionToMemory(decision);
+        // Confidence accumulation: if symbol is present, look for existing record
+        if (symbol) {
+            const existing = await (0, memory_persistence_1.getProposedOrIgnoredRecordBySymbol)({
+                symbol,
+                repoPath: this.repoPath,
+            });
+            if (existing) {
+                // Build a minimal domain MemoryRecord for applySignal.
+                // Evidence counters are zeroed intentionally — full evidence replay
+                // is out of scope for MVP. Only confidence is persisted.
+                const domainRecord = {
+                    id: existing.id,
+                    projectId: "",
+                    repo: this.repoPath,
+                    type: "decision",
+                    title: existing.title ?? "",
+                    content: existing.content,
+                    symbol: existing.symbol ?? "",
+                    tags: existing.tags ?? [],
+                    status: existing.status,
+                    confidence: existing.confidence,
+                    evidence: {
+                        strongCodeChangeCount: 0,
+                        structuralCount: 0,
+                        metadataCount: 0,
+                        evidenceGain: 0,
+                    },
+                    createdAt: existing.createdAt,
+                    updatedAt: existing.createdAt,
+                };
+                const updated = (0, kodingo_core_1.applySignal)(domainRecord, {
+                    weightClass: "code_change",
+                });
+                await (0, memory_persistence_1.updateMemoryConfidence)({
+                    id: existing.id,
+                    confidence: updated.confidence,
+                });
+                console.log(`Signal applied to existing memory: ${existing.id} (symbol=${symbol}, confidence=${updated.confidence.toFixed(2)})`);
+                return;
+            }
+        }
+        // No existing proposed/ignored record — insert new record as usual
+        const input = {
+            type: "decision",
+            content,
+            repoPath: this.repoPath,
+            status: "proposed",
+            confidence: 0.3,
+            externalId,
+        };
+        if (title)
+            input.title = title;
+        if (symbol)
+            input.symbol = symbol;
+        input.tags = ["signal:git", "kind:decision"];
+        await (0, memory_persistence_1.saveMemory)(input);
+    }
+    async mapDecisionToMemory(decision) {
+        const summary = safeParseJson(decision.changeSummary);
+        const commitHash = typeof summary?.commitHash === "string"
+            ? summary.commitHash
+            : decision.id;
+        const filesChanged = Array.isArray(summary?.filesChanged)
+            ? summary.filesChanged
+            : [];
+        const symbolsTouched = Array.isArray(summary?.symbolsTouched)
+            ? summary.symbolsTouched
+            : [];
+        const symbol = this.pickBestSymbol(symbolsTouched, filesChanged);
+        const filePaths = extractFilePaths(filesChanged);
+        const repoName = path_1.default.basename(this.repoPath);
+        const shortHash = String(commitHash).slice(0, 8);
+        const content = await (0, inference_1.inferDecisionSummary)({
+            diff: typeof summary?.rawDiff === "string"
+                ? summary.rawDiff
+                : (decision.changeSummary ?? ""),
+            changedFiles: filePaths,
+            symbol: symbol ?? "unknown",
+            commitMessage: decision.rationale ?? "",
+            repoName,
+        });
+        const title = symbol
+            ? `Decision: changes to ${symbol}`
+            : `Decision: changes in commit ${shortHash}`;
+        const externalId = `git:${String(commitHash)}`;
+        return { title, content, symbol, externalId };
+    }
+    pickBestSymbol(symbolsTouched, filesChanged) {
+        const firstSymbol = typeof symbolsTouched?.[0] === "string"
+            ? symbolsTouched[0]
+            : null;
+        if (firstSymbol)
+            return firstSymbol;
+        const filePaths = extractFilePaths(filesChanged);
+        for (const p of filePaths) {
+            const feature = deriveFeatureSymbol(p);
+            if (feature)
+                return feature;
+        }
+        for (const p of filePaths) {
+            const folder = deriveTopFolderSymbol(p);
+            if (folder)
+                return folder;
+        }
+        return "repo";
+    }
+}
+exports.DbEventPort = DbEventPort;
+function extractFilePaths(filesChanged) {
+    const out = [];
+    for (const item of filesChanged) {
+        if (item && typeof item === "object") {
+            const anyItem = item;
+            if (typeof anyItem.file === "string" && anyItem.file.trim()) {
+                out.push(normalizePath(anyItem.file.trim()));
+            }
+        }
+    }
+    return out;
+}
+function normalizePath(p) {
+    return p.replace(/\\/g, "/");
+}
+function deriveFeatureSymbol(filePath) {
+    const parts = filePath.split("/").filter(Boolean);
+    if (parts.length < 3)
+        return null;
+    if (parts[0] !== "lib")
+        return null;
+    if (parts[1] !== "features")
+        return null;
+    const featureName = parts[2];
+    if (!featureName)
+        return null;
+    return `feature:lib/features/${featureName}`;
+}
+function deriveTopFolderSymbol(filePath) {
+    const parts = filePath.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return null;
+    if (parts[0] === "lib") {
+        if (parts.length >= 2) {
+            if (parts.length === 2 && parts[1].includes("."))
+                return "module:lib";
+            return `module:lib/${parts[1]}`;
+        }
+        return "module:lib";
+    }
+    return `path:${parts[0]}`;
+}
+function safeParseJson(input) {
+    if (typeof input !== "string")
+        return null;
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/persistence-config.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_PATH = void 0;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.isCloudMode = isCloudMode;
+exports.getPersistence = getPersistence;
+/**
+ * Persistence config switcher.
+ * Reads ~/.kodingo/config.json and returns the correct adapter.
+ *
+ * Config file shape:
+ * {
+ *   "mode": "cloud",           // "local" | "cloud"
+ *   "apiUrl": "https://...",   // required when mode=cloud
+ *   "token": "uuid"            // required when mode=cloud
+ * }
+ *
+ * Falls back to "local" if config file is missing or mode=local.
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+exports.CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".kodingo", "config.json");
+function readConfig() {
+    if (!node_fs_1.default.existsSync(exports.CONFIG_PATH)) {
+        return { mode: "local" };
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(exports.CONFIG_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch {
+        console.warn("Warning: could not parse ~/.kodingo/config.json — using local mode");
+        return { mode: "local" };
+    }
+}
+function writeConfig(config) {
+    const dir = node_path_1.default.dirname(exports.CONFIG_PATH);
+    if (!node_fs_1.default.existsSync(dir)) {
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    node_fs_1.default.writeFileSync(exports.CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function isCloudMode() {
+    return readConfig().mode === "cloud";
+}
+/**
+ * Returns the correct persistence adapter based on config.
+ * Import this in commands instead of importing the adapters directly.
+ */
+function getPersistence() {
+    const config = readConfig();
+    if (config.mode === "cloud") {
+        if (!config.apiUrl)
+            throw new Error("Cloud mode requires apiUrl in ~/.kodingo/config.json");
+        if (!config.token)
+            throw new Error("Cloud mode requires token in ~/.kodingo/config.json");
+        // Inject into env so cloud-persistence picks them up
+        process.env.KODINGO_API_URL = config.apiUrl;
+        process.env.KODINGO_API_TOKEN = config.token;
+        return require("../adapters/cloud-adapter/cloud-persistence");
+    }
+    return require("../adapters/db-adapter/memory-persistence");
+}

package/dist/utils/repo-scope.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRepoScope = resolveRepoScope;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolveRepoScope(options = {}) {
+    if (options.global) {
+        return null;
+    }
+    const basePath = options.repo
+        ? path_1.default.resolve(options.repo)
+        : path_1.default.resolve(options.cwd ?? process.cwd());
+    const repoRoot = findRepoRoot(basePath);
+    if (options.repo) {
+        return repoRoot ?? basePath;
+    }
+    return repoRoot ?? basePath;
+}
+function findRepoRoot(startPath) {
+    let current = normalizePath(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 null;
+        }
+        current = parent;
+    }
+}
+function normalizePath(startPath) {
+    let current = path_1.default.resolve(startPath);
+    try {
+        const stats = fs_1.default.statSync(current);
+        if (stats.isFile()) {
+            current = path_1.default.dirname(current);
+        }
+    }
+    catch {
+        // If the path doesn't exist, keep the resolved path as-is.
+    }
+    return current;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "kodingo-cli",
+  "version": "1.0.0",
+  "description": "Kodingo CLI",
+  "license": "MIT",
+  "private": false,
+  "type": "commonjs",
+  "main": "dist/cli.js",
+  "bin": {
+    "kodingo": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "start": "node dist/cli.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "commander": "^12.1.0",
+    "kodingo-core": "file:../kodingo-core",
+    "simple-git": "^3.30.0",
+    "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.28.0",
+    "@types/node": "^22.0.0",
+    "@types/uuid": "^10.0.0",
+    "typescript": "^5.6.0"
+  }
+}