mulmoclaude 0.5.2 → 0.6.0

package/server/api/routes/todosItemsHandlers.ts

@@ -1,386 +0,0 @@
-// 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[], itemId: string, input: PatchInput): ItemsActionResult {
-  const target = items.find((item) => item.id === itemId);
-  if (!target) {
-    return { kind: "error", status: 404, error: `item not found: ${itemId}` };
-  }
-  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 === itemId ? 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[], itemId: string, input: MoveInput): ItemsActionResult {
-  const target = items.find((item) => item.id === itemId);
-  if (!target) {
-    return { kind: "error", status: 404, error: `item not found: ${itemId}` };
-  }
-  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 !== itemId && 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 === itemId) {
-      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 === itemId)!;
-  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[], itemId: string): ItemsActionResult {
-  const target = items.find((item) => item.id === itemId);
-  if (!target) {
-    return { kind: "error", status: 404, error: `item not found: ${itemId}` };
-  }
-  return { kind: "success", items: items.filter((item) => item.id !== itemId) };
-}

package/server/utils/files/todos-io.ts

@@ -1,29 +0,0 @@
-// Domain I/O: todo items + status columns
-//   data/todos/todos.json     — items
-//   data/todos/columns.json   — status columns
-//
-// Sync API. Optional `root` for test DI.
-
-import { WORKSPACE_FILES } from "../../workspace/paths.js";
-import { workspacePath } from "../../workspace/paths.js";
-import { resolvePath } from "./workspace-io.js";
-import { loadJsonFile } from "./json.js";
-import { writeFileAtomicSync } from "./atomic.js";
-
-const root = (workspaceRoot?: string) => workspaceRoot ?? workspacePath;
-
-export function loadTodos<T>(fallback: T, workspaceRoot?: string): T {
-  return loadJsonFile(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosItems), fallback);
-}
-
-export function saveTodos(items: unknown, workspaceRoot?: string): void {
-  writeFileAtomicSync(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosItems), JSON.stringify(items, null, 2));
-}
-
-export function loadColumns<T>(fallback: T, workspaceRoot?: string): T {
-  return loadJsonFile(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosColumns), fallback);
-}
-
-export function saveColumns(columns: unknown, workspaceRoot?: string): void {
-  writeFileAtomicSync(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosColumns), JSON.stringify(columns, null, 2));
-}

package/src/components/NotificationToast.vue

@@ -1,75 +0,0 @@
-<script setup lang="ts">
-import { ref, watch } from "vue";
-import { useI18n } from "vue-i18n";
-import { useNotifications } from "../composables/useNotifications";
-
-const { t } = useI18n();
-import { NOTIFICATION_ICONS } from "../types/notification";
-import type { NotificationPayload } from "../types/notification";
-import { ONE_SECOND_MS } from "../../server/utils/time";
-import { formatSmartTime } from "../utils/format/date";
-
-const AUTO_HIDE_MS = 5 * ONE_SECOND_MS;
-
-const { latest } = useNotifications();
-const visible = ref<NotificationPayload | null>(null);
-let hideTimer: ReturnType<typeof setTimeout> | null = null;
-
-watch(latest, (item) => {
-  if (!item) return;
-  visible.value = item;
-  if (hideTimer !== null) clearTimeout(hideTimer);
-  hideTimer = setTimeout(() => {
-    visible.value = null;
-    hideTimer = null;
-  }, AUTO_HIDE_MS);
-});
-
-function dismiss(): void {
-  if (hideTimer !== null) clearTimeout(hideTimer);
-  hideTimer = null;
-  visible.value = null;
-}
-
-function iconName(notif: NotificationPayload): string {
-  return notif.icon ?? NOTIFICATION_ICONS[notif.kind] ?? "notifications";
-}
-</script>
-
-<template>
-  <Transition name="toast">
-    <div
-      v-if="visible"
-      data-testid="notification-toast"
-      class="fixed top-4 right-4 z-50 max-w-sm rounded-lg bg-slate-800 text-white shadow-lg p-4 flex items-start gap-3"
-    >
-      <span class="material-icons text-sky-300" aria-hidden="true">
-        {{ iconName(visible) }}
-      </span>
-      <div class="flex-1 min-w-0">
-        <p class="text-sm font-medium break-words">{{ visible.title }}</p>
-        <p v-if="visible.body" class="mt-0.5 text-xs text-slate-300 break-words">
-          {{ visible.body }}
-        </p>
-        <p class="mt-1 text-xs text-slate-400">
-          {{ formatSmartTime(visible.firedAt) }}
-        </p>
-      </div>
-      <button type="button" class="text-slate-400 hover:text-white" :aria-label="t('common.dismiss')" @click="dismiss">
-        <span class="material-icons text-base">close</span>
-      </button>
-    </div>
-  </Transition>
-</template>
-
-<style scoped>
-.toast-enter-active,
-.toast-leave-active {
-  transition: all 200ms ease;
-}
-.toast-enter-from,
-.toast-leave-to {
-  opacity: 0;
-  transform: translateY(-8px);
-}
-</style>

package/src/plugins/editImage/definition.ts

@@ -1,27 +0,0 @@
-import type { ToolDefinition } from "gui-chat-protocol";
-
-export const TOOL_NAME = "editImage";
-
-export interface ImageToolData {
-  imageData: string;
-  prompt: string;
-}
-
-const toolDefinition: ToolDefinition = {
-  type: "function",
-  name: TOOL_NAME,
-  description: "Edit the previously generated image based on a text prompt.",
-  prompt: `When the user asks 'turn this image into ...', call ${TOOL_NAME} API to generate a new image.`,
-  parameters: {
-    type: "object",
-    properties: {
-      prompt: {
-        type: "string",
-        description: "Description of the edits to be made to the image in English",
-      },
-    },
-    required: ["prompt"],
-  },
-};
-
-export default toolDefinition;

package/src/plugins/editImage/index.ts

@@ -1,37 +0,0 @@
-import type { ToolPlugin } from "../../tools/types";
-import type { ToolResult } from "gui-chat-protocol";
-import toolDefinition, { TOOL_NAME } from "./definition";
-import type { ImageToolData } from "./definition";
-import View from "./View.vue";
-import Preview from "./Preview.vue";
-import { apiPost } from "../../utils/api";
-import { API_ROUTES } from "../../config/apiRoutes";
-import { makeUuid } from "../../utils/id";
-
-const editImagePlugin: ToolPlugin<ImageToolData> = {
-  toolDefinition,
-
-  async execute(_context, args) {
-    const result = await apiPost<ToolResult<ImageToolData>>(API_ROUTES.image.edit, args);
-    if (!result.ok) {
-      return {
-        toolName: TOOL_NAME,
-        uuid: makeUuid(),
-        message: result.error,
-      };
-    }
-    return {
-      ...result.data,
-      toolName: TOOL_NAME,
-      uuid: makeUuid(),
-    };
-  },
-
-  isEnabled: () => true,
-  generatingMessage: "Editing image...",
-  viewComponent: View,
-  previewComponent: Preview,
-};
-
-export default editImagePlugin;
-export { TOOL_NAME };

package/src/plugins/presentHtml/helpers.ts

@@ -1,72 +0,0 @@
-// Pure helpers for presentHtml/Preview.vue. Replaces the former
-// `/<[^>]*>/g` + `/\s+/g` regex pair — both flagged by
-// `sonarjs/slow-regex` for backtracking risk — with a single
-// linear walker that produces the exact same output.
-
-/**
- * Produce a short plain-text preview from an HTML fragment:
- *
- * - every `<...>` span (a `<` with a later `>`) is replaced by a
- *   single space
- * - a bare `<` with no matching `>` is kept as a literal character
- *   (matches the old regex, which required both brackets to match)
- * - runs of whitespace are collapsed to one space
- * - the result is trimmed and truncated to `maxLength` characters
- *
- * The walker is O(n) in the input length and does no regex
- * backtracking.
- */
-export function stripHtmlToPreview(html: string, maxLength: number): string {
-  const state: WalkerState = {
-    out: [],
-    // Start as if we just emitted a space so leading whitespace
-    // and a leading tag both get trimmed without a separate pass.
-    lastWasSpace: true,
-  };
-  let i = 0;
-  while (i < html.length) {
-    const char = html[i];
-    if (char === "<") {
-      const close = html.indexOf(">", i + 1);
-      if (close !== -1) {
-        // Real tag span `<...>` — skip it, emit a separator.
-        emitSeparator(state);
-        i = close + 1;
-        continue;
-      }
-      // No closing `>` anywhere after — treat as literal.
-    }
-    emitChar(state, char);
-    i++;
-  }
-  trimTrailingSpace(state.out);
-  return state.out.join("").slice(0, maxLength);
-}
-
-interface WalkerState {
-  out: string[];
-  lastWasSpace: boolean;
-}
-
-function emitChar(state: WalkerState, char: string): void {
-  if (isWhitespace(char)) {
-    emitSeparator(state);
-    return;
-  }
-  state.out.push(char);
-  state.lastWasSpace = false;
-}
-
-function emitSeparator(state: WalkerState): void {
-  if (state.lastWasSpace) return;
-  state.out.push(" ");
-  state.lastWasSpace = true;
-}
-
-function trimTrailingSpace(out: string[]): void {
-  if (out.length > 0 && out[out.length - 1] === " ") out.pop();
-}
-
-function isWhitespace(char: string): boolean {
-  return char === " " || char === "\t" || char === "\n" || char === "\r" || char === "\v" || char === "\f";
-}

package/src/plugins/scheduler/LegacySchedulerView.vue

@@ -1,32 +0,0 @@
-<template>
-  <!-- View-only fallback for chat sessions saved before the
-       manageScheduler split (#824). The legacy tool returned two
-       distinct payload shapes — calendar items vs task records —
-       so we route on shape and mount the matching post-split view.
-       Never produces fresh tool calls (the plugin is not exposed
-       to the LLM); only renders persisted history. -->
-  <AutomationsView v-if="renderAutomations" :selected-result="selectedResult" @update-result="(result) => emit('updateResult', result)" />
-  <CalendarView v-else :selected-result="selectedResult" @update-result="(result) => emit('updateResult', result)" />
-</template>
-
-<script setup lang="ts">
-import { computed } from "vue";
-import type { ToolResultComplete } from "gui-chat-protocol/vue";
-import AutomationsView from "./AutomationsView.vue";
-import CalendarView from "./CalendarView.vue";
-import { isLegacyAutomationsShape } from "./legacyShape";
-import type { SchedulerData } from "./index";
-
-const props = defineProps<{
-  selectedResult?: ToolResultComplete<SchedulerData>;
-}>();
-
-const emit = defineEmits<{ updateResult: [result: ToolResultComplete] }>();
-
-// Shape-based dispatch. Errors on the side of CalendarView when
-// the payload shape is unknown — calendar was the more common
-// pre-split action and the view degrades gracefully on missing
-// fields, while the automations view assumes the task shape and
-// would render an empty Tasks tab.
-const renderAutomations = computed(() => isLegacyAutomationsShape(props.selectedResult?.data));
-</script>