mulmoclaude 0.5.2 → 0.6.0

package/server/api/routes/todosColumnsHandlers.ts

@@ -1,333 +0,0 @@
-// Pure handlers for status columns used by the file-explorer todo
-// view. Same shape as todosHandlers / schedulerHandlers: each function
-// takes the current state + an input record and returns either an
-// error or the next state. The Express route is responsible for
-// loading / saving the underlying JSON files.
-//
-// Storage layout:
-//   workspace/todos/columns.json   ← StatusColumn[]
-//
-// At least one column must always carry `isDone: true` so completed
-// items have somewhere to live and the legacy `completed` boolean has
-// something to map to.
-
-import { slugify as slugifyCanonical, disambiguateSlug } from "../../utils/slug.js";
-import { isRecord } from "../../utils/types.js";
-import type { TodoItem } from "./todos.js";
-
-export interface StatusColumn {
-  id: string;
-  label: string;
-  // True for the column whose items are considered "completed".
-  // Exactly one column should have isDone: true at any given time;
-  // remove_column / patch_column rules enforce this.
-  isDone?: boolean;
-}
-
-export const DEFAULT_COLUMNS: StatusColumn[] = [
-  { id: "backlog", label: "Backlog" },
-  { id: "todo", label: "Todo" },
-  { id: "in-progress", label: "In Progress" },
-  { id: "done", label: "Done", isDone: true },
-];
-
-// ── Result types ──────────────────────────────────────────────────
-
-export type ColumnsActionResult =
-  | { kind: "error"; status: number; error: string }
-  | {
-      kind: "success";
-      columns: StatusColumn[];
-      // Some operations also need to mutate items (e.g. removing a
-      // column reassigns its items to another column). When set, the
-      // route persists this items array as well.
-      items?: TodoItem[];
-    };
-
-// ── id slug generation ────────────────────────────────────────────
-
-// Convert a free-text label into a URL-safe column id. Thin wrapper
-// around the canonical slugify (server/utils/slug.ts) with the
-// "column" fallback. Hyphen-separated to match wiki / files / journal
-// — the previous underscore-separated rule was the only divergent
-// slug producer in the codebase. See #732.
-function slugify(label: string): string {
-  return slugifyCanonical(label, "column");
-}
-
-// Pick an id that doesn't collide with `existingIds`. Thin wrapper
-// around the shared `disambiguateSlug` helper so the e2e dispatcher
-// (which mocks this server-side flow) can mirror the truncation
-// boundary without duplicating the logic — Codex iter-2 #732.
-function uniqueId(base: string, existingIds: ReadonlySet<string>): string {
-  return disambiguateSlug(base, existingIds);
-}
-
-// ── Validation helpers ────────────────────────────────────────────
-
-function findColumn(columns: StatusColumn[], columnId: string): StatusColumn | undefined {
-  return columns.find((column) => column.id === columnId);
-}
-
-function ensureColumnsValid(columns: StatusColumn[]): StatusColumn[] {
-  // Guarantee invariants when reading: at least one column, exactly
-  // one isDone column, ids are unique. If anything is off, fall back
-  // to DEFAULT_COLUMNS rather than try to repair partial state.
-  if (columns.length === 0) return [...DEFAULT_COLUMNS];
-  const seen = new Set<string>();
-  for (const column of columns) {
-    if (seen.has(column.id)) return [...DEFAULT_COLUMNS];
-    seen.add(column.id);
-  }
-  const doneCount = columns.filter((column) => column.isDone).length;
-  if (doneCount === 0) {
-    // Promote the last column to done so the invariant holds.
-    const fixed = columns.map((column, i) => (i === columns.length - 1 ? { ...column, isDone: true } : column));
-    return fixed;
-  }
-  if (doneCount > 1) {
-    // Keep only the first done flag.
-    let kept = false;
-    return columns.map((column) => {
-      if (!column.isDone) return column;
-      if (kept) {
-        const next: StatusColumn = { id: column.id, label: column.label };
-        return next;
-      }
-      kept = true;
-      return column;
-    });
-  }
-  return columns;
-}
-
-// Public: load-time normaliser. Use this when parsing columns.json so
-// the rest of the system never has to think about invalid shapes.
-export function normalizeColumns(raw: unknown): StatusColumn[] {
-  if (!Array.isArray(raw)) return [...DEFAULT_COLUMNS];
-  const cleaned: StatusColumn[] = [];
-  for (const entry of raw) {
-    if (!isRecord(entry)) continue;
-    if (typeof entry["id"] !== "string" || typeof entry["label"] !== "string") continue;
-    const col: StatusColumn = { id: entry["id"], label: entry["label"] };
-    if (entry["isDone"] === true) col.isDone = true;
-    cleaned.push(col);
-  }
-  return ensureColumnsValid(cleaned);
-}
-
-// ── Item helpers tied to columns ──────────────────────────────────
-
-// id of the first column flagged isDone. Guaranteed to exist after
-// normalizeColumns.
-export function doneColumnId(columns: StatusColumn[]): string {
-  const done = columns.find((column) => column.isDone);
-  return done ? done.id : columns[columns.length - 1]!.id;
-}
-
-// id of the first non-done column, used as the default status when
-// adding new items. Falls back to the done column if everything is
-// somehow flagged done.
-export function defaultStatusId(columns: StatusColumn[]): string {
-  const open = columns.find((column) => !column.isDone);
-  return open ? open.id : doneColumnId(columns);
-}
-
-// Reconcile each item's `completed` boolean with the new done-column
-// id. Items in the new done column are completed=true, items
-// elsewhere are completed=false. Returns [updatedItems, changed]
-// where `changed` says whether any item was actually rewritten —
-// callers use that to decide whether to persist items along with
-// the column change.
-//
-// This is the *only* place that mass-mutates `completed` based on
-// status. The migration on read deliberately does NOT do this any
-// more (so the legacy MCP `check` action's plain boolean flips keep
-// working). Column operations are explicit user intent so it's safe
-// to sync at that point.
-export function resyncDoneMembership(items: TodoItem[], newDoneId: string): { items: TodoItem[]; changed: boolean } {
-  let changed = false;
-  const next = items.map((item): TodoItem => {
-    const shouldBeDone = item.status === newDoneId;
-    if (item.completed === shouldBeDone) return item;
-    changed = true;
-    return { ...item, completed: shouldBeDone };
-  });
-  return { items: next, changed };
-}
-
-// Re-stripe order values for every item in `columnId`. Items already
-// sorted by their existing `order` get reassigned to 1000, 2000, ...
-// so two columns being merged together (handleDeleteColumn's refuge
-// case) end up with unique, contiguous orders rather than colliding
-// 1000s from each side.
-function rebuildColumnOrder(items: TodoItem[], columnId: string): TodoItem[] {
-  const inColumn = items.filter((item) => item.status === columnId).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
-  const newOrders = new Map<string, number>();
-  inColumn.forEach((item, index) => newOrders.set(item.id, (index + 1) * ORDER_STEP));
-  return items.map((item): TodoItem => {
-    const newOrder = newOrders.get(item.id);
-    if (newOrder === undefined) return item;
-    return { ...item, order: newOrder };
-  });
-}
-
-const ORDER_STEP = 1000;
-
-// ── Action handlers ───────────────────────────────────────────────
-
-export interface AddColumnInput {
-  label?: string;
-  isDone?: boolean;
-}
-
-export function handleAddColumn(columns: StatusColumn[], items: TodoItem[], input: AddColumnInput): ColumnsActionResult {
-  if (!input.label || input.label.trim().length === 0) {
-    return { kind: "error", status: 400, error: "label required" };
-  }
-  const baseId = slugify(input.label);
-  const columnId = uniqueId(baseId, new Set(columns.map((column) => column.id)));
-  const columnToAdd: StatusColumn = { id: columnId, label: input.label.trim() };
-  if (input.isDone === true) columnToAdd.isDone = true;
-  // If the new column is flagged done, demote any existing done
-  // columns (only one is allowed at a time) and resync items so the
-  // old done column's items are no longer marked completed. The new
-  // column itself is empty so there's nothing on its side to sync.
-  if (input.isDone === true) {
-    const nextColumns = [...columns.map((column) => ({ ...column, isDone: false })), columnToAdd];
-    const { items: nextItems, changed } = resyncDoneMembership(items, columnId);
-    return {
-      kind: "success",
-      columns: nextColumns,
-      ...(changed ? { items: nextItems } : {}),
-    };
-  }
-  return { kind: "success", columns: [...columns, columnToAdd] };
-}
-
-export interface PatchColumnInput {
-  label?: string;
-  isDone?: boolean;
-}
-
-export function handlePatchColumn(columns: StatusColumn[], columnId: string, input: PatchColumnInput, items: TodoItem[]): ColumnsActionResult {
-  const target = findColumn(columns, columnId);
-  if (!target) {
-    return { kind: "error", status: 404, error: `column not found: ${columnId}` };
-  }
-  const patched: StatusColumn = { id: target.id, label: target.label };
-  if (target.isDone) patched.isDone = true;
-  if (typeof input.label === "string" && input.label.trim().length > 0) {
-    patched.label = input.label.trim();
-  }
-  let nextColumns = columns.map((column) => (column.id === columnId ? patched : column));
-  // Toggling done flag is non-trivial: only one column may be done.
-  let itemsChanged = false;
-  let nextItems = items;
-  if (input.isDone === true && !target.isDone) {
-    // Promote this column to done; demote everyone else.
-    nextColumns = nextColumns.map((column) => (column.id === columnId ? { ...column, isDone: true } : { id: column.id, label: column.label }));
-    // Resync `completed` across all items: the new done column's
-    // items become true, the old done column's items become false.
-    // Doing this with the helper rather than a one-sided pass means
-    // both ends of the swap stay consistent.
-    const synced = resyncDoneMembership(items, columnId);
-    nextItems = synced.items;
-    itemsChanged = synced.changed;
-  } else if (input.isDone === false && target.isDone) {
-    // Refuse to demote the only done column — there must always be one.
-    return {
-      kind: "error",
-      status: 400,
-      error: "at least one column must be marked as done",
-    };
-  }
-  return {
-    kind: "success",
-    columns: nextColumns,
-    ...(itemsChanged ? { items: nextItems } : {}),
-  };
-}
-
-export function handleDeleteColumn(columns: StatusColumn[], columnId: string, items: TodoItem[]): ColumnsActionResult {
-  if (columns.length <= 1) {
-    return {
-      kind: "error",
-      status: 400,
-      error: "cannot delete the last remaining column",
-    };
-  }
-  const target = findColumn(columns, columnId);
-  if (!target) {
-    return { kind: "error", status: 404, error: `column not found: ${columnId}` };
-  }
-  const remaining = columns.filter((column) => column.id !== columnId);
-  // If we just removed the done column, promote the new last column.
-  let nextColumns = remaining;
-  if (target.isDone) {
-    nextColumns = remaining.map((column, i) => (i === remaining.length - 1 ? { ...column, isDone: true } : column));
-  }
-  const newDoneId = doneColumnId(nextColumns);
-  // Reassign orphaned items to the (possibly new) done column if the
-  // deleted column was done; otherwise to the new default open column.
-  const refugeId = target.isDone ? newDoneId : defaultStatusId(nextColumns);
-  let itemsChanged = false;
-  let nextItems = items.map((item): TodoItem => {
-    if (item.status !== columnId) return item;
-    itemsChanged = true;
-    return { ...item, status: refugeId };
-  });
-  if (itemsChanged) {
-    // The refuge column might have already had items in it; the ones
-    // we just merged in came with their original order values from
-    // the deleted column, which can collide with the refuge's
-    // existing orders. Re-stripe the whole refuge column to 1000,
-    // 2000, ... so the kanban sort stays unique and stable.
-    nextItems = rebuildColumnOrder(nextItems, refugeId);
-  }
-  // Resync the done flag across the result. Necessary in two
-  // scenarios: (a) we deleted the done column, so the new last column
-  // is now done and its existing items should flip to completed=true;
-  // (b) we deleted any other column whose items happened to be the
-  // refuge target — already handled by the migration above, but
-  // running the helper unconditionally keeps the rest of the items
-  // consistent too.
-  if (target.isDone) {
-    const synced = resyncDoneMembership(nextItems, newDoneId);
-    nextItems = synced.items;
-    itemsChanged = itemsChanged || synced.changed;
-  }
-  return {
-    kind: "success",
-    columns: nextColumns,
-    ...(itemsChanged ? { items: nextItems } : {}),
-  };
-}
-
-export function handleReorderColumns(columns: StatusColumn[], ids: string[]): ColumnsActionResult {
-  if (!Array.isArray(ids)) {
-    return { kind: "error", status: 400, error: "ids array required" };
-  }
-  if (ids.length !== columns.length) {
-    return {
-      kind: "error",
-      status: 400,
-      error: "ids must contain every existing column id exactly once",
-    };
-  }
-  const known = new Set(columns.map((column) => column.id));
-  const seen = new Set<string>();
-  for (const columnId of ids) {
-    if (!known.has(columnId) || seen.has(columnId)) {
-      return {
-        kind: "error",
-        status: 400,
-        error: "ids must contain every existing column id exactly once",
-      };
-    }
-    seen.add(columnId);
-  }
-  const byId = new Map(columns.map((column) => [column.id, column]));
-  const next = ids.map((columnId) => byId.get(columnId)!);
-  return { kind: "success", columns: next };
-}

package/server/api/routes/todosHandlers.ts

@@ -1,274 +0,0 @@
-// Pure action handlers for the todos POST route. Same shape as
-// schedulerHandlers.ts: each handler takes the current items + the
-// relevant body fields and returns a discriminated result describing
-// either an HTTP error or the next state. The route handler in
-// todos.ts dispatches to one of these and translates the result into
-// an HTTP response.
-//
-// Keeping the action logic pure (no I/O, no globals) makes every
-// case unit-testable in isolation, and brings the cognitive
-// complexity of the route handler under the lint threshold.
-
-import type { TodoItem } from "./todos.js";
-import { filterByLabels, listLabelsWithCount, mergeLabels, subtractLabels } from "../../../src/plugins/todo/labels.js";
-import { makeId } from "../../utils/id.js";
-
-export interface TodosActionInput {
-  text?: string;
-  newText?: string;
-  note?: string;
-  // For `add`: labels to tag the new item with.
-  // For `add_label` / `remove_label`: labels to add to / remove from
-  // the item matched by `text`.
-  labels?: string[];
-  // For `show`: OR-semantics filter that restricts the returned list
-  // to items carrying at least one of these labels (case-insensitive).
-  filterLabels?: string[];
-}
-
-export type TodosActionResult =
-  | { kind: "error"; status: number; error: string }
-  | {
-      kind: "success";
-      items: TodoItem[];
-      message: string;
-      jsonData: Record<string, unknown>;
-    };
-
-// Substring match (case-insensitive). Used by delete / update /
-// check / uncheck / add_label / remove_label — all share the same
-// lookup contract.
-export function findTodoByText(items: TodoItem[], text: string): TodoItem | undefined {
-  const needle = text.toLowerCase();
-  return items.find((i) => i.text.toLowerCase().includes(needle));
-}
-
-export function handleShow(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  const filterLabels = input.filterLabels ?? [];
-  const filtered = filterByLabels(items, filterLabels);
-  const filtering = filterLabels.length > 0;
-  const message = filtering
-    ? `Showing ${filtered.length} of ${items.length} todo item(s) filtered by: ${filterLabels.join(", ")}`
-    : `Showing ${items.length} todo item(s)`;
-  return {
-    kind: "success",
-    items: filtered,
-    message,
-    jsonData: {
-      items: filtered.map((i) => ({
-        text: i.text,
-        completed: i.completed,
-        ...(i.labels && i.labels.length > 0 && { labels: i.labels }),
-      })),
-    },
-  };
-}
-
-export function handleAdd(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  if (!input.text) {
-    return { kind: "error", status: 400, error: "text required" };
-  }
-  // Normalise incoming labels by routing them through
-  // `mergeLabels([], labels ?? [])` — that handles trim / collapse /
-  // case-insensitive dedup in one shot.
-  const normalizedLabels = mergeLabels([], input.labels ?? []);
-  const item: TodoItem = {
-    id: makeId("todo"),
-    text: input.text,
-    ...(input.note !== undefined && { note: input.note }),
-    ...(normalizedLabels.length > 0 && { labels: normalizedLabels }),
-    completed: false,
-    createdAt: Date.now(),
-  };
-  return {
-    kind: "success",
-    items: [...items, item],
-    message: normalizedLabels.length > 0 ? `Added: "${input.text}" [${normalizedLabels.join(", ")}]` : `Added: "${input.text}"`,
-    jsonData: { added: input.text, labels: normalizedLabels },
-  };
-}
-
-export function handleDelete(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  if (!input.text) {
-    return { kind: "error", status: 400, error: "text required" };
-  }
-  const needle = input.text.toLowerCase();
-  const next = items.filter((i) => !i.text.toLowerCase().includes(needle));
-  const found = next.length < items.length;
-  return {
-    kind: "success",
-    items: next,
-    message: found ? `Deleted: "${input.text}"` : `Item not found: "${input.text}"`,
-    jsonData: { deleted: input.text },
-  };
-}
-
-export function handleUpdate(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  if (!input.text || !input.newText) {
-    return { kind: "error", status: 400, error: "text and newText required" };
-  }
-  const target = findTodoByText(items, input.text);
-  if (!target) {
-    return {
-      kind: "success",
-      items,
-      message: `Item not found: "${input.text}"`,
-      jsonData: {},
-    };
-  }
-  const oldText = target.text;
-  const updated: TodoItem = {
-    ...target,
-    text: input.newText,
-    note: input.note !== undefined ? input.note || undefined : target.note,
-  };
-  const next = items.map((i) => (i.id === target.id ? updated : i));
-  return {
-    kind: "success",
-    items: next,
-    message: `Updated: "${oldText}" → "${input.newText}"`,
-    jsonData: { oldText, newText: input.newText },
-  };
-}
-
-function setCompleted(
-  items: TodoItem[],
-  input: TodosActionInput,
-  completed: boolean,
-  verb: "Checked" | "Unchecked",
-  jsonKey: "checkedItem" | "uncheckedItem",
-): TodosActionResult {
-  if (!input.text) {
-    return { kind: "error", status: 400, error: "text required" };
-  }
-  const target = findTodoByText(items, input.text);
-  if (!target) {
-    return {
-      kind: "success",
-      items,
-      message: `Item not found: "${input.text}"`,
-      jsonData: {},
-    };
-  }
-  const updated: TodoItem = { ...target, completed };
-  const next = items.map((i) => (i.id === target.id ? updated : i));
-  return {
-    kind: "success",
-    items: next,
-    message: `${verb}: "${target.text}"`,
-    jsonData: { [jsonKey]: target.text },
-  };
-}
-
-export function handleCheck(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  return setCompleted(items, input, true, "Checked", "checkedItem");
-}
-
-export function handleUncheck(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  return setCompleted(items, input, false, "Unchecked", "uncheckedItem");
-}
-
-export function handleClearCompleted(items: TodoItem[]): TodosActionResult {
-  const count = items.filter((i) => i.completed).length;
-  const next = items.filter((i) => !i.completed);
-  return {
-    kind: "success",
-    items: next,
-    message: `Cleared ${count} completed item(s)`,
-    jsonData: { clearedCount: count },
-  };
-}
-
-export function handleAddLabel(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  if (!input.text || !input.labels || input.labels.length === 0) {
-    return {
-      kind: "error",
-      status: 400,
-      error: "text and a non-empty labels array required",
-    };
-  }
-  const target = findTodoByText(items, input.text);
-  if (!target) {
-    return {
-      kind: "success",
-      items,
-      message: `Item not found: "${input.text}"`,
-      jsonData: { notFound: input.text },
-    };
-  }
-  const merged = mergeLabels(target.labels ?? [], input.labels);
-  const updated: TodoItem = { ...target, labels: merged };
-  const next = items.map((i) => (i.id === target.id ? updated : i));
-  return {
-    kind: "success",
-    items: next,
-    message: `Labels on "${target.text}": ${merged.join(", ")}`,
-    jsonData: { item: target.text, labels: merged },
-  };
-}
-
-export function handleRemoveLabel(items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  if (!input.text || !input.labels || input.labels.length === 0) {
-    return {
-      kind: "error",
-      status: 400,
-      error: "text and a non-empty labels array required",
-    };
-  }
-  const target = findTodoByText(items, input.text);
-  if (!target) {
-    return {
-      kind: "success",
-      items,
-      message: `Item not found: "${input.text}"`,
-      jsonData: { notFound: input.text },
-    };
-  }
-  const remaining = subtractLabels(target.labels ?? [], input.labels);
-  const updated: TodoItem = { ...target };
-  if (remaining.length > 0) {
-    updated.labels = remaining;
-  } else {
-    delete updated.labels;
-  }
-  const next = items.map((i) => (i.id === target.id ? updated : i));
-  return {
-    kind: "success",
-    items: next,
-    message: remaining.length > 0 ? `Labels on "${target.text}": ${remaining.join(", ")}` : `"${target.text}" now has no labels`,
-    jsonData: { item: target.text, labels: remaining },
-  };
-}
-
-export function handleListLabels(items: TodoItem[]): TodosActionResult {
-  const inventory = listLabelsWithCount(items);
-  const summary = inventory.map((entry) => `${entry.label} (${entry.count})`).join(", ");
-  const message = inventory.length === 0 ? "No labels in use" : `${inventory.length} label(s) in use: ${summary}`;
-  return {
-    kind: "success",
-    items,
-    message,
-    jsonData: { labels: inventory },
-  };
-}
-
-const HANDLERS: Record<string, (items: TodoItem[], input: TodosActionInput) => TodosActionResult> = {
-  show: handleShow,
-  add: handleAdd,
-  delete: handleDelete,
-  update: handleUpdate,
-  check: handleCheck,
-  uncheck: handleUncheck,
-  clear_completed: handleClearCompleted,
-  add_label: handleAddLabel,
-  remove_label: handleRemoveLabel,
-  list_labels: handleListLabels,
-};
-
-export function dispatchTodos(action: string, items: TodoItem[], input: TodosActionInput): TodosActionResult {
-  const handler = HANDLERS[action];
-  if (!handler) {
-    return { kind: "error", status: 400, error: `Unknown action: ${action}` };
-  }
-  return handler(items, input);
-}