mulmoclaude 0.1.0

package/server/api/routes/todosHandlers.ts

@@ -0,0 +1,274 @@
+// 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((l) => `${l.label} (${l.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);
+}

package/server/api/routes/todosItemsHandlers.ts

@@ -0,0 +1,386 @@
+// Pure handlers for the id-based REST routes used by the file-explorer
+// todo view (TodoExplorer.vue). The MCP `manageTodoList` action route
+// continues to live in todosHandlers.ts; these handlers are intended
+// for the web UI which knows item ids directly and doesn't need the
+// substring-match contract that the MCP handlers use.
+//
+// Each function takes the current items + columns + an input record
+// and returns a result. The Express route is responsible for loading
+// and saving JSON to disk.
+
+import type { TodoItem, TodoPriority } from "./todos.js";
+import { type StatusColumn, defaultStatusId, doneColumnId } from "./todosColumnsHandlers.js";
+import { mergeLabels } from "../../../src/plugins/todo/labels.js";
+import { makeId } from "../../utils/id.js";
+
+const ORDER_STEP = 1000;
+const PRIORITIES: readonly TodoPriority[] = ["low", "medium", "high", "urgent"];
+
+// ── Result type ───────────────────────────────────────────────────
+
+export type ItemsActionResult = { kind: "error"; status: number; error: string } | { kind: "success"; items: TodoItem[]; item?: TodoItem };
+
+// ── Migration ─────────────────────────────────────────────────────
+
+// Backfill `status` and `order` on items that pre-date the kanban
+// extension. Pure / idempotent: items that already have valid values
+// pass through unchanged. Done via a single forward pass that assigns
+// monotonically-increasing order values per status column so the
+// kanban view has a stable initial sort.
+//
+// Reasoning for the order assignment: legacy items only carry a
+// `createdAt`, and we want oldest-first within each column. We can't
+// just use createdAt as the order key because it's a milliseconds
+// number which makes hand-editing painful and conflicts with the
+// 1000-step convention drag-drop uses for new items.
+export function migrateItems(rawItems: TodoItem[], columns: StatusColumn[]): TodoItem[] {
+  const doneId = doneColumnId(columns);
+  const openId = defaultStatusId(columns);
+  const validStatusIds = new Set(columns.map((column) => column.id));
+
+  // First pass: backfill status. Items pointing at a column that no
+  // longer exists are reassigned to the default open or done column
+  // depending on `completed`.
+  //
+  // Note: we deliberately do NOT re-sync `completed` to status on
+  // every read. Earlier versions of this function did, but that
+  // overrode the legacy MCP `check` / `uncheck` actions — those
+  // actions only flip the boolean, never touch status, so a sync
+  // pass kept reverting them on the next read. Treating the two
+  // fields as independent at the storage layer leaves both the REST
+  // PATCH path (which keeps them in sync explicitly) and the legacy
+  // MCP actions (which only touch `completed`) working correctly.
+  const withStatus = rawItems.map((item): TodoItem => {
+    const hasValidStatus = typeof item.status === "string" && validStatusIds.has(item.status);
+    if (hasValidStatus) return item;
+    const status = item.completed ? doneId : openId;
+    return { ...item, status };
+  });
+
+  // Second pass: backfill order per column. Items that already have
+  // an order keep item untouched — only items missing order get one
+  // assigned, and they go after the column's current max so they
+  // sort to the bottom in createdAt order. This preserves any
+  // hand-managed ordering even when a column is a mix of legacy
+  // and kanban-aware items.
+  const byStatus = new Map<string, TodoItem[]>();
+  for (const item of withStatus) {
+    const key = item.status ?? openId;
+    if (!byStatus.has(key)) byStatus.set(key, []);
+    byStatus.get(key)!.push(item);
+  }
+  const orderById = new Map<string, number>();
+  for (const [, group] of byStatus) {
+    const missing = group.filter((item) => typeof item.order !== "number");
+    if (missing.length === 0) continue;
+    const existingMax = group.filter((item) => typeof item.order === "number").reduce((acc, item) => Math.max(acc, item.order!), 0);
+    const sorted = [...missing].sort((left, right) => left.createdAt - right.createdAt);
+    sorted.forEach((item, i) => {
+      orderById.set(item.id, existingMax + (i + 1) * ORDER_STEP);
+    });
+  }
+  return withStatus.map((item): TodoItem => {
+    const next = orderById.get(item.id);
+    if (next === undefined) return item;
+    return { ...item, order: next };
+  });
+}
+
+// ── Validators ────────────────────────────────────────────────────
+
+function isPriority(value: unknown): value is TodoPriority {
+  return typeof value === "string" && PRIORITIES.includes(value as TodoPriority);
+}
+
+// YYYY-MM-DD only — keep item boring so the column is sortable as text.
+function isDueDate(value: unknown): value is string {
+  return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+
+function nextOrder(items: TodoItem[], statusId: string): number {
+  const inColumn = items.filter((item) => item.status === statusId).map((item) => item.order ?? 0);
+  if (inColumn.length === 0) return ORDER_STEP;
+  return Math.max(...inColumn) + ORDER_STEP;
+}
+
+// ── Create ────────────────────────────────────────────────────────
+
+export interface CreateInput {
+  text?: string;
+  note?: string;
+  status?: string;
+  priority?: string;
+  dueDate?: string;
+  labels?: string[];
+}
+
+// Resolve the status field from input, validating against known
+// columns. Returns the resolved column id or an error result.
+type ResolveStatusResult = { kind: "ok"; status: string } | { kind: "error"; status: number; error: string };
+
+function resolveStatus(input: CreateInput, columns: StatusColumn[]): ResolveStatusResult {
+  if (input.status === undefined || input.status === "") {
+    return { kind: "ok", status: defaultStatusId(columns) };
+  }
+  const validStatusIds = new Set(columns.map((column) => column.id));
+  if (validStatusIds.has(input.status)) {
+    return { kind: "ok", status: input.status };
+  }
+  return {
+    kind: "error",
+    status: 400,
+    error: `unknown status: ${input.status}`,
+  };
+}
+
+// Apply optional priority + dueDate to an item, returning an error
+// result on validation failure.
+function applyOptionalFields(item: TodoItem, input: CreateInput): ItemsActionResult | null {
+  if (input.priority !== undefined && input.priority !== "") {
+    if (!isPriority(input.priority)) {
+      return { kind: "error", status: 400, error: "invalid priority" };
+    }
+    item.priority = input.priority;
+  }
+  if (input.dueDate !== undefined && input.dueDate !== "") {
+    if (!isDueDate(input.dueDate)) {
+      return {
+        kind: "error",
+        status: 400,
+        error: "dueDate must be YYYY-MM-DD",
+      };
+    }
+    item.dueDate = input.dueDate;
+  }
+  return null;
+}
+
+export function handleCreate(items: TodoItem[], columns: StatusColumn[], input: CreateInput): ItemsActionResult {
+  if (!input.text || input.text.trim().length === 0) {
+    return { kind: "error", status: 400, error: "text required" };
+  }
+  const resolved = resolveStatus(input, columns);
+  if (resolved.kind === "error") return resolved;
+
+  const status = resolved.status;
+  const item: TodoItem = {
+    id: makeId("todo"),
+    text: input.text.trim(),
+    completed: status === doneColumnId(columns),
+    createdAt: Date.now(),
+    status,
+    order: nextOrder(items, status),
+  };
+  if (input.note !== undefined && input.note !== "") item.note = input.note;
+  const normalizedLabels = mergeLabels([], input.labels ?? []);
+  if (normalizedLabels.length > 0) item.labels = normalizedLabels;
+
+  const fieldError = applyOptionalFields(item, input);
+  if (fieldError) return fieldError;
+
+  return { kind: "success", items: [...items, item], item };
+}
+
+// ── Patch ─────────────────────────────────────────────────────────
+
+export interface PatchInput {
+  text?: string;
+  note?: string | null;
+  status?: string;
+  priority?: string | null;
+  dueDate?: string | null;
+  labels?: string[];
+  completed?: boolean;
+}
+
+// Each `applyXxx` helper mutates `updated` in place and returns either
+// `null` (success) or an error result. Splitting them out keeps the
+// top-level `handlePatch` linear so item stays under the cognitive
+// complexity threshold and so each field's edit semantics live in one
+// obvious place.
+
+function applyTextPatch(updated: TodoItem, input: PatchInput): ItemsActionResult | null {
+  if (typeof input.text !== "string") return null;
+  if (input.text.trim().length === 0) {
+    return { kind: "error", status: 400, error: "text cannot be empty" };
+  }
+  updated.text = input.text.trim();
+  return null;
+}
+
+function applyNotePatch(updated: TodoItem, input: PatchInput): void {
+  if (input.note === null || input.note === "") {
+    delete updated.note;
+    return;
+  }
+  if (typeof input.note === "string") updated.note = input.note;
+}
+
+function applyLabelsPatch(updated: TodoItem, input: PatchInput): void {
+  if (!Array.isArray(input.labels)) return;
+  const merged = mergeLabels([], input.labels);
+  if (merged.length > 0) updated.labels = merged;
+  else delete updated.labels;
+}
+
+function applyPriorityPatch(updated: TodoItem, input: PatchInput): ItemsActionResult | null {
+  if (input.priority === null || input.priority === "") {
+    delete updated.priority;
+    return null;
+  }
+  if (input.priority === undefined) return null;
+  if (!isPriority(input.priority)) {
+    return { kind: "error", status: 400, error: "invalid priority" };
+  }
+  updated.priority = input.priority;
+  return null;
+}
+
+function applyDueDatePatch(updated: TodoItem, input: PatchInput): ItemsActionResult | null {
+  if (input.dueDate === null || input.dueDate === "") {
+    delete updated.dueDate;
+    return null;
+  }
+  if (input.dueDate === undefined) return null;
+  if (!isDueDate(input.dueDate)) {
+    return { kind: "error", status: 400, error: "dueDate must be YYYY-MM-DD" };
+  }
+  updated.dueDate = input.dueDate;
+  return null;
+}
+
+function applyStatusPatch(updated: TodoItem, target: TodoItem, items: TodoItem[], columns: StatusColumn[], input: PatchInput): ItemsActionResult | null {
+  if (typeof input.status !== "string" || input.status === target.status) {
+    return null;
+  }
+  const validStatusIds = new Set(columns.map((column) => column.id));
+  if (!validStatusIds.has(input.status)) {
+    return {
+      kind: "error",
+      status: 400,
+      error: `unknown status: ${input.status}`,
+    };
+  }
+  updated.status = input.status;
+  updated.order = nextOrder(items, input.status);
+  updated.completed = input.status === doneColumnId(columns);
+  return null;
+}
+
+// Explicit `completed` toggle without changing status: lets the user
+// check / uncheck a card and have item move between the done column and
+// a default open column the obvious way.
+function applyCompletedPatch(updated: TodoItem, items: TodoItem[], columns: StatusColumn[], input: PatchInput): void {
+  if (typeof input.completed !== "boolean") return;
+  if (input.completed === updated.completed) return;
+  updated.completed = input.completed;
+  const targetStatus = input.completed ? doneColumnId(columns) : defaultStatusId(columns);
+  if (targetStatus !== updated.status) {
+    updated.status = targetStatus;
+    updated.order = nextOrder(items, targetStatus);
+  }
+}
+
+export function handlePatch(items: TodoItem[], columns: StatusColumn[], id: string, input: PatchInput): ItemsActionResult {
+  const target = items.find((i) => i.id === id);
+  if (!target) {
+    return { kind: "error", status: 404, error: `item not found: ${id}` };
+  }
+  const updated: TodoItem = { ...target };
+
+  // Each step short-circuits on validation failure. Order matters:
+  // status changes happen before completed-toggling so an explicit
+  // completed: true alongside a non-done status doesn't fight itself.
+  const steps: Array<() => ItemsActionResult | null | void> = [
+    () => applyTextPatch(updated, input),
+    () => applyNotePatch(updated, input),
+    () => applyLabelsPatch(updated, input),
+    () => applyPriorityPatch(updated, input),
+    () => applyDueDatePatch(updated, input),
+    () => applyStatusPatch(updated, target, items, columns, input),
+    () => applyCompletedPatch(updated, items, columns, input),
+  ];
+  for (const step of steps) {
+    const err = step();
+    if (err) return err;
+  }
+
+  const next = items.map((item) => (item.id === id ? updated : item));
+  return { kind: "success", items: next, item: updated };
+}
+
+// ── Move (drag & drop) ────────────────────────────────────────────
+
+// Reorder + cross-column move in a single call. `position` is the
+// 0-based index the item should occupy in its target column AFTER
+// the move (with the moving item itself excluded from the count).
+//
+// We rebuild the entire target column's order field for simplicity:
+// it's O(n) per column, which for a kanban with hundreds of items is
+// negligible and makes the math obviously correct.
+export interface MoveInput {
+  status?: string;
+  position?: number;
+}
+
+export function handleMove(items: TodoItem[], columns: StatusColumn[], id: string, input: MoveInput): ItemsActionResult {
+  const target = items.find((i) => i.id === id);
+  if (!target) {
+    return { kind: "error", status: 404, error: `item not found: ${id}` };
+  }
+  const validStatusIds = new Set(columns.map((column) => column.id));
+  const newStatus = input.status ?? target.status ?? defaultStatusId(columns);
+  if (!validStatusIds.has(newStatus)) {
+    return {
+      kind: "error",
+      status: 400,
+      error: `unknown status: ${newStatus}`,
+    };
+  }
+  const isDone = newStatus === doneColumnId(columns);
+  const updatedSelf: TodoItem = {
+    ...target,
+    status: newStatus,
+    completed: isDone,
+  };
+  // Re-collect the items in the target column with the moving item
+  // pulled out, then splice item back in at `position`.
+  const others = items.filter((item) => item.id !== id && item.status === newStatus).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+  const insertAt = clampPosition(input.position, others.length);
+  const reordered = [...others];
+  reordered.splice(insertAt, 0, updatedSelf);
+  // Reassign order values 1000 / 2000 / 3000 ...
+  const reorderedById = new Map<string, number>();
+  reordered.forEach((item, i) => reorderedById.set(item.id, (i + 1) * ORDER_STEP));
+  const nextItems = items.map((item): TodoItem => {
+    const newOrder = reorderedById.get(item.id);
+    if (item.id === id) {
+      const out: TodoItem = {
+        ...updatedSelf,
+        order: newOrder ?? updatedSelf.order ?? ORDER_STEP,
+      };
+      return out;
+    }
+    if (newOrder !== undefined) return { ...item, order: newOrder };
+    return item;
+  });
+  const finalSelf = nextItems.find((item) => item.id === id)!;
+  return { kind: "success", items: nextItems, item: finalSelf };
+}
+
+function clampPosition(raw: number | undefined, max: number): number {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return max;
+  if (raw < 0) return 0;
+  if (raw > max) return max;
+  return Math.floor(raw);
+}
+
+// ── Delete ────────────────────────────────────────────────────────
+
+export function handleDeleteItem(items: TodoItem[], id: string): ItemsActionResult {
+  const target = items.find((i) => i.id === id);
+  if (!target) {
+    return { kind: "error", status: 404, error: `item not found: ${id}` };
+  }
+  return { kind: "success", items: items.filter((item) => item.id !== id) };
+}