mulmoclaude 0.1.0

package/src/plugins/spreadsheet/engine/registry.ts

@@ -0,0 +1,150 @@
+/**
+ * Spreadsheet Function Registry
+ *
+ * This module provides a registry system for spreadsheet functions,
+ * allowing modular organization and easy extension of formula capabilities.
+ */
+
+import type { CellValue } from "./types";
+export type { CellValue };
+export type CellGetter = (ref: string) => CellValue;
+export type RangeGetter = (range: string) => CellValue[];
+export type RawRangeGetter = (range: string) => CellValue[];
+
+export interface FunctionContext {
+  getCellValue: CellGetter;
+  getRangeValues: RangeGetter;
+  getRangeValuesRaw?: RawRangeGetter;
+  evaluateFormula: (formula: string) => CellValue;
+}
+
+export type FunctionHandler = (args: string[], context: FunctionContext) => CellValue;
+
+export interface FunctionDefinition {
+  name: string;
+  handler: FunctionHandler;
+  minArgs?: number;
+  maxArgs?: number;
+  description?: string;
+  examples?: string[];
+  category?: string;
+}
+
+class FunctionRegistry {
+  private functions = new Map<string, FunctionDefinition>();
+
+  register(def: FunctionDefinition): void {
+    this.functions.set(def.name.toUpperCase(), def);
+  }
+
+  get(name: string): FunctionDefinition | undefined {
+    return this.functions.get(name.toUpperCase());
+  }
+
+  hasFunction(name: string): boolean {
+    return this.functions.has(name.toUpperCase());
+  }
+
+  getAllFunctions(): FunctionDefinition[] {
+    return Array.from(this.functions.values());
+  }
+
+  getFunctionsByCategory(): Map<string, FunctionDefinition[]> {
+    const categories = new Map<string, FunctionDefinition[]>();
+
+    for (const func of Array.from(this.functions.values())) {
+      const category = func.category || "Other";
+      if (!categories.has(category)) {
+        categories.set(category, []);
+      }
+      categories.get(category)!.push(func);
+    }
+
+    return categories;
+  }
+}
+
+export const functionRegistry = new FunctionRegistry();
+
+/**
+ * Helper function to convert a value to a number
+ */
+export function toNumber(value: CellValue): number {
+  if (typeof value === "number") return value;
+
+  // Handle percentage strings like "5%" or "0.4167%"
+  if (typeof value === "string" && value.includes("%")) {
+    const numericPart = value.replace("%", "").trim();
+    const num = parseFloat(numericPart);
+    return isNaN(num) ? 0 : num / 100;
+  }
+
+  // Handle currency strings like "$1,000" or "$1,000.00"
+  if (typeof value === "string" && value.includes("$")) {
+    const numericPart = value.replace(/[$,]/g, "").trim();
+    const num = parseFloat(numericPart);
+    return isNaN(num) ? 0 : num;
+  }
+
+  // Handle comma-separated numbers like "1,000"
+  if (typeof value === "string" && value.includes(",")) {
+    const numericPart = value.replace(/,/g, "").trim();
+    const num = parseFloat(numericPart);
+    return isNaN(num) ? 0 : num;
+  }
+
+  // Handle regular numeric strings
+  const num = parseFloat(String(value));
+  return isNaN(num) ? 0 : num;
+}
+
+/**
+ * Helper function to convert a value to a string
+ */
+export function toString(value: CellValue): string {
+  return String(value);
+}
+
+/**
+ * Helper to parse criteria for conditional functions like COUNTIF, SUMIF
+ * Returns a comparison function that tests if a value matches the criteria
+ */
+export function parseCriteria(criteria: string): (value: CellValue) => boolean {
+  // eslint-disable -- sonarjs/anchor-precedence
+  const trimmedCriteria = criteria.trim().replace(/^["']|["']$/g, "");
+
+  // Check for comparison operators
+  // eslint-disable -- sonarjs/slow-regex
+  const opMatch = trimmedCriteria.match(/^([><=!]+)(.+)$/);
+  if (opMatch) {
+    const [, op, value] = opMatch;
+    const numValue = parseFloat(value);
+
+    switch (op) {
+      case ">":
+        return (v) => toNumber(v) > numValue;
+      case ">=":
+        return (v) => toNumber(v) >= numValue;
+      case "<":
+        return (v) => toNumber(v) < numValue;
+      case "<=":
+        return (v) => toNumber(v) <= numValue;
+      case "=":
+      case "==":
+        return (v) => String(v) === value || toNumber(v) === numValue;
+      case "!=":
+      case "<>":
+        return (v) => String(v) !== value && toNumber(v) !== numValue;
+      default:
+        return () => false;
+    }
+  }
+
+  // Exact match (string or number)
+  return (v) => {
+    const strMatch = String(v) === trimmedCriteria;
+    const numCriteria = parseFloat(trimmedCriteria);
+    const numMatch = !isNaN(numCriteria) && toNumber(v) === numCriteria;
+    return strMatch || numMatch;
+  };
+}

package/src/plugins/spreadsheet/engine/responseDecoder.ts

@@ -0,0 +1,67 @@
+/**
+ * Decode the `/api/files/content` response for a spreadsheet file
+ * into an "ok with sheets" / "error with message" discriminated
+ * union. Extracted from `fetchSheets` in
+ * `src/plugins/spreadsheet/View.vue` where the decision tree was
+ * inlined as several nested try/catch + if branches.
+ *
+ * Pure — no fetch, no refs. Takes the parsed JSON body and returns
+ * a result the caller can pattern-match on. Tested in
+ * `test/plugins/spreadsheet/engine/test_responseDecoder.ts`.
+ */
+
+import type { SheetData } from "./types.js";
+
+/** Shape of the `/api/files/content` response we care about. The
+ *  server returns more fields (kind, size, modifiedMs, …) but this
+ *  decoder only depends on the three that drive branching. */
+export interface FilesContentResponseLike {
+  kind?: string;
+  content?: string;
+  message?: string;
+}
+
+export type DecodeResult = { kind: "ok"; sheets: SheetData[] } | { kind: "error"; message: string };
+
+/**
+ * Turn a parsed `/files/content` body into an OK/error decision:
+ *
+ * - `kind` present and not "text" → error with the server's message
+ *   (e.g. "too-large", "binary"). Spreadsheets only live in text
+ *   JSON files.
+ * - Missing or non-string `content` → error.
+ * - `content` is not valid JSON → error.
+ * - Parsed `content` is not an array → error (server should never
+ *   return a non-array but the guard protects downstream render).
+ * - Otherwise → ok with the sheets array.
+ */
+export function decodeSpreadsheetResponse(body: FilesContentResponseLike): DecodeResult {
+  if (body.kind && body.kind !== "text") {
+    return {
+      kind: "error",
+      message: body.message ?? `Cannot load spreadsheet: ${body.kind}`,
+    };
+  }
+  if (typeof body.content !== "string") {
+    return { kind: "error", message: "Spreadsheet file has no content" };
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body.content);
+  } catch (err) {
+    return {
+      kind: "error",
+      message: `Spreadsheet JSON is malformed: ${err instanceof Error ? err.message : "parse error"}`,
+    };
+  }
+  if (!Array.isArray(parsed)) {
+    return {
+      kind: "error",
+      message: "Spreadsheet content is not an array of sheets",
+    };
+  }
+  // Array.isArray narrows to unknown[]; we trust the server contract
+  // and type the local explicitly rather than using an inline `as`.
+  const sheets: SheetData[] = parsed;
+  return { kind: "ok", sheets };
+}

package/src/plugins/spreadsheet/engine/types.ts

@@ -0,0 +1,64 @@
+/**
+ * Spreadsheet Engine Type Definitions
+ */
+
+export type CellValue = number | string | boolean;
+
+export interface SpreadsheetCell {
+  v: CellValue; // Value or formula (formulas start with "=")
+  f?: string; // Format code (e.g., "$#,##0.00")
+}
+
+export interface SheetData {
+  name: string;
+  data: SpreadsheetCell[][];
+}
+
+export interface CalculatedSheet {
+  name: string;
+  data: CellValue[][]; // Calculated values
+  formulas: FormulaInfo[]; // Formula metadata
+  errors: CalculationError[]; // Any errors encountered
+}
+
+export interface CellRef {
+  row: number;
+  col: number;
+  sheet?: string; // For cross-sheet refs
+  absolute?: {
+    // For $A$1 style
+    row: boolean;
+    col: boolean;
+  };
+}
+
+export interface RangeRef {
+  start: CellRef;
+  end: CellRef;
+}
+
+export interface EvaluationContext {
+  currentSheet: string;
+  sheets: Map<string, SpreadsheetCell[][]>;
+  calculatedValues?: Map<string, CellValue>; // Cache
+}
+
+export interface FormulaInfo {
+  cell: CellRef;
+  formula: string;
+  dependencies: CellRef[];
+  result: CellValue;
+}
+
+export interface CalculationError {
+  cell: CellRef;
+  formula: string;
+  error: string;
+  type: "circular" | "invalid_ref" | "div_zero" | "syntax" | "unknown";
+}
+
+export interface EngineOptions {
+  maxIterations?: number; // For circular reference detection
+  enableCrossSheetRefs?: boolean; // Default: true
+  strictMode?: boolean; // Throw on errors vs. return 0
+}

package/src/plugins/spreadsheet/index.ts

@@ -0,0 +1,36 @@
+import type { ToolPlugin } from "../../tools/types";
+import type { ToolResult } from "gui-chat-protocol";
+import toolDefinition, { TOOL_NAME } from "./definition";
+import type { SpreadsheetToolData } from "./definition";
+import View from "./View.vue";
+import Preview from "./Preview.vue";
+import { apiPost } from "../../utils/api";
+import { API_ROUTES } from "../../config/apiRoutes";
+
+const spreadsheetPlugin: ToolPlugin<SpreadsheetToolData> = {
+  toolDefinition,
+
+  async execute(_context, args) {
+    const result = await apiPost<ToolResult<SpreadsheetToolData>>(API_ROUTES.plugins.presentSpreadsheet, args);
+    if (!result.ok) {
+      return {
+        toolName: TOOL_NAME,
+        uuid: crypto.randomUUID(),
+        message: result.error,
+      };
+    }
+    return {
+      ...result.data,
+      toolName: TOOL_NAME,
+      uuid: crypto.randomUUID(),
+    };
+  },
+
+  isEnabled: () => true,
+  generatingMessage: "Creating spreadsheet...",
+  viewComponent: View,
+  previewComponent: Preview,
+};
+
+export default spreadsheetPlugin;
+export { TOOL_NAME };

package/src/plugins/textResponse/Preview.vue

@@ -0,0 +1,94 @@
+<template>
+  <div class="text-sm leading-snug" :class="textColorClass">
+    <div class="preview-markdown" v-html="renderedMarkdown" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from "vue";
+import { marked } from "marked";
+import type { ToolResultComplete } from "gui-chat-protocol/vue";
+import type { TextResponseData } from "./types";
+
+const props = defineProps<{
+  result: ToolResultComplete<TextResponseData>;
+}>();
+
+const previewText = computed(() => props.result.data?.text ?? "");
+const messageRole = computed(() => props.result.data?.role ?? "assistant");
+
+const textColorClass = computed(() => {
+  switch (messageRole.value) {
+    case "system":
+      return "text-blue-700";
+    case "user":
+      return "text-green-700 font-medium";
+    default:
+      return "text-gray-700";
+  }
+});
+
+const renderedMarkdown = computed(() => marked(previewText.value, { breaks: true, gfm: true }));
+</script>
+
+<style scoped>
+.preview-markdown {
+  overflow: hidden;
+  display: -webkit-box;
+  -webkit-line-clamp: 5;
+  -webkit-box-orient: vertical;
+  /* Links inside v-html would otherwise hijack the row-level
+     select click and navigate to the article URL. */
+  pointer-events: none;
+}
+
+.preview-markdown :deep(p) {
+  margin: 0;
+  display: inline;
+}
+
+.preview-markdown :deep(h1),
+.preview-markdown :deep(h2),
+.preview-markdown :deep(h3),
+.preview-markdown :deep(h4),
+.preview-markdown :deep(h5),
+.preview-markdown :deep(h6) {
+  font-size: inherit;
+  font-weight: bold;
+  display: inline;
+}
+
+.preview-markdown :deep(ul),
+.preview-markdown :deep(ol) {
+  display: inline;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.preview-markdown :deep(li) {
+  display: inline;
+}
+
+.preview-markdown :deep(li)::before {
+  content: "• ";
+}
+
+.preview-markdown :deep(strong) {
+  font-weight: bold;
+}
+
+.preview-markdown :deep(em) {
+  font-style: italic;
+}
+
+.preview-markdown :deep(code) {
+  font-family: monospace;
+  font-size: 0.9em;
+}
+
+.preview-markdown :deep(pre) {
+  display: inline;
+  white-space: pre-wrap;
+}
+</style>