shortcutxl 0.2.19 → 0.2.21

package/dist/custom/new-sheet/api-overlay.js

@@ -0,0 +1,133 @@
+/**
+ * Agent API overlay — allowlist, tags, and doc overrides for the OS API.
+ *
+ * Only CORE methods go here — these appear in the system prompt.
+ * Everything else is discoverable at runtime via getMethodInfo().
+ *
+ * The generated reference (agent-docs/api-reference.json) contains every
+ * method. This overlay controls what the agent sees upfront.
+ */
+// ========================== WORKSHEET ======================================
+export const WORKSHEET_METHODS = {
+    // --- Identity ---
+    getName: { tags: ['action', 'ask'] },
+    setName: { tags: ['action', 'approval'] },
+    // --- Cell read/write ---
+    setCell: { tags: ['action', 'approval'] },
+    getCell: { tags: ['action', 'ask'] },
+    getValue: { tags: ['action', 'ask'] },
+    getRange: { tags: ['action', 'ask'] },
+    setRange: {
+        tags: ['action', 'approval'],
+        doc: 'Bulk set cell contents. ALWAYS use this instead of setCell() loops for >100 cells.'
+    },
+    getData: { tags: ['action', 'ask'] },
+    getFormula: { tags: ['action', 'ask'] },
+    clearData: { tags: ['action', 'approval'] },
+    // --- LLM presentation ---
+    describe: {
+        tags: ['action', 'ask'],
+        doc: 'Human-readable cell description: "Revenue | =SUM(B2:B10) | [bold]". Prefer over getCell for context.'
+    },
+    describeRange: {
+        tags: ['action', 'ask'],
+        doc: 'Tabular range description with formula abbreviation. Prefer over getRange for reading context.'
+    },
+    summarize: {
+        tags: ['action', 'ask'],
+        doc: 'Sheet overview: name, used range, dimensions, tables, charts, named ranges.'
+    },
+    // --- Query & search ---
+    getUsedRange: { tags: ['action', 'ask'] },
+    findByValue: { tags: ['action', 'ask'] },
+    regexSearch: { tags: ['action', 'ask'] },
+    // --- Sort / batch / autofill ---
+    sortRange: { tags: ['action', 'approval'] },
+    autoFill: { tags: ['action', 'approval'] },
+    batchSetCells: {
+        tags: ['action', 'approval'],
+        doc: 'Batch-write cell values. More efficient than setCell() in a loop.'
+    },
+    // --- Visibility ---
+    isVisible: { tags: ['action', 'ask'] },
+    setVisible: { tags: ['action', 'approval'] },
+    // --- formats (core) ---
+    'formats.set': { tags: ['action', 'approval'] },
+    'formats.setRange': { tags: ['action', 'approval'] },
+    'formats.get': { tags: ['action', 'ask'] },
+    'formats.clear': { tags: ['action', 'approval'] },
+    // --- structure (core) ---
+    'structure.insertRows': { tags: ['action', 'approval'] },
+    'structure.deleteRows': { tags: ['action', 'approval'] },
+    'structure.insertColumns': { tags: ['action', 'approval'] },
+    'structure.deleteColumns': { tags: ['action', 'approval'] },
+    'structure.merge': { tags: ['action', 'approval'] },
+    'structure.unmerge': { tags: ['action', 'approval'] },
+    // --- layout (core) ---
+    'layout.setRowHeight': { tags: ['action', 'approval'] },
+    'layout.setColumnWidth': { tags: ['action', 'approval'] },
+    'layout.autoFitColumn': { tags: ['action', 'approval'] },
+    // --- view (core) ---
+    'view.freezeRows': { tags: ['action', 'approval'] },
+    'view.freezeColumns': { tags: ['action', 'approval'] },
+    'view.unfreeze': { tags: ['action', 'approval'] },
+    'view.setGridlines': { tags: ['action', 'approval'] },
+    // --- comments (core) ---
+    'comments.addNote': { tags: ['action', 'approval'] },
+    'comments.getNote': { tags: ['action', 'ask'] },
+    'comments.removeNote': { tags: ['action', 'approval'] }
+};
+// ========================== WORKBOOK =======================================
+export const WORKBOOK_METHODS = {
+    // --- Sheet access ---
+    getActiveSheet: { tags: ['action', 'ask'] },
+    getSheetByName: { tags: ['action', 'ask'] },
+    getSheetByIndex: { tags: ['action', 'ask'] },
+    getSheetNames: { tags: ['action', 'ask'] },
+    // --- Formula introspection ---
+    getAPIInfo: {
+        tags: ['action', 'ask'],
+        doc: 'Get docs for a spreadsheet formula (e.g. "SUM", "VLOOKUP"). For API method docs, use getMethodInfo() instead.'
+    },
+    // --- Utilities ---
+    indexToAddress: { tags: ['action', 'ask'] },
+    addressToIndex: { tags: ['action', 'ask'] },
+    // --- sheets (core) ---
+    'sheets.add': { tags: ['action', 'approval'] },
+    'sheets.remove': { tags: ['action', 'approval'] },
+    'sheets.rename': { tags: ['action', 'approval'] },
+    'sheets.move': { tags: ['action', 'approval'] },
+    'sheets.copy': { tags: ['action', 'approval'] },
+    // --- history (core) ---
+    'history.undo': { tags: ['action', 'approval'] },
+    'history.redo': { tags: ['action', 'approval'] },
+    // --- names (core) ---
+    'names.add': { tags: ['action', 'approval'] },
+    'names.remove': { tags: ['action', 'approval'] },
+    'names.list': { tags: ['action', 'ask'] }
+};
+export const WORKSHEET_PATCHES = {
+    getValue: {
+        signature: 'getValue(address: string): Promise<CellValue>',
+        docstring: 'Get the computed value of a cell. Returns null for empty cells. Also accepts (row, col) overload.'
+    },
+    getData: {
+        signature: 'getData(): Promise<CellValue[][]>',
+        docstring: 'Get all cell values in the used range as a 2D array. Returns [] if sheet is empty.'
+    },
+    clearData: {
+        signature: 'clearData(range: string): Promise<void>',
+        docstring: 'Clear cell values and formulas in a range, preserving formatting.'
+    },
+    batchSetCells: {
+        signature: 'batchSetCells(updates: Array<{ row: number; col: number; value: any }>): Promise<void>',
+        docstring: 'Batch-write cell values. More efficient than setCell() in a loop.'
+    }
+};
+export const WORKBOOK_PATCHES = {};
+// ---------------------------------------------------------------------------
+// Docstring overrides
+// ---------------------------------------------------------------------------
+export const WORKSHEET_DOC_OVERRIDES = {};
+export const WORKBOOK_DOC_OVERRIDES = {};
+//# sourceMappingURL=api-overlay.js.map

package/dist/custom/new-sheet/api-reference-loader.js

@@ -0,0 +1,29 @@
+/**
+ * Shared loader for agent-docs/api-reference.json.
+ *
+ * Both api-guidelines.ts (system prompt) and api-lookup.ts (runtime sandbox)
+ * need the same parsed JSON. This module loads it once and caches the result.
+ */
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { getPackageDir } from '../../config.js';
+let _cached = null;
+export function loadApiReference() {
+    if (_cached)
+        return _cached;
+    const path = join(getPackageDir(), 'agent-docs', 'api-reference.json');
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        const ifaces = raw.interfaces ?? {};
+        _cached = {
+            Worksheet: ifaces.Worksheet?.functions ?? {},
+            Workbook: ifaces.Workbook?.functions ?? {}
+        };
+    }
+    catch {
+        console.warn(`[api-reference] ${path} not found`);
+        _cached = { Worksheet: {}, Workbook: {} };
+    }
+    return _cached;
+}
+//# sourceMappingURL=api-reference-loader.js.map

package/dist/custom/new-sheet/cell-diff/address-utils.js

@@ -0,0 +1,80 @@
+/**
+ * Excel address utilities — subset copied from client/shared for use without
+ * pulling in the full client/shared dependency.
+ */
+const CELL_REGEX = /^([A-Z]+)([0-9]+)$/;
+export function getColumnLetter(index) {
+    let columnName = '';
+    let dividend = index + 1;
+    let modulo;
+    while (dividend > 0) {
+        modulo = (dividend - 1) % 26;
+        columnName = String.fromCharCode(65 + modulo) + columnName;
+        dividend = Math.floor((dividend - modulo) / 26);
+    }
+    return columnName;
+}
+function extractSheetAndAddress(input) {
+    if (!input.includes('!')) {
+        return { rest: input };
+    }
+    if (input.startsWith("'")) {
+        let i = 1;
+        while (i < input.length) {
+            if (input[i] === "'") {
+                if (i + 1 < input.length && input[i + 1] === "'") {
+                    i += 2;
+                }
+                else {
+                    if (i + 1 < input.length && input[i + 1] === '!') {
+                        const sheetName = input.slice(1, i).replace(/''/g, "'");
+                        const rest = input.slice(i + 2);
+                        return { sheetName, rest };
+                    }
+                    break;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+        return { rest: input };
+    }
+    const bangIndex = input.indexOf('!');
+    const sheetName = input.slice(0, bangIndex);
+    if (!sheetName) {
+        return { rest: input };
+    }
+    return {
+        sheetName,
+        rest: input.slice(bangIndex + 1)
+    };
+}
+export function parseExcelAddress(address) {
+    const { sheetName, rest: cellAddress } = extractSheetAndAddress(address);
+    if (cellAddress.includes('!')) {
+        throw new Error(`Invalid Excel address: ${address}`);
+    }
+    const match = cellAddress.match(CELL_REGEX);
+    if (!match) {
+        throw new Error(`Invalid Excel address: ${address}`);
+    }
+    const colStr = match[1];
+    const rowStr = match[2];
+    let col = -1;
+    for (let i = 0; i < colStr.length; i++) {
+        const v = colStr.charCodeAt(i) - 65;
+        col = (col + 1) * 26 + v;
+    }
+    const row = parseInt(rowStr, 10) - 1;
+    const result = { row, col };
+    if (sheetName) {
+        result.sheetName = sheetName;
+    }
+    return result;
+}
+/** Convert 0-based row/col to A1 notation. */
+export function indexToAddress(row, col) {
+    return `${getColumnLetter(col)}${row + 1}`;
+}
+//# sourceMappingURL=address-utils.js.map

package/dist/custom/new-sheet/cell-diff/cell-categorizer.js

@@ -0,0 +1,100 @@
+/**
+ * Cell categorizer — copied from client/shared/src/lib/platform/utils/cell-categorizer.ts
+ * with imports adjusted for local types.
+ */
+export var IssueType;
+(function (IssueType) {
+    IssueType["UNTAGGED_HARDCODED_NUMBER"] = "hardcodes";
+    IssueType["HARDCODED_NUMBER_IN_FORMULA"] = "hardcodes in formulas";
+    IssueType["LARGE_PERCENTAGE"] = "large %s";
+    IssueType["INVALID_FORMULA"] = "formula errs";
+})(IssueType || (IssueType = {}));
+/** Issues that require MUST FIX prefix */
+export const MUST_FIX_ISSUES = new Set([IssueType.INVALID_FORMULA]);
+export function isHardcodedNumber(cell) {
+    if (cell.formula)
+        return false;
+    const value = cell.value;
+    if (typeof value !== 'number')
+        return false;
+    const format = cell.numberFormat?.toLowerCase() || '';
+    if (format.includes('d') || format.includes('m') || format.includes('y'))
+        return false;
+    if (format.includes('h') || format.includes('s'))
+        return false;
+    if (format.includes('$') || format.includes('¥') || format.includes('€'))
+        return false;
+    return true;
+}
+export function hasHardcodedNumbersInFormula(formula) {
+    const hardcodedNumberPattern = /(?<![A-Z$!])(?<![A-Z]\d*)\b\d+\.?\d*\b(?![A-Z])/i;
+    const formulaWithoutStrings = formula.replace(/"[^"]*"/g, '');
+    return hardcodedNumberPattern.test(formulaWithoutStrings);
+}
+export function hasFormulaError(cell) {
+    // Engine returns errors as { type: 'error', value: 'Div0' | 'Name' | 'Value' | ... }
+    if (cell.value && typeof cell.value === 'object' && cell.value.type === 'error') {
+        return true;
+    }
+    const valueStr = cell.value?.toString() || '';
+    const formulaStr = cell.formula?.toString() || '';
+    const errorPatterns = ['#ERROR', '#REF', '#VALUE', '#DIV/0', '#NUM', '#N/A', '#NAME', '#NULL'];
+    return errorPatterns.some((error) => valueStr.includes(error) || formulaStr.includes(error));
+}
+export function isLargePercentage(cell) {
+    const format = cell.numberFormat || '';
+    if (!format.includes('%'))
+        return false;
+    if (cell.formula)
+        return false;
+    const value = cell.value;
+    if (typeof value !== 'number')
+        return false;
+    return Math.abs(value) >= 1;
+}
+export function categorizeCellIssues(cell) {
+    const issues = [];
+    if (isLargePercentage(cell))
+        issues.push(IssueType.LARGE_PERCENTAGE);
+    if (isHardcodedNumber(cell))
+        issues.push(IssueType.UNTAGGED_HARDCODED_NUMBER);
+    if (cell.formula && hasHardcodedNumbersInFormula(cell.formula))
+        issues.push(IssueType.HARDCODED_NUMBER_IN_FORMULA);
+    if (hasFormulaError(cell))
+        issues.push(IssueType.INVALID_FORMULA);
+    return { cell, issues };
+}
+export function categorizeCells(cells) {
+    const goodCells = [];
+    const largePercentages = [];
+    const hardcodedNumbers = [];
+    const hardcodedNumbersInFormulas = [];
+    const invalidFormulas = [];
+    const allProblemCells = [];
+    for (const cell of cells) {
+        const categorized = categorizeCellIssues(cell);
+        if (categorized.issues.length === 0) {
+            goodCells.push(cell);
+        }
+        else {
+            allProblemCells.push(categorized);
+            if (categorized.issues.includes(IssueType.LARGE_PERCENTAGE))
+                largePercentages.push(categorized);
+            if (categorized.issues.includes(IssueType.UNTAGGED_HARDCODED_NUMBER))
+                hardcodedNumbers.push(categorized);
+            if (categorized.issues.includes(IssueType.HARDCODED_NUMBER_IN_FORMULA))
+                hardcodedNumbersInFormulas.push(categorized);
+            if (categorized.issues.includes(IssueType.INVALID_FORMULA))
+                invalidFormulas.push(categorized);
+        }
+    }
+    return {
+        goodCells,
+        largePercentages,
+        hardcodedNumbers,
+        hardcodedNumbersInFormulas,
+        invalidFormulas,
+        allProblemCells
+    };
+}
+//# sourceMappingURL=cell-categorizer.js.map

package/dist/custom/new-sheet/cell-diff/cell-diff-formatter.js

@@ -0,0 +1,201 @@
+/**
+ * Cell diff formatter — formats categorized dirty cells into a human-readable
+ * summary for the LLM. Adapted from client/shared with simplified output.
+ */
+import { getColumnLetter, parseExcelAddress } from './address-utils.js';
+import { IssueType, MUST_FIX_ISSUES } from './cell-categorizer.js';
+import { shouldIncludeCell } from './types.js';
+const MAX_ROWS_TO_SHOW = 10;
+const MAX_SAMPLES_PER_ROW = 5;
+const UNDEFINED_SYMBOL = '∅';
+// =============================================================================
+// Sampling
+// =============================================================================
+/** Pick first, last, and evenly-spaced items in between. Deterministic. */
+function sampleWithFirstAndLast(items, maxSamples) {
+    if (items.length <= maxSamples)
+        return items;
+    const selected = [0];
+    const lastIndex = items.length - 1;
+    if (maxSamples >= 2)
+        selected.push(lastIndex);
+    const remaining = maxSamples - 2;
+    if (remaining > 0 && items.length > 2) {
+        const step = (lastIndex - 1) / (remaining + 1);
+        for (let i = 0; i < remaining; i++) {
+            selected.push(Math.round(1 + step * (i + 1)));
+        }
+    }
+    const unique = [...new Set(selected)].sort((a, b) => a - b);
+    return unique.map((i) => items[i]);
+}
+// =============================================================================
+// Value formatting
+// =============================================================================
+/** Stringify a raw cell value for display when no engine displayValue is available. */
+function stringifyValue(value) {
+    if (value === undefined || value === null)
+        return UNDEFINED_SYMBOL;
+    if (typeof value === 'string')
+        return value.length === 0 ? UNDEFINED_SYMBOL : value;
+    if (value && typeof value === 'object' && value.type === 'error')
+        return String(value.value);
+    return String(value);
+}
+// TODO: computeBridge.getDisplayValue() returns number instead of string for
+// plain value cells in headless/napi mode (contract says Promise<string>).
+// We work around this by using cellData.formatted from getRange() in
+// mutation-tracker.ts, but if getDisplayValue is ever used again, the kernel
+// bug needs fixing. See: os/kernel/src/bridges/compute/compute-bridge.gen.ts
+export function getDisplayValue(cell) {
+    if (cell.displayValue !== undefined && cell.displayValue !== null) {
+        return cell.displayValue.length === 0 ? UNDEFINED_SYMBOL : cell.displayValue;
+    }
+    return stringifyValue(cell.value);
+}
+function getOldDisplayValue(cell) {
+    if (cell.oldDisplayValue !== undefined && cell.oldDisplayValue !== null) {
+        return cell.oldDisplayValue.length === 0 ? UNDEFINED_SYMBOL : cell.oldDisplayValue;
+    }
+    return stringifyValue(cell.oldValue);
+}
+function collectSortedRows(cells) {
+    const bySheetAndRow = new Map();
+    for (const cell of cells) {
+        if (!shouldIncludeCell(cell))
+            continue;
+        try {
+            const parsed = parseExcelAddress(cell.address);
+            const sheet = cell.sheet || 'Sheet1';
+            if (!bySheetAndRow.has(sheet))
+                bySheetAndRow.set(sheet, new Map());
+            const rowsMap = bySheetAndRow.get(sheet);
+            if (!rowsMap.has(parsed.row))
+                rowsMap.set(parsed.row, []);
+            rowsMap.get(parsed.row).push({ cell, col: parsed.col });
+        }
+        catch {
+            continue;
+        }
+    }
+    // Sort cells within each row by column
+    for (const [, rowsMap] of bySheetAndRow) {
+        for (const [, rowCells] of rowsMap) {
+            rowCells.sort((a, b) => a.col - b.col);
+        }
+    }
+    const allRows = [];
+    for (const [sheet, rowsMap] of bySheetAndRow) {
+        for (const [row, parsedCells] of rowsMap) {
+            allRows.push({ sheet, row, parsedCells });
+        }
+    }
+    allRows.sort((a, b) => {
+        const s = a.sheet.localeCompare(b.sheet);
+        return s !== 0 ? s : a.row - b.row;
+    });
+    return allRows;
+}
+// =============================================================================
+// Row formatting
+// =============================================================================
+function formatRow(sheet, row, parsedCells, indent = 4) {
+    const lines = [];
+    const pad = ' '.repeat(indent);
+    const samplePad = ' '.repeat(indent + 2);
+    const minCol = parsedCells[0].col;
+    const maxCol = parsedCells[parsedCells.length - 1].col;
+    const colRange = minCol === maxCol
+        ? getColumnLetter(minCol)
+        : `${getColumnLetter(minCol)}-${getColumnLetter(maxCol)}`;
+    lines.push(`${pad}${sheet}!Row ${row + 1} (${colRange}): ${parsedCells.length} cells`);
+    const samples = sampleWithFirstAndLast(parsedCells, MAX_SAMPLES_PER_ROW);
+    for (const { cell } of samples) {
+        const oldStr = getOldDisplayValue(cell);
+        const newStr = getDisplayValue(cell);
+        const formulaSuffix = cell.formula ? ` [${cell.formula}]` : '';
+        lines.push(`${samplePad}→ ${cell.address}: ${oldStr} -> ${newStr}${formulaSuffix}`);
+    }
+    if (parsedCells.length > MAX_SAMPLES_PER_ROW) {
+        lines.push(`${samplePad}... and ${parsedCells.length - MAX_SAMPLES_PER_ROW} more cells`);
+    }
+    return lines;
+}
+function formatRows(rows, indent = 4) {
+    const lines = [];
+    const selected = sampleWithFirstAndLast(rows, MAX_ROWS_TO_SHOW);
+    for (const { sheet, row, parsedCells } of selected) {
+        lines.push(...formatRow(sheet, row, parsedCells, indent));
+    }
+    if (rows.length > MAX_ROWS_TO_SHOW) {
+        lines.push(`${' '.repeat(indent)}... and ${rows.length - MAX_ROWS_TO_SHOW} more rows`);
+    }
+    return lines;
+}
+// =============================================================================
+// Section formatters
+// =============================================================================
+function formatSection(cells, title, mustFix = false, indent = 2) {
+    const filtered = cells.filter(shouldIncludeCell);
+    if (filtered.length === 0)
+        return '';
+    const prefix = mustFix ? 'MUST FIX: ' : '';
+    const lines = [];
+    lines.push(`${' '.repeat(indent)}${prefix}${title}: ${filtered.length} total cells`);
+    const rows = collectSortedRows(filtered);
+    lines.push(...formatRows(rows, indent + 2));
+    return lines.join('\n');
+}
+function formatGoodSection(goodCells, indent = 2) {
+    return formatSection(goodCells, 'Changed without issues', false, indent);
+}
+function formatProblemSections(categorized, indent = 2) {
+    if (categorized.allProblemCells.length === 0)
+        return '';
+    const sections = [];
+    const categories = [
+        { cells: categorized.largePercentages, type: IssueType.LARGE_PERCENTAGE },
+        { cells: categorized.hardcodedNumbers, type: IssueType.UNTAGGED_HARDCODED_NUMBER },
+        { cells: categorized.hardcodedNumbersInFormulas, type: IssueType.HARDCODED_NUMBER_IN_FORMULA },
+        { cells: categorized.invalidFormulas, type: IssueType.INVALID_FORMULA }
+    ];
+    for (const { cells, type } of categories) {
+        if (cells.length === 0)
+            continue;
+        const dirtyCells = cells.map((c) => c.cell);
+        const mustFix = MUST_FIX_ISSUES.has(type);
+        const section = formatSection(dirtyCells, type, mustFix, indent);
+        if (section)
+            sections.push(section);
+    }
+    if (sections.length === 0)
+        return '';
+    return `${' '.repeat(indent)}Cells that need review:\n${sections.join('\n\n')}`;
+}
+// =============================================================================
+// Main entry
+// =============================================================================
+export function formatCellDiff(categorizedCells, stringOnlyCount = 0) {
+    const allCells = categorizedCells.goodCells.length + categorizedCells.allProblemCells.length;
+    if (allCells === 0 && stringOnlyCount === 0)
+        return 'No changes made.';
+    const sections = [];
+    sections.push('--- CELL DIFF SUMMARY ---');
+    sections.push(`(${UNDEFINED_SYMBOL} = undefined/empty value)`);
+    const goodSection = formatGoodSection(categorizedCells.goodCells);
+    if (goodSection) {
+        sections.push('');
+        sections.push(goodSection);
+    }
+    const problemSection = formatProblemSections(categorizedCells);
+    if (problemSection) {
+        sections.push('');
+        sections.push(problemSection);
+    }
+    if (stringOnlyCount > 0) {
+        sections.push('');
+        sections.push(`  ${stringOnlyCount} text-only cell(s) not shown.`);
+    }
+    return sections.join('\n');
+}
+//# sourceMappingURL=cell-diff-formatter.js.map

package/dist/custom/new-sheet/cell-diff/index.js

@@ -0,0 +1,23 @@
+/**
+ * Cell diff summary — generates the same formatted dirty cell summary
+ * as client/shared's getDirtyCellSummary.
+ */
+import { categorizeCells } from './cell-categorizer.js';
+import { formatCellDiff } from './cell-diff-formatter.js';
+import { shouldIncludeCell } from './types.js';
+export { categorizeCellIssues, categorizeCells, IssueType } from './cell-categorizer.js';
+export { formatCellDiff } from './cell-diff-formatter.js';
+export { shouldIncludeCell } from './types.js';
+/**
+ * Get a formatted cell diff summary from CellEdits.
+ * Same output format as client/shared's getDirtyCellSummary.
+ */
+export function getDirtyCellSummary(cellEdits) {
+    if (cellEdits.length === 0)
+        return '';
+    // Count cells excluded from the summary (uses the same filter as the formatter)
+    const excludedCount = cellEdits.filter((c) => !shouldIncludeCell(c)).length;
+    const categorizedCells = categorizeCells(cellEdits);
+    return formatCellDiff(categorizedCells, excludedCount);
+}
+//# sourceMappingURL=index.js.map

package/dist/custom/new-sheet/cell-diff/types.js

@@ -0,0 +1,33 @@
+/**
+ * Cell types for mutation tracking and cell-diff formatting.
+ *
+ * TODO: Indirect change tracking — detect formula dependents that recalculate
+ * when a direct cell is mutated. Currently all changes are marked as direct.
+ */
+/**
+ * Returns true if a cell should appear in the diff summary.
+ * Excludes string/label-only cells (no formula, value is a string) since
+ * the LLM can see those in the code. Keeps formulas, numbers, booleans,
+ * and error values.
+ */
+export function shouldIncludeCell(cell) {
+    // Always show formula cells
+    if (cell.formula)
+        return true;
+    // Hide pure label→label changes (LLM can see these in code)
+    if (typeof cell.value === 'string' && typeof cell.oldValue === 'string')
+        return false;
+    // Show numeric and boolean transitions
+    if (typeof cell.value === 'number' || typeof cell.oldValue === 'number')
+        return true;
+    if (typeof cell.value === 'boolean' || typeof cell.oldValue === 'boolean')
+        return true;
+    // Show engine error objects ({ type: 'error', value: 'Div0' | ... })
+    if (cell.value && typeof cell.value === 'object' && cell.value.type === 'error')
+        return true;
+    // Show legacy string error values (#REF!, #DIV/0!, etc.)
+    if (typeof cell.value === 'string' && cell.value.startsWith('#'))
+        return true;
+    return false;
+}
+//# sourceMappingURL=types.js.map