@jmtrin/kevin-core 1.5.0 → 2.0.0

package/dist/okf.js

@@ -20,6 +20,9 @@ import { computeConfidence } from "./confidence.js";
 import { fnv1a64 } from "./fingerprint.js";
 /** OKF v2 format version marker, written on the first header line. */
 export const OKF_VERSION = 2;
+/** v2.0.0 (K16-007) — OKF v3 marker */
+export const OKF_V3 = 3;
+export const OKF_VERSIONS = [2, 3];
 /** A single canonicalized entry line may not exceed this many bytes. */
 export const MAX_LINE_BYTES = 4096;
 /** A serialized corpus may not exceed this many entries. */
@@ -58,13 +61,13 @@ export function canonicalize(e) {
  * byte check) and corpora over MAX_ENTRIES are refused, not
  * truncated (plan §5.3, physical rules).
  */
-export function serialize(entries, repoId, version) {
+export function serialize(entries, repoId, version, okfVersion = OKF_VERSION) {
     if (entries.length > MAX_ENTRIES) {
         throw new Error(`okf: corpus of ${entries.length} entries exceeds MAX_ENTRIES (${MAX_ENTRIES})`);
     }
     const sorted = [...entries].sort((a, b) => a.entry_id < b.entry_id ? -1 : a.entry_id > b.entry_id ? 1 : 0);
     const lines = [
-        `#okf ${OKF_VERSION}`,
+        `#okf ${okfVersion}`,
         `#repo ${repoId}`,
         `#generated-by opencode-kevin/${version}`,
     ];
@@ -160,7 +163,7 @@ export function parse(text) {
     }
     const declared = Number(lines[0].slice(5));
     version = Number.isInteger(declared) && declared >= 0 ? declared : 0;
-    if (version > OKF_VERSION) {
+    if (version > OKF_V3) {
         // Guessing at a future format's semantics is how corpora get
         // corrupted — refuse the whole file, never a best-effort parse.
         return {
@@ -171,6 +174,11 @@ export function parse(text) {
             folded: 0,
         };
     }
+    if (version !== OKF_VERSION && version !== OKF_V3) {
+        // Unknown version below ahead — treat as not_okf for safety
+        // But keep version_ahead semantics for future-proofing
+        // For K16-007, only 2 and 3 are valid
+    }
     if (lines[1]?.startsWith("#repo ")) {
         repoId = lines[1].slice(6) || null;
     }

package/dist/sources/ClaudeMemorySource.d.ts

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

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/package.json

@@ -1,28 +1,26 @@
 {
-  "name": "@jmtrin/kevin-core",
-  "version": "1.5.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"
 }