@tritard/waterbrother 0.5.0

package/src/task-store.js

@@ -0,0 +1,178 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const TASKS_DIR_NAME = "tasks";
+const INDEX_FILE = "index.json";
+const TASK_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+
+const VALID_STATES = [
+  "decide-required",
+  "decision-ready",
+  "build-ready",
+  "review-ready",
+  "accepted",
+  "closed"
+];
+
+function tasksDir(cwd) {
+  return path.join(cwd, ".waterbrother", TASKS_DIR_NAME);
+}
+
+function taskFilePath(cwd, taskId) {
+  return path.join(tasksDir(cwd), `${taskId}.json`);
+}
+
+function indexFilePath(cwd) {
+  return path.join(tasksDir(cwd), INDEX_FILE);
+}
+
+function slugify(name) {
+  return String(name || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 60);
+}
+
+function makeTaskId(name) {
+  const slug = slugify(name);
+  const rand = crypto.randomBytes(3).toString("hex");
+  return slug ? `task_${slug}-${rand}` : `task_${rand}`;
+}
+
+async function ensureTasksDir(cwd) {
+  await fs.mkdir(tasksDir(cwd), { recursive: true });
+}
+
+async function readJsonSafe(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+async function readIndex(cwd) {
+  const data = await readJsonSafe(indexFilePath(cwd));
+  if (!data || typeof data !== "object") return { activeTaskId: null, taskIds: [] };
+  return {
+    activeTaskId: data.activeTaskId || null,
+    taskIds: Array.isArray(data.taskIds) ? data.taskIds : []
+  };
+}
+
+async function writeIndex(cwd, index) {
+  await ensureTasksDir(cwd);
+  await fs.writeFile(indexFilePath(cwd), `${JSON.stringify(index, null, 2)}\n`, "utf8");
+}
+
+export async function createTask({ cwd, name, sessionId, mode, autonomy }) {
+  if (!cwd) throw new Error("cwd is required");
+  if (!name) throw new Error("task name is required");
+
+  const id = makeTaskId(name);
+  const now = new Date().toISOString();
+  const task = {
+    id,
+    name: String(name).trim(),
+    cwd,
+    sessionId: sessionId || null,
+    branch: null,
+    state: "decide-required",
+    goal: "",
+    decisionId: null,
+    chosenOption: null,
+    activeContract: null,
+    currentCheckpoint: null,
+    latestReceiptId: null,
+    lastVerdict: null,
+    experienceMode: mode || "standard",
+    autonomyMode: autonomy || "scoped",
+    accepted: false,
+    createdAt: now,
+    updatedAt: now
+  };
+
+  await ensureTasksDir(cwd);
+  await fs.writeFile(taskFilePath(cwd, id), `${JSON.stringify(task, null, 2)}\n`, "utf8");
+
+  const index = await readIndex(cwd);
+  if (!index.taskIds.includes(id)) {
+    index.taskIds.push(id);
+  }
+  index.activeTaskId = id;
+  await writeIndex(cwd, index);
+
+  return task;
+}
+
+export async function loadTask({ cwd, taskId }) {
+  if (!cwd || !taskId) return null;
+  return readJsonSafe(taskFilePath(cwd, taskId));
+}
+
+export async function saveTask({ cwd, task }) {
+  if (!cwd || !task?.id) throw new Error("cwd and task.id are required");
+  const next = { ...task, updatedAt: new Date().toISOString() };
+  await ensureTasksDir(cwd);
+  await fs.writeFile(taskFilePath(cwd, next.id), `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return next;
+}
+
+export async function listTasks({ cwd, limit = 20 }) {
+  const index = await readIndex(cwd);
+  const safeLimit = Math.max(1, Math.min(100, Number(limit) || 20));
+  const tasks = [];
+
+  for (const taskId of index.taskIds) {
+    const task = await loadTask({ cwd, taskId });
+    if (task) tasks.push(task);
+  }
+
+  return tasks
+    .sort((a, b) => Date.parse(b.updatedAt || 0) - Date.parse(a.updatedAt || 0))
+    .slice(0, safeLimit);
+}
+
+export async function findTaskByName({ cwd, name }) {
+  if (!name) return null;
+  const normalized = String(name).trim().toLowerCase();
+  const tasks = await listTasks({ cwd, limit: 100 });
+  return tasks.find((t) => t.name.toLowerCase() === normalized) || null;
+}
+
+export async function setActiveTask({ cwd, taskId }) {
+  const index = await readIndex(cwd);
+  index.activeTaskId = taskId || null;
+  await writeIndex(cwd, index);
+}
+
+export async function getActiveTask({ cwd }) {
+  const index = await readIndex(cwd);
+  if (!index.activeTaskId) return null;
+  return loadTask({ cwd, taskId: index.activeTaskId });
+}
+
+export async function closeTask({ cwd, taskId }) {
+  const task = await loadTask({ cwd, taskId });
+  if (!task) return null;
+  task.state = "closed";
+  task.updatedAt = new Date().toISOString();
+  await saveTask({ cwd, task });
+
+  const index = await readIndex(cwd);
+  if (index.activeTaskId === taskId) {
+    index.activeTaskId = null;
+    await writeIndex(cwd, index);
+  }
+  return task;
+}
+
+export function isValidTaskState(state) {
+  return VALID_STATES.includes(state);
+}
+
+export { VALID_STATES, slugify };