mulmoclaude 0.1.0

package/src/plugins/todo/index.ts

@@ -0,0 +1,61 @@
+import type { ToolPlugin } from "../../tools/types";
+import type { ToolResult } from "gui-chat-protocol";
+import View from "./View.vue";
+import Preview from "./Preview.vue";
+import toolDefinition from "./definition";
+import { apiPost } from "../../utils/api";
+import { API_ROUTES } from "../../config/apiRoutes";
+
+export type TodoPriority = "low" | "medium" | "high" | "urgent";
+
+export interface TodoItem {
+  id: string;
+  text: string;
+  note?: string;
+  labels?: string[];
+  completed: boolean;
+  createdAt: number;
+  // ── Added for the file-explorer kanban view ──
+  status?: string;
+  priority?: TodoPriority;
+  dueDate?: string;
+  order?: number;
+}
+
+export interface StatusColumn {
+  id: string;
+  label: string;
+  isDone?: boolean;
+}
+
+export interface TodoData {
+  items: TodoItem[];
+  columns?: StatusColumn[];
+}
+
+const todoPlugin: ToolPlugin<TodoData> = {
+  toolDefinition,
+
+  async execute(_context, args) {
+    const result = await apiPost<ToolResult<TodoData>>(API_ROUTES.todos.dispatch, args);
+    if (!result.ok) {
+      return {
+        toolName: "manageTodoList",
+        uuid: crypto.randomUUID(),
+        message: result.error,
+      };
+    }
+    return {
+      ...result.data,
+      toolName: "manageTodoList",
+      uuid: result.data.uuid ?? crypto.randomUUID(),
+    };
+  },
+
+  isEnabled: () => true,
+  generatingMessage: "Managing todos...",
+  viewComponent: View,
+  previewComponent: Preview,
+};
+
+export default todoPlugin;

package/src/plugins/todo/labels.ts

@@ -0,0 +1,163 @@
+// Pure helpers for todo labels. Used by both the server route
+// (server/routes/todos.ts) and the Vue views (View.vue / Preview.vue),
+// so the file is kept free of Node-only and browser-only APIs.
+//
+// Storage contract:
+//   - Labels are case-preserving strings (e.g. "Work", "Groceries")
+//   - Matching / deduplication is case-insensitive
+//   - Whitespace is trimmed and collapsed on normalise
+//   - Empty / whitespace-only labels are rejected
+
+// ── Normalisation and comparison ──────────────────────────────────
+
+// Trim leading/trailing whitespace and collapse internal whitespace
+// runs to single spaces. Returns `null` for empty / whitespace-only
+// input so callers can filter out bad entries at the boundary.
+export function normalizeLabel(raw: string): string | null {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  return collapsed.length > 0 ? collapsed : null;
+}
+
+// Case-insensitive label equality. Both inputs are normalised first
+// so `" Work "` and `"work"` compare equal.
+export function labelsEqual(left: string, right: string): boolean {
+  const normLeft = normalizeLabel(left);
+  const normRight = normalizeLabel(right);
+  if (normLeft === null || normRight === null) return false;
+  return normLeft.toLowerCase() === normRight.toLowerCase();
+}
+
+// ── Colour assignment ─────────────────────────────────────────────
+
+// Eight Tailwind pastel chip styles. Enough visual variety without
+// turning the UI into a rainbow. Every label maps deterministically
+// to one of these via `colorForLabel`.
+export const LABEL_PALETTE: readonly string[] = [
+  "bg-blue-100 text-blue-700",
+  "bg-green-100 text-green-700",
+  "bg-purple-100 text-purple-700",
+  "bg-yellow-100 text-yellow-700",
+  "bg-pink-100 text-pink-700",
+  "bg-indigo-100 text-indigo-700",
+  "bg-red-100 text-red-700",
+  "bg-teal-100 text-teal-700",
+] as const;
+
+// Deterministic colour class for a label. Same label → same colour
+// across sessions and across clients. Case-insensitive so that
+// `"Work"` and `"work"` look identical even if they drift in
+// different items over time.
+export function colorForLabel(label: string): string {
+  const key = label.toLowerCase();
+  let hash = 0;
+  for (let i = 0; i < key.length; i++) {
+    // Classic 31-multiplier string hash. Kept as unsigned via >>> 0
+    // so the modulo at the end doesn't produce negatives.
+    hash = (hash * 31 + key.charCodeAt(i)) >>> 0;
+  }
+  return LABEL_PALETTE[hash % LABEL_PALETTE.length];
+}
+
+// ── Filtering ─────────────────────────────────────────────────────
+
+// OR-semantics filter: return items that have at least one label in
+// `filterLabels`. Matching is case-insensitive. An empty filter list
+// is a pass-through — callers don't need to special-case "no filter"
+// themselves.
+//
+// Items whose `labels` is `undefined` or `[]` are excluded when
+// `filterLabels` is non-empty, since they have nothing to match.
+export function filterByLabels<T extends { labels?: string[] }>(items: readonly T[], filterLabels: readonly string[]): T[] {
+  if (filterLabels.length === 0) return [...items];
+  const wanted = new Set(
+    filterLabels
+      .map(normalizeLabel)
+      .filter((label): label is string => label !== null)
+      .map((label) => label.toLowerCase()),
+  );
+  if (wanted.size === 0) return [...items];
+  return items.filter((item) => {
+    const itemLabels = item.labels ?? [];
+    return itemLabels.some((label) => {
+      const normalized = normalizeLabel(label);
+      return normalized !== null && wanted.has(normalized.toLowerCase());
+    });
+  });
+}
+
+// ── Label inventory ──────────────────────────────────────────────
+
+// Distinct-label summary for the whole collection. Counts are
+// case-insensitive: `"Work"` and `"work"` merge into one row. The
+// displayed form is the first spelling encountered while scanning,
+// which is usually the most recently added item at the top of the
+// list — stable enough in practice and avoids a second full pass.
+//
+// Sorted by count desc, then by the displayed label asc (case-
+// insensitive) for deterministic output.
+export function listLabelsWithCount(items: readonly { labels?: string[] }[]): Array<{ label: string; count: number }> {
+  const groups = new Map<string, { label: string; count: number }>();
+  for (const item of items) {
+    const seenInItem = new Set<string>();
+    for (const raw of item.labels ?? []) {
+      const normalized = normalizeLabel(raw);
+      if (normalized === null) continue;
+      const key = normalized.toLowerCase();
+      // Guard against the same label appearing twice within one item
+      // (shouldn't happen post-mergeLabels but be safe).
+      if (seenInItem.has(key)) continue;
+      seenInItem.add(key);
+      const existing = groups.get(key);
+      if (existing) {
+        existing.count++;
+      } else {
+        groups.set(key, { label: normalized, count: 1 });
+      }
+    }
+  }
+  return [...groups.values()].sort((left, right) => {
+    if (right.count !== left.count) return right.count - left.count;
+    return left.label.toLowerCase() < right.label.toLowerCase() ? -1 : left.label.toLowerCase() > right.label.toLowerCase() ? 1 : 0;
+  });
+}
+
+// ── Set operations (for add_label / remove_label) ────────────────
+
+// Union of `existing` and `adding`, de-duped case-insensitively.
+// Preserves the order of `existing`, then appends newly-introduced
+// labels in the order they appear in `adding`. Normalises both
+// sides (trim/collapse) before comparison and storage.
+export function mergeLabels(existing: readonly string[], adding: readonly string[]): string[] {
+  const result: string[] = [];
+  const seen = new Set<string>();
+  const push = (label: string): void => {
+    const normalized = normalizeLabel(label);
+    if (normalized === null) return;
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    result.push(normalized);
+  };
+  for (const label of existing) push(label);
+  for (const label of adding) push(label);
+  return result;
+}
+
+// Remove `removing` labels from `existing`, case-insensitively.
+// Removing a label that isn't present is a no-op. The order of
+// surviving labels is preserved. Normalises both sides first.
+export function subtractLabels(existing: readonly string[], removing: readonly string[]): string[] {
+  const toRemove = new Set(
+    removing
+      .map(normalizeLabel)
+      .filter((label): label is string => label !== null)
+      .map((label) => label.toLowerCase()),
+  );
+  if (toRemove.size === 0) {
+    return existing.map(normalizeLabel).filter((label): label is string => label !== null);
+  }
+  return existing
+    .map(normalizeLabel)
+    .filter((label): label is string => label !== null)
+    .filter((label) => !toRemove.has(label.toLowerCase()));
+}

package/src/plugins/todo/priority.ts

@@ -0,0 +1,98 @@
+// Pure helpers for the todo `priority` field. Used by the kanban
+// cards, the table view, and any future plugin code that needs to
+// render a priority badge — kept dependency-free so both the server
+// and the browser can import it.
+
+import type { TodoPriority } from "./index";
+
+export const PRIORITY_ORDER: Record<TodoPriority, number> = {
+  low: 0,
+  medium: 1,
+  high: 2,
+  urgent: 3,
+};
+
+// Display label for each priority level. Capitalised so it reads well
+// in chips / dropdowns without further formatting at the call site.
+export const PRIORITY_LABELS: Record<TodoPriority, string> = {
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  urgent: "Urgent",
+};
+
+// Tailwind classes for the priority chip backgrounds. Picked to be
+// distinguishable at small sizes without competing too hard with the
+// label colours from labels.ts.
+export const PRIORITY_CLASSES: Record<TodoPriority, string> = {
+  low: "bg-slate-100 text-slate-600",
+  medium: "bg-sky-100 text-sky-700",
+  high: "bg-orange-100 text-orange-700",
+  urgent: "bg-red-100 text-red-700",
+};
+
+// Tailwind border-color classes for the kanban card left border.
+// Slightly bolder than the chip palette so a card with no labels still
+// shows priority at a glance.
+export const PRIORITY_BORDER: Record<TodoPriority, string> = {
+  low: "border-l-slate-300",
+  medium: "border-l-sky-400",
+  high: "border-l-orange-400",
+  urgent: "border-l-red-500",
+};
+
+export const PRIORITIES: readonly TodoPriority[] = ["low", "medium", "high", "urgent"];
+
+export function isPriority(value: unknown): value is TodoPriority {
+  // Use hasOwnProperty rather than the `in` operator: `in` walks the
+  // prototype chain, so `"toString" in PRIORITY_ORDER` would return
+  // true and incorrectly narrow `"toString"` to TodoPriority. We use
+  // the .call form (rather than Object.hasOwn) because the project's
+  // client tsconfig targets ES2021, and Object.hasOwn is ES2022.
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(PRIORITY_ORDER, value);
+}
+
+// ── due date helpers ─────────────────────────────────────────────
+
+// Returns a Tailwind class string for a due-date badge based on how
+// far the date is from today. The 4 buckets match what GitHub
+// Projects shows in its kanban view.
+export function dueDateClasses(dueDate: string | undefined): string {
+  if (!dueDate) return "";
+  const today = todayISO();
+  if (dueDate < today) return "bg-red-100 text-red-700";
+  if (dueDate === today) return "bg-orange-100 text-orange-700";
+  // Within 3 days?
+  const todayDate = new Date(today);
+  const dueDateObj = new Date(dueDate);
+  const diffDays = Math.round((dueDateObj.getTime() - todayDate.getTime()) / (1000 * 60 * 60 * 24));
+  if (diffDays <= 3) return "bg-yellow-100 text-yellow-700";
+  return "bg-gray-100 text-gray-600";
+}
+
+// Today's date as YYYY-MM-DD in the user's local timezone. Avoiding
+// `toISOString` here on purpose: that returns UTC, which would flip
+// the day boundary for users west of UTC and lead to "due today"
+// flickering at midnight.
+export function todayISO(): string {
+  const now = new Date();
+  const yyyy = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${yyyy}-${month}-${day}`;
+}
+
+// Pretty short label for the kanban card badges. "2026-04-12" →
+// "Apr 12". Year is omitted unless it differs from the current one.
+export function formatDueLabel(dueDate: string | undefined): string {
+  if (!dueDate) return "";
+  const date = new Date(`${dueDate}T00:00:00`);
+  if (Number.isNaN(date.getTime())) return dueDate;
+  const today = new Date();
+  const sameYear = date.getFullYear() === today.getFullYear();
+  return date.toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+    ...(sameYear ? {} : { year: "numeric" }),
+  });
+}

package/src/plugins/todo/viewModes.ts

@@ -0,0 +1,19 @@
+// View mode constants for the Todo Explorer.
+
+export const TODO_VIEW = {
+  kanban: "kanban",
+  table: "table",
+  list: "list",
+} as const;
+
+export type TodoViewMode = (typeof TODO_VIEW)[keyof typeof TODO_VIEW];
+
+export const TODO_VIEW_MODES: {
+  key: TodoViewMode;
+  label: string;
+  icon: string;
+}[] = [
+  { key: TODO_VIEW.kanban, label: "Kanban", icon: "view_kanban" },
+  { key: TODO_VIEW.table, label: "Table", icon: "table_rows" },
+  { key: TODO_VIEW.list, label: "List", icon: "view_list" },
+];

package/src/plugins/ui-image/ImagePreview.vue

@@ -0,0 +1,23 @@
+<template>
+  <div class="min-h-24 flex items-center justify-center">
+    <img v-if="resolvedSrc" :src="resolvedSrc" class="max-w-full h-auto rounded" :alt="alt" />
+    <div v-else class="text-gray-400 text-sm">No image yet</div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from "vue";
+import type { ToolResult } from "gui-chat-protocol/vue";
+import type { ImageToolData } from "./types";
+import { resolveImageSrc } from "../../utils/image/resolve";
+
+const props = withDefaults(
+  defineProps<{
+    result: ToolResult<ImageToolData>;
+    alt?: string;
+  }>(),
+  { alt: "Image" },
+);
+
+const resolvedSrc = computed(() => (props.result.data?.imageData ? resolveImageSrc(props.result.data.imageData) : ""));
+</script>

package/src/plugins/ui-image/ImageView.vue

@@ -0,0 +1,34 @@
+<template>
+  <div class="w-full h-full overflow-y-auto">
+    <div class="min-h-full flex flex-col items-center justify-center p-4">
+      <div v-if="resolvedSrc" class="flex-1 flex items-center justify-center min-h-0">
+        <img :src="resolvedSrc" class="max-w-full max-h-full object-contain rounded" :alt="alt" />
+      </div>
+      <div v-else class="flex-1 flex items-center justify-center text-gray-400 text-sm">No image yet</div>
+      <div v-if="selectedResult.data?.prompt" class="mt-4 p-3 bg-gray-100 rounded-lg max-w-full flex-shrink-0">
+        <p class="text-sm text-gray-700">
+          <span class="font-medium">{{ promptLabel }}:</span>
+          {{ selectedResult.data.prompt }}
+        </p>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from "vue";
+import type { ToolResult } from "gui-chat-protocol/vue";
+import type { ImageToolData } from "./types";
+import { resolveImageSrc } from "../../utils/image/resolve";
+
+const props = withDefaults(
+  defineProps<{
+    selectedResult: ToolResult<ImageToolData>;
+    alt?: string;
+    promptLabel?: string;
+  }>(),
+  { alt: "Image", promptLabel: "Prompt" },
+);
+
+const resolvedSrc = computed(() => (props.selectedResult.data?.imageData ? resolveImageSrc(props.selectedResult.data.imageData) : ""));
+</script>

package/src/plugins/ui-image/index.ts

@@ -0,0 +1,3 @@
+export { default as ImageView } from "./ImageView.vue";
+export { default as ImagePreview } from "./ImagePreview.vue";
+export type { ImageToolData } from "./types";

package/src/plugins/ui-image/types.ts

@@ -0,0 +1,4 @@
+export interface ImageToolData {
+  imageData: string;
+  prompt?: string;
+}

package/src/plugins/wiki/Preview.vue

@@ -0,0 +1,65 @@
+<template>
+  <div class="text-sm">
+    <div class="flex items-center gap-1 font-medium text-gray-700 mb-1">
+      <span class="material-icons" style="font-size: 14px">menu_book</span>
+      <span>{{ label }}</span>
+    </div>
+    <div v-for="entry in previewEntries" :key="entry.slug" class="text-xs text-gray-500 truncate">
+      {{ entry.title }}
+    </div>
+    <div v-if="more > 0" class="text-xs text-gray-400">+ {{ more }} more…</div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import type { ToolResultComplete } from "gui-chat-protocol/vue";
+import type { WikiData, WikiPageEntry } from "./index";
+import { useFreshPluginData } from "../../composables/useFreshPluginData";
+import { API_ROUTES } from "../../config/apiRoutes";
+
+const props = defineProps<{ result: ToolResultComplete<WikiData> }>();
+
+const action = ref(props.result.data?.action ?? "index");
+const title = ref(props.result.data?.title ?? "Wiki");
+const pageEntries = ref<WikiPageEntry[]>(props.result.data?.pageEntries ?? []);
+
+const { refresh } = useFreshPluginData<WikiData>({
+  endpoint: () => API_ROUTES.wiki.base,
+  extract: (json) => (json as { data?: WikiData }).data ?? null,
+  apply: (data) => {
+    // Bug fix (CodeRabbit V1 #6): /api/wiki (no slug) always
+    // returns the index payload. The Preview component is reused
+    // for page / log / lint_report previews as well, so blindly
+    // overwriting action/title/pageEntries would clobber non-index
+    // previews with "Wiki Index" the moment the fetch resolves.
+    // Only apply when this preview is currently showing the index.
+    if (action.value !== "index") return;
+    title.value = data.title ?? "Wiki";
+    pageEntries.value = data.pageEntries ?? [];
+  },
+});
+
+watch(
+  () => props.result.uuid,
+  () => {
+    const d = props.result.data;
+    if (d) {
+      action.value = d.action ?? "index";
+      title.value = d.title ?? "Wiki";
+      pageEntries.value = d.pageEntries ?? [];
+    }
+    void refresh();
+  },
+);
+
+const label = computed(() => {
+  if (action.value === "index") return `Wiki Index (${pageEntries.value.length} pages)`;
+  if (action.value === "log") return "Wiki Log";
+  if (action.value === "lint_report") return "Wiki Lint";
+  return `Wiki: ${title.value}`;
+});
+
+const previewEntries = computed(() => pageEntries.value.slice(0, 3));
+const more = computed(() => Math.max(0, pageEntries.value.length - 3));
+</script>