@univerjs-pro/sheets-mcp 0.10.6-experimental.20250904-44da50e

package/lib/types/controllers/config.schema.d.ts

@@ -0,0 +1,5 @@
+export declare const SHEET_MCP_PLUGIN_CONFIG_KEY = "sheet-mcp.config";
+export declare const configSymbol: unique symbol;
+export interface IUniverSheetMCPConfig {
+}
+export declare const defaultPluginConfig: IUniverSheetMCPConfig;

package/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export { UniverSheetMCPPlugin as UniverCDClientPlugin } from './plugin';
+export * from './tools';

package/lib/types/plugin.d.ts

@@ -0,0 +1,12 @@
+import { IUniverSheetMCPConfig } from './controllers/config.schema';
+import { IConfigService, Injector, Plugin, UniverInstanceType } from '@univerjs/core';
+export declare class UniverSheetMCPPlugin extends Plugin {
+    private readonly _config;
+    protected readonly _injector: Injector;
+    private readonly _configService;
+    static pluginName: string;
+    static type: UniverInstanceType;
+    constructor(_config: IUniverSheetMCPConfig | undefined, _injector: Injector, _configService: IConfigService);
+    onStarting(): Promise<void>;
+    onReady(): void;
+}

package/lib/types/services/conditional-format.service.d.ts

@@ -0,0 +1,61 @@
+import { IConditionalFormattingRuleConfig, IConditionFormattingRule } from '@univerjs/sheets-conditional-formatting';
+/**
+ * MCP parameter structure definition
+ * All parameters are flattened and change dynamically according to rule_type/sub_type
+ */
+export interface MCPConditionalFormatParams {
+    rule_id?: string;
+    range?: string;
+    operation?: 'create' | 'update';
+    stop_if_true?: boolean;
+    priority?: number;
+    rule_type?: 'highlightCell' | 'dataBar' | 'colorScale';
+    min_type?: 'num' | 'min' | 'max' | 'percent' | 'percentile' | 'formula';
+    min_value?: number | string;
+    max_type?: 'num' | 'min' | 'max' | 'percent' | 'percentile' | 'formula';
+    max_value?: number | string;
+    positive_color?: string;
+    native_color?: string;
+    is_show_value?: boolean;
+    is_gradient?: boolean;
+    is_bottom?: boolean;
+    is_percent?: boolean;
+    points?: Array<{
+        index: number;
+        color: string;
+        value_type: 'num' | 'min' | 'max' | 'percent' | 'percentile' | 'formula';
+        value?: number | string;
+    }>;
+    sub_type?: 'uniqueValues' | 'duplicateValues' | 'rank' | 'text' | 'timePeriod' | 'number' | 'average' | 'formula';
+    operator?: 'beginsWith' | 'endsWith' | 'containsText' | 'notContainsText' | 'equal' | 'notEqual' | 'containsBlanks' | 'notContainsBlanks' | 'containsErrors' | 'notContainsErrors' | 'today' | 'yesterday' | 'tomorrow' | 'last7Days' | 'thisMonth' | 'lastMonth' | 'nextMonth' | 'thisWeek' | 'lastWeek' | 'nextWeek' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'notBetween' | 'between';
+    value?: number | string | [number, number];
+    formula?: string;
+    style?: {
+        fgColor?: string;
+        bgColor?: string;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+    };
+}
+/**
+ * Conditional Format Converter: MCP parameter structure ↔ IConditionalFormattingRuleConfig
+ */
+export declare class ConditionalFormatConverter {
+    /**
+     * Convert MCP parameters to internal rule configuration
+     */
+    static toInternalConfig(params: MCPConditionalFormatParams): IConditionFormattingRule;
+    /**
+     * Convert internal rule configuration to MCP parameters
+     */
+    static fromInternalConfig<T extends IConditionalFormattingRuleConfig>(config: IConditionFormattingRule<T>): MCPConditionalFormatParams;
+    private static toInternalStyle;
+    private static fromInternalStyle;
+    private static toHighlightCellConfig;
+    private static fromHighlightCellConfig;
+    private static toDataBarConfig;
+    private static fromDataBarConfig;
+    private static toColorScaleConfig;
+    private static fromColorScaleConfig;
+}

package/lib/types/services/data-validation.service.d.ts

@@ -0,0 +1,10 @@
+import { IDataValidationRule } from '@univerjs/core';
+import { IMCPDataValidationRule } from '../tools/format-types';
+export declare class DataValidationConverter {
+    static toInternalConfig(mcpRule: IMCPDataValidationRule): IDataValidationRule;
+    static fromInternalConfig(data: IDataValidationRule): IMCPDataValidationRule;
+    private static columnToIndex;
+    private static indexToColumn;
+    private static generateId;
+    private static parseValue;
+}

package/lib/types/services/numfmt.service.d.ts

@@ -0,0 +1,12 @@
+import { ICellData, IUniverInstanceService } from '@univerjs/core';
+import { INumfmtService, SheetInterceptorService } from '@univerjs/sheets';
+export declare class NumFmtMCPService {
+    private readonly _sheetInterceptorService;
+    private readonly _univerInstanceService;
+    private _numfmtService;
+    constructor(_sheetInterceptorService: SheetInterceptorService, _univerInstanceService: IUniverInstanceService, _numfmtService: INumfmtService);
+    /**
+     * 获取单元格真实数值，按数值格式逻辑处理
+     */
+    getRealValue(unitId: string, sheetId: string, row: number, column: number, cell: ICellData): ICellData;
+}

package/lib/types/tools/common.d.ts

@@ -0,0 +1,105 @@
+import { ICommandService } from '@univerjs/core';
+import { SheetInterceptorService } from '@univerjs/sheets';
+import { z } from 'zod';
+/**
+ * Get UniverAPI instance from globalThis (temporary implementation)
+ */
+export declare function getUniverAPI(): any;
+/**
+ * Get ICommandService instance from UniverAPI injector
+ */
+export declare function getCommandService(): ICommandService;
+/**
+ * Get SheetInterceptorService instance from UniverAPI injector
+ */
+export declare function getSheetInterceptorService(): SheetInterceptorService;
+/**
+ * Parse range string to determine if it's a column range (contains letters) or row range (only numbers)
+ * @param rangeStr Range string like "A:C", "1:5", "A1:B2", etc.
+ * @returns Object with type and parsed range info
+ */
+export declare function parseRangeType(rangeStr: string): {
+    type: 'column' | 'row' | 'mixed';
+    isValid: boolean;
+};
+/**
+ * Convert column letter to number (A=0, B=1, etc.)
+ */
+export declare function columnLetterToNumber(letter: string): number;
+/**
+ * Helper method to handle JS result with error handling
+ */
+export declare function handleJsResult(obj: any, defaultMessage?: string): string;
+/**
+ * Helper method to ensure parameter is integer
+ */
+export declare function ensureInt(value: string | number, paramName: string): number;
+/**
+ * Style object properties for Univer sheets with runtime validation
+ */
+export declare const styleDataSchema: z.ZodObject<{
+    ff: z.ZodOptional<z.ZodString>;
+    fs: z.ZodOptional<z.ZodNumber>;
+    it: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    bl: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    ul: z.ZodOptional<z.ZodObject<{
+        s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        cl: z.ZodString;
+        c: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        t: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    st: z.ZodOptional<z.ZodObject<{
+        s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        cl: z.ZodString;
+        c: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        t: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ol: z.ZodOptional<z.ZodObject<{
+        s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        cl: z.ZodString;
+        c: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        t: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    bg: z.ZodOptional<z.ZodObject<{
+        rgb: z.ZodString;
+    }, z.core.$strip>>;
+    bd: z.ZodOptional<z.ZodObject<{
+        t: z.ZodOptional<z.ZodObject<{
+            s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+            cl: z.ZodString;
+        }, z.core.$strip>>;
+        b: z.ZodOptional<z.ZodObject<{
+            s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+            cl: z.ZodString;
+        }, z.core.$strip>>;
+        l: z.ZodOptional<z.ZodObject<{
+            s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+            cl: z.ZodString;
+        }, z.core.$strip>>;
+        r: z.ZodOptional<z.ZodObject<{
+            s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+            cl: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    cl: z.ZodOptional<z.ZodObject<{
+        rgb: z.ZodString;
+    }, z.core.$strip>>;
+    va: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    tr: z.ZodOptional<z.ZodObject<{
+        a: z.ZodNumber;
+    }, z.core.$strip>>;
+    td: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    ht: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    vt: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    tb: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    pd: z.ZodOptional<z.ZodObject<{
+        t: z.ZodOptional<z.ZodNumber>;
+        b: z.ZodOptional<z.ZodNumber>;
+        l: z.ZodOptional<z.ZodNumber>;
+        r: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    n: z.ZodOptional<z.ZodObject<{
+        pattern: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type StyleData = z.infer<typeof styleDataSchema>;

package/lib/types/tools/conditional-format-tools.d.ts

@@ -0,0 +1,115 @@
+import { IMCPTool } from '@univerjs-pro/mcp';
+import { z } from 'zod';
+export declare const ZodConditionalFormatRuleSchema: z.ZodObject<{
+    rule_id: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodString>;
+    stop_if_true: z.ZodOptional<z.ZodBoolean>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    rule_type: z.ZodOptional<z.ZodEnum<{
+        highlightCell: "highlightCell";
+        dataBar: "dataBar";
+        colorScale: "colorScale";
+    }>>;
+    min_type: z.ZodOptional<z.ZodEnum<{
+        formula: "formula";
+        num: "num";
+        min: "min";
+        max: "max";
+        percent: "percent";
+        percentile: "percentile";
+    }>>;
+    min_value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    max_type: z.ZodOptional<z.ZodEnum<{
+        formula: "formula";
+        num: "num";
+        min: "min";
+        max: "max";
+        percent: "percent";
+        percentile: "percentile";
+    }>>;
+    max_value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    positive_color: z.ZodOptional<z.ZodString>;
+    native_color: z.ZodOptional<z.ZodString>;
+    is_show_value: z.ZodOptional<z.ZodBoolean>;
+    is_gradient: z.ZodOptional<z.ZodBoolean>;
+    is_bottom: z.ZodOptional<z.ZodBoolean>;
+    is_percent: z.ZodOptional<z.ZodBoolean>;
+    points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        color: z.ZodString;
+        value_type: z.ZodEnum<{
+            formula: "formula";
+            num: "num";
+            min: "min";
+            max: "max";
+            percent: "percent";
+            percentile: "percentile";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>>;
+    sub_type: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        text: "text";
+        uniqueValues: "uniqueValues";
+        duplicateValues: "duplicateValues";
+        rank: "rank";
+        timePeriod: "timePeriod";
+        average: "average";
+        formula: "formula";
+    }>>;
+    operator: z.ZodOptional<z.ZodEnum<{
+        endsWith: "endsWith";
+        between: "between";
+        equal: "equal";
+        greaterThan: "greaterThan";
+        greaterThanOrEqual: "greaterThanOrEqual";
+        lessThan: "lessThan";
+        lessThanOrEqual: "lessThanOrEqual";
+        notBetween: "notBetween";
+        notEqual: "notEqual";
+        beginsWith: "beginsWith";
+        containsText: "containsText";
+        notContainsText: "notContainsText";
+        containsBlanks: "containsBlanks";
+        notContainsBlanks: "notContainsBlanks";
+        containsErrors: "containsErrors";
+        notContainsErrors: "notContainsErrors";
+        today: "today";
+        yesterday: "yesterday";
+        tomorrow: "tomorrow";
+        last7Days: "last7Days";
+        thisMonth: "thisMonth";
+        lastMonth: "lastMonth";
+        nextMonth: "nextMonth";
+        thisWeek: "thisWeek";
+        lastWeek: "lastWeek";
+        nextWeek: "nextWeek";
+    }>>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
+    formula: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodObject<{
+        fgColor: z.ZodOptional<z.ZodString>;
+        bgColor: z.ZodOptional<z.ZodString>;
+        bold: z.ZodOptional<z.ZodBoolean>;
+        italic: z.ZodOptional<z.ZodBoolean>;
+        underline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type ConditionalFormatRule = z.infer<typeof ZodConditionalFormatRuleSchema>;
+/**
+ * Add one or more conditional formatting rules to the given sheet
+ */
+export declare function addConditionalFormattingRule(sheet_name: string, rules: ConditionalFormatRule[]): Promise<string>;
+/**
+ * Set (replace) all conditional formatting rules for the given sheet
+ */
+export declare function setConditionalFormattingRule(sheet_name: string, rules: ConditionalFormatRule[]): Promise<string>;
+/**
+ * Delete one or more conditional formatting rules by ID
+ */
+export declare function deleteConditionalFormattingRule(sheet_name: string, rule_ids: string[]): Promise<string>;
+/**
+ * Get all conditional formatting rules for the given sheet
+ */
+export declare function getConditionalFormattingRules(sheet_name: string): Promise<string>;
+export declare const conditionalFormattingTools: IMCPTool[];

package/lib/types/tools/data-validation-tools.d.ts

@@ -0,0 +1,54 @@
+import { IMCPTool } from '@univerjs-pro/mcp';
+import { DataValidationOperator } from '@univerjs/core';
+import { z } from 'zod';
+export declare const dataValidationRuleSchema: z.ZodObject<{
+    rule_id: z.ZodOptional<z.ZodString>;
+    range_a1: z.ZodString;
+    validation_type: z.ZodEnum<{
+        list: "list";
+        date: "date";
+        decimal: "decimal";
+        checkbox: "checkbox";
+        integer: "integer";
+        text_length: "text_length";
+        custom_formula: "custom_formula";
+    }>;
+    operator: z.ZodOptional<z.ZodEnum<typeof DataValidationOperator>>;
+    value1: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    value2: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>>;
+    source: z.ZodOptional<z.ZodString>;
+    allow_multiple: z.ZodOptional<z.ZodBoolean>;
+    custom_formula: z.ZodOptional<z.ZodString>;
+    show_time: z.ZodOptional<z.ZodBoolean>;
+    ignore_blank: z.ZodOptional<z.ZodBoolean>;
+    show_dropdown: z.ZodOptional<z.ZodBoolean>;
+    show_error_message: z.ZodOptional<z.ZodBoolean>;
+    error_style: z.ZodOptional<z.ZodEnum<{
+        information: "information";
+        stop: "stop";
+        warning: "warning";
+    }>>;
+    error_title: z.ZodOptional<z.ZodString>;
+    error_message: z.ZodOptional<z.ZodString>;
+    show_input_message: z.ZodOptional<z.ZodBoolean>;
+    input_title: z.ZodOptional<z.ZodString>;
+    input_message: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type ZodDataValidationRule = z.infer<typeof dataValidationRuleSchema>;
+/**
+ * Add one or more data validation rules to the specified sheet
+ */
+export declare function addDataValidationRule(sheet_name: string, rules: ZodDataValidationRule[]): Promise<string>;
+/**
+ * Set (replace) data validation rules for the specified sheet
+ */
+export declare function setDataValidationRule(sheet_name: string, rules: ZodDataValidationRule[]): Promise<string>;
+/**
+ * Delete one or more data validation rules by ID
+ */
+export declare function deleteDataValidationRule(sheet_name: string, rule_ids: string[]): Promise<string>;
+/**
+ * Get all data validation rules for the specified sheet
+ */
+export declare function getDataValidationRules(sheet_name: string): Promise<string>;
+export declare const dataValidationTools: IMCPTool[];

package/lib/types/tools/error-utils.d.ts

@@ -0,0 +1,10 @@
+import { ISheetFormulaError } from '@univerjs/engine-formula';
+import { IDataValidationError } from '@univerjs/sheets-data-validation/facade';
+/**
+ * Get lint errors from formula errors and data validation errors
+ */
+export declare function getLintErrors(formulaErrors: ISheetFormulaError[], dataValidationErrors: IDataValidationError[]): string;
+/**
+ * Get comprehensive lint errors from workbook
+ */
+export declare function getWorkbookLintErrors(): Promise<string>;

package/lib/types/tools/format-types.d.ts

@@ -0,0 +1,104 @@
+import { DataValidationOperator } from '@univerjs/core';
+/**
+ * MCP Conditional Format Parameters
+ * All parameters are flattened and change dynamically based on rule_type/sub_type
+ */
+export interface MCPConditionalFormatParams {
+    rule_id?: string;
+    range?: string;
+    operation?: 'create' | 'update';
+    stop_if_true?: boolean;
+    priority?: number;
+    rule_type?: 'highlightCell' | 'dataBar' | 'colorScale';
+    min_type?: 'num' | 'min' | 'max' | 'percent' | 'percentile' | 'formula';
+    min_value?: number | string;
+    max_type?: 'num' | 'min' | 'max' | 'percent' | 'percentile' | 'formula';
+    max_value?: number | string;
+    positive_color?: string;
+    native_color?: string;
+    is_show_value?: boolean;
+    is_gradient?: boolean;
+    is_bottom?: boolean;
+    is_percent?: boolean;
+    points?: Array<{
+        index: number;
+        color: string;
+        value_type: 'num' | 'min' | 'max' | 'percent' | 'percentile' | 'formula';
+        value?: number | string;
+    }>;
+    sub_type?: 'uniqueValues' | 'duplicateValues' | 'rank' | 'text' | 'timePeriod' | 'number' | 'average' | 'formula';
+    operator?: 'beginsWith' | 'endsWith' | 'containsText' | 'notContainsText' | 'equal' | 'notEqual' | 'containsBlanks' | 'notContainsBlanks' | 'containsErrors' | 'notContainsErrors' | 'today' | 'yesterday' | 'tomorrow' | 'last7Days' | 'thisMonth' | 'lastMonth' | 'nextMonth' | 'thisWeek' | 'lastWeek' | 'nextWeek' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'notBetween' | 'between';
+    value?: number | string | [number, number];
+    formula?: string;
+    style?: {
+        fgColor?: string;
+        bgColor?: string;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+    };
+}
+/**
+ * MCP Data Validation Rule Interface
+ */
+export interface IMCPDataValidationRule {
+    /** Rule ID. If not provided when creating, a random string will be used */
+    rule_id?: string;
+    /** A1 range, multiple ranges separated by commas */
+    range_a1: string;
+    /** Validation type */
+    validation_type: 'list' | 'integer' | 'decimal' | 'date' | 'text_length' | 'custom_formula' | 'checkbox';
+    /**
+     * Operator for validation. Used in combination with validation_type in ["integer", "decimal", "date", "time", "text_length"], not required.
+     * Excel standard enum:
+     *   Range: "between", "notBetween"
+     *   Single value: "equal", "notEqual", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual"
+     * Note: Ignored for validation_type="list" or "custom_formula".
+     * No default value; set only when more complex validation is needed.
+     */
+    operator?: DataValidationOperator;
+    /**
+     * First value required by the operator. Required if operator is set.
+     * Format depends on validation_type:
+     *   - integer/decimal: number (e.g. 10)
+     *   - date: ISO string (e.g. "2023-01-01")
+     *   - text_length: number (e.g. 5)
+     * Renamed from min_value for clarity.
+     */
+    value1?: number | string;
+    /**
+     * Second value required by the operator. Required only if operator is "between" or "notBetween".
+     * Format same as value1.
+     * Must be null or omitted for other operators.
+     * Renamed from max_value for clarity.
+     */
+    value2?: number | string | null;
+    /** List source, only valid when validation_type="list". Comma-separated string or cell range */
+    source?: string;
+    /** Custom formula, only valid when validation_type="custom_formula" */
+    custom_formula?: string;
+    /** Ignore blank (optional) */
+    ignore_blank?: boolean;
+    /** Show dropdown (optional) */
+    show_dropdown?: boolean;
+    /** Allow multiple selection, only valid when validation_type="list". Univer specific property */
+    allow_multiple?: boolean;
+    /** Show time in date picker, only valid when validation_type="date". Univer specific property */
+    show_time?: boolean;
+    /** Error handling */
+    /** Show error message (optional), default true */
+    show_error_message?: boolean;
+    /** Error style, default is stop */
+    error_style?: 'stop' | 'warning' | 'information';
+    /** Error title (optional) */
+    error_title?: string;
+    /** Error message (optional), default is Invalid input */
+    error_message?: string;
+    /** Input prompt */
+    /** Show input prompt message (optional), default true */
+    show_input_message?: boolean;
+    /** Input prompt title (optional) */
+    input_title?: string;
+    /** Input prompt message (optional), default is empty */
+    input_message?: string;
+}

package/lib/types/tools/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Central export file for all MCP tools
+ */
+export { conditionalFormattingTools } from './conditional-format-tools';
+export { dataValidationTools } from './data-validation-tools';
+export { rangeOperationTools } from './range-operations';
+export { rowColumnOperationTools } from './row-column-operations';
+export { sheetManagementTools } from './sheet-management';
+export { utilityTools } from './utility-tools';
+export declare const allSheetTools: import('@univerjs-pro/mcp').IMCPTool[];

package/lib/types/tools/range-operations.d.ts

@@ -0,0 +1,89 @@
+import { IMCPTool } from '@univerjs-pro/mcp';
+import { z } from 'zod';
+export declare const batchRangeDataItemSchema: z.ZodObject<{
+    range: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodAny>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+}, z.core.$strip>;
+export declare const batchRangeStyleItemSchema: z.ZodObject<{
+    range: z.ZodString;
+    style: z.ZodObject<{
+        ff: z.ZodOptional<z.ZodString>;
+        fs: z.ZodOptional<z.ZodNumber>;
+        it: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        bl: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        ul: z.ZodOptional<z.ZodObject<{
+            s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+            cl: z.ZodString;
+            c: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+            t: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        st: z.ZodOptional<z.ZodObject<{
+            s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+            cl: z.ZodString;
+            c: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+            t: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        ol: z.ZodOptional<z.ZodObject<{
+            s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+            cl: z.ZodString;
+            c: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+            t: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        bg: z.ZodOptional<z.ZodObject<{
+            rgb: z.ZodString;
+        }, z.core.$strip>>;
+        bd: z.ZodOptional<z.ZodObject<{
+            t: z.ZodOptional<z.ZodObject<{
+                s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+                cl: z.ZodString;
+            }, z.core.$strip>>;
+            b: z.ZodOptional<z.ZodObject<{
+                s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+                cl: z.ZodString;
+            }, z.core.$strip>>;
+            l: z.ZodOptional<z.ZodObject<{
+                s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+                cl: z.ZodString;
+            }, z.core.$strip>>;
+            r: z.ZodOptional<z.ZodObject<{
+                s: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+                cl: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        cl: z.ZodOptional<z.ZodObject<{
+            rgb: z.ZodString;
+        }, z.core.$strip>>;
+        va: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+        tr: z.ZodOptional<z.ZodObject<{
+            a: z.ZodNumber;
+        }, z.core.$strip>>;
+        td: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        ht: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+        vt: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+        tb: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+        pd: z.ZodOptional<z.ZodObject<{
+            t: z.ZodOptional<z.ZodNumber>;
+            b: z.ZodOptional<z.ZodNumber>;
+            l: z.ZodOptional<z.ZodNumber>;
+            r: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        n: z.ZodOptional<z.ZodObject<{
+            pattern: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type BatchRangeDataItem = z.infer<typeof batchRangeDataItemSchema>;
+export type BatchRangeStyleItem = z.infer<typeof batchRangeStyleItemSchema>;
+/**
+ * Batch set value or formula for multiple ranges
+ */
+export declare function batchSetRangeData(items: BatchRangeDataItem[]): Promise<string>;
+/**
+ * Batch set style for multiple ranges
+ */
+export declare function setRangeStyle(items: BatchRangeStyleItem[]): Promise<string>;
+/**
+ * Merge a single range
+ */
+export declare function setMerge(range_a1: string): Promise<string>;
+export declare const rangeOperationTools: IMCPTool[];

package/lib/types/tools/row-column-operations.d.ts

@@ -0,0 +1,51 @@
+import { IMCPTool } from '@univerjs-pro/mcp';
+import { z } from 'zod';
+export declare const insertRowOperationSchema: z.ZodObject<{
+    position: z.ZodNumber;
+    how_many: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    where: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        before: "before";
+        after: "after";
+    }>>>;
+    sheet_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const insertColumnOperationSchema: z.ZodObject<{
+    position: z.ZodNumber;
+    how_many: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    where: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        before: "before";
+        after: "after";
+    }>>>;
+    sheet_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const deleteRowOperationSchema: z.ZodObject<{
+    position: z.ZodNumber;
+    how_many: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sheet_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const deleteColumnOperationSchema: z.ZodObject<{
+    position: z.ZodNumber;
+    how_many: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sheet_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type InsertRowOperation = z.infer<typeof insertRowOperationSchema>;
+export type InsertColumnOperation = z.infer<typeof insertColumnOperationSchema>;
+export type DeleteRowOperation = z.infer<typeof deleteRowOperationSchema>;
+export type DeleteColumnOperation = z.infer<typeof deleteColumnOperationSchema>;
+/**
+ * Insert rows for multiple operations
+ */
+export declare function insertRows(operations: InsertRowOperation[]): Promise<Record<string, any>>;
+/**
+ * Insert columns for multiple operations
+ */
+export declare function insertColumns(operations: InsertColumnOperation[]): Promise<Record<string, any>>;
+/**
+ * Delete rows for multiple operations
+ */
+export declare function deleteRows(operations: DeleteRowOperation[]): Promise<Record<string, any>>;
+/**
+ * Delete columns for multiple operations
+ */
+export declare function deleteColumns(operations: DeleteColumnOperation[]): Promise<Record<string, any>>;
+export declare const rowColumnOperationTools: IMCPTool[];