@dawn-ai/memory 0.8.3

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type MemoryScopeTuple, serializeNamespace } from "./namespace.js";
+export { classifyWrite, type WriteOp } from "./reconcile.js";
+export { sqliteMemoryStore } from "./sqlite-store.js";
+export { tokenize } from "./tokenize.js";
+export type { MemoryKind, MemoryQuery, MemoryRecord, MemorySource, MemoryStatus, MemoryStore, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,YAAY,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,WAAW,GACZ,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { serializeNamespace } from "./namespace.js";
+export { classifyWrite } from "./reconcile.js";
+export { sqliteMemoryStore } from "./sqlite-store.js";
+export { tokenize } from "./tokenize.js";

package/dist/namespace.d.ts

@@ -0,0 +1,10 @@
+export interface MemoryScopeTuple {
+    readonly workspace?: string;
+    readonly route?: string;
+    readonly tenant?: string;
+    readonly user?: string;
+    readonly agent?: string;
+}
+/** Serialize a scope tuple to a stable namespace string. Fail-closed on empty. */
+export declare function serializeNamespace(tuple: MemoryScopeTuple): string;
+//# sourceMappingURL=namespace.d.ts.map

package/dist/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../src/namespace.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CASlE"}

package/dist/namespace.js

@@ -0,0 +1,13 @@
+const ORDER = ["workspace", "route", "tenant", "user", "agent"];
+/** Serialize a scope tuple to a stable namespace string. Fail-closed on empty. */
+export function serializeNamespace(tuple) {
+    const parts = [];
+    for (const key of ORDER) {
+        const value = tuple[key];
+        if (value !== undefined && value !== "")
+            parts.push(`${key}=${value}`);
+    }
+    if (parts.length === 0)
+        throw new Error("serializeNamespace: scope tuple must have at least one dimension");
+    return parts.join("|");
+}

package/dist/reconcile.d.ts

@@ -0,0 +1,13 @@
+import type { MemoryRecord } from "./types.js";
+export type WriteOp = {
+    op: "add";
+} | {
+    op: "update";
+    targetId: string;
+} | {
+    op: "supersede";
+    targetId: string;
+};
+/** Deterministic write classification (no LLM): ADD if no identity match; UPDATE if identity+data equal; SUPERSEDE if identity matches but data differs. */
+export declare function classifyWrite(incoming: MemoryRecord, candidates: readonly MemoryRecord[], identityKeys: readonly string[]): WriteOp;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../src/reconcile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,MAAM,MAAM,OAAO,GACf;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,GACb;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,EAAE,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAIzC,4JAA4J;AAC5J,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,YAAY,EACtB,UAAU,EAAE,SAAS,YAAY,EAAE,EACnC,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,OAAO,CAMT"}

package/dist/reconcile.js

@@ -0,0 +1,12 @@
+function identityOf(data, keys) {
+    return keys.map((k) => JSON.stringify(data[k] ?? null)).join(" ");
+}
+/** Deterministic write classification (no LLM): ADD if no identity match; UPDATE if identity+data equal; SUPERSEDE if identity matches but data differs. */
+export function classifyWrite(incoming, candidates, identityKeys) {
+    const incomingId = identityOf(incoming.data, identityKeys);
+    const match = candidates.find((c) => identityOf(c.data, identityKeys) === incomingId);
+    if (!match)
+        return { op: "add" };
+    const same = JSON.stringify(match.data) === JSON.stringify(incoming.data);
+    return same ? { op: "update", targetId: match.id } : { op: "supersede", targetId: match.id };
+}

package/dist/sqlite-store.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryStore } from "./types.js";
+export declare function sqliteMemoryStore(opts: {
+    path: string;
+}): MemoryStore;
+//# sourceMappingURL=sqlite-store.d.ts.map

package/dist/sqlite-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-store.d.ts","sourceRoot":"","sources":["../src/sqlite-store.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAA6B,WAAW,EAAE,MAAM,YAAY,CAAA;AAwGxE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,WAAW,CAsGrE"}

package/dist/sqlite-store.js

@@ -0,0 +1,170 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { tokenize } from "./tokenize.js";
+// ---------------------------------------------------------------------------
+// Inline DB helpers (mirrors packages/sqlite-storage/src/internal — not
+// re-exported from that package's public API, so we replicate the tiny shim).
+// ---------------------------------------------------------------------------
+function openDb(path) {
+    const isMemory = path === ":memory:";
+    if (!isMemory) {
+        mkdirSync(dirname(path), { recursive: true });
+    }
+    const db = new DatabaseSync(path);
+    if (!isMemory) {
+        db.exec("PRAGMA journal_mode = WAL");
+    }
+    db.exec("PRAGMA foreign_keys = ON");
+    db.exec("PRAGMA synchronous = NORMAL");
+    return db;
+}
+function runMigrations(db, migrations) {
+    db.exec("CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY)");
+    const row = db.prepare("SELECT max(version) AS v FROM schema_version").get();
+    const current = row?.v ?? 0;
+    const sorted = [...migrations].sort((a, b) => a.version - b.version);
+    for (const m of sorted) {
+        if (m.version <= current)
+            continue;
+        db.exec("BEGIN");
+        try {
+            db.exec(m.up);
+            db.prepare("INSERT INTO schema_version(version) VALUES (?)").run(m.version);
+            db.exec("COMMIT");
+        }
+        catch (err) {
+            db.exec("ROLLBACK");
+            throw err;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+const MIGRATIONS = [
+    {
+        version: 1,
+        up: `
+      CREATE TABLE memories (
+        id TEXT PRIMARY KEY, kind TEXT NOT NULL, namespace TEXT NOT NULL,
+        content TEXT NOT NULL, data TEXT NOT NULL, source TEXT NOT NULL,
+        confidence REAL NOT NULL, tags TEXT NOT NULL, status TEXT NOT NULL,
+        supersedes TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+        effective_at TEXT, expires_at TEXT
+      );
+      CREATE INDEX idx_mem_ns_status_updated ON memories(namespace, status, updated_at DESC);
+      CREATE TABLE memory_tokens (
+        memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE, token TEXT NOT NULL
+      );
+      CREATE INDEX idx_memtok_token ON memory_tokens(token);
+      CREATE INDEX idx_memtok_mem ON memory_tokens(memory_id);
+    `,
+    },
+];
+// ---------------------------------------------------------------------------
+// Row ↔ record conversion
+// ---------------------------------------------------------------------------
+function rowToRecord(row) {
+    return {
+        id: row.id,
+        kind: row.kind,
+        namespace: row.namespace,
+        content: row.content,
+        data: JSON.parse(row.data),
+        source: JSON.parse(row.source),
+        confidence: row.confidence,
+        tags: JSON.parse(row.tags),
+        status: row.status,
+        ...(row.supersedes ? { supersedes: JSON.parse(row.supersedes) } : {}),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        ...(row.effective_at ? { effectiveAt: row.effective_at } : {}),
+        ...(row.expires_at ? { expiresAt: row.expires_at } : {}),
+    };
+}
+function tokensFor(rec) {
+    const values = Object.values(rec.data).filter((v) => typeof v === "string");
+    return tokenize([rec.content, rec.tags.join(" "), values.join(" ")].join(" "));
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function sqliteMemoryStore(opts) {
+    const db = openDb(opts.path);
+    runMigrations(db, MIGRATIONS);
+    function reindex(rec) {
+        db.prepare("DELETE FROM memory_tokens WHERE memory_id = ?").run(rec.id);
+        const ins = db.prepare("INSERT INTO memory_tokens(memory_id, token) VALUES (?, ?)");
+        for (const t of tokensFor(rec))
+            ins.run(rec.id, t);
+    }
+    function getById(id) {
+        const row = db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+        return row ? rowToRecord(row) : null;
+    }
+    function putRecord(rec) {
+        db.prepare(`INSERT OR REPLACE INTO memories
+       (id,kind,namespace,content,data,source,confidence,tags,status,supersedes,created_at,updated_at,effective_at,expires_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(rec.id, rec.kind, rec.namespace, rec.content, JSON.stringify(rec.data), JSON.stringify(rec.source), rec.confidence, JSON.stringify(rec.tags), rec.status, rec.supersedes ? JSON.stringify(rec.supersedes) : null, rec.createdAt, rec.updatedAt, rec.effectiveAt ?? null, rec.expiresAt ?? null);
+        reindex(rec);
+    }
+    return {
+        async put(rec) {
+            putRecord(rec);
+        },
+        async get(id) {
+            return getById(id);
+        },
+        async search(q) {
+            const status = q.status ?? "active";
+            const limit = q.limit ?? 8;
+            const terms = q.query ? tokenize(q.query) : [];
+            const params = [q.namespace, status];
+            let sql = `SELECT m.* FROM memories m WHERE m.namespace = ? AND m.status = ?`;
+            if (q.kind) {
+                sql += ` AND m.kind = ?`;
+                params.push(q.kind);
+            }
+            if (terms.length > 0) {
+                const placeholders = terms.map(() => "?").join(",");
+                sql += ` AND m.id IN (SELECT memory_id FROM memory_tokens WHERE token IN (${placeholders}))`;
+                params.push(...terms);
+            }
+            sql += ` ORDER BY m.updated_at DESC, m.id ASC LIMIT ?`;
+            params.push(limit);
+            const rows = db.prepare(sql).all(...params);
+            let records = rows.map(rowToRecord);
+            if (q.tags && q.tags.length > 0) {
+                const want = new Set(q.tags);
+                records = records.filter((r) => r.tags.some((t) => want.has(t)));
+            }
+            return records;
+        },
+        async update(id, patch) {
+            const current = getById(id);
+            if (!current)
+                throw new Error(`memory not found: ${id}`);
+            putRecord({ ...current, ...patch, id });
+        },
+        async supersede(id, bySupersedingId) {
+            if (!getById(id))
+                throw new Error(`memory not found: ${id}`);
+            db.prepare("UPDATE memories SET status = 'superseded' WHERE id = ?").run(id);
+            const superseding = getById(bySupersedingId);
+            if (superseding) {
+                const links = new Set([...(superseding.supersedes ?? []), id]);
+                db.prepare("UPDATE memories SET supersedes = ? WHERE id = ?").run(JSON.stringify([...links]), bySupersedingId);
+            }
+        },
+        async delete(id) {
+            db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+        },
+        async listCandidates(namespacePrefix) {
+            const rows = db
+                .prepare("SELECT * FROM memories WHERE status = 'candidate' AND namespace LIKE ? ORDER BY created_at DESC")
+                .all(`${namespacePrefix}%`);
+            return rows.map(rowToRecord);
+        },
+    };
+}

package/dist/tokenize.d.ts

@@ -0,0 +1,3 @@
+/** Lowercase, split on non-alphanumerics, drop 1-char tokens, dedupe (insertion order). */
+export declare function tokenize(text: string): string[];
+//# sourceMappingURL=tokenize.d.ts.map

package/dist/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../src/tokenize.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAU/C"}

package/dist/tokenize.js

@@ -0,0 +1,14 @@
+/** Lowercase, split on non-alphanumerics, drop 1-char tokens, dedupe (insertion order). */
+export function tokenize(text) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of text.toLowerCase().split(/[^a-z0-9]+/)) {
+        if (raw.length < 2)
+            continue;
+        if (seen.has(raw))
+            continue;
+        seen.add(raw);
+        out.push(raw);
+    }
+    return out;
+}

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+export type MemoryKind = "semantic" | "episodic" | "procedural" | "reflection";
+export type MemoryStatus = "candidate" | "active" | "superseded";
+export interface MemorySource {
+    readonly type: "run" | "user" | "tool" | "eval" | "human";
+    readonly id: string;
+}
+export interface MemoryRecord {
+    readonly id: string;
+    readonly kind: MemoryKind;
+    readonly namespace: string;
+    readonly content: string;
+    readonly data: Record<string, unknown>;
+    readonly source: MemorySource;
+    readonly confidence: number;
+    readonly tags: readonly string[];
+    readonly status: MemoryStatus;
+    readonly supersedes?: readonly string[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly effectiveAt?: string;
+    readonly expiresAt?: string;
+}
+export interface MemoryQuery {
+    readonly namespace: string;
+    readonly query?: string;
+    readonly kind?: MemoryKind;
+    readonly tags?: readonly string[];
+    readonly status?: MemoryStatus;
+    readonly limit?: number;
+}
+export interface MemoryStore {
+    put(rec: MemoryRecord): Promise<void>;
+    get(id: string): Promise<MemoryRecord | null>;
+    search(q: MemoryQuery): Promise<readonly MemoryRecord[]>;
+    update(id: string, patch: Partial<MemoryRecord>): Promise<void>;
+    supersede(id: string, bySupersedingId: string): Promise<void>;
+    delete(id: string): Promise<void>;
+    listCandidates(namespacePrefix: string): Promise<readonly MemoryRecord[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,CAAA;AAC9E,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,YAAY,CAAA;AAChE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;IACzD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB;AACD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC5B;AACD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AACD,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAA;IAC7C,MAAM,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC,CAAA;IACxD,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/D,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7D,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACjC,cAAc,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC,CAAA;CAC1E"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dawn-ai/memory",
+  "version": "0.8.3",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://github.com/cacheplane/dawnai/tree/main/packages/memory#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cacheplane/dawnai.git",
+    "directory": "packages/memory"
+  },
+  "bugs": {
+    "url": "https://github.com/cacheplane/dawnai/issues"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "lint": "biome check --config-path ../config-biome/biome.json package.json src tsconfig.json vitest.config.ts",
+    "test": "vitest --run --config vitest.config.ts --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@dawn-ai/sqlite-storage": "workspace:*"
+  },
+  "devDependencies": {
+    "@dawn-ai/config-typescript": "workspace:*",
+    "@types/node": "25.6.0"
+  }
+}