mulmoclaude 0.4.0 → 0.5.0

package/src/plugins/presentForm/definition.ts

@@ -0,0 +1,127 @@
+/**
+ * Form Tool Definition (Schema)
+ */
+
+import type { ToolDefinition } from "gui-chat-protocol";
+
+export const TOOL_NAME = "presentForm";
+
+export const TOOL_DEFINITION: ToolDefinition = {
+  type: "function",
+  name: TOOL_NAME,
+  description:
+    "Create a structured form to collect information from the user. Supports various field types including text input, textarea, multiple choice (radio), dropdown menus, checkboxes, date/time pickers, and number inputs. Each field can have validation rules and help text.",
+  parameters: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Optional title for the form (e.g., 'User Registration')",
+      },
+      description: {
+        type: "string",
+        description: "Optional description explaining the purpose of the form",
+      },
+      fields: {
+        type: "array",
+        description: "Array of form fields with various types and configurations",
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description:
+                "Unique identifier for the field (e.g., 'email', 'birthdate'). This will be the key in the JSON response. Use descriptive camelCase or snake_case names.",
+            },
+            type: {
+              type: "string",
+              enum: ["text", "textarea", "radio", "dropdown", "checkbox", "date", "time", "number"],
+              description:
+                "Field type: 'text' for short text, 'textarea' for long text, 'radio' for 2-6 choices, 'dropdown' for many choices, 'checkbox' for multiple selections, 'date' for date picker, 'time' for time picker, 'number' for numeric input",
+            },
+            label: {
+              type: "string",
+              description: "Field label shown to the user",
+            },
+            description: {
+              type: "string",
+              description: "Optional help text explaining the field",
+            },
+            required: {
+              type: "boolean",
+              description: "Whether the field is required (default: false)",
+            },
+            placeholder: {
+              type: "string",
+              description: "Placeholder text for text/textarea fields",
+            },
+            validation: {
+              type: "string",
+              description: "For text fields: 'email', 'url', 'phone', or a regex pattern",
+            },
+            minLength: {
+              type: "number",
+              description: "Minimum character length for textarea fields",
+            },
+            maxLength: {
+              type: "number",
+              description: "Maximum character length for textarea fields",
+            },
+            rows: {
+              type: "number",
+              description: "Number of visible rows for textarea (default: 4)",
+            },
+            choices: {
+              type: "array",
+              items: { type: "string" },
+              description: "Array of choices for radio/dropdown/checkbox fields. Radio should have 2-6 choices, dropdown for 7+ choices.",
+            },
+            searchable: {
+              type: "boolean",
+              description: "Make dropdown searchable (for large lists)",
+            },
+            minSelections: {
+              type: "number",
+              description: "Minimum number of selections for checkbox fields",
+            },
+            maxSelections: {
+              type: "number",
+              description: "Maximum number of selections for checkbox fields",
+            },
+            minDate: {
+              type: "string",
+              description: "Minimum date (ISO format: YYYY-MM-DD)",
+            },
+            maxDate: {
+              type: "string",
+              description: "Maximum date (ISO format: YYYY-MM-DD)",
+            },
+            format: {
+              type: "string",
+              description: "Format for time fields: '12hr' or '24hr'",
+            },
+            min: {
+              type: "number",
+              description: "Minimum value for number fields",
+            },
+            max: {
+              type: "number",
+              description: "Maximum value for number fields",
+            },
+            step: {
+              type: "number",
+              description: "Step increment for number fields",
+            },
+            defaultValue: {
+              description:
+                "Optional default/pre-filled value for the field. Type varies by field: string for text/textarea/radio/dropdown/date/time, number for number fields, array of strings for checkbox fields. For radio/dropdown, must be one of the choices. For checkbox, must be a subset of choices.",
+            },
+          },
+          required: ["id", "type", "label"],
+        },
+        minItems: 1,
+      },
+    },
+    required: ["fields"],
+  },
+};

package/src/plugins/presentForm/index.ts

@@ -0,0 +1,18 @@
+import type { ToolPlugin } from "gui-chat-protocol/vue";
+import type { FormData, FormArgs } from "./types";
+import { TOOL_DEFINITION } from "./definition";
+import { executeForm } from "./plugin";
+import View from "./View.vue";
+import Preview from "./Preview.vue";
+
+const presentFormPlugin: ToolPlugin<never, FormData, FormArgs> = {
+  toolDefinition: TOOL_DEFINITION,
+  execute: executeForm,
+  generatingMessage: "Preparing form...",
+  isEnabled: () => true,
+  viewComponent: View,
+  previewComponent: Preview,
+};
+
+export default presentFormPlugin;
+export { TOOL_NAME } from "./definition";

package/src/plugins/presentForm/plugin.ts

@@ -0,0 +1,94 @@
+// Local fork of @mulmochat-plugin/form (originally
+// ~/ss/llm/GUIChatPlugins/MulmoChatPluginForm). Forked so the form
+// submission payload (see View.vue:handleSubmit) renders as readable
+// markdown bullets in the chat history instead of a JSON-wrapped
+// object.
+
+import type { ToolContext, ToolResult } from "gui-chat-protocol";
+import type { FormData, FormArgs, FormField } from "./types";
+
+export { TOOL_NAME, TOOL_DEFINITION } from "./definition";
+
+function validateChoiceField(field: FormField): void {
+  if (field.type === "radio") {
+    if (!Array.isArray(field.choices) || field.choices.length < 2) {
+      throw new Error(`Field '${field.id}': radio fields must have at least 2 choices`);
+    }
+    return;
+  }
+  if (field.type === "dropdown" || field.type === "checkbox") {
+    if (!Array.isArray(field.choices) || field.choices.length < 1) {
+      throw new Error(`Field '${field.id}': ${field.type} fields must have at least 1 choice`);
+    }
+  }
+}
+
+function validateCheckboxRange(field: FormField & { type: "checkbox" }): void {
+  const { minSelections, maxSelections, choices, id } = field;
+  if (minSelections !== undefined && maxSelections !== undefined && minSelections > maxSelections) {
+    throw new Error(`Field '${id}': minSelections cannot be greater than maxSelections`);
+  }
+  if (maxSelections !== undefined && maxSelections > choices.length) {
+    throw new Error(`Field '${id}': maxSelections cannot exceed number of choices`);
+  }
+  // Without this lower-bound check, a form with minSelections > choices.length
+  // would render but be impossible to submit — the user can never satisfy the
+  // minimum because there aren't enough options to pick.
+  if (minSelections !== undefined && minSelections > choices.length) {
+    throw new Error(`Field '${id}': minSelections cannot exceed number of choices`);
+  }
+}
+
+function validateRangeField(field: FormField): void {
+  if (
+    (field.type === "text" || field.type === "textarea") &&
+    field.minLength !== undefined &&
+    field.maxLength !== undefined &&
+    field.minLength > field.maxLength
+  ) {
+    throw new Error(`Field '${field.id}': minLength cannot be greater than maxLength`);
+  }
+  if (field.type === "number" && field.min !== undefined && field.max !== undefined && field.min > field.max) {
+    throw new Error(`Field '${field.id}': min cannot be greater than max`);
+  }
+  if (field.type === "date" && field.minDate && field.maxDate && field.minDate > field.maxDate) {
+    throw new Error(`Field '${field.id}': minDate cannot be after maxDate`);
+  }
+  if (field.type === "checkbox") validateCheckboxRange(field);
+}
+
+function validateField(field: FormField, index: number, seenIds: Set<string>): void {
+  if (!field.id || typeof field.id !== "string") throw new Error(`Field ${index + 1} must have a valid 'id' property`);
+  if (!field.type || typeof field.type !== "string") throw new Error(`Field ${index + 1} must have a valid 'type' property`);
+  if (!field.label || typeof field.label !== "string") throw new Error(`Field ${index + 1} must have a valid 'label' property`);
+  if (seenIds.has(field.id)) throw new Error(`Duplicate field ID: '${field.id}'`);
+  seenIds.add(field.id);
+  validateChoiceField(field);
+  validateRangeField(field);
+}
+
+export const executeForm = async (_context: ToolContext, args: FormArgs): Promise<ToolResult<never, FormData>> => {
+  try {
+    const { title, description, fields } = args;
+    if (!fields || !Array.isArray(fields) || fields.length === 0) {
+      throw new Error("At least one field is required");
+    }
+    const seen = new Set<string>();
+    fields.forEach((field, i) => validateField(field, i, seen));
+
+    const formData: FormData = { title, description, fields };
+    const fieldCount = `${fields.length} field${fields.length > 1 ? "s" : ""}`;
+    const titleSuffix = title ? `: ${title}` : "";
+    return {
+      message: `Form created with ${fieldCount}${titleSuffix}`,
+      jsonData: formData,
+      instructions:
+        "The form has been presented to the user. Wait for the user to fill out and submit it. They will reply with a markdown bullet list of `- {label}: {value}` lines.",
+    };
+  } catch (error) {
+    return {
+      message: `Form error: ${error instanceof Error ? error.message : "Unknown error"}`,
+      instructions: "Acknowledge that there was an error creating the form and suggest trying again with corrected field definitions.",
+    };
+  }
+};

package/src/plugins/presentForm/types.ts

@@ -0,0 +1,109 @@
+/**
+ * Form Plugin Types
+ *
+ * Form-specific type definitions only.
+ * Common types should be imported directly from gui-chat-protocol.
+ */
+
+// ============================================================================
+// Form-specific Types
+// ============================================================================
+
+/** Field type discriminator */
+export type FieldType = "text" | "textarea" | "radio" | "dropdown" | "checkbox" | "date" | "time" | "number";
+
+/** Base field interface */
+export interface BaseField {
+  id: string;
+  type: FieldType;
+  label: string;
+  description?: string;
+  required?: boolean;
+  maxLength?: number;
+}
+
+/** Text field */
+export interface TextField extends BaseField {
+  type: "text";
+  placeholder?: string;
+  validation?: "email" | "url" | "phone" | string;
+  defaultValue?: string;
+  minLength?: number;
+  maxLength?: number;
+}
+
+/** Textarea field */
+export interface TextareaField extends BaseField {
+  type: "textarea";
+  placeholder?: string;
+  minLength?: number;
+  maxLength?: number;
+  rows?: number;
+  defaultValue?: string;
+}
+
+/** Radio field */
+export interface RadioField extends BaseField {
+  type: "radio";
+  choices: string[];
+  defaultValue?: string;
+}
+
+/** Dropdown field */
+export interface DropdownField extends BaseField {
+  type: "dropdown";
+  choices: string[];
+  searchable?: boolean;
+  defaultValue?: string;
+}
+
+/** Checkbox field */
+export interface CheckboxField extends BaseField {
+  type: "checkbox";
+  choices: string[];
+  minSelections?: number;
+  maxSelections?: number;
+  defaultValue?: string[];
+}
+
+/** Date field */
+export interface DateField extends BaseField {
+  type: "date";
+  minDate?: string;
+  maxDate?: string;
+  format?: string;
+  defaultValue?: string;
+}
+
+/** Time field */
+export interface TimeField extends BaseField {
+  type: "time";
+  format?: "12hr" | "24hr";
+  defaultValue?: string;
+}
+
+/** Number field */
+export interface NumberField extends BaseField {
+  type: "number";
+  min?: number;
+  max?: number;
+  step?: number;
+  defaultValue?: number;
+}
+
+/** Union type for all fields */
+export type FormField = TextField | TextareaField | RadioField | DropdownField | CheckboxField | DateField | TimeField | NumberField;
+
+/** Form data stored in result.jsonData */
+export interface FormData {
+  title?: string;
+  description?: string;
+  fields: FormField[];
+}
+
+/** Arguments passed to the form tool */
+export interface FormArgs {
+  title?: string;
+  description?: string;
+  fields: FormField[];
+}

package/src/plugins/presentHtml/index.ts

@@ -5,6 +5,7 @@ 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";
 
 export interface PresentHtmlData {
   html: string;
@@ -20,14 +21,14 @@ const presentHtmlPlugin: ToolPlugin<PresentHtmlData> = {
     if (!result.ok) {
       return {
         toolName: TOOL_NAME,
-        uuid: crypto.randomUUID(),
+        uuid: makeUuid(),
         message: result.error,
       };
     }
     return {
       ...result.data,
       toolName: TOOL_NAME,
-      uuid: crypto.randomUUID(),
+      uuid: makeUuid(),
     };
   },
 

package/src/plugins/presentMulmoScript/index.ts

@@ -6,6 +6,7 @@ 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";
 
 export interface MulmoScriptData {
   script: MulmoScript;
@@ -20,14 +21,14 @@ const presentMulmoScriptPlugin: ToolPlugin<MulmoScriptData> = {
     if (!result.ok) {
       return {
         toolName: TOOL_NAME,
-        uuid: crypto.randomUUID(),
+        uuid: makeUuid(),
         message: result.error,
       };
     }
     return {
       ...result.data,
       toolName: TOOL_NAME,
-      uuid: crypto.randomUUID(),
+      uuid: makeUuid(),
     };
   },
 

package/src/plugins/scheduler/AutomationsPreview.vue

@@ -0,0 +1,37 @@
+<template>
+  <div class="p-2 text-sm">
+    <div class="flex items-center gap-1 font-medium text-gray-700 mb-1">
+      <span aria-hidden="true">{{ t("pluginScheduler.previewIcon") }}</span>
+      <span>{{ t("pluginScheduler.previewAutomations", { count: items.length }) }}</span>
+    </div>
+    <div v-for="item in preview" :key="item.id" class="text-xs truncate text-gray-600">
+      {{ item.title }}
+    </div>
+    <div v-if="more > 0" class="text-xs text-gray-400">{{ t("pluginScheduler.previewMore", { count: more }) }}</div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from "vue";
+import { useI18n } from "vue-i18n";
+import type { ToolResultComplete } from "gui-chat-protocol/vue";
+import type { SchedulerData } from "./index";
+
+// Sidebar preview for `manageAutomations` tool results. Deliberately
+// does NOT auto-refresh from `/api/scheduler` (which returns calendar
+// items, not tasks — see #828 follow-up). The post-action snapshot
+// in `props.result.data.items` is the right thing to show; tasks
+// have their own GET endpoint (`/api/scheduler/tasks`) but the
+// preview is a frozen time-slice of one tool call, so re-fetching
+// would either drift to wrong data (calendar) or duplicate state
+// the AutomationsView already owns.
+
+const { t } = useI18n();
+
+const props = defineProps<{ result: ToolResultComplete<SchedulerData> }>();
+
+const items = computed(() => props.result.data?.items ?? []);
+const PREVIEW_LIMIT = 3;
+const preview = computed(() => items.value.slice(0, PREVIEW_LIMIT));
+const more = computed(() => Math.max(0, items.value.length - PREVIEW_LIMIT));
+</script>

package/src/plugins/scheduler/AutomationsView.vue

@@ -0,0 +1,23 @@
+<template>
+  <!-- Automations mount point used in two places (#758, #824):
+       1. Standalone /automations page — no `selectedResult`, the
+          underlying TasksTab fetches via /api/scheduler/tasks.
+       2. `manageAutomations` chat tool result — `selectedResult`
+          is forwarded so View.vue can pick up task-shaped data.
+       Both modes lock the tab to "tasks" so the legacy tab bar
+       inside SchedulerView stays hidden. -->
+  <SchedulerView :force-tab="SCHEDULER_TAB.tasks" :selected-result="selectedResult" @update-result="(result) => emit('updateResult', result)" />
+</template>
+
+<script setup lang="ts">
+import type { ToolResultComplete } from "gui-chat-protocol/vue";
+import SchedulerView from "./View.vue";
+import { SCHEDULER_TAB } from "./viewModes";
+import type { SchedulerData } from "./index";
+
+defineProps<{
+  selectedResult?: ToolResultComplete<SchedulerData>;
+}>();
+
+const emit = defineEmits<{ updateResult: [result: ToolResultComplete] }>();
+</script>

package/src/plugins/scheduler/CalendarView.vue

@@ -0,0 +1,23 @@
+<template>
+  <!-- Calendar mount point used in two places (#758, #824):
+       1. Standalone /calendar page — no `selectedResult`, View.vue
+          fetches items itself.
+       2. `manageCalendar` chat tool result — `selectedResult` is
+          forwarded so View.vue seeds items from the tool payload.
+       Both modes lock the tab to "calendar" so the legacy tab bar
+       inside SchedulerView stays hidden. -->
+  <SchedulerView :force-tab="SCHEDULER_TAB.calendar" :selected-result="selectedResult" @update-result="(result) => emit('updateResult', result)" />
+</template>
+
+<script setup lang="ts">
+import type { ToolResultComplete } from "gui-chat-protocol/vue";
+import SchedulerView from "./View.vue";
+import { SCHEDULER_TAB } from "./viewModes";
+import type { SchedulerData } from "./index";
+
+defineProps<{
+  selectedResult?: ToolResultComplete<SchedulerData>;
+}>();
+
+const emit = defineEmits<{ updateResult: [result: ToolResultComplete] }>();
+</script>

package/src/plugins/scheduler/LegacySchedulerView.vue

@@ -0,0 +1,32 @@
+<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>

package/src/plugins/scheduler/TasksTab.vue

@@ -104,10 +104,35 @@
             <span v-if="task.state?.nextScheduledAt">{{ t("pluginSchedulerTasks.nextRun", { time: formatShortTime(task.state.nextScheduledAt) }) }}</span>
           </div>
 
-          <!-- Description -->
-          <div v-if="task.description" class="mt-1 text-xs text-gray-400 truncate">
+          <!-- Description (full, not truncated — users need to know what
+               each task actually does). System tasks have only this
+               line; user / skill tasks have an expandable details
+               block below with the prompt + role. -->
+          <div v-if="task.description" class="mt-1 text-xs text-gray-500 whitespace-pre-line">
             {{ task.description }}
           </div>
+
+          <!-- Prompt + role (user / skill tasks only). Collapsed by
+               default to keep the list compact; click to inspect. -->
+          <details v-if="task.prompt" class="mt-2" :data-testid="`scheduler-task-details-${task.id}`">
+            <summary class="text-xs text-gray-500 cursor-pointer select-none hover:text-gray-700">
+              {{ t("pluginSchedulerTasks.detailsToggle") }}
+            </summary>
+            <div class="mt-1.5 space-y-1.5 ml-4">
+              <div v-if="task.roleId" class="text-xs text-gray-600">
+                <span class="font-medium">{{ t("pluginSchedulerTasks.roleLabel") }}:</span>
+                <code class="ml-1 px-1 py-0.5 rounded bg-gray-100 text-gray-700">{{ task.roleId }}</code>
+              </div>
+              <div class="text-xs text-gray-600">
+                <div class="font-medium mb-0.5">{{ t("pluginSchedulerTasks.promptLabel") }}:</div>
+                <pre
+                  class="px-2 py-1.5 rounded bg-gray-50 border border-gray-200 text-gray-700 whitespace-pre-wrap break-words font-mono text-[11px] leading-relaxed"
+                  :data-testid="`scheduler-task-prompt-${task.id}`"
+                  >{{ task.prompt }}</pre
+                >
+              </div>
+            </div>
+          </details>
         </div>
       </div>
     </div>
@@ -115,12 +140,14 @@
 </template>
 
 <script setup lang="ts">
-import { ref, onMounted } from "vue";
+import { ref, onMounted, nextTick, watch } from "vue";
 import { useI18n } from "vue-i18n";
+import { useRoute } from "vue-router";
 import { apiGet, apiPost, apiPut, apiDelete } from "../../utils/api";
 import { API_ROUTES } from "../../config/apiRoutes";
 import { formatShortTime } from "../../utils/format/date";
 import { formatSchedule as formatTaskSchedule, type TaskSchedule as FormatterTaskSchedule } from "./formatSchedule";
+import { scrollIntoViewByTestId } from "../../utils/dom/scrollIntoViewByTestId";
 
 const { t } = useI18n();
 
@@ -144,6 +171,12 @@ interface SchedulerTask {
   origin: string;
   enabled?: boolean;
   state?: TaskState;
+  // user / skill tasks carry the agent prompt + role on the wire;
+  // system tasks omit them (their "what does this do" is the
+  // description text plus the source code behind the id).
+  prompt?: string;
+  roleId?: string;
+  missedRunPolicy?: string;
 }
 
 // Hints showing common task cadences. Stored as structured schedules
@@ -230,5 +263,34 @@ async function deleteTask(taskId: string): Promise<void> {
   await fetchTasks();
 }
 
-onMounted(fetchTasks);
+// When the user lands on /automations/:taskId (e.g. from a
+// notification), fetch the list, then scroll + flash the matching
+// row once it's rendered. Unknown IDs are a no-op — the list still
+// renders normally.
+const route = useRoute();
+
+async function focusUrlTask(taskId: string): Promise<void> {
+  await nextTick();
+  scrollIntoViewByTestId(`scheduler-task-${taskId}`);
+}
+
+onMounted(async () => {
+  await fetchTasks();
+  const urlTaskId = route.params.taskId;
+  if (typeof urlTaskId === "string" && urlTaskId) {
+    await focusUrlTask(urlTaskId);
+  }
+});
+
+// Also react when the user is already on the page and the URL
+// changes (e.g. clicking a second notification without leaving the
+// Automations view).
+watch(
+  () => route.params.taskId,
+  (taskId) => {
+    if (typeof taskId === "string" && taskId) {
+      void focusUrlTask(taskId);
+    }
+  },
+);
 </script>