logisheets-logician 1.11.0

package/dist/tools/edit.js

@@ -0,0 +1,356 @@
+/**
+ * Edit tools — modify data in an existing workbook without changing
+ * structure. Use builder tools for create_sheet / create_block /
+ * set_field_rule; use these for "change this value", "fill these in",
+ * "wipe this block". Preview is a dry-run wrapper around a batch of
+ * edits, leveraging the workbook's temp-transaction machinery.
+ */
+import { BlockInputBuilder, DeleteRowsInBlockBuilder, isErrorMessage, } from 'logisheets-web/pure';
+/** Narrow ToolContext.workbook to the concrete `Client` from
+ *  logisheets-web. `WorkbookClient` is a type alias for `Client` —
+ *  this helper hides the cast at call sites. */
+function asClient(ctx) {
+    return ctx.workbook;
+}
+/** Coerce arbitrary JSON values into the string form BlockInput
+ *  expects. Mirrors the helper in builder.ts; lifted here so edit
+ *  handlers don't reach into builder.ts. */
+function stringifyForBlockInput(v) {
+    if (v === null || v === undefined)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return JSON.stringify(v);
+}
+/** Submit one transaction; throw on transport or status='err'. */
+async function commitTransaction(client, payloads, label) {
+    const tx = { payloads, undoable: true, temp: false };
+    const result = await client.handleTransaction({ transaction: tx });
+    if (isErrorMessage(result)) {
+        throw new Error(`${label}: ${result.msg}`);
+    }
+    if (result.status.type === 'err') {
+        throw new Error(`${label}: status code ${result.status.value}`);
+    }
+}
+const BLOCK_CELL_CHANGE_SCHEMA = {
+    type: 'object',
+    properties: {
+        block: { type: 'string' },
+        row_key: {
+            type: 'string',
+            description: "Value of the block's key column.",
+        },
+        field: { type: 'string' },
+        value: {
+            type: ['string', 'number', 'boolean', 'null'],
+            description: 'Cell value. Prefix with "=" to write a formula. null clears.',
+        },
+    },
+    required: ['block', 'row_key', 'field', 'value'],
+};
+export const setBlockCells = {
+    namespace: 'edit',
+    name: 'set_block_cells',
+    description: [
+        'Write one or more cells inside any block(s) in a single atomic transaction. Each change addresses a cell by (block ref name, row_key, field) — the LLM never deals with raw (sheet, row, col).',
+        '',
+        'Pass `changes` as an array; one-cell writes are just length-1 arrays. Batching is the cheap default — putting N writes in one call is one transaction, one calc pass, one undo entry.',
+        '',
+        'Rejected up-front (whole tx aborts) when any change:',
+        '  - targets a non-existent block / row_key / field, or',
+        '  - targets a field with a `value_formula` on its schema (engine-computed; use set_field_rule to change the rule instead).',
+        '',
+        "Value can be a literal (string / number / boolean) or a formula prefixed with '='. `null` clears the cell.",
+    ].join('\n'),
+    mutates: true,
+    confirmation: 'always',
+    inputSchema: {
+        properties: {
+            changes: {
+                type: 'array',
+                items: BLOCK_CELL_CHANGE_SCHEMA,
+                minItems: 1,
+            },
+        },
+        required: ['changes'],
+    },
+    handler: async (input, ctx) => {
+        var _a;
+        const client = asClient(ctx);
+        // 1. Resolve every distinct block ref name once. One workbook-
+        //    wide getAllBlocks is cheaper than N getBlockInfo by id.
+        const allRes = await client.getAllBlocks({});
+        if (isErrorMessage(allRes)) {
+            throw new Error(`getAllBlocks failed: ${allRes.msg}`);
+        }
+        const blockByName = new Map();
+        for (const b of allRes) {
+            if ((_a = b.schema) === null || _a === void 0 ? void 0 : _a.name)
+                blockByName.set(b.schema.name, b);
+        }
+        // 2. Translate each change into a BlockInput payload, failing
+        //    fast on any unresolved reference. We collect ALL payloads
+        //    before committing so a single bad change rejects the whole
+        //    batch (matches the description's "all-or-nothing" promise).
+        const payloads = [];
+        for (let i = 0; i < input.changes.length; i++) {
+            const c = input.changes[i];
+            const block = blockByName.get(c.block);
+            if (!block) {
+                throw new Error(`changes[${i}]: no block with ref name "${c.block}"`);
+            }
+            const schema = block.schema;
+            if (!schema) {
+                throw new Error(`changes[${i}]: block "${c.block}" has no schema`);
+            }
+            const rowEntry = schema.keys.find((k) => k.key === c.row_key);
+            if (!rowEntry) {
+                throw new Error(`changes[${i}]: no row with key "${c.row_key}" in block "${c.block}"`);
+            }
+            const fieldEntry = schema.fields.find((f) => f.field === c.field);
+            if (!fieldEntry) {
+                throw new Error(`changes[${i}]: no field named "${c.field}" in block "${c.block}"`);
+            }
+            // Surface the engine-computed gate up front (the container
+            // layer would silently drop the write otherwise — bad UX for
+            // an LLM that doesn't know why nothing happened).
+            if (typeof fieldEntry.valueFormula === 'string' &&
+                fieldEntry.valueFormula.trim() !== '') {
+                throw new Error(`changes[${i}]: field "${c.field}" on block "${c.block}" has a value_formula — its cells are engine-computed. Use set_field_rule to change the rule.`);
+            }
+            payloads.push({
+                type: 'blockInput',
+                value: new BlockInputBuilder()
+                    .sheetIdx(block.sheetIdx)
+                    .blockId(block.blockId)
+                    .row(rowEntry.idx)
+                    .col(fieldEntry.idx)
+                    .input(stringifyForBlockInput(c.value))
+                    .build(),
+            });
+        }
+        // 3. One atomic transaction.
+        await commitTransaction(client, payloads, `set_block_cells (${payloads.length} change${payloads.length === 1 ? '' : 's'})`);
+        return {
+            data: { applied: payloads.length },
+            display: payloads.length === 1
+                ? `Set ${input.changes[0].block}[${input.changes[0].row_key}].${input.changes[0].field} = ${JSON.stringify(input.changes[0].value)}.`
+                : `Applied ${payloads.length} cell writes in one transaction.`,
+        };
+    },
+};
+export const clearBlock = {
+    namespace: 'edit',
+    name: 'clear_block',
+    description: 'Remove all rows from a block while keeping its schema and rules intact. Useful for resetting a working sheet between scenarios. Pass dry_run=true to count without committing.',
+    mutates: true,
+    confirmation: 'destructive',
+    inputSchema: {
+        properties: {
+            block: { type: 'string' },
+            dry_run: { type: 'boolean', default: false },
+        },
+        required: ['block'],
+    },
+    handler: async (input, ctx) => {
+        const client = asClient(ctx);
+        const allRes = await client.getAllBlocks({});
+        if (isErrorMessage(allRes)) {
+            throw new Error(`getAllBlocks failed: ${allRes.msg}`);
+        }
+        const block = allRes.find((b) => { var _a; return ((_a = b.schema) === null || _a === void 0 ? void 0 : _a.name) === input.block; });
+        if (!block) {
+            throw new Error(`no block with ref name "${input.block}"`);
+        }
+        if (block.rowCnt === 0) {
+            return {
+                data: { rows_cleared: 0 },
+                display: `${input.block} already empty.`,
+            };
+        }
+        if (input.dry_run) {
+            return {
+                data: { rows_cleared: block.rowCnt },
+                display: `dry_run: would clear ${block.rowCnt} rows from ${input.block}.`,
+            };
+        }
+        const payload = {
+            type: 'deleteRowsInBlock',
+            value: new DeleteRowsInBlockBuilder()
+                .sheetIdx(block.sheetIdx)
+                .blockId(block.blockId)
+                .start(0)
+                .cnt(block.rowCnt)
+                .build(),
+        };
+        await commitTransaction(client, [payload], `clear_block(${input.block})`);
+        return {
+            data: { rows_cleared: block.rowCnt },
+            display: `Cleared ${block.rowCnt} row${block.rowCnt === 1 ? '' : 's'} from ${input.block}.`,
+        };
+    },
+};
+export const previewChanges = {
+    namespace: 'edit',
+    name: 'preview_changes',
+    description: 'Dry-run a batch of edits via the workbook\'s temp-transaction branch: returns every cell whose value would change (direct writes + cascaded formula recalcs). Nothing is committed. Use before set_block_cells when the user asks "what would happen if…".',
+    mutates: false,
+    confirmation: 'never',
+    cost: 'normal',
+    inputSchema: {
+        properties: {
+            changes: {
+                type: 'array',
+                items: BLOCK_CELL_CHANGE_SCHEMA,
+                minItems: 1,
+            },
+        },
+        required: ['changes'],
+    },
+    handler: async (input, ctx) => {
+        var _a;
+        const client = asClient(ctx);
+        // Resolve blocks for payload translation + diff annotation.
+        const allRes = await client.getAllBlocks({});
+        if (isErrorMessage(allRes)) {
+            throw new Error(`getAllBlocks failed: ${allRes.msg}`);
+        }
+        const blockByName = new Map();
+        for (const b of allRes) {
+            if ((_a = b.schema) === null || _a === void 0 ? void 0 : _a.name)
+                blockByName.set(b.schema.name, b);
+        }
+        const payloads = [];
+        for (let i = 0; i < input.changes.length; i++) {
+            const c = input.changes[i];
+            const block = blockByName.get(c.block);
+            if (!block) {
+                throw new Error(`changes[${i}]: no block with ref name "${c.block}"`);
+            }
+            const schema = block.schema;
+            if (!schema) {
+                throw new Error(`changes[${i}]: block "${c.block}" has no schema`);
+            }
+            const rowEntry = schema.keys.find((k) => k.key === c.row_key);
+            if (!rowEntry) {
+                throw new Error(`changes[${i}]: no row with key "${c.row_key}" in block "${c.block}"`);
+            }
+            const fieldEntry = schema.fields.find((f) => f.field === c.field);
+            if (!fieldEntry) {
+                throw new Error(`changes[${i}]: no field named "${c.field}" in block "${c.block}"`);
+            }
+            payloads.push({
+                type: 'blockInput',
+                value: new BlockInputBuilder()
+                    .sheetIdx(block.sheetIdx)
+                    .blockId(block.blockId)
+                    .row(rowEntry.idx)
+                    .col(fieldEntry.idx)
+                    .input(stringifyForBlockInput(c.value))
+                    .build(),
+            });
+        }
+        // Run inside a temp branch — toggle on, apply, snapshot diff,
+        // discard. cleanup runs in finally so a mid-flight failure
+        // doesn't leave the workbook stuck in temp mode.
+        const toggleRes = await client.toggleStatus({ useTemp: true });
+        if (isErrorMessage(toggleRes)) {
+            throw new Error(`toggleStatus failed: ${toggleRes.msg}`);
+        }
+        try {
+            const tx = { payloads, undoable: false, temp: true };
+            const result = await client.handleTransaction({ transaction: tx });
+            if (isErrorMessage(result)) {
+                throw new Error(`preview_changes: ${result.msg}`);
+            }
+            if (result.status.type === 'err') {
+                throw new Error(`preview_changes: status code ${result.status.value}`);
+            }
+            const diffRes = await client.getTempStatusChanges();
+            if (isErrorMessage(diffRes)) {
+                throw new Error(`getTempStatusChanges failed: ${diffRes.msg}`);
+            }
+            // Annotate diff entries with block context when the cell
+            // falls inside a known block.
+            const diff = diffRes.cells.map((c) => {
+                var _a, _b, _c;
+                const annot = locateInBlock(c.sheetIdx, c.row, c.col, allRes);
+                return {
+                    block: (_a = annot === null || annot === void 0 ? void 0 : annot.block) !== null && _a !== void 0 ? _a : null,
+                    row_key: (_b = annot === null || annot === void 0 ? void 0 : annot.row_key) !== null && _b !== void 0 ? _b : null,
+                    field: (_c = annot === null || annot === void 0 ? void 0 : annot.field) !== null && _c !== void 0 ? _c : null,
+                    sheet_idx: c.sheetIdx,
+                    row: c.row,
+                    col: c.col,
+                    before: flattenValue(c.oldValue),
+                    after: flattenValue(c.newValue),
+                };
+            });
+            return {
+                data: { diff },
+                display: diff.length === 0
+                    ? 'No cells would change.'
+                    : `${diff.length} cell${diff.length === 1 ? '' : 's'} would change.`,
+            };
+        }
+        finally {
+            await client.cleanupTempStatus();
+        }
+    },
+};
+function flattenValue(v) {
+    if (v === 'empty')
+        return null;
+    switch (v.type) {
+        case 'str':
+            return v.value;
+        case 'number':
+            return v.value;
+        case 'bool':
+            return v.value;
+        case 'error':
+            return `#ERR:${v.value}`;
+    }
+}
+function locateInBlock(sheetIdx, row, col, blocks) {
+    for (const b of blocks) {
+        if (b.sheetIdx !== sheetIdx)
+            continue;
+        if (row < b.rowStart || row >= b.rowStart + b.rowCnt)
+            continue;
+        if (col < b.colStart || col >= b.colStart + b.colCnt)
+            continue;
+        const schema = b.schema;
+        if (!schema)
+            return undefined;
+        const key = schema.keys.find((k) => k.idx === row - b.rowStart);
+        const field = schema.fields.find((f) => f.idx === col - b.colStart);
+        if (key && field) {
+            return { block: schema.name, row_key: key.key, field: field.field };
+        }
+        return undefined;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Design note: no `undo_redo` here.
+//
+// Rationale: the engine's undo stack is shared with the human user
+// (it's what Ctrl-Z/Y drives). Letting the AI step it would silently
+// wipe user actions that landed between AI tx's. The AI's rollback
+// primitive is `build__checkpoint` — labelled, isolated, and itself
+// undoable so the user can reverse an AI restore with a single Ctrl-Z.
+// Users still get standard Ctrl-Z/Y on the canvas; that path is
+// untouched.
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Bundle
+// ---------------------------------------------------------------------------
+export const EDIT_TOOLS = [
+    setBlockCells,
+    clearBlock,
+    previewChanges,
+];

package/dist/tools/format.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Format tools — cell appearance (fill, font, borders, alignment, number
+ * format) and merging. Applies a style to every cell in a range in one
+ * transaction. Colors are accepted as ordinary hex ("#1976D2" or "1976D2");
+ * the engine's two internal color formats (RGB object for fills, 8-hex ARGB
+ * string for fonts/borders) are handled here.
+ */
+import type { Tool } from '../tool.js';
+interface FormatInput {
+    sheetIdx: number;
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+    bold?: boolean;
+    italic?: boolean;
+    fontColor?: string;
+    fontSize?: number;
+    fill?: string;
+    align?: 'left' | 'center' | 'right';
+    valign?: 'top' | 'center' | 'bottom';
+    numberFormat?: string;
+    border?: 'thin' | 'medium' | 'thick' | 'none';
+    borderColor?: string;
+}
+export declare const formatCells: Tool<FormatInput, {
+    formatted: number;
+}>;
+export declare const mergeCells: Tool<{
+    sheetIdx: number;
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+}, {
+    merged: boolean;
+}>;
+export declare const unmergeCells: Tool<{
+    sheetIdx: number;
+    row: number;
+    col: number;
+}, {
+    unmerged: boolean;
+}>;
+export declare const formatBrush: Tool<{
+    srcSheetIdx: number;
+    srcRow: number;
+    srcCol: number;
+    dstSheetIdx: number;
+    dstRowStart: number;
+    dstColStart: number;
+    dstRowEnd: number;
+    dstColEnd: number;
+}, {
+    painted: number;
+}>;
+export declare const FORMAT_TOOLS: Tool[];
+export {};

package/dist/tools/format.js

@@ -0,0 +1,208 @@
+/**
+ * Format tools — cell appearance (fill, font, borders, alignment, number
+ * format) and merging. Applies a style to every cell in a range in one
+ * transaction. Colors are accepted as ordinary hex ("#1976D2" or "1976D2");
+ * the engine's two internal color formats (RGB object for fills, 8-hex ARGB
+ * string for fonts/borders) are handled here.
+ */
+import { isErrorMessage } from 'logisheets-web/pure';
+function asClient(ctx) {
+    return ctx.workbook;
+}
+async function commit(client, payloads, label) {
+    const tx = { payloads, undoable: true, temp: false };
+    const r = await client.handleTransaction({ transaction: tx });
+    if (isErrorMessage(r))
+        throw new Error(`${label}: ${r.msg}`);
+    if (r.status.type === 'err')
+        throw new Error(`${label}: status code ${r.status.value}`);
+}
+/** "#RRGGBB" / "RRGGBB" / "AARRGGBB" → {red,green,blue} (fills). */
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    const rgb = h.length === 8 ? h.slice(2) : h;
+    return {
+        red: parseInt(rgb.slice(0, 2), 16) || 0,
+        green: parseInt(rgb.slice(2, 4), 16) || 0,
+        blue: parseInt(rgb.slice(4, 6), 16) || 0,
+    };
+}
+/** Hex → 8-digit ARGB string, no '#' (fonts/borders). */
+function hexToArgb(hex) {
+    const h = hex.replace('#', '').toUpperCase();
+    if (h.length === 8)
+        return h;
+    if (h.length === 6)
+        return `FF${h}`;
+    return 'FF000000';
+}
+const MAX_RANGE = 500;
+function buildStyle(i) {
+    const ty = {};
+    if (i.bold !== undefined)
+        ty.setFontBold = i.bold;
+    if (i.italic !== undefined)
+        ty.setFontItalic = i.italic;
+    if (i.fontColor)
+        ty.setFontColor = hexToArgb(i.fontColor);
+    if (i.fontSize !== undefined)
+        ty.setFontSize = i.fontSize;
+    if (i.fill)
+        ty.setPatternFill = { patternType: 'solid', fgColor: hexToRgb(i.fill) };
+    if (i.align || i.valign) {
+        const a = {};
+        if (i.align)
+            a.horizontal = i.align;
+        if (i.valign)
+            a.vertical = i.valign;
+        ty.setAlignment = a;
+    }
+    if (i.numberFormat)
+        ty.setNumFmt = i.numberFormat;
+    if (i.border) {
+        const style = i.border;
+        const color = i.borderColor ? hexToArgb(i.borderColor) : 'FF0B0F19';
+        ty.setTopBorderStyle = style;
+        ty.setBottomBorderStyle = style;
+        ty.setLeftBorderStyle = style;
+        ty.setRightBorderStyle = style;
+        if (i.border !== 'none') {
+            ty.setTopBorderColor = color;
+            ty.setBottomBorderColor = color;
+            ty.setLeftBorderColor = color;
+            ty.setRightBorderColor = color;
+        }
+    }
+    return ty;
+}
+export const formatCells = {
+    namespace: 'format',
+    name: 'format_cells',
+    description: [
+        'Apply formatting to every cell in a rectangular range (zero-based sheetIdx/startRow/startCol/endRow/endCol). One transaction, one undo step.',
+        'Set any of: bold, italic, fontColor (hex), fontSize, fill (hex background), align (left|center|right), valign (top|center|bottom), numberFormat (e.g. "0.00", "0%", "$#,##0.00"), border (thin|medium|thick|none) + optional borderColor (hex). Omitted fields are left unchanged.',
+        `At most ${MAX_RANGE} cells per call.`,
+    ].join('\n'),
+    mutates: true,
+    confirmation: 'always',
+    inputSchema: {
+        properties: {
+            sheetIdx: { type: 'integer' },
+            startRow: { type: 'integer' },
+            startCol: { type: 'integer' },
+            endRow: { type: 'integer' },
+            endCol: { type: 'integer' },
+            bold: { type: 'boolean' },
+            italic: { type: 'boolean' },
+            fontColor: { type: 'string', description: 'Hex, e.g. "#1976D2".' },
+            fontSize: { type: 'number' },
+            fill: { type: 'string', description: 'Hex background, e.g. "#FFF3CD".' },
+            align: { type: 'string', enum: ['left', 'center', 'right'] },
+            valign: { type: 'string', enum: ['top', 'center', 'bottom'] },
+            numberFormat: { type: 'string' },
+            border: { type: 'string', enum: ['thin', 'medium', 'thick', 'none'] },
+            borderColor: { type: 'string', description: 'Hex.' },
+        },
+        required: ['sheetIdx', 'startRow', 'startCol', 'endRow', 'endCol'],
+    },
+    handler: async (input, ctx) => {
+        const startRow = Math.min(input.startRow, input.endRow);
+        const endRow = Math.max(input.startRow, input.endRow);
+        const startCol = Math.min(input.startCol, input.endCol);
+        const endCol = Math.max(input.startCol, input.endCol);
+        const count = (endRow - startRow + 1) * (endCol - startCol + 1);
+        if (count > MAX_RANGE)
+            throw new Error(`range covers ${count} cells (max ${MAX_RANGE})`);
+        const ty = buildStyle(input);
+        const payloads = [];
+        for (let row = startRow; row <= endRow; row++)
+            for (let col = startCol; col <= endCol; col++)
+                payloads.push({
+                    type: 'cellStyleUpdate',
+                    value: { sheetIdx: input.sheetIdx, row, col, ty },
+                });
+        await commit(asClient(ctx), payloads, 'format_cells');
+        return { data: { formatted: count }, display: `Formatted ${count} cell(s)` };
+    },
+};
+export const mergeCells = {
+    namespace: 'format',
+    name: 'merge_cells',
+    description: 'Merge a rectangular range of cells into one (zero-based coordinates). The top-left cell keeps its value.',
+    mutates: true,
+    confirmation: 'always',
+    inputSchema: {
+        properties: {
+            sheetIdx: { type: 'integer' },
+            startRow: { type: 'integer' },
+            startCol: { type: 'integer' },
+            endRow: { type: 'integer' },
+            endCol: { type: 'integer' },
+        },
+        required: ['sheetIdx', 'startRow', 'startCol', 'endRow', 'endCol'],
+    },
+    handler: async (input, ctx) => {
+        await commit(asClient(ctx), [{ type: 'mergeCells', value: input }], 'merge_cells');
+        return { data: { merged: true }, display: 'Merged' };
+    },
+};
+export const unmergeCells = {
+    namespace: 'format',
+    name: 'unmerge_cells',
+    description: 'Split a merged region back into individual cells. Pass any cell inside the merged region (zero-based).',
+    mutates: true,
+    confirmation: 'always',
+    inputSchema: {
+        properties: {
+            sheetIdx: { type: 'integer' },
+            row: { type: 'integer' },
+            col: { type: 'integer' },
+        },
+        required: ['sheetIdx', 'row', 'col'],
+    },
+    handler: async (input, ctx) => {
+        await commit(asClient(ctx), [{ type: 'splitMergedCells', value: input }], 'unmerge_cells');
+        return { data: { unmerged: true }, display: 'Unmerged' };
+    },
+};
+export const formatBrush = {
+    namespace: 'format',
+    name: 'format_brush',
+    description: "Copy one source cell's formatting onto a destination range (the format-painter). Only formatting is copied, not values. All coordinates zero-based.",
+    mutates: true,
+    confirmation: 'always',
+    inputSchema: {
+        properties: {
+            srcSheetIdx: { type: 'integer' },
+            srcRow: { type: 'integer' },
+            srcCol: { type: 'integer' },
+            dstSheetIdx: { type: 'integer' },
+            dstRowStart: { type: 'integer' },
+            dstColStart: { type: 'integer' },
+            dstRowEnd: { type: 'integer' },
+            dstColEnd: { type: 'integer' },
+        },
+        required: [
+            'srcSheetIdx',
+            'srcRow',
+            'srcCol',
+            'dstSheetIdx',
+            'dstRowStart',
+            'dstColStart',
+            'dstRowEnd',
+            'dstColEnd',
+        ],
+    },
+    handler: async (input, ctx) => {
+        await commit(asClient(ctx), [{ type: 'cellFormatBrush', value: input }], 'format_brush');
+        const n = (Math.abs(input.dstRowEnd - input.dstRowStart) + 1) *
+            (Math.abs(input.dstColEnd - input.dstColStart) + 1);
+        return { data: { painted: n }, display: `Painted format onto ${n} cell(s)` };
+    },
+};
+export const FORMAT_TOOLS = [
+    formatCells,
+    mergeCells,
+    unmergeCells,
+    formatBrush,
+];

package/dist/tools/history.d.ts

@@ -0,0 +1,13 @@
+/**
+ * History tools — undo / redo the last committed change(s). These operate on
+ * the workbook's own undo stack (the same one Ctrl-Z drives), so they reverse
+ * any edit, whether made by the user or by Watson.
+ */
+import type { Tool } from '../tool.js';
+export declare const undo: Tool<Record<string, never>, {
+    undone: boolean;
+}>;
+export declare const redo: Tool<Record<string, never>, {
+    redone: boolean;
+}>;
+export declare const HISTORY_TOOLS: Tool[];

package/dist/tools/history.js

@@ -0,0 +1,39 @@
+/**
+ * History tools — undo / redo the last committed change(s). These operate on
+ * the workbook's own undo stack (the same one Ctrl-Z drives), so they reverse
+ * any edit, whether made by the user or by Watson.
+ */
+import { isErrorMessage } from 'logisheets-web/pure';
+function asClient(ctx) {
+    return ctx.workbook;
+}
+export const undo = {
+    namespace: 'history',
+    name: 'undo',
+    description: 'Undo the last committed change to the workbook. Returns whether anything was undone (false if the undo stack was empty).',
+    mutates: true,
+    // Undo/redo are inherently reversible — no confirmation needed.
+    confirmation: 'never',
+    inputSchema: { properties: {} },
+    handler: async (_input, ctx) => {
+        const r = await asClient(ctx).undo();
+        if (isErrorMessage(r))
+            throw new Error(`undo: ${r.msg}`);
+        return { data: { undone: r }, display: r ? 'Undone' : 'Nothing to undo' };
+    },
+};
+export const redo = {
+    namespace: 'history',
+    name: 'redo',
+    description: 'Redo the change that was just undone. Returns whether anything was redone.',
+    mutates: true,
+    confirmation: 'never',
+    inputSchema: { properties: {} },
+    handler: async (_input, ctx) => {
+        const r = await asClient(ctx).redo();
+        if (isErrorMessage(r))
+            throw new Error(`redo: ${r.msg}`);
+        return { data: { redone: r }, display: r ? 'Redone' : 'Nothing to redo' };
+    },
+};
+export const HISTORY_TOOLS = [undo, redo];