@skein-js/storage-memory 0.5.0 → 0.7.0

package/dist/index.js

@@ -7,6 +7,19 @@ import {
 } from "@skein-js/core";
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 var clone = (value) => structuredClone(value);
+function toVersion(assistant, createdAt) {
+  return {
+    assistant_id: assistant.assistant_id,
+    graph_id: assistant.graph_id,
+    config: assistant.config,
+    context: assistant.context,
+    created_at: createdAt ?? assistant.created_at,
+    metadata: assistant.metadata,
+    version: assistant.version,
+    name: assistant.name,
+    description: assistant.description
+  };
+}
 function readOne(map, id) {
   const found = map.get(id);
   return found ? clone(found) : null;
@@ -27,8 +40,14 @@ function hasPrefix(namespace, prefix) {
 function itemKey(namespace, key) {
   return JSON.stringify([namespace, key]);
 }
+function versionKey(assistantId, version) {
+  return JSON.stringify([assistantId, version]);
+}
 var MemorySkeinStore = class {
   #assistants = /* @__PURE__ */ new Map();
+  // Immutable version snapshots, keyed by `versionKey(assistant_id, version)`. The live #assistants
+  // row always mirrors the currently-active version; this map is the append-only history.
+  #assistantVersions = /* @__PURE__ */ new Map();
   #threads = /* @__PURE__ */ new Map();
   #runs = /* @__PURE__ */ new Map();
   // The opaque execution payload lives beside the run row (it is not part of the wire `Run`).
@@ -65,13 +84,48 @@ var MemorySkeinStore = class {
       this.#itemExpiry.set(id, { ...entry, expiresAt: Date.now() + entry.ttlMinutes * 6e4 });
     }
   }
+  /** Drop every version snapshot belonging to an assistant (memory has no cascading FK). */
+  #deleteVersionsOf(assistantId) {
+    for (const [key, version] of this.#assistantVersions) {
+      if (version.assistant_id === assistantId) this.#assistantVersions.delete(key);
+    }
+  }
+  /** Highest version number recorded for an assistant, or 0 when it has no history yet. */
+  #maxVersionOf(assistantId) {
+    let max = 0;
+    for (const version of this.#assistantVersions.values()) {
+      if (version.assistant_id === assistantId && version.version > max) max = version.version;
+    }
+    return max;
+  }
   assistants = {
     list: async () => readAll(this.#assistants),
+    search: async (query) => {
+      const matched = readAll(this.#assistants).filter(
+        (assistant) => (query.graph_id === void 0 || assistant.graph_id === query.graph_id) && (query.name === void 0 || assistant.name === query.name) && isMetadataSubset(assistant.metadata, query.metadata)
+      );
+      const sortBy = query.sortBy ?? "created_at";
+      const direction = query.sortOrder === "asc" ? 1 : -1;
+      const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+      matched.sort((a, b) => {
+        const primary = compare(String(a[sortBy] ?? ""), String(b[sortBy] ?? ""));
+        const ordered = primary !== 0 ? primary : compare(a.assistant_id, b.assistant_id);
+        return direction * ordered;
+      });
+      const offset = query.offset ?? 0;
+      const limit = query.limit ?? matched.length;
+      return matched.slice(offset, offset + limit);
+    },
+    count: async (query) => (await this.assistants.search({ ...query, limit: void 0, offset: void 0 })).length,
     get: async (assistantId) => readOne(this.#assistants, assistantId),
     create: async (input) => {
+      const assistantId = input.assistant_id ?? randomUUID();
+      if (this.#assistants.has(assistantId)) {
+        throw SkeinHttpError.conflict(`Assistant "${assistantId}" already exists.`);
+      }
       const at = nowIso();
       const assistant = {
-        assistant_id: input.assistant_id ?? randomUUID(),
+        assistant_id: assistantId,
         graph_id: input.graph_id,
         config: input.config ?? {},
         context: input.context ?? {},
@@ -82,10 +136,62 @@ var MemorySkeinStore = class {
         name: input.name ?? input.graph_id,
         description: input.description
       };
-      return write(this.#assistants, assistant.assistant_id, assistant);
+      this.#assistantVersions.set(versionKey(assistantId, 1), clone(toVersion(assistant)));
+      return write(this.#assistants, assistantId, assistant);
+    },
+    update: async (assistantId, patch) => {
+      const existing = this.#assistants.get(assistantId);
+      if (!existing) throw SkeinHttpError.notFound(`Assistant "${assistantId}" not found.`);
+      const at = nowIso();
+      const next = this.#maxVersionOf(assistantId) + 1;
+      const updated = {
+        ...existing,
+        graph_id: patch.graph_id ?? existing.graph_id,
+        name: patch.name ?? existing.name,
+        description: patch.description !== void 0 ? patch.description : existing.description,
+        config: patch.config ?? existing.config,
+        context: patch.context !== void 0 ? patch.context : existing.context,
+        // metadata MERGES (shallow), matching LangGraph — patching one key keeps the siblings.
+        metadata: patch.metadata !== void 0 ? { ...existing.metadata, ...patch.metadata } : existing.metadata,
+        version: next,
+        updated_at: at
+      };
+      this.#assistantVersions.set(versionKey(assistantId, next), clone(toVersion(updated, at)));
+      return write(this.#assistants, assistantId, updated);
+    },
+    listVersions: async (assistantId, query) => {
+      const versions = [...this.#assistantVersions.values()].filter(
+        (version) => version.assistant_id === assistantId && isMetadataSubset(version.metadata, query?.metadata)
+      ).sort((a, b) => b.version - a.version);
+      const offset = query?.offset ?? 0;
+      const limit = query?.limit ?? versions.length;
+      return versions.slice(offset, offset + limit).map(clone);
+    },
+    setLatest: async (assistantId, version) => {
+      const existing = this.#assistants.get(assistantId);
+      if (!existing) throw SkeinHttpError.notFound(`Assistant "${assistantId}" not found.`);
+      const target = this.#assistantVersions.get(versionKey(assistantId, version));
+      if (!target) {
+        throw SkeinHttpError.notFound(
+          `Version ${version} of assistant "${assistantId}" not found.`
+        );
+      }
+      const updated = {
+        ...existing,
+        graph_id: target.graph_id,
+        name: target.name,
+        description: target.description,
+        config: target.config,
+        context: target.context,
+        metadata: target.metadata,
+        version: target.version,
+        updated_at: nowIso()
+      };
+      return write(this.#assistants, assistantId, updated);
     },
     delete: async (assistantId) => {
       this.#assistants.delete(assistantId);
+      this.#deleteVersionsOf(assistantId);
     }
   };
   threads = {
@@ -196,7 +302,10 @@ var MemorySkeinStore = class {
         if (run.thread_id === threadId && !isTerminalRunStatus(run.status)) return true;
       }
       return false;
-    }
+    },
+    listActiveRuns: async (threadId) => readAll(this.#runs).filter(
+      (run) => run.thread_id === threadId && !isTerminalRunStatus(run.status)
+    )
   };
   store = {
     get: async (namespace, key) => {
@@ -274,6 +383,7 @@ var MemorySkeinStore = class {
     const entries = (map) => [...map.entries()].map(([id, row]) => [id, clone(row)]);
     return {
       assistants: entries(this.#assistants),
+      assistantVersions: entries(this.#assistantVersions),
       threads: entries(this.#threads),
       runs: entries(this.#runs),
       runKwargs: entries(this.#runKwargs),
@@ -287,10 +397,19 @@ var MemorySkeinStore = class {
       for (const [id, row] of rows) map.set(id, clone(row));
     };
     fill(this.#assistants, snapshot.assistants);
+    fill(this.#assistantVersions, snapshot.assistantVersions ?? []);
     fill(this.#threads, snapshot.threads);
     fill(this.#runs, snapshot.runs);
     fill(this.#runKwargs, snapshot.runKwargs);
     fill(this.#items, snapshot.items);
+    for (const assistant of this.#assistants.values()) {
+      if (this.#maxVersionOf(assistant.assistant_id) === 0) {
+        this.#assistantVersions.set(
+          versionKey(assistant.assistant_id, assistant.version),
+          clone(toVersion(assistant))
+        );
+      }
+    }
     this.#itemExpiry.clear();
   }
   /**
@@ -305,6 +424,7 @@ var MemorySkeinStore = class {
       for (const [id, row] of rows) if (!map.has(id)) map.set(id, clone(row));
     };
     add(this.#assistants, snapshot.assistants);
+    add(this.#assistantVersions, snapshot.assistantVersions ?? []);
     add(this.#threads, snapshot.threads);
     add(this.#runs, snapshot.runs);
     add(this.#runKwargs, snapshot.runKwargs);

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@skein-js/storage-memory",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "In-memory SkeinStore + queue driver for development and tests.",
   "license": "Apache-2.0",
   "author": "Maina Wycliffe <wmmaina7@gmail.com>",
-  "homepage": "https://github.com/mainawycliffe/skein-js/tree/main/packages/storage-memory#readme",
+  "homepage": "https://github.com/skein-js/skein-js/tree/main/packages/storage-memory#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mainawycliffe/skein-js.git",
+    "url": "git+https://github.com/skein-js/skein-js.git",
     "directory": "packages/storage-memory"
   },
   "bugs": {
-    "url": "https://github.com/mainawycliffe/skein-js/issues"
+    "url": "https://github.com/skein-js/skein-js/issues"
   },
   "keywords": [
     "typescript",
@@ -40,10 +40,10 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@skein-js/core": "0.5.0"
+    "@skein-js/core": "0.7.0"
   },
   "devDependencies": {
-    "@skein-js/test-support": "0.5.0"
+    "@skein-js/test-support": "0.7.0"
   },
   "publishConfig": {
     "access": "public"