@mu-crew/mu 3.9.0 → 3.10.0

package/dist/chunk-XXK7FR37.js

@@ -0,0 +1,640 @@
+import {
+  groupIdFromPrefix
+} from "./chunk-WT7IN2OD.js";
+import {
+  LEGACY_LOG_ONLY_SQL_EXCLUSION,
+  localMachineId,
+  mapLegacyStatus,
+  repairTaskPair,
+  resolvePair,
+  resolveWorkstreamId,
+  withOpContext
+} from "./chunk-YIF3X32A.js";
+
+// src/undo.ts
+var UndoGroupNotFoundError = class extends Error {
+  constructor(groupId) {
+    super(`no ops found for group ${JSON.stringify(groupId)}`);
+    this.groupId = groupId;
+    this.name = "UndoGroupNotFoundError";
+  }
+  groupId;
+  errorNextSteps() {
+    return [
+      { intent: "List recent undoable groups", command: "mu undo" },
+      { intent: "Inspect a group's ops", command: "mu log --group <id>" }
+    ];
+  }
+};
+var NothingToUndoError = class extends Error {
+  constructor() {
+    super("the ops log is empty; nothing to undo");
+    this.name = "NothingToUndoError";
+  }
+  errorNextSteps() {
+    return [{ intent: "Make a change first", command: "mu task add <id> -t <title>" }];
+  }
+};
+var UndoSupersededError = class extends Error {
+  constructor(groupId, conflicts) {
+    const shown = conflicts.slice(0, 5).map((c) => `${c.key}.${c.field} (changed by ${c.groupId.slice(0, 8)})`).join(", ");
+    super(
+      `group ${groupId.slice(0, 8)} has been superseded: ${conflicts.length} field(s) were changed by a later action \u2014 ${shown}. Undoing would discard that newer work.`
+    );
+    this.groupId = groupId;
+    this.conflicts = conflicts;
+    this.name = "UndoSupersededError";
+  }
+  groupId;
+  conflicts;
+  errorNextSteps() {
+    return [
+      {
+        intent: "Inspect what changed since",
+        command: `mu log --group ${this.groupId.slice(0, 8)}`
+      },
+      {
+        intent: "Undo anyway, discarding the newer edits",
+        command: `mu undo ${this.groupId.slice(0, 8)} --yes --force`
+      }
+    ];
+  }
+};
+var ENTITY_RESTORE_ORDER = {
+  workstream: 0,
+  task: 1,
+  note: 2,
+  edge: 2
+};
+function restoreRank(entity) {
+  return ENTITY_RESTORE_ORDER[entity] ?? 3;
+}
+function priorFieldValue(db, entity, key, hlc, field, machineId) {
+  const row = db.prepare(
+    `SELECT json_extract(payload, '$.' || @field) AS value
+         FROM ops
+        WHERE entity = @entity
+          AND key    = @key
+          AND op     = 'put'
+          AND hlc    < @hlc
+          AND (@machineId IS NULL OR machine_id = @machineId)
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+          AND json_type(payload, '$.' || @field) IS NOT NULL
+        ORDER BY hlc DESC
+        LIMIT 1`
+  ).get({ entity, key, hlc, field, machineId: machineId ?? null });
+  if (row === void 0) return { found: false };
+  return { found: true, value: row.value };
+}
+function laterWriters(db, entity, key, hlc, field, excludeGroup, machineId) {
+  return db.prepare(
+    `SELECT DISTINCT group_id AS groupId, intent
+         FROM ops
+        WHERE entity   = @entity
+          AND key      = @key
+          AND op       = 'put'
+          AND hlc      > @hlc
+          AND group_id <> @excludeGroup
+          AND (@machineId IS NULL OR machine_id = @machineId)
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+          AND json_type(payload, '$.' || @field) IS NOT NULL`
+  ).all({ entity, key, hlc, field, excludeGroup, machineId: machineId ?? null });
+}
+function laterRowWriters(db, entity, key, hlc, excludeGroup) {
+  return db.prepare(
+    `SELECT DISTINCT group_id AS groupId, intent
+         FROM ops
+        WHERE entity   = @entity
+          AND key      = @key
+          AND op       = 'put'
+          AND hlc      > @hlc
+          AND group_id <> @excludeGroup
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}`
+  ).all({ entity, key, hlc, excludeGroup });
+}
+function isDeletedByLaterGroup(db, entity, key, groupId) {
+  const row = db.prepare(
+    `SELECT op, group_id AS groupId FROM ops
+        WHERE entity = @entity AND key = @key
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+        ORDER BY hlc DESC LIMIT 1`
+  ).get({ entity, key });
+  return row?.op === "del" && row.groupId !== groupId;
+}
+function laterDeleters(db, entity, key, hlc, excludeGroup) {
+  return db.prepare(
+    `SELECT DISTINCT group_id AS groupId, intent
+         FROM ops
+        WHERE entity   = @entity
+          AND key      = @key
+          AND op       = 'del'
+          AND hlc      > @hlc
+          AND group_id <> @excludeGroup`
+  ).all({ entity, key, hlc, excludeGroup });
+}
+function listRecentGroups(db, limit = 10) {
+  const rows = db.prepare(
+    `SELECT group_id                    AS groupId,
+              MAX(hlc)                    AS hlc,
+              MIN(created_at)             AS when_,
+              COUNT(*)                    AS ops,
+              MAX(actor)                  AS actor
+         FROM ops
+        WHERE entity IN ('workstream','task','note','edge')
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+        GROUP BY group_id
+        ORDER BY MAX(hlc) DESC
+        LIMIT @limit`
+  ).all({ limit });
+  return rows.map((row) => {
+    const intents = db.prepare(
+      `SELECT DISTINCT intent FROM ops
+            WHERE group_id = @groupId AND intent IS NOT NULL
+            ORDER BY seq`
+    ).all({ groupId: row.groupId }).map((r) => r.intent);
+    return {
+      groupId: row.groupId,
+      intents,
+      actor: row.actor,
+      ops: row.ops,
+      when: row.when_,
+      hlc: row.hlc
+    };
+  });
+}
+function mostRecentGroup(db) {
+  return listRecentGroups(db, 1)[0] ?? null;
+}
+function resolveGroupId(db, prefix) {
+  const resolved = groupIdFromPrefix(db, prefix);
+  if (resolved === null) throw new UndoGroupNotFoundError(prefix);
+  return resolved;
+}
+var CAPTURED_TABLE_FOR = {
+  workstream: "workstreams",
+  task: "tasks",
+  note: "task_notes",
+  edge: "task_edges"
+};
+var NEVER_RESTORE = /* @__PURE__ */ new Set(["id", "local_id", "name", "workstream_id", "task_id"]);
+var OWNER_FIELD = "owner_id";
+var NEVER_RECONSTRUCT = /* @__PURE__ */ new Set([...NEVER_RESTORE, OWNER_FIELD]);
+var TOUCH_FIELD = "updated_at";
+function planUndo(db, groupId) {
+  const rows = db.prepare(
+    `SELECT o.seq, o.hlc, o.group_id, o.machine_id, o.intent, o.actor, o.entity, o.key, o.op, o.payload,
+              (SELECT COUNT(*) FROM ops p
+                WHERE p.entity = o.entity AND p.key = o.key AND p.hlc < o.hlc
+                  AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}) AS prior,
+              (SELECT p.op FROM ops p
+                WHERE p.entity = o.entity AND p.key = o.key AND p.hlc < o.hlc
+                  AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+                ORDER BY p.hlc DESC LIMIT 1) AS priorKind
+         FROM ops o
+        WHERE o.group_id = @groupId
+          AND o.entity IN ('workstream','task','note','edge')
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+        ORDER BY o.hlc`
+  ).all({ groupId });
+  if (rows.length === 0) throw new UndoGroupNotFoundError(groupId);
+  const inverses = [];
+  let skipped = 0;
+  const seenLegacyNoteTasks = /* @__PURE__ */ new Set();
+  const restoredFields = /* @__PURE__ */ new Map();
+  let machine;
+  const localMachine = () => {
+    machine ??= localMachineId(db);
+    return machine;
+  };
+  for (const row of rows) {
+    if (row.op === "del") {
+      let fields2 = reconstructRow(db, row.entity, row.key, row.hlc);
+      if (Object.keys(fields2).length === 0) fields2 = payloadFields(row.payload);
+      if (Object.keys(fields2).length === 0 && row.entity === "note") {
+        const recovered = recoverLegacyNoteContents(db, row.key, row.hlc, seenLegacyNoteTasks);
+        for (const legacy2 of recovered) {
+          inverses.push({
+            entity: "note",
+            key: legacy2.key,
+            op: "put",
+            fields: legacy2.fields,
+            summary: `note ${legacy2.key} (recovered from legacy history)`,
+            supersededBy: []
+          });
+        }
+        skipped += 1;
+        continue;
+      }
+      const status = fields2.status;
+      const legacy = typeof status === "string" ? mapLegacyStatus(status) : null;
+      if (legacy) {
+        fields2.status = legacy.status;
+        fields2.substate = legacy.substate;
+      }
+      const conflicts = laterRowWriters(db, row.entity, row.key, row.hlc, groupId).map((w) => ({
+        field: "<row>",
+        groupId: w.groupId,
+        intent: w.intent
+      }));
+      inverses.push({
+        entity: row.entity,
+        key: row.key,
+        op: "put",
+        fields: fields2,
+        summary: `${row.entity} ${row.key} (from tombstone)`,
+        supersededBy: conflicts
+      });
+      continue;
+    }
+    if (row.prior === 0 || row.priorKind === "del") {
+      if (isDeletedByLaterGroup(db, row.entity, row.key, groupId)) {
+        skipped += 1;
+        continue;
+      }
+      const later = [...laterRowWriters(db, row.entity, row.key, row.hlc, groupId)];
+      inverses.push({
+        entity: row.entity,
+        key: row.key,
+        op: "del",
+        fields: {},
+        summary: `${row.entity} ${row.key} (it was created by this group)`,
+        supersededBy: later.map((w) => ({ field: "<row>", groupId: w.groupId, intent: w.intent }))
+      });
+      continue;
+    }
+    const payload = JSON.parse(row.payload);
+    const fields = {};
+    const supersededBy = [];
+    const rowKey = `${row.entity}\0${row.key}`;
+    const restored = restoredFields.get(rowKey) ?? /* @__PURE__ */ new Set();
+    restoredFields.set(rowKey, restored);
+    for (const field of Object.keys(payload)) {
+      if (NEVER_RESTORE.has(field) || restored.has(field)) continue;
+      restored.add(field);
+      let machineId;
+      if (field === OWNER_FIELD) {
+        if (row.machine_id !== localMachine()) continue;
+        machineId = localMachine();
+      }
+      const prior = field === OWNER_FIELD ? priorOwner(db, row.key, row.hlc, localMachine()) : priorFieldValue(db, row.entity, row.key, row.hlc, field, machineId);
+      if (!prior.found) {
+        continue;
+      }
+      if (field === OWNER_FIELD && prior.value !== null && !agentExists(db, prior.value)) continue;
+      const writers = laterWriters(db, row.entity, row.key, row.hlc, field, groupId, machineId);
+      if (field === TOUCH_FIELD && writers.length > 0) continue;
+      fields[field] = prior.value;
+      for (const writer of writers) {
+        supersededBy.push({ field, groupId: writer.groupId, intent: writer.intent });
+      }
+    }
+    for (const deleter of laterDeleters(db, row.entity, row.key, row.hlc, groupId)) {
+      supersededBy.push({ field: "<row>", groupId: deleter.groupId, intent: deleter.intent });
+    }
+    if (Object.keys(fields).length === 0) {
+      skipped += 1;
+      continue;
+    }
+    inverses.push({
+      entity: row.entity,
+      key: row.key,
+      op: "put",
+      fields,
+      summary: `${row.entity} ${row.key} ${Object.entries(fields).map(([f, v]) => `${f}=${v === null ? "NULL" : String(v)}`).join(" ")}`,
+      supersededBy
+    });
+  }
+  const ordered = [...inverses].sort((a, b) => {
+    if (a.op !== b.op) return a.op === "put" ? -1 : 1;
+    const rank = a.op === "put" ? restoreRank(a.entity) - restoreRank(b.entity) : restoreRank(b.entity) - restoreRank(a.entity);
+    return rank;
+  });
+  const intents = [...new Set(rows.map((r) => r.intent).filter((i) => i !== null))];
+  return {
+    groupId,
+    intents,
+    when: groupWhen(db, groupId),
+    inverses: ordered,
+    superseded: ordered.some((i) => i.supersededBy.length > 0),
+    skipped
+  };
+}
+function priorOwner(db, key, hlc, machineId) {
+  const local = priorFieldValue(db, "task", key, hlc, OWNER_FIELD, machineId);
+  if (!local.found) return { found: true, value: null };
+  const tomb = db.prepare(
+    `SELECT 1 FROM ops d
+        WHERE d.entity = 'task' AND d.key = @key AND d.op = 'del' AND d.hlc < @hlc
+          AND d.hlc > (SELECT MAX(hlc) FROM ops
+                        WHERE entity = 'task' AND key = @key AND op = 'put'
+                          AND hlc < @hlc AND machine_id = @machineId
+                          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+                          AND json_type(payload, '$.owner_id') IS NOT NULL)
+          AND NOT EXISTS (SELECT 1 FROM ops p
+                           WHERE p.entity = 'task' AND p.key = @key AND p.op = 'put'
+                             AND p.hlc > d.hlc AND p.seq < d.seq)
+        LIMIT 1`
+  ).get({ key, hlc, machineId });
+  return tomb === void 0 ? local : { found: true, value: null };
+}
+function agentExists(db, id) {
+  return db.prepare("SELECT 1 FROM agents WHERE id = ?").get(id) !== void 0;
+}
+function groupWhen(db, groupId) {
+  const row = db.prepare("SELECT MIN(created_at) AS when_ FROM ops WHERE group_id = ?").get(groupId);
+  return row?.when_ ?? "";
+}
+function recoverLegacyNoteContents(db, tombstoneKey, beforeHlc, seen) {
+  const parsed = parseNoteKey(tombstoneKey);
+  if (parsed === null) return [];
+  if (seen.has(parsed.taskKey)) return [];
+  seen.add(parsed.taskKey);
+  const rows = db.prepare(
+    `SELECT key, payload FROM ops
+        WHERE entity = 'note'
+          AND op = 'put'
+          AND hlc < @hlc
+          AND key LIKE @prefix
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+        ORDER BY hlc`
+  ).all({ hlc: beforeHlc, prefix: `${parsed.taskKey}#%` });
+  const out = [];
+  const contents = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const fields = payloadFields(row.payload);
+    const content = fields.content;
+    if (typeof content !== "string" || content === "") continue;
+    if (contents.has(content)) continue;
+    contents.add(content);
+    out.push({ key: row.key, fields });
+  }
+  return out;
+}
+function payloadFields(payload) {
+  const fields = {};
+  const parsed = JSON.parse(payload);
+  for (const [field, value] of Object.entries(parsed)) {
+    if (NEVER_RECONSTRUCT.has(field)) continue;
+    if (value === null || typeof value === "string" || typeof value === "number") {
+      fields[field] = value;
+    }
+  }
+  return fields;
+}
+function reconstructRow(db, entity, key, beforeHlc) {
+  const puts = db.prepare(
+    `SELECT payload FROM ops
+        WHERE entity = @entity AND key = @key AND op = 'put' AND hlc < @hlc
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+        ORDER BY hlc`
+  ).all({ entity, key, hlc: beforeHlc });
+  const fields = {};
+  for (const put of puts) {
+    const parsed = JSON.parse(put.payload);
+    for (const [field, value] of Object.entries(parsed)) {
+      if (NEVER_RECONSTRUCT.has(field)) continue;
+      if (value === null || typeof value === "string" || typeof value === "number") {
+        fields[field] = value;
+      }
+    }
+  }
+  return fields;
+}
+function undoGroup(db, groupId, opts = {}) {
+  const plan = planUndo(db, groupId);
+  if (plan.superseded && opts.force !== true) {
+    const conflicts = plan.inverses.flatMap(
+      (inv) => inv.supersededBy.map((s) => ({ key: inv.key, field: s.field, groupId: s.groupId }))
+    );
+    throw new UndoSupersededError(groupId, conflicts);
+  }
+  let applied = 0;
+  let undoGroupId = "";
+  const run = db.transaction(() => {
+    withOpContext(
+      db,
+      { intent: "undo", group: "new", ...opts.actor !== void 0 ? { actor: opts.actor } : {} },
+      () => {
+        const ctx = db.prepare("SELECT group_id FROM _op_ctx").get();
+        undoGroupId = ctx?.group_id ?? "";
+        for (const inverse of plan.inverses) {
+          if (applyInverse(db, inverse)) applied += 1;
+        }
+      }
+    );
+  });
+  run.immediate();
+  return { plan, undoGroupId: applied > 0 && undoGroupId !== "" ? undoGroupId : null, applied };
+}
+function applyInverse(db, inverse) {
+  const table = CAPTURED_TABLE_FOR[inverse.entity];
+  if (table === void 0) return false;
+  if (inverse.op === "del") return deleteRow(db, inverse);
+  return restoreRow(db, inverse, table);
+}
+function deleteRow(db, inverse) {
+  switch (inverse.entity) {
+    case "workstream":
+      return db.prepare("DELETE FROM workstreams WHERE name = ?").run(inverse.key).changes > 0;
+    case "task": {
+      const id = taskIdForKey(db, inverse.key);
+      if (id === null) return false;
+      return db.prepare("DELETE FROM tasks WHERE id = ?").run(id).changes > 0;
+    }
+    case "note": {
+      const parsed = parseNoteKey(inverse.key);
+      if (parsed === null) return false;
+      const taskId = taskIdForKey(db, parsed.taskKey);
+      if (taskId === null) return false;
+      const note = db.prepare(
+        `SELECT json_extract(payload, '$.content') AS content,
+                  json_extract(payload, '$.author') AS author,
+                  json_extract(payload, '$.created_at') AS created_at FROM ops
+            WHERE entity = 'note' AND key = ? AND op = 'put'
+              AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+            ORDER BY hlc DESC LIMIT 1`
+      ).get(inverse.key);
+      if (note?.content === void 0 || note.content === null) return false;
+      return db.prepare(
+        `DELETE FROM task_notes
+              WHERE task_id = @taskId AND content = @content
+                AND COALESCE(author, '') = COALESCE(@author, '')
+                AND (@createdAt IS NULL OR created_at = @createdAt)`
+      ).run({
+        taskId,
+        content: note.content,
+        author: note.author,
+        createdAt: note.created_at
+      }).changes > 0;
+    }
+    case "edge": {
+      const parsed = parseEdgeKey(inverse.key);
+      if (parsed === null) return false;
+      const from = taskIdForKey(db, parsed.blocker);
+      const to = taskIdForKey(db, parsed.blocked);
+      if (from === null || to === null) return false;
+      return db.prepare("DELETE FROM task_edges WHERE from_task_id = ? AND to_task_id = ?").run(from, to).changes > 0;
+    }
+    default:
+      return false;
+  }
+}
+function restoreRow(db, inverse, table) {
+  switch (inverse.entity) {
+    case "workstream": {
+      const exists = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(inverse.key);
+      if (!exists) {
+        db.prepare("INSERT INTO workstreams (name, created_at) VALUES (?, ?)").run(
+          inverse.key,
+          String(inverse.fields.created_at ?? (/* @__PURE__ */ new Date()).toISOString())
+        );
+        return true;
+      }
+      return updateFields(db, "workstreams", "id", exists.id, inverse.fields);
+    }
+    case "task": {
+      const parsed = parseTaskKey(inverse.key);
+      if (parsed === null) return false;
+      const id = taskIdForKey(db, inverse.key);
+      if (id === null) {
+        const wsId = ensureWorkstream(db, parsed.workstream);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const pair = resolvePair(
+          String(inverse.fields.status ?? "OPEN"),
+          inverse.fields.substate
+        ) ?? {
+          status: "OPEN",
+          substate: "todo"
+        };
+        db.prepare(
+          `INSERT INTO tasks (workstream_id, local_id, title, status, substate, impact,
+                              effort_days, owner_id, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`
+        ).run(
+          wsId,
+          parsed.localId,
+          String(inverse.fields.title ?? parsed.localId),
+          pair.status,
+          pair.substate,
+          Number(inverse.fields.impact ?? 50),
+          Number(inverse.fields.effort_days ?? 1),
+          String(inverse.fields.created_at ?? now),
+          String(inverse.fields.updated_at ?? now)
+        );
+        return true;
+      }
+      const updated = updateFields(db, "tasks", "id", id, inverse.fields);
+      return repairTaskPair(db, id) || updated;
+    }
+    case "note": {
+      const parsed = parseNoteKey(inverse.key);
+      if (parsed === null) return false;
+      const taskId = taskIdForKey(db, parsed.taskKey);
+      if (taskId === null) return false;
+      const content = inverse.fields.content;
+      if (content === void 0 || content === null) return false;
+      const author = inverse.fields.author;
+      const createdAt = inverse.fields.created_at;
+      const exists = db.prepare(
+        `SELECT id FROM task_notes
+            WHERE task_id = @taskId AND content = @content
+              AND COALESCE(author, '') = COALESCE(@author, '')
+              AND (@createdAt IS NULL OR created_at = @createdAt)`
+      ).get({
+        taskId,
+        content: String(content),
+        author: author === void 0 || author === null ? null : String(author),
+        createdAt: createdAt === void 0 || createdAt === null ? null : String(createdAt)
+      });
+      if (exists) return false;
+      db.prepare(
+        "INSERT INTO task_notes (task_id, author, content, created_at) VALUES (?, ?, ?, ?)"
+      ).run(
+        taskId,
+        inverse.fields.author === void 0 || inverse.fields.author === null ? null : String(inverse.fields.author),
+        String(content),
+        String(inverse.fields.created_at ?? (/* @__PURE__ */ new Date()).toISOString())
+      );
+      return true;
+    }
+    case "edge": {
+      const parsed = parseEdgeKey(inverse.key);
+      if (parsed === null) return false;
+      const from = taskIdForKey(db, parsed.blocker);
+      const to = taskIdForKey(db, parsed.blocked);
+      if (from === null || to === null) return false;
+      const exists = db.prepare("SELECT 1 AS x FROM task_edges WHERE from_task_id = ? AND to_task_id = ?").get(from, to);
+      if (exists) return false;
+      db.prepare(
+        "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
+      ).run(from, to, String(inverse.fields.created_at ?? (/* @__PURE__ */ new Date()).toISOString()));
+      return true;
+    }
+    default:
+      void table;
+      return false;
+  }
+}
+function updateFields(db, table, idColumn, id, fields) {
+  const names = Object.keys(fields).filter((f) => !NEVER_RESTORE.has(f));
+  if (names.length === 0) return false;
+  const current = db.prepare(`SELECT * FROM ${table} WHERE ${idColumn} = ?`).get(id);
+  const pending = names.filter((name) => {
+    const target = fields[name] ?? null;
+    if (current === void 0) return true;
+    return current[name] !== target;
+  });
+  if (pending.length === 0) return false;
+  const setClause = pending.map((name) => `${name} = @${name}`).join(", ");
+  const params = { id };
+  for (const name of pending) params[name] = fields[name] ?? null;
+  db.prepare(`UPDATE ${table} SET ${setClause} WHERE ${idColumn} = @id`).run(params);
+  return true;
+}
+function ensureWorkstream(db, name) {
+  const existing = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(name);
+  if (existing) return existing.id;
+  db.prepare("INSERT INTO workstreams (name, created_at) VALUES (?, ?)").run(
+    name,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  return resolveWorkstreamId(db, name);
+}
+function parseTaskKey(key) {
+  const slash = key.indexOf("/");
+  if (slash <= 0 || slash === key.length - 1) return null;
+  return { workstream: key.slice(0, slash), localId: key.slice(slash + 1) };
+}
+function parseNoteKey(key) {
+  const hash = key.lastIndexOf("#");
+  if (hash <= 0) return null;
+  return { taskKey: key.slice(0, hash) };
+}
+function parseEdgeKey(key) {
+  const arrow = key.indexOf("->");
+  if (arrow <= 0) return null;
+  return { blocker: key.slice(0, arrow), blocked: key.slice(arrow + 2) };
+}
+function taskIdForKey(db, key) {
+  const parsed = parseTaskKey(key);
+  if (parsed === null) return null;
+  const row = db.prepare(
+    `SELECT t.id AS id FROM tasks t
+         JOIN workstreams w ON w.id = t.workstream_id
+        WHERE w.name = ? AND t.local_id = ?`
+  ).get(parsed.workstream, parsed.localId);
+  return row?.id ?? null;
+}
+
+export {
+  UndoGroupNotFoundError,
+  NothingToUndoError,
+  UndoSupersededError,
+  priorFieldValue,
+  listRecentGroups,
+  mostRecentGroup,
+  resolveGroupId,
+  planUndo,
+  undoGroup
+};
+//# sourceMappingURL=chunk-XXK7FR37.js.map