@wrongstack/core 0.1.10 → 0.2.0

package/dist/storage/index.js

@@ -284,6 +284,12 @@ var FileSessionWriter = class {
   tokenIn = 0;
   tokenOut = 0;
   filePath;
+  /** Public accessor for the JSONL path — required by SessionWriter so
+   *  observability surfaces (`/fleet log`, FleetPanel) can locate the
+   *  transcript without recomputing the path from session metadata. */
+  get transcriptPath() {
+    return this.filePath || void 0;
+  }
   initDone = false;
   resumed;
   appendFailCount = 0;
@@ -1524,7 +1530,273 @@ var SessionAnalyzer = class {
     return last - first;
   }
 };
+async function loadTodosCheckpoint(filePath) {
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || !Array.isArray(parsed.todos)) return null;
+    return parsed.todos.filter(
+      (t) => !!t && typeof t.id === "string" && typeof t.content === "string" && typeof t.status === "string"
+    );
+  } catch {
+    return null;
+  }
+}
+async function saveTodosCheckpoint(filePath, sessionId, todos) {
+  const payload = {
+    version: 1,
+    sessionId,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    todos: [...todos]
+  };
+  try {
+    await atomicWrite(filePath, JSON.stringify(payload, null, 2), { mode: 384 });
+  } catch (err) {
+    console.warn(
+      "[todos-checkpoint] save failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+function attachTodosCheckpoint(state, filePath, sessionId) {
+  let timer = null;
+  let pending = null;
+  const flush = () => {
+    timer = null;
+    if (pending) {
+      void saveTodosCheckpoint(filePath, sessionId, pending);
+      pending = null;
+    }
+  };
+  const unsubscribe = state.onChange((change) => {
+    if (change.kind !== "todos_replaced") return;
+    pending = change.todos;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(flush, 150);
+  });
+  return () => {
+    unsubscribe();
+    if (timer) {
+      clearTimeout(timer);
+      flush();
+    }
+  };
+}
+async function loadPlan(filePath) {
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || !Array.isArray(parsed.items)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function savePlan(filePath, plan) {
+  try {
+    await atomicWrite(filePath, JSON.stringify(plan, null, 2), { mode: 384 });
+  } catch (err) {
+    console.warn(
+      "[plan-store] save failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+function emptyPlan(sessionId, title) {
+  return {
+    version: 1,
+    sessionId,
+    title,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    items: []
+  };
+}
+function addPlanItem(plan, title, details) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const item = {
+    id: `plan_${Date.now()}_${randomUUID().slice(0, 6)}`,
+    title,
+    details,
+    status: "open",
+    createdAt: now,
+    updatedAt: now
+  };
+  return {
+    plan: { ...plan, items: [...plan.items, item], updatedAt: now },
+    item
+  };
+}
+function removePlanItem(plan, idOrIndex) {
+  const idx = matchIndex(plan, idOrIndex);
+  if (idx === -1) return plan;
+  return {
+    ...plan,
+    items: plan.items.filter((_, i) => i !== idx),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function setPlanItemStatus(plan, idOrIndex, status) {
+  const idx = matchIndex(plan, idOrIndex);
+  if (idx === -1) return plan;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const items = plan.items.map(
+    (it, i) => i === idx ? { ...it, status, updatedAt: now } : it
+  );
+  return { ...plan, items, updatedAt: now };
+}
+function clearPlan(plan) {
+  return { ...plan, items: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function formatPlan(plan) {
+  if (plan.items.length === 0) return "Plan is empty.";
+  const lines = [];
+  if (plan.title) lines.push(`# ${plan.title}`);
+  plan.items.forEach((it, i) => {
+    const mark = it.status === "done" ? "[x]" : it.status === "in_progress" ? "[~]" : "[ ]";
+    lines.push(`${i + 1}. ${mark} ${it.title}`);
+    if (it.details) {
+      for (const line of it.details.split("\n")) lines.push(`     ${line}`);
+    }
+  });
+  return lines.join("\n");
+}
+function matchIndex(plan, idOrIndex) {
+  const asNum = Number.parseInt(idOrIndex, 10);
+  if (!Number.isNaN(asNum) && asNum >= 1 && asNum <= plan.items.length) return asNum - 1;
+  const byId = plan.items.findIndex((it) => it.id === idOrIndex);
+  if (byId !== -1) return byId;
+  const lower = idOrIndex.toLowerCase();
+  return plan.items.findIndex((it) => it.title.toLowerCase().includes(lower));
+}
+function attachPlanCheckpoint(_state, _filePath, _sessionId) {
+  return () => void 0;
+}
+async function loadDirectorState(filePath) {
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+var DirectorStateCheckpoint = class {
+  snapshot;
+  filePath;
+  timer = null;
+  debounceMs;
+  writing = false;
+  rewriteRequested = false;
+  constructor(filePath, init, debounceMs = 250) {
+    this.filePath = filePath;
+    this.debounceMs = debounceMs;
+    this.snapshot = {
+      version: 1,
+      directorRunId: init.directorRunId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      spawnCount: 0,
+      maxSpawns: init.maxSpawns,
+      spawnDepth: init.spawnDepth,
+      maxSpawnDepth: init.maxSpawnDepth,
+      subagents: [],
+      tasks: []
+    };
+  }
+  current() {
+    return this.snapshot;
+  }
+  recordSpawn(sub, spawnCount) {
+    this.snapshot = {
+      ...this.snapshot,
+      spawnCount,
+      subagents: [...this.snapshot.subagents.filter((s) => s.id !== sub.id), sub]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskAssigned(task) {
+    const exists = this.snapshot.tasks.some((t) => t.taskId === task.taskId);
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: exists ? this.snapshot.tasks.map((t) => t.taskId === task.taskId ? { ...t, ...task } : t) : [...this.snapshot.tasks, task]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskStatus(taskId, patch) {
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: this.snapshot.tasks.map(
+        (t) => t.taskId === taskId ? { ...t, ...patch } : t
+      )
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  setUsage(usage) {
+    this.snapshot = { ...this.snapshot, usage };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  /** Force a synchronous flush — used by Director.shutdown(). */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.persist();
+  }
+  bumpUpdatedAt() {
+    this.snapshot = { ...this.snapshot, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  schedule() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.persist();
+    }, this.debounceMs);
+  }
+  async persist() {
+    if (this.writing) {
+      this.rewriteRequested = true;
+      return;
+    }
+    this.writing = true;
+    try {
+      await atomicWrite(this.filePath, JSON.stringify(this.snapshot, null, 2), {
+        mode: 384
+      });
+    } catch (err) {
+      console.warn(
+        "[director-state] checkpoint write failed:",
+        err instanceof Error ? err.message : String(err)
+      );
+    } finally {
+      this.writing = false;
+      if (this.rewriteRequested) {
+        this.rewriteRequested = false;
+        this.schedule();
+      }
+    }
+  }
+};
 
-export { ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultSessionReader, DefaultSessionStore, QueueStore, RecoveryLock, SessionAnalyzer, runConfigMigrations };
+export { ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultSessionReader, DefaultSessionStore, DirectorStateCheckpoint, QueueStore, RecoveryLock, SessionAnalyzer, addPlanItem, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, emptyPlan, formatPlan, loadDirectorState, loadPlan, loadTodosCheckpoint, removePlanItem, runConfigMigrations, savePlan, saveTodosCheckpoint, setPlanItemStatus };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map