mulmoclaude 0.1.0

package/src/plugins/spreadsheet/engine/functions/text.ts

@@ -0,0 +1,389 @@
+/**
+ * Text Functions
+ */
+
+import { functionRegistry, toString, type FunctionHandler } from "../registry";
+
+const concatenateHandler: FunctionHandler = (args, context) => {
+  if (args.length === 0) throw new Error("CONCATENATE requires at least 1 argument");
+
+  return args
+    .map((arg) => {
+      const value = context.evaluateFormula(arg.trim());
+      return toString(value);
+    })
+    .join("");
+};
+
+const concatHandler: FunctionHandler = concatenateHandler; // Alias
+
+const leftHandler: FunctionHandler = (args, context) => {
+  if (args.length < 1 || args.length > 2) {
+    throw new Error("LEFT requires 1 or 2 arguments");
+  }
+
+  const text = toString(context.evaluateFormula(args[0]));
+  const numChars = args.length === 2 ? Number(context.evaluateFormula(args[1])) : 1;
+
+  return text.substring(0, numChars);
+};
+
+const rightHandler: FunctionHandler = (args, context) => {
+  if (args.length < 1 || args.length > 2) {
+    throw new Error("RIGHT requires 1 or 2 arguments");
+  }
+
+  const text = toString(context.evaluateFormula(args[0]));
+  const numChars = args.length === 2 ? Number(context.evaluateFormula(args[1])) : 1;
+
+  return text.substring(text.length - numChars);
+};
+
+const midHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 3) throw new Error("MID requires 3 arguments");
+
+  const text = toString(context.evaluateFormula(args[0]));
+  const start = Number(context.evaluateFormula(args[1])) - 1; // 1-indexed to 0-indexed
+  const numChars = Number(context.evaluateFormula(args[2]));
+
+  return text.substring(start, start + numChars);
+};
+
+const lenHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 1) throw new Error("LEN requires 1 argument");
+
+  const text = toString(context.evaluateFormula(args[0]));
+  return text.length;
+};
+
+const upperHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 1) throw new Error("UPPER requires 1 argument");
+
+  const text = toString(context.evaluateFormula(args[0]));
+  return text.toUpperCase();
+};
+
+const lowerHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 1) throw new Error("LOWER requires 1 argument");
+
+  const text = toString(context.evaluateFormula(args[0]));
+  return text.toLowerCase();
+};
+
+const properHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 1) throw new Error("PROPER requires 1 argument");
+
+  const text = toString(context.evaluateFormula(args[0]));
+  return text
+    .toLowerCase()
+    .split(" ")
+    .map((word) => (word.length > 0 ? word[0].toUpperCase() + word.slice(1) : ""))
+    .join(" ");
+};
+
+const trimHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 1) throw new Error("TRIM requires 1 argument");
+
+  const text = toString(context.evaluateFormula(args[0]));
+  // Trim leading/trailing spaces and replace multiple spaces with single space
+  return text.trim().replace(/\s+/g, " ");
+};
+
+const substituteHandler: FunctionHandler = (args, context) => {
+  if (args.length < 3 || args.length > 4) {
+    throw new Error("SUBSTITUTE requires 3 or 4 arguments");
+  }
+
+  const text = toString(context.evaluateFormula(args[0]));
+  const oldText = toString(context.evaluateFormula(args[1]));
+  const newText = toString(context.evaluateFormula(args[2]));
+
+  if (args.length === 4) {
+    // Replace specific instance
+    const instance = Number(context.evaluateFormula(args[3]));
+    let count = 0;
+    let index = 0;
+
+    while (index < text.length) {
+      const pos = text.indexOf(oldText, index);
+      if (pos === -1) break;
+
+      count++;
+      if (count === instance) {
+        return text.substring(0, pos) + newText + text.substring(pos + oldText.length);
+      }
+      index = pos + 1;
+    }
+    return text; // Instance not found
+  } else {
+    // Replace all instances
+    return text.split(oldText).join(newText);
+  }
+};
+
+const replaceHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 4) throw new Error("REPLACE requires 4 arguments");
+
+  const oldText = toString(context.evaluateFormula(args[0]));
+  const startPos = Number(context.evaluateFormula(args[1])) - 1; // 1-indexed to 0-indexed
+  const numChars = Number(context.evaluateFormula(args[2]));
+  const newText = toString(context.evaluateFormula(args[3]));
+
+  return oldText.substring(0, startPos) + newText + oldText.substring(startPos + numChars);
+};
+
+const findHandler: FunctionHandler = (args, context) => {
+  if (args.length < 2 || args.length > 3) {
+    throw new Error("FIND requires 2 or 3 arguments");
+  }
+
+  const findText = toString(context.evaluateFormula(args[0]));
+  const withinText = toString(context.evaluateFormula(args[1]));
+  const startPos = args.length === 3 ? Number(context.evaluateFormula(args[2])) - 1 : 0;
+
+  const index = withinText.indexOf(findText, startPos);
+  return index === -1 ? "#VALUE!" : index + 1; // Return 1-indexed position
+};
+
+const searchHandler: FunctionHandler = (args, context) => {
+  if (args.length < 2 || args.length > 3) {
+    throw new Error("SEARCH requires 2 or 3 arguments");
+  }
+
+  const findText = toString(context.evaluateFormula(args[0]));
+  const withinText = toString(context.evaluateFormula(args[1]));
+  const startPos = args.length === 3 ? Number(context.evaluateFormula(args[2])) - 1 : 0;
+
+  // SEARCH is case-insensitive
+  const lowerFind = findText.toLowerCase();
+  const lowerWithin = withinText.toLowerCase();
+
+  const index = lowerWithin.indexOf(lowerFind, startPos);
+  return index === -1 ? "#VALUE!" : index + 1; // Return 1-indexed position
+};
+
+const textHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 2) throw new Error("TEXT requires 2 arguments");
+
+  const value = context.evaluateFormula(args[0]);
+  const format = toString(context.evaluateFormula(args[1])).replace(
+    // eslint-disable -- sonarjs/anchor-precedence
+    /^["']|["']$/g,
+    "",
+  );
+
+  // Simple format code handling
+  if (typeof value === "number") {
+    // Handle common format codes
+    if (format.includes("$")) {
+      const decimals = (format.match(/\.0+/) || [""])[0].length - 1;
+      return "$" + value.toFixed(decimals >= 0 ? decimals : 2);
+    }
+    if (format.includes("%")) {
+      const decimals = (format.match(/\.0+/) || [""])[0].length - 1;
+      return (value * 100).toFixed(decimals >= 0 ? decimals : 2) + "%";
+    }
+    if (format.includes("0")) {
+      const decimals = (format.match(/\.0+/) || [""])[0].length - 1;
+      return value.toFixed(decimals >= 0 ? decimals : 0);
+    }
+  }
+
+  return toString(value);
+};
+
+const valueHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 1) throw new Error("VALUE requires 1 argument");
+
+  const text = toString(context.evaluateFormula(args[0]));
+
+  // Remove currency symbols and commas
+  const cleaned = text.replace(/[$,]/g, "").trim();
+
+  // Handle percentages
+  if (cleaned.includes("%")) {
+    const num = parseFloat(cleaned.replace("%", ""));
+    return isNaN(num) ? "#VALUE!" : num / 100;
+  }
+
+  const num = parseFloat(cleaned);
+  return isNaN(num) ? "#VALUE!" : num;
+};
+
+const exactHandler: FunctionHandler = (args, context) => {
+  if (args.length !== 2) throw new Error("EXACT requires 2 arguments");
+
+  const text1 = toString(context.evaluateFormula(args[0]));
+  const text2 = toString(context.evaluateFormula(args[1]));
+
+  return text1 === text2;
+};
+
+// Register all text functions
+functionRegistry.register({
+  name: "CONCATENATE",
+  handler: concatenateHandler,
+  minArgs: 1,
+  description: "Joins several text strings into one string",
+  examples: ['CONCATENATE("Hello", " ", "World")', "CONCATENATE(A1, B1)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "CONCAT",
+  handler: concatHandler,
+  minArgs: 1,
+  description: "Joins several text strings into one string (same as CONCATENATE)",
+  examples: ['CONCAT("Hello", " ", "World")', "CONCAT(A1, B1)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "LEFT",
+  handler: leftHandler,
+  minArgs: 1,
+  maxArgs: 2,
+  description: "Returns the leftmost characters from a text string",
+  examples: ['LEFT("Hello", 2)', "LEFT(A1, 3)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "RIGHT",
+  handler: rightHandler,
+  minArgs: 1,
+  maxArgs: 2,
+  description: "Returns the rightmost characters from a text string",
+  examples: ['RIGHT("Hello", 2)', "RIGHT(A1, 3)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "MID",
+  handler: midHandler,
+  minArgs: 3,
+  maxArgs: 3,
+  description: "Returns characters from the middle of a text string",
+  examples: ['MID("Hello", 2, 3)', "MID(A1, 1, 5)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "LEN",
+  handler: lenHandler,
+  minArgs: 1,
+  maxArgs: 1,
+  description: "Returns the number of characters in a text string",
+  examples: ['LEN("Hello")', "LEN(A1)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "UPPER",
+  handler: upperHandler,
+  minArgs: 1,
+  maxArgs: 1,
+  description: "Converts text to uppercase",
+  examples: ['UPPER("hello")', "UPPER(A1)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "LOWER",
+  handler: lowerHandler,
+  minArgs: 1,
+  maxArgs: 1,
+  description: "Converts text to lowercase",
+  examples: ['LOWER("HELLO")', "LOWER(A1)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "PROPER",
+  handler: properHandler,
+  minArgs: 1,
+  maxArgs: 1,
+  description: "Capitalizes the first letter of each word",
+  examples: ['PROPER("hello world")', "PROPER(A1)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "TRIM",
+  handler: trimHandler,
+  minArgs: 1,
+  maxArgs: 1,
+  description: "Removes extra spaces from text",
+  examples: ['TRIM("  hello  world  ")', "TRIM(A1)"],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "SUBSTITUTE",
+  handler: substituteHandler,
+  minArgs: 3,
+  maxArgs: 4,
+  description: "Replaces old text with new text in a string",
+  examples: ['SUBSTITUTE("Hello World", "World", "Earth")', 'SUBSTITUTE(A1, "old", "new", 1)'],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "REPLACE",
+  handler: replaceHandler,
+  minArgs: 4,
+  maxArgs: 4,
+  description: "Replaces part of a text string with a different text string",
+  examples: ['REPLACE("Hello World", 7, 5, "Earth")', 'REPLACE(A1, 1, 3, "New")'],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "FIND",
+  handler: findHandler,
+  minArgs: 2,
+  maxArgs: 3,
+  description: "Finds one text string within another (case-sensitive)",
+  examples: ['FIND("o", "Hello")', 'FIND("World", A1)'],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "SEARCH",
+  handler: searchHandler,
+  minArgs: 2,
+  maxArgs: 3,
+  description: "Finds one text string within another (case-insensitive)",
+  examples: ['SEARCH("O", "Hello")', 'SEARCH("world", A1)'],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "TEXT",
+  handler: textHandler,
+  minArgs: 2,
+  maxArgs: 2,
+  description: "Formats a number and converts it to text",
+  examples: ['TEXT(1234.5, "$#,##0.00")', 'TEXT(0.5, "0%")'],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "VALUE",
+  handler: valueHandler,
+  minArgs: 1,
+  maxArgs: 1,
+  description: "Converts a text string to a number",
+  examples: ['VALUE("123")', 'VALUE("$1,234.56")'],
+  category: "Text",
+});
+
+functionRegistry.register({
+  name: "EXACT",
+  handler: exactHandler,
+  minArgs: 2,
+  maxArgs: 2,
+  description: "Checks if two text strings are exactly the same",
+  examples: ['EXACT("Hello", "hello")', "EXACT(A1, B1)"],
+  category: "Text",
+});

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

@@ -0,0 +1,27 @@
+/**
+ * Spreadsheet Engine
+ *
+ * Framework-agnostic spreadsheet calculation engine
+ */
+
+// Export types
+export * from "./types";
+
+// Export utilities
+export * from "./parser";
+export * from "./formatter";
+export * from "./evaluator";
+export * from "./calculator";
+export * from "./formulaRefs";
+export * from "./cellBuilder";
+export * from "./responseDecoder";
+export * from "./jsonCellLocator";
+
+// Export function registry
+export * from "./registry";
+
+// Load all built-in functions
+import "./functions";
+
+// Export main SpreadsheetEngine class
+export { SpreadsheetEngine } from "./engine";

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

@@ -0,0 +1,111 @@
+/**
+ * Locate the start offset of a specific cell value inside a
+ * pretty-printed JSON spreadsheet document. Extracted from
+ * `handleTableClick` in `src/plugins/spreadsheet/View.vue` where the
+ * inline scanner pushed cognitive complexity to 163.
+ *
+ * The scanner walks the raw editor text character-by-character,
+ * tracking string boundaries, bracket depth, and object depth to
+ * find the n-th cell of the m-th row within a named sheet's `data`
+ * array. We deliberately do NOT parse the JSON — we need the
+ * character offset inside the user's text buffer (which may not be
+ * valid JSON mid-edit), so a positional scan is required.
+ *
+ * Pure — no refs, no DOM. Returns -1 if the cell can't be located.
+ * Tested in `test/plugins/spreadsheet/engine/test_jsonCellLocator.ts`.
+ */
+
+// Advance `pos` through `text` until we reach the `rowIndex`-th
+// opening `[` after `startPos` (counting from -1 so the first `[`
+// encountered is index 0). Returns the position just after that
+// opening bracket, or -1 if we ran off the end.
+function findRowOpenBracket(text: string, startPos: number, rowIndex: number): number {
+  let currentRow = -1;
+  let inString = false;
+  for (let i = startPos; i < text.length; i++) {
+    const c = text[i];
+    const prevChar = i > 0 ? text[i - 1] : "";
+    // Track string literal boundaries so that a `[` inside a cell
+    // value like `"has [bracket]"` doesn't get mistaken for a row
+    // opener and throw off the row offset.
+    if (c === '"' && prevChar !== "\\") {
+      inString = !inString;
+      continue;
+    }
+    if (!inString && c === "[") {
+      currentRow++;
+      if (currentRow === rowIndex) return i + 1;
+    }
+  }
+  return -1;
+}
+
+// Starting just inside the row's `[`, scan for the start offset of
+// the `colIndex`-th cell. Tracks string/object/bracket state so
+// commas inside cell objects don't miscounted as cell separators.
+// Returns -1 if the row ends before we reach colIndex.
+function findCellStartWithinRow(text: string, rowStart: number, colIndex: number): number {
+  let currentCol = 0;
+  let inString = false;
+  let inObject = 0;
+  let bracketDepth = 1; // we already stepped past one `[`
+
+  for (let i = rowStart; i < text.length; i++) {
+    const c = text[i];
+    const prevChar = i > 0 ? text[i - 1] : "";
+
+    if (c === '"' && prevChar !== "\\") {
+      inString = !inString;
+    }
+
+    if (!inString) {
+      if (c === "[") bracketDepth++;
+      if (c === "]") {
+        bracketDepth--;
+        if (bracketDepth === 0) return -1; // row ended before colIndex
+      }
+      if (c === "{") inObject++;
+      if (c === "}") inObject--;
+      if (c === "," && inObject === 0 && bracketDepth === 1) {
+        currentCol++;
+      }
+    }
+
+    // Once currentCol matches, skip any structural whitespace /
+    // opening bracket / comma and return the first content char.
+    if (currentCol === colIndex) {
+      if (c !== " " && c !== "\n" && c !== "\t" && c !== "[" && c !== ",") {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+/**
+ * Given the pretty-printed JSON editor text, a sheet name, and
+ * (rowIndex, colIndex), return the character offset of that cell's
+ * JSON token. The returned offset can be fed into
+ * `textarea.setSelectionRange(offset, offset + cellJsonLength)` to
+ * highlight the cell.
+ *
+ * Returns -1 if the sheet isn't found or the (row, col) is out of
+ * range. Never throws.
+ */
+export function findCellJsonPosition(editorText: string, sheetName: string, rowIndex: number, colIndex: number): number {
+  // JSON.stringify escapes embedded quotes/backslashes so the marker
+  // matches the way the sheet name actually appears in editorText.
+  const sheetStartMarker = `"name": ${JSON.stringify(sheetName)}`;
+  const dataStartMarker = `"data": [`;
+
+  const sheetPos = editorText.indexOf(sheetStartMarker);
+  if (sheetPos === -1) return -1;
+
+  const dataPos = editorText.indexOf(dataStartMarker, sheetPos);
+  if (dataPos === -1) return -1;
+
+  const rowStart = findRowOpenBracket(editorText, dataPos + dataStartMarker.length, rowIndex);
+  if (rowStart === -1) return -1;
+
+  return findCellStartWithinRow(editorText, rowStart, colIndex);
+}

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

@@ -0,0 +1,143 @@
+/**
+ * Cell and Range Reference Parsing
+ *
+ * Handles Excel A1 notation parsing and conversion
+ */
+
+import type { CellRef, RangeRef } from "./types";
+
+/**
+ * Convert Excel column letters to 0-based index
+ * A=0, B=1, ..., Z=25, AA=26, etc.
+ *
+ * @param col - Column letters (e.g., "A", "Z", "AA")
+ * @returns 0-based column index
+ */
+export function columnToIndex(col: string): number {
+  let result = 0;
+  for (let i = 0; i < col.length; i++) {
+    result = result * 26 + (col.charCodeAt(i) - 64); // A=1, B=2, etc.
+  }
+  return result - 1; // Convert to 0-based
+}
+
+/**
+ * Convert 0-based index to Excel column letters
+ * 0=A, 1=B, ..., 25=Z, 26=AA, etc.
+ *
+ * @param index - 0-based column index
+ * @returns Column letters (e.g., "A", "Z", "AA")
+ */
+export function indexToColumn(index: number): string {
+  let col = "";
+  let num = index + 1; // Convert to 1-based
+  while (num > 0) {
+    const remainder = (num - 1) % 26;
+    col = String.fromCharCode(65 + remainder) + col;
+    num = Math.floor((num - 1) / 26);
+  }
+  return col;
+}
+
+/**
+ * Parse a cell reference to its components
+ * Supports: A1, $A$1, $A1, A$1, Sheet1!A1, 'My Sheet'!A1
+ *
+ * @param ref - Cell reference string
+ * @returns Parsed cell reference object
+ */
+export function parseCellRef(ref: string): CellRef {
+  let cellRef = ref;
+  let sheetName: string | undefined;
+
+  // Check for cross-sheet reference (e.g., 'Sheet Name'!B2 or Sheet1!B2)
+  const sheetMatch = ref.match(/^(?:'([^']+)'|([^!]+))!(.+)$/);
+  if (sheetMatch) {
+    sheetName = sheetMatch[1] || sheetMatch[2]; // Quoted or unquoted sheet name
+    cellRef = sheetMatch[3]; // Cell reference part
+  }
+
+  // Parse absolute references ($A$1)
+  const absoluteRow = cellRef.includes("$") && cellRef.match(/\$\d+/);
+  const absoluteCol = cellRef.includes("$") && cellRef.match(/\$[A-Z]+/);
+
+  // Remove $ symbols
+  const cleanRef = cellRef.replace(/\$/g, "");
+  const match = cleanRef.match(/^([A-Z]+)(\d+)$/);
+
+  if (!match) {
+    throw new Error(`Invalid cell reference: ${ref}`);
+  }
+
+  const col = columnToIndex(match[1]);
+  const row = parseInt(match[2]) - 1; // 1-indexed to 0-indexed
+
+  const result: CellRef = { row, col };
+
+  if (sheetName) {
+    result.sheet = sheetName;
+  }
+
+  if (absoluteRow || absoluteCol) {
+    result.absolute = {
+      row: !!absoluteRow,
+      col: !!absoluteCol,
+    };
+  }
+
+  return result;
+}
+
+/**
+ * Parse a range reference to its components
+ * Supports: A1:B10, $A$1:$B$10, Sheet1!A1:B10
+ *
+ * @param range - Range reference string
+ * @returns Parsed range reference object
+ */
+export function parseRangeRef(range: string): RangeRef {
+  // Use non-greedy match to improve performance
+  const colonIndex = range.lastIndexOf(":");
+  if (colonIndex === -1) {
+    throw new Error(`Invalid range reference: ${range}`);
+  }
+
+  const start = parseCellRef(range.substring(0, colonIndex));
+  const end = parseCellRef(range.substring(colonIndex + 1));
+
+  return { start, end };
+}
+
+/**
+ * Convert a cell reference object back to A1 notation
+ *
+ * @param ref - Cell reference object
+ * @returns A1 notation string
+ */
+export function cellRefToA1(ref: CellRef): string {
+  const col = indexToColumn(ref.col);
+  const row = ref.row + 1; // 0-based to 1-based
+
+  let result = "";
+
+  if (ref.absolute?.col) {
+    result += "$";
+  }
+  result += col;
+
+  if (ref.absolute?.row) {
+    result += "$";
+  }
+  result += row;
+
+  if (ref.sheet) {
+    // Quote sheet name if it contains spaces
+    if (ref.sheet.includes(" ")) {
+      result = `'${ref.sheet}'!${result}`;
+    } else {
+      result = `${ref.sheet}!${result}`;
+    }
+  }
+
+  return result;
+}