zidane 1.7.0 → 1.8.0

package/dist/{chunk-V4PBD7LE.js → chunk-2IB4XBQE.js}

@@ -1,3 +1,161 @@
+// src/session/file-map.ts
+function toMeta(data) {
+  return {
+    id: data.id,
+    agentId: data.agentId,
+    runs: data.runs,
+    status: data.status,
+    metadata: data.metadata,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt
+  };
+}
+function toData(meta, turns) {
+  return {
+    id: meta.id,
+    agentId: meta.agentId,
+    turns,
+    runs: meta.runs,
+    status: meta.status,
+    metadata: meta.metadata,
+    createdAt: meta.createdAt,
+    updatedAt: meta.updatedAt
+  };
+}
+function parseTurnsJsonl(jsonl) {
+  if (!jsonl)
+    return [];
+  const turns = [];
+  for (const line of jsonl.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      turns.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return turns;
+}
+function serializeTurnsJsonl(turns) {
+  if (turns.length === 0)
+    return "";
+  return `${turns.map((t) => JSON.stringify(t)).join("\n")}
+`;
+}
+function createFileMapStore(adapter, options = {}) {
+  const turnsFile = options.turnsFile ?? "turns.jsonl";
+  const metaFile = options.metaFile ?? "meta.json";
+  let cached = null;
+  let hydrated = false;
+  async function hydrate() {
+    if (hydrated)
+      return;
+    const { files } = await adapter.get();
+    const metaRaw = files[metaFile];
+    if (metaRaw) {
+      let meta = null;
+      try {
+        meta = JSON.parse(metaRaw);
+      } catch {
+        meta = null;
+      }
+      if (meta) {
+        cached = toData(meta, parseTurnsJsonl(files[turnsFile] ?? ""));
+      }
+    }
+    hydrated = true;
+  }
+  async function persist(data) {
+    const meta = toMeta(data);
+    await adapter.save({
+      [metaFile]: JSON.stringify(meta, null, 2),
+      [turnsFile]: serializeTurnsJsonl(data.turns)
+    });
+  }
+  async function ensureCachedFor(sessionId) {
+    await hydrate();
+    if (cached) {
+      return cached.id === sessionId;
+    }
+    const now = Date.now();
+    cached = {
+      id: sessionId,
+      turns: [],
+      runs: [],
+      status: "idle",
+      metadata: {},
+      createdAt: now,
+      updatedAt: now
+    };
+    hydrated = true;
+    return true;
+  }
+  return {
+    async load(sessionId) {
+      await hydrate();
+      if (!cached || cached.id !== sessionId)
+        return null;
+      return structuredClone(cached);
+    },
+    async save(data) {
+      cached = structuredClone(data);
+      hydrated = true;
+      await persist(cached);
+    },
+    async delete(sessionId) {
+      await hydrate();
+      if (cached && cached.id !== sessionId)
+        return;
+      cached = null;
+      await adapter.delete();
+    },
+    async list(filter) {
+      await hydrate();
+      if (!cached)
+        return [];
+      if (filter?.agentId && cached.agentId !== filter.agentId)
+        return [];
+      return [cached.id];
+    },
+    async appendTurns(sessionId, turns) {
+      const ok = await ensureCachedFor(sessionId);
+      if (!ok)
+        return;
+      cached.turns.push(...structuredClone(turns));
+      cached.updatedAt = Date.now();
+      await persist(cached);
+    },
+    async getTurns(sessionId, from = 0, limit) {
+      await hydrate();
+      if (!cached || cached.id !== sessionId)
+        return [];
+      const slice = cached.turns.slice(from, limit !== void 0 ? from + limit : void 0);
+      return structuredClone(slice);
+    },
+    async updateRun(sessionId, run) {
+      const ok = await ensureCachedFor(sessionId);
+      if (!ok)
+        return;
+      const idx = cached.runs.findIndex((r) => r.id === run.id);
+      if (idx >= 0)
+        cached.runs[idx] = structuredClone(run);
+      else
+        cached.runs.push(structuredClone(run));
+      cached.updatedAt = Date.now();
+      await persist(cached);
+    },
+    async updateStatus(sessionId, status) {
+      const ok = await ensureCachedFor(sessionId);
+      if (!ok)
+        return;
+      cached.status = status;
+      cached.updatedAt = Date.now();
+      await persist(cached);
+    }
+  };
+}
+
 // src/session/memory.ts
 function createMemoryStore() {
   const sessions = /* @__PURE__ */ new Map();
@@ -294,6 +452,9 @@ async function createSession(options = {}) {
     get turns() {
       return data.turns;
     },
+    get isEmpty() {
+      return data.turns.length === 0;
+    },
     get status() {
       return data.status;
     },
@@ -415,6 +576,7 @@ function generateId() {
 }
 
 export {
+  createFileMapStore,
   createMemoryStore,
   createRemoteStore,
   createSqliteStore,

package/dist/{chunk-T6MC3WP5.js → chunk-3RJOWJOJ.js}

@@ -4,7 +4,7 @@ import {
   shell,
   spawn,
   writeFile
-} from "./chunk-O4QCBJQF.js";
+} from "./chunk-4N5ADW7A.js";
 
 // src/harnesses/basic.ts
 var basicTools = { shell, readFile, writeFile, listFiles };