@jmtrin/kevin-core 1.4.0 → 2.0.0

package/dist/sources/ClaudeMemorySource.js

@@ -0,0 +1,36 @@
+// K16-014 — ClaudeMemorySource (read-only mirror of ~/.claude/memory)
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+export class ClaudeMemorySource {
+    enabledFlag;
+    root;
+    name = "claude-memory";
+    precedence = 20;
+    constructor(enabledFlag, root = join(homedir(), ".claude")) {
+        this.enabledFlag = enabledFlag;
+        this.root = root;
+    }
+    enabled() { return this.enabledFlag(); }
+    async fetch() {
+        if (!this.enabled())
+            return [];
+        const memPath = join(this.root, "memory");
+        // Could be directory of markdown files or single file — best-effort
+        if (!existsSync(memPath))
+            return [];
+        try {
+            const txt = readFileSync(memPath, "utf8");
+            // naive: split lines non-empty as statements
+            return txt.split("\n").map(s => s.trim()).filter(Boolean).slice(0, 100).map(statement => ({
+                statement,
+                type: "rule",
+                scope: null,
+                source: this.name,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/sources/CodexMemoriesSource.d.ts

@@ -0,0 +1,10 @@
+import type { MemorySource, SourceEntry } from "./MemorySource.js";
+export declare class CodexMemoriesSource implements MemorySource {
+    private enabledFlag;
+    private root;
+    name: string;
+    precedence: number;
+    constructor(enabledFlag: () => boolean, root?: string);
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}

package/dist/sources/CodexMemoriesSource.js

@@ -0,0 +1,37 @@
+// K16-015 — CodexMemoriesSource (mirror of ~/.codex/memories)
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+export class CodexMemoriesSource {
+    enabledFlag;
+    root;
+    name = "codex-memories";
+    precedence = 30;
+    constructor(enabledFlag, root = join(homedir(), ".codex", "memories")) {
+        this.enabledFlag = enabledFlag;
+        this.root = root;
+    }
+    enabled() { return this.enabledFlag(); }
+    async fetch() {
+        if (!this.enabled())
+            return [];
+        if (!existsSync(this.root))
+            return [];
+        const out = [];
+        try {
+            for (const f of readdirSync(this.root)) {
+                if (!f.endsWith(".md") && !f.endsWith(".txt"))
+                    continue;
+                try {
+                    const txt = readFileSync(join(this.root, f), "utf8");
+                    for (const line of txt.split("\n").map(s => s.trim()).filter(Boolean).slice(0, 50)) {
+                        out.push({ statement: line, type: "rule", scope: null, source: this.name });
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+        return out;
+    }
+}

package/dist/sources/IdleSync.d.ts

@@ -0,0 +1,10 @@
+import type { Store } from "../Store.js";
+import type { MemorySource, SourceSyncResult } from "./MemorySource.js";
+export interface SyncDeps {
+    store: Store;
+    sources: MemorySource[];
+    metrics?: {
+        incr(key: string, by?: number): void;
+    };
+}
+export declare function idleSync(deps: SyncDeps): Promise<SourceSyncResult[]>;

package/dist/sources/IdleSync.js

@@ -0,0 +1,49 @@
+import { fingerprint } from "../fingerprint.js";
+function dedupKey(e) {
+    // lower precedence wins attribution: fingerprint over normalized statement + scope
+    return fingerprint(`${e.type}\0${e.statement}\0${e.scope ?? ""}`);
+}
+export async function idleSync(deps) {
+    const results = [];
+    const seen = new Set();
+    // Pre-populate dedup with existing memories fingerprints (lowest precedence already wins)
+    try {
+        const rows = deps.store.prepare("SELECT fingerprint FROM memories").all();
+        for (const r of rows)
+            if (r.fingerprint)
+                seen.add(r.fingerprint);
+    }
+    catch { }
+    for (const src of deps.sources.sort((a, b) => a.precedence - b.precedence)) {
+        if (!src.enabled()) {
+            results.push({ source: src.name, fetched: 0, dedupSkipped: 0, inserted: 0 });
+            continue;
+        }
+        const entries = await src.fetch().catch(() => []);
+        let dedupSkipped = 0;
+        let inserted = 0;
+        for (const e of entries) {
+            const fp = dedupKey(e);
+            if (seen.has(fp)) {
+                dedupSkipped++;
+                continue;
+            }
+            seen.add(fp);
+            // Insert as memory with source provenance (simplified)
+            try {
+                deps.store.prepare(`INSERT OR IGNORE INTO memories (id, project_id, type, content, scope, fingerprint, confidence, origin, source, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`).run(`src-${fp.slice(0, 12)}-${src.name}`, "default", e.type, e.statement, e.scope, fp, 0.5, src.name, src.name);
+                inserted++;
+            }
+            catch {
+                dedupSkipped++;
+            }
+        }
+        if (dedupSkipped > 0)
+            deps.metrics?.incr("source_dedup_skips_total", dedupSkipped);
+        if (inserted > 0)
+            deps.metrics?.incr("source_syncs_total", 1);
+        results.push({ source: src.name, fetched: entries.length, dedupSkipped, inserted });
+    }
+    return results;
+}

package/dist/sources/MemorySource.d.ts

@@ -0,0 +1,19 @@
+export interface MemorySource {
+    name: string;
+    precedence: number;
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}
+export interface SourceEntry {
+    statement: string;
+    type: "decision" | "rule" | "pattern" | "solution";
+    scope: string | null;
+    source: string;
+    updatedAt?: string;
+}
+export interface SourceSyncResult {
+    source: string;
+    fetched: number;
+    dedupSkipped: number;
+    inserted: number;
+}

package/dist/sources/MemorySource.js

@@ -0,0 +1 @@
+export {};

package/dist/sources/OpencodeNativeSource.d.ts

@@ -0,0 +1,10 @@
+import type { MemorySource, SourceEntry } from "./MemorySource.js";
+export declare class OpencodeNativeSource implements MemorySource {
+    private enabledFlag;
+    private projectRoot;
+    name: string;
+    precedence: number;
+    constructor(enabledFlag: () => boolean, projectRoot?: string);
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}

package/dist/sources/OpencodeNativeSource.js

@@ -0,0 +1,33 @@
+// K16-016 — OpencodeNativeSource (native opencode memories, e.g. .opencode/memory)
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export class OpencodeNativeSource {
+    enabledFlag;
+    projectRoot;
+    name = "opencode-native";
+    precedence = 40;
+    constructor(enabledFlag, projectRoot = process.cwd()) {
+        this.enabledFlag = enabledFlag;
+        this.projectRoot = projectRoot;
+    }
+    enabled() { return this.enabledFlag(); }
+    async fetch() {
+        if (!this.enabled())
+            return [];
+        const p = join(this.projectRoot, ".opencode", "memory");
+        if (!existsSync(p))
+            return [];
+        try {
+            const txt = readFileSync(p, "utf8");
+            return txt.split("\n").map(s => s.trim()).filter(Boolean).slice(0, 100).map(statement => ({
+                statement,
+                type: "rule",
+                scope: null,
+                source: this.name,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/sources/OpencodePluginSource.d.ts

@@ -0,0 +1,9 @@
+import type { MemorySource, SourceEntry } from "./MemorySource.js";
+export declare class OpencodePluginSource implements MemorySource {
+    private enabledFlag;
+    name: string;
+    precedence: number;
+    constructor(enabledFlag: () => boolean);
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}

package/dist/sources/OpencodePluginSource.js

@@ -0,0 +1,13 @@
+export class OpencodePluginSource {
+    enabledFlag;
+    name = "opencode-plugin";
+    precedence = 10;
+    constructor(enabledFlag) {
+        this.enabledFlag = enabledFlag;
+    }
+    enabled() { return this.enabledFlag(); }
+    async fetch() {
+        // Plugin source is the local DB itself — no fetch, handled elsewhere
+        return [];
+    }
+}

package/dist/sqlite-adapter.js

@@ -31,7 +31,7 @@ class NodeSqliteAdapter {
     }
     transaction(fn) {
         return () => {
-            this.db.exec("BEGIN");
+            this.db.exec("BEGIN IMMEDIATE");
             try {
                 const result = fn();
                 this.db.exec("COMMIT");

package/package.json

@@ -1,28 +1,26 @@
 {
-  "name": "@jmtrin/kevin-core",
-  "version": "1.4.0",
-  "description": "Kevin core — host-agnostic deterministic brain (Bedrock)",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node ./scripts/copy-migrations.mjs",
-    "typecheck": "tsc --noEmit"
-  },
-  "engines": {
-    "node": ">=22.5.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT"
+	"name": "@jmtrin/kevin-core",
+	"version": "2.0.0",
+	"description": "Kevin core — host-agnostic deterministic brain (Bedrock)",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": ["dist"],
+	"scripts": {
+		"build": "tsc -p tsconfig.json && node ./scripts/copy-migrations.mjs",
+		"typecheck": "tsc --noEmit"
+	},
+	"engines": {
+		"node": ">=22.5.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "MIT"
 }