@chiligpt/memory 0.1.0

package/dist/storage/in-memory.js

@@ -0,0 +1,54 @@
+/**
+ * InMemoryStorage — IMemoryStorage implementation backed by in-memory Maps.
+ *
+ * No disk I/O. No locking. All methods return immediately resolved promises.
+ * Used for:
+ *   - Unit tests (replacing temp-dir JSONL setup with fast in-memory fixtures)
+ *   - Phase 1 web validation (confirms MemoryService lifecycle works without Postgres)
+ *
+ * Records are stored in insertion order per collection. readAll() returns
+ * records in insertion order, matching the JSONL file behaviour.
+ */
+export class InMemoryStorage {
+    store = new Map();
+    async init() {
+        // Nothing to initialise for in-memory storage.
+    }
+    async append(collection, record) {
+        const existing = this.store.get(collection) ?? [];
+        existing.push(record);
+        this.store.set(collection, existing);
+    }
+    async readAll(collection) {
+        return (this.store.get(collection) ?? []);
+    }
+    async update(collection, id, patch) {
+        const records = this.store.get(collection);
+        if (!records)
+            return;
+        const idx = records.findIndex((r) => r.id === id);
+        if (idx === -1)
+            return;
+        records[idx] = { ...records[idx], ...patch };
+    }
+    async archive(collection, record) {
+        const existing = this.store.get(collection) ?? [];
+        existing.push(record);
+        this.store.set(collection, existing);
+    }
+    /**
+     * Reset all collections — useful between tests.
+     * Not part of IMemoryStorage interface; test-only utility.
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Read from archive collections — not part of IMemoryStorage but useful for
+     * asserting archive operations in tests.
+     */
+    readArchive(collection) {
+        return (this.store.get(collection) ?? []);
+    }
+}
+//# sourceMappingURL=in-memory.js.map

package/dist/storage/jsonl-entry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @chili/memory/storage/jsonl — direct sub-entry point for JsonlMemoryStorage.
+ * Consumers who only need the JSONL adapter can import this path directly.
+ */
+export { JsonlMemoryStorage } from "./jsonl.js";
+//# sourceMappingURL=jsonl-entry.d.ts.map

package/dist/storage/jsonl-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-entry.d.ts","sourceRoot":"","sources":["../../src/storage/jsonl-entry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC","sourcesContent":["/**\n * @chili/memory/storage/jsonl — direct sub-entry point for JsonlMemoryStorage.\n * Consumers who only need the JSONL adapter can import this path directly.\n */\nexport { JsonlMemoryStorage } from \"./jsonl.js\";\n"]}

package/dist/storage/jsonl-entry.js

@@ -0,0 +1,6 @@
+/**
+ * @chili/memory/storage/jsonl — direct sub-entry point for JsonlMemoryStorage.
+ * Consumers who only need the JSONL adapter can import this path directly.
+ */
+export { JsonlMemoryStorage } from "./jsonl.js";
+//# sourceMappingURL=jsonl-entry.js.map

package/dist/storage/jsonl.d.ts

@@ -0,0 +1,32 @@
+/**
+ * JsonlMemoryStorage — IMemoryStorage implementation backed by JSONL files on disk.
+ *
+ * Intra-process write safety: per-file async queue (one write at a time per path).
+ * Inter-process write safety: proper-lockfile (stale lock detection, retry backoff).
+ *
+ * readAll() wraps readFileSync in Promise.resolve() — synchronous under the hood,
+ * zero async overhead, satisfies the IMemoryStorage async interface.
+ *
+ * Archive paths:
+ *   entities-archive  → <storageDir>/archive/entities/<id>.jsonl
+ *   narratives-archive → <storageDir>/archive/narratives/<id>.jsonl
+ */
+import type { IMemoryStorage, MemoryCollection, MemoryArchiveCollection } from "./adapter.js";
+export declare class JsonlMemoryStorage implements IMemoryStorage {
+    private readonly storageDir;
+    constructor(storageDir: string);
+    private filePath;
+    private archivePath;
+    init(): Promise<void>;
+    append<T extends {
+        id: string;
+    }>(collection: MemoryCollection, record: T): Promise<void>;
+    readAll<T>(collection: MemoryCollection): Promise<T[]>;
+    update<T extends {
+        id: string;
+    }>(collection: MemoryCollection, id: string, patch: Partial<T>): Promise<void>;
+    archive<T extends {
+        id: string;
+    }>(collection: MemoryArchiveCollection, record: T): Promise<void>;
+}
+//# sourceMappingURL=jsonl.d.ts.map

package/dist/storage/jsonl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../../src/storage/jsonl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAyE9F,qBAAa,kBAAmB,YAAW,cAAc;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC,YAAY,UAAU,EAAE,MAAM,EAE7B;IAED,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;IAKb,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ1B;IAEK,MAAM,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAW7F;IAEK,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAG3D;IAEK,MAAM,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EACpC,UAAU,EAAE,gBAAgB,EAC5B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GACf,OAAO,CAAC,IAAI,CAAC,CAqCf;IAEK,OAAO,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EACrC,UAAU,EAAE,uBAAuB,EACnC,MAAM,EAAE,CAAC,GACP,OAAO,CAAC,IAAI,CAAC,CAWf;CACD","sourcesContent":["/**\n * JsonlMemoryStorage — IMemoryStorage implementation backed by JSONL files on disk.\n *\n * Intra-process write safety: per-file async queue (one write at a time per path).\n * Inter-process write safety: proper-lockfile (stale lock detection, retry backoff).\n *\n * readAll() wraps readFileSync in Promise.resolve() — synchronous under the hood,\n * zero async overhead, satisfies the IMemoryStorage async interface.\n *\n * Archive paths:\n *   entities-archive  → <storageDir>/archive/entities/<id>.jsonl\n *   narratives-archive → <storageDir>/archive/narratives/<id>.jsonl\n */\n\nimport { closeSync, mkdirSync, openSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { dirname, join } from \"node:path\";\nimport lockfile from \"proper-lockfile\";\nimport type { IMemoryStorage, MemoryCollection, MemoryArchiveCollection } from \"./adapter.js\";\n\n// ---------------------------------------------------------------------------\n// Collection → file path mapping\n// ---------------------------------------------------------------------------\n\nconst COLLECTION_FILES: Record<MemoryCollection, string> = {\n\t\"context\": \"layer2-context.jsonl\",\n\t\"entities\": \"layer2-entity.jsonl\",\n\t\"narratives\": \"layer3-narrative.jsonl\",\n\t\"session-tree\": \"layer0-session-tree.jsonl\",\n};\n\n// ---------------------------------------------------------------------------\n// Per-file write queue (intra-process serialisation)\n// ---------------------------------------------------------------------------\n\nconst _writeQueues = new Map<string, Promise<void>>();\n\nfunction enqueue(filePath: string, fn: () => Promise<void>): Promise<void> {\n\tconst prev = _writeQueues.get(filePath) ?? Promise.resolve();\n\tconst next = prev.then(fn, fn); // run even if previous failed\n\t_writeQueues.set(filePath, next);\n\tnext.then(() => {\n\t\tif (_writeQueues.get(filePath) === next) _writeQueues.delete(filePath);\n\t});\n\treturn next;\n}\n\n// ---------------------------------------------------------------------------\n// File helpers\n// ---------------------------------------------------------------------------\n\nfunction ensureDir(filePath: string): void {\n\tmkdirSync(dirname(filePath), { recursive: true });\n}\n\nfunction ensureFile(filePath: string): void {\n\tensureDir(filePath);\n\tconst fd = openSync(filePath, \"a\"); // creates if absent, no-op otherwise\n\tcloseSync(fd);\n}\n\nconst LOCK_OPTIONS = {\n\tretries: { retries: 8, minTimeout: 30, maxTimeout: 300 },\n\tstale: 10_000,\n} as const;\n\nfunction readAllFromFile<T>(filePath: string): T[] {\n\tlet raw: string;\n\ttry {\n\t\traw = readFileSync(filePath, \"utf-8\");\n\t} catch {\n\t\treturn [];\n\t}\n\n\tconst records: T[] = [];\n\tfor (const line of raw.split(\"\\n\")) {\n\t\tconst trimmed = line.trim();\n\t\tif (!trimmed) continue;\n\t\ttry {\n\t\t\trecords.push(JSON.parse(trimmed) as T);\n\t\t} catch {\n\t\t\t// Skip malformed lines\n\t\t}\n\t}\n\treturn records;\n}\n\n// ---------------------------------------------------------------------------\n// JsonlMemoryStorage\n// ---------------------------------------------------------------------------\n\nexport class JsonlMemoryStorage implements IMemoryStorage {\n\tprivate readonly storageDir: string;\n\n\tconstructor(storageDir: string) {\n\t\tthis.storageDir = storageDir;\n\t}\n\n\tprivate filePath(collection: MemoryCollection): string {\n\t\treturn join(this.storageDir, COLLECTION_FILES[collection]);\n\t}\n\n\tprivate archivePath(collection: MemoryArchiveCollection, id: string): string {\n\t\tconst subDir = collection === \"entities-archive\" ? \"entities\" : \"narratives\";\n\t\treturn join(this.storageDir, \"archive\", subDir, `${id}.jsonl`);\n\t}\n\n\tasync init(): Promise<void> {\n\t\t// Create archive subdirs and touch all collection JSONL files\n\t\tmkdirSync(join(this.storageDir, \"archive\", \"entities\"), { recursive: true });\n\t\tmkdirSync(join(this.storageDir, \"archive\", \"narratives\"), { recursive: true });\n\n\t\tfor (const collection of Object.keys(COLLECTION_FILES) as MemoryCollection[]) {\n\t\t\tensureFile(this.filePath(collection));\n\t\t}\n\t}\n\n\tasync append<T extends { id: string }>(collection: MemoryCollection, record: T): Promise<void> {\n\t\tconst filePath = this.filePath(collection);\n\t\treturn enqueue(filePath, async () => {\n\t\t\tensureFile(filePath);\n\t\t\tconst release = await lockfile.lock(filePath, LOCK_OPTIONS);\n\t\t\ttry {\n\t\t\t\twriteFileSync(filePath, `${JSON.stringify(record)}\\n`, { flag: \"a\", encoding: \"utf-8\" });\n\t\t\t} finally {\n\t\t\t\tawait release();\n\t\t\t}\n\t\t});\n\t}\n\n\tasync readAll<T>(collection: MemoryCollection): Promise<T[]> {\n\t\t// Synchronous file read wrapped in a resolved promise — zero async overhead.\n\t\treturn Promise.resolve(readAllFromFile<T>(this.filePath(collection)));\n\t}\n\n\tasync update<T extends { id: string }>(\n\t\tcollection: MemoryCollection,\n\t\tid: string,\n\t\tpatch: Partial<T>,\n\t): Promise<void> {\n\t\tconst filePath = this.filePath(collection);\n\t\treturn enqueue(filePath, async () => {\n\t\t\tensureFile(filePath);\n\t\t\tconst release = await lockfile.lock(filePath, LOCK_OPTIONS);\n\t\t\ttry {\n\t\t\t\tlet raw: string;\n\t\t\t\ttry {\n\t\t\t\t\traw = readFileSync(filePath, \"utf-8\");\n\t\t\t\t} catch {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tlet matched = false;\n\t\t\t\tconst updated = raw.split(\"\\n\").map((line) => {\n\t\t\t\t\tconst trimmed = line.trim();\n\t\t\t\t\tif (!trimmed) return line;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst record = JSON.parse(trimmed) as T;\n\t\t\t\t\t\tif ((record as { id?: string }).id === id) {\n\t\t\t\t\t\t\tmatched = true;\n\t\t\t\t\t\t\treturn JSON.stringify({ ...record, ...patch });\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch {\n\t\t\t\t\t\t// Leave malformed lines untouched\n\t\t\t\t\t}\n\t\t\t\t\treturn line;\n\t\t\t\t});\n\n\t\t\t\tif (!matched) return;\n\n\t\t\t\tconst content = `${updated.join(\"\\n\").replace(/\\n+$/, \"\")}\\n`;\n\t\t\t\twriteFileSync(filePath, content, { encoding: \"utf-8\" });\n\t\t\t} finally {\n\t\t\t\tawait release();\n\t\t\t}\n\t\t});\n\t}\n\n\tasync archive<T extends { id: string }>(\n\t\tcollection: MemoryArchiveCollection,\n\t\trecord: T,\n\t): Promise<void> {\n\t\tconst archivePath = this.archivePath(collection, record.id);\n\t\treturn enqueue(archivePath, async () => {\n\t\t\tensureFile(archivePath);\n\t\t\tconst release = await lockfile.lock(archivePath, LOCK_OPTIONS);\n\t\t\ttry {\n\t\t\t\twriteFileSync(archivePath, `${JSON.stringify(record)}\\n`, { flag: \"a\", encoding: \"utf-8\" });\n\t\t\t} finally {\n\t\t\t\tawait release();\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/dist/storage/jsonl.js

@@ -0,0 +1,171 @@
+/**
+ * JsonlMemoryStorage — IMemoryStorage implementation backed by JSONL files on disk.
+ *
+ * Intra-process write safety: per-file async queue (one write at a time per path).
+ * Inter-process write safety: proper-lockfile (stale lock detection, retry backoff).
+ *
+ * readAll() wraps readFileSync in Promise.resolve() — synchronous under the hood,
+ * zero async overhead, satisfies the IMemoryStorage async interface.
+ *
+ * Archive paths:
+ *   entities-archive  → <storageDir>/archive/entities/<id>.jsonl
+ *   narratives-archive → <storageDir>/archive/narratives/<id>.jsonl
+ */
+import { closeSync, mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import lockfile from "proper-lockfile";
+// ---------------------------------------------------------------------------
+// Collection → file path mapping
+// ---------------------------------------------------------------------------
+const COLLECTION_FILES = {
+    "context": "layer2-context.jsonl",
+    "entities": "layer2-entity.jsonl",
+    "narratives": "layer3-narrative.jsonl",
+    "session-tree": "layer0-session-tree.jsonl",
+};
+// ---------------------------------------------------------------------------
+// Per-file write queue (intra-process serialisation)
+// ---------------------------------------------------------------------------
+const _writeQueues = new Map();
+function enqueue(filePath, fn) {
+    const prev = _writeQueues.get(filePath) ?? Promise.resolve();
+    const next = prev.then(fn, fn); // run even if previous failed
+    _writeQueues.set(filePath, next);
+    next.then(() => {
+        if (_writeQueues.get(filePath) === next)
+            _writeQueues.delete(filePath);
+    });
+    return next;
+}
+// ---------------------------------------------------------------------------
+// File helpers
+// ---------------------------------------------------------------------------
+function ensureDir(filePath) {
+    mkdirSync(dirname(filePath), { recursive: true });
+}
+function ensureFile(filePath) {
+    ensureDir(filePath);
+    const fd = openSync(filePath, "a"); // creates if absent, no-op otherwise
+    closeSync(fd);
+}
+const LOCK_OPTIONS = {
+    retries: { retries: 8, minTimeout: 30, maxTimeout: 300 },
+    stale: 10_000,
+};
+function readAllFromFile(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            records.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return records;
+}
+// ---------------------------------------------------------------------------
+// JsonlMemoryStorage
+// ---------------------------------------------------------------------------
+export class JsonlMemoryStorage {
+    storageDir;
+    constructor(storageDir) {
+        this.storageDir = storageDir;
+    }
+    filePath(collection) {
+        return join(this.storageDir, COLLECTION_FILES[collection]);
+    }
+    archivePath(collection, id) {
+        const subDir = collection === "entities-archive" ? "entities" : "narratives";
+        return join(this.storageDir, "archive", subDir, `${id}.jsonl`);
+    }
+    async init() {
+        // Create archive subdirs and touch all collection JSONL files
+        mkdirSync(join(this.storageDir, "archive", "entities"), { recursive: true });
+        mkdirSync(join(this.storageDir, "archive", "narratives"), { recursive: true });
+        for (const collection of Object.keys(COLLECTION_FILES)) {
+            ensureFile(this.filePath(collection));
+        }
+    }
+    async append(collection, record) {
+        const filePath = this.filePath(collection);
+        return enqueue(filePath, async () => {
+            ensureFile(filePath);
+            const release = await lockfile.lock(filePath, LOCK_OPTIONS);
+            try {
+                writeFileSync(filePath, `${JSON.stringify(record)}\n`, { flag: "a", encoding: "utf-8" });
+            }
+            finally {
+                await release();
+            }
+        });
+    }
+    async readAll(collection) {
+        // Synchronous file read wrapped in a resolved promise — zero async overhead.
+        return Promise.resolve(readAllFromFile(this.filePath(collection)));
+    }
+    async update(collection, id, patch) {
+        const filePath = this.filePath(collection);
+        return enqueue(filePath, async () => {
+            ensureFile(filePath);
+            const release = await lockfile.lock(filePath, LOCK_OPTIONS);
+            try {
+                let raw;
+                try {
+                    raw = readFileSync(filePath, "utf-8");
+                }
+                catch {
+                    return;
+                }
+                let matched = false;
+                const updated = raw.split("\n").map((line) => {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        return line;
+                    try {
+                        const record = JSON.parse(trimmed);
+                        if (record.id === id) {
+                            matched = true;
+                            return JSON.stringify({ ...record, ...patch });
+                        }
+                    }
+                    catch {
+                        // Leave malformed lines untouched
+                    }
+                    return line;
+                });
+                if (!matched)
+                    return;
+                const content = `${updated.join("\n").replace(/\n+$/, "")}\n`;
+                writeFileSync(filePath, content, { encoding: "utf-8" });
+            }
+            finally {
+                await release();
+            }
+        });
+    }
+    async archive(collection, record) {
+        const archivePath = this.archivePath(collection, record.id);
+        return enqueue(archivePath, async () => {
+            ensureFile(archivePath);
+            const release = await lockfile.lock(archivePath, LOCK_OPTIONS);
+            try {
+                writeFileSync(archivePath, `${JSON.stringify(record)}\n`, { flag: "a", encoding: "utf-8" });
+            }
+            finally {
+                await release();
+            }
+        });
+    }
+}
+//# sourceMappingURL=jsonl.js.map

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Portable boundary types for @chili/memory.
+ *
+ * These replace chili-internal types so the package has zero dependency on
+ * @chili/ai or @chili/app internals. All types are structurally compatible
+ * with their chili counterparts — adapters pass chili objects directly.
+ */
+/**
+ * Portable representation of a session entry passed into memory operations.
+ * The chili adapter maps SessionEntry[] → MemoryBranchEntry[] before handing off.
+ * Only the fields the memory system actually reads are required here.
+ */
+export interface MemoryBranchEntry {
+    /** Entry type discriminant — memory processing only acts on "message" entries. */
+    type: string;
+    /** Present when type === "message". */
+    message?: {
+        role: "user" | "assistant";
+        /**
+         * Content as a plain string or array of typed blocks.
+         * Memory system extracts text blocks for transcript formatting.
+         */
+        content: string | Array<{
+            type: string;
+            text?: string;
+            [key: string]: unknown;
+        }>;
+    };
+}
+/**
+ * Minimal LLM message shape. Structurally compatible with @chili/ai's
+ * UserMessage and AssistantMessage — the chili adapter passes ctx.complete
+ * directly without wrapping.
+ */
+export interface LLMMessage {
+    role: "user" | "assistant";
+    content: string | Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    timestamp?: number;
+}
+/**
+ * Minimal LLM response shape. The memory system only reads text blocks
+ * from content — extra fields (usage, stopReason, etc.) are ignored.
+ * Structurally compatible with @chili/ai's AssistantMessage.
+ */
+export interface LLMResponse {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * LLM completion function. Any LLM provider that accepts a message array and
+ * returns a response with content blocks satisfies this contract.
+ *
+ * The chili adapter passes ctx.complete (which uses @chili/ai under the hood).
+ * A web consumer passes whatever client it uses.
+ */
+export type LLMCompleteFn = (messages: LLMMessage[], options?: {
+    systemPrompt?: string;
+}) => Promise<LLMResponse>;
+//# 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;;;;;;GAMG;AAMH;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,oFAAkF;IAClF,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,OAAO,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAC3B;;;WAGG;QACH,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC,CAAC;KACjF,CAAC;CACF;AAMD;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;IACjF,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC3B,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;CACxE;AAED;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAC3B,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KAC/B,OAAO,CAAC,WAAW,CAAC,CAAC","sourcesContent":["/**\n * Portable boundary types for @chili/memory.\n *\n * These replace chili-internal types so the package has zero dependency on\n * @chili/ai or @chili/app internals. All types are structurally compatible\n * with their chili counterparts — adapters pass chili objects directly.\n */\n\n// ---------------------------------------------------------------------------\n// Session entry — replaces chili-internal SessionEntry\n// ---------------------------------------------------------------------------\n\n/**\n * Portable representation of a session entry passed into memory operations.\n * The chili adapter maps SessionEntry[] → MemoryBranchEntry[] before handing off.\n * Only the fields the memory system actually reads are required here.\n */\nexport interface MemoryBranchEntry {\n\t/** Entry type discriminant — memory processing only acts on \"message\" entries. */\n\ttype: string;\n\t/** Present when type === \"message\". */\n\tmessage?: {\n\t\trole: \"user\" | \"assistant\";\n\t\t/**\n\t\t * Content as a plain string or array of typed blocks.\n\t\t * Memory system extracts text blocks for transcript formatting.\n\t\t */\n\t\tcontent: string | Array<{ type: string; text?: string; [key: string]: unknown }>;\n\t};\n}\n\n// ---------------------------------------------------------------------------\n// LLM completion — replaces @chili/ai Message / AssistantMessage dependency\n// ---------------------------------------------------------------------------\n\n/**\n * Minimal LLM message shape. Structurally compatible with @chili/ai's\n * UserMessage and AssistantMessage — the chili adapter passes ctx.complete\n * directly without wrapping.\n */\nexport interface LLMMessage {\n\trole: \"user\" | \"assistant\";\n\tcontent: string | Array<{ type: string; text?: string; [key: string]: unknown }>;\n\ttimestamp?: number;\n}\n\n/**\n * Minimal LLM response shape. The memory system only reads text blocks\n * from content — extra fields (usage, stopReason, etc.) are ignored.\n * Structurally compatible with @chili/ai's AssistantMessage.\n */\nexport interface LLMResponse {\n\tcontent: Array<{ type: string; text?: string; [key: string]: unknown }>;\n}\n\n/**\n * LLM completion function. Any LLM provider that accepts a message array and\n * returns a response with content blocks satisfies this contract.\n *\n * The chili adapter passes ctx.complete (which uses @chili/ai under the hood).\n * A web consumer passes whatever client it uses.\n */\nexport type LLMCompleteFn = (\n\tmessages: LLMMessage[],\n\toptions?: { systemPrompt?: string },\n) => Promise<LLMResponse>;\n"]}

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * Portable boundary types for @chili/memory.
+ *
+ * These replace chili-internal types so the package has zero dependency on
+ * @chili/ai or @chili/app internals. All types are structurally compatible
+ * with their chili counterparts — adapters pass chili objects directly.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@chiligpt/memory",
+	"version": "0.1.0",
+	"description": "Persistent agent memory system — storage-adapter-agnostic, LLM-provider-agnostic",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./storage/jsonl": {
+			"types": "./dist/storage/jsonl-entry.d.ts",
+			"import": "./dist/storage/jsonl-entry.js"
+		},
+		"./storage/in-memory": {
+			"types": "./dist/storage/in-memory-entry.d.ts",
+			"import": "./dist/storage/in-memory-entry.js"
+		}
+	},
+	"files": [
+		"dist/**/*.js",
+		"dist/**/*.d.ts",
+		"dist/**/*.d.ts.map",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=19.0.0"
+	},
+	"scripts": {
+		"build": "tsgo -p tsconfig.build.json",
+		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
+		"clean": "shx rm -rf dist"
+	},
+	"devDependencies": {
+		"@types/node": "^22.10.5",
+		"shx": "^0.4.0"
+	},
+	"dependencies": {
+		"proper-lockfile": "^4.1.2"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}