@yeyuan98/opencode-bioresearcher-plugin 1.7.0 → 1.7.1

package/dist/tools/table/tools.js

@@ -1,10 +1,24 @@
 import { tool } from '@opencode-ai/plugin/tool';
 import * as fs from 'fs';
-import * as XLSX from 'xlsx';
+import * as path from 'path';
+import * as XLSX from '../../vendor/xlsx.mjs';
+XLSX.set_fs(fs);
 import * as z from 'zod';
-import { processCellValue, formatError, resolvePath, getSheet, checkFileSize, writeAtomic, iterativeMin, iterativeMax, DEFAULT_MAX_ROW_CAP, DEFAULT_MAX_RANGE_CELLS, } from './utils';
-const CELL_ADDRESS_REGEX = /^[A-Za-z]+\d+$/;
+import { formatError, resolvePath, writeAtomic, invalidateWorkbookCache, DEFAULT_MAX_ROW_CAP, } from './utils';
+import { createBackend } from './backends/factory';
 const FORCE_DESC = "Override file size / row count limits. Use when you need to work with large files and accept the performance implications.";
+function resolveSheetIndex(backend, sheetName) {
+    if (!sheetName)
+        return 0;
+    const sheets = backend.listSheets();
+    const idx = sheets.findIndex(s => s.name === sheetName);
+    if (idx === -1)
+        throw new Error(`Sheet "${sheetName}" not found`);
+    return idx;
+}
+function getSheetName(backend, sheetIndex) {
+    return backend.listSheets()[sheetIndex].name;
+}
 export const tableGetSheetPreview = tool({
     description: "Get first 6 rows of a worksheet to preview data structure",
     args: {
@@ -14,23 +28,24 @@ export const tableGetSheetPreview = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableGetSheetPreview", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const data = XLSX.utils.sheet_to_json(worksheet, { header: 1, range: 6 });
-            const previewRows = data.slice(0, 6);
-            const ref = worksheet['!ref'] ? XLSX.utils.decode_range(worksheet['!ref']) : null;
-            const totalRows = ref ? ref.e.r - ref.s.r + 1 : data.length;
-            return JSON.stringify({
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                total_rows: totalRows,
-                preview: previewRows,
-            }, null, 2);
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const { rows: preview, totalRows } = backend.getPreview(sheetIndex, 6);
+                return JSON.stringify({
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    total_rows: totalRows,
+                    preview,
+                }, null, 2);
+            }
+            finally {
+                backend.dispose();
+            }
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "get_sheet_preview", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "get_sheet_preview", error });
         }
     }
 });
@@ -42,14 +57,19 @@ export const tableListSheets = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableListSheets", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            return JSON.stringify({ sheets: workbook.SheetNames }, null, 2);
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheets = backend.listSheets();
+                return JSON.stringify({ sheets: sheets.map(s => s.name) }, null, 2);
+            }
+            finally {
+                backend.dispose();
+            }
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, operation: "list_sheets", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, operation: "list_sheets", error });
         }
     }
 });
@@ -62,26 +82,24 @@ export const tableGetHeaders = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableGetHeaders", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const ref = worksheet['!ref'] ? XLSX.utils.decode_range(worksheet['!ref']) : { s: { r: 0, c: 0 }, e: { r: 0, c: 0 } };
-            const headers = [];
-            for (let C = ref.s.c; C <= ref.e.c; C++) {
-                const addr = XLSX.utils.encode_cell({ r: ref.s.r, c: C });
-                const cell = worksheet[addr];
-                headers.push(processCellValue(cell));
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const { headers, columnCount } = backend.getHeaders(sheetIndex);
+                return JSON.stringify({
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    headers,
+                    column_count: columnCount,
+                }, null, 2);
+            }
+            finally {
+                backend.dispose();
             }
-            return JSON.stringify({
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                headers: headers,
-                column_count: headers.length,
-            }, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "get_headers", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "get_headers", error });
         }
     }
 });
@@ -95,25 +113,25 @@ export const tableGetCell = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableGetCell", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            if (!CELL_ADDRESS_REGEX.test(args.cell_address)) {
-                throw new Error(`Invalid cell address "${args.cell_address}". Expected format like "A1", "B5", "AA123".`);
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const { value, type } = backend.getCell(sheetIndex, args.cell_address);
+                return JSON.stringify({
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    cell_address: args.cell_address,
+                    value,
+                    type,
+                }, null, 2);
+            }
+            finally {
+                backend.dispose();
             }
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const cell = worksheet[args.cell_address];
-            const value = processCellValue(cell);
-            return JSON.stringify({
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                cell_address: args.cell_address,
-                value: value,
-                type: cell?.t || 'unknown',
-            }, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "get_cell", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "get_cell", error });
         }
     }
 });
@@ -130,81 +148,35 @@ export const tableFilterRows = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableFilterRows", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const effectiveMax = args.force ? args.max_results : Math.min(args.max_results, DEFAULT_MAX_ROW_CAP);
-            const filteredRows = [];
-            let totalMatchesFound = 0;
-            const data = XLSX.utils.sheet_to_json(worksheet);
-            for (let i = 0; i < data.length; i++) {
-                const row = data[i];
-                let cellValue = row[args.column];
-                let comparisonValue = args.value;
-                if (typeof cellValue === 'string' && cellValue.trim() !== '' && !isNaN(Number(cellValue))) {
-                    cellValue = Number(cellValue);
-                }
-                if (typeof comparisonValue === 'string' && comparisonValue.trim() !== '' && !isNaN(Number(comparisonValue))) {
-                    comparisonValue = Number(comparisonValue);
-                }
-                let matches = false;
-                switch (args.operator) {
-                    case '=':
-                        matches = cellValue === comparisonValue;
-                        break;
-                    case '!=':
-                        matches = cellValue !== comparisonValue;
-                        break;
-                    case '>':
-                        matches = cellValue > comparisonValue;
-                        break;
-                    case '<':
-                        matches = cellValue < comparisonValue;
-                        break;
-                    case '>=':
-                        matches = cellValue >= comparisonValue;
-                        break;
-                    case '<=':
-                        matches = cellValue <= comparisonValue;
-                        break;
-                    case 'contains':
-                        matches = String(cellValue).toLowerCase().includes(String(comparisonValue).toLowerCase());
-                        break;
-                    case 'starts_with':
-                        matches = String(cellValue).toLowerCase().startsWith(String(comparisonValue).toLowerCase());
-                        break;
-                    case 'ends_with':
-                        matches = String(cellValue).toLowerCase().endsWith(String(comparisonValue).toLowerCase());
-                        break;
-                }
-                if (matches) {
-                    totalMatchesFound++;
-                    if (filteredRows.length < effectiveMax) {
-                        filteredRows.push(row);
-                    }
-                }
-                if (!args.force && i >= DEFAULT_MAX_ROW_CAP - 1) {
-                    break;
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const totalDataRows = backend.getTotalDataRows(sheetIndex);
+                const maxRowsScan = args.force ? totalDataRows : Math.min(totalDataRows, DEFAULT_MAX_ROW_CAP);
+                const effectiveMax = args.force ? args.max_results : Math.min(args.max_results, DEFAULT_MAX_ROW_CAP);
+                const { matchedRows, totalMatchesFound, totalDataRows: backendTotalRows } = backend.filterRows(sheetIndex, args.column, args.operator, args.value, { maxResults: effectiveMax, maxRowsScan });
+                const truncated = !args.force && backendTotalRows > DEFAULT_MAX_ROW_CAP;
+                const result = {
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    filter: { column: args.column, operator: args.operator, value: args.value },
+                    total_matches_found: totalMatchesFound,
+                    returned_count: matchedRows.length,
+                    matched_rows: matchedRows,
+                };
+                if (truncated) {
+                    result.truncated = true;
+                    result.message = `Processed ${DEFAULT_MAX_ROW_CAP} of ${backendTotalRows} rows. Set force: true to process all rows.`;
                 }
+                return JSON.stringify(result, null, 2);
             }
-            const truncated = !args.force && data.length > DEFAULT_MAX_ROW_CAP;
-            const result = {
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                filter: { column: args.column, operator: args.operator, value: args.value },
-                total_matches_found: totalMatchesFound,
-                returned_count: filteredRows.length,
-                matched_rows: filteredRows,
-            };
-            if (truncated) {
-                result.truncated = true;
-                result.message = `Processed ${DEFAULT_MAX_ROW_CAP} of ${data.length} rows. Set force: true to process all rows.`;
+            finally {
+                backend.dispose();
             }
-            return JSON.stringify(result, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "filter_rows", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "filter_rows", error });
         }
     }
 });
@@ -214,56 +186,45 @@ export const tableSearch = tool({
         file_path: z.string().describe("Path to table file (supports .xlsx, .ods, .csv formats)"),
         sheet_name: z.string().optional().describe("Worksheet name (optional, uses first sheet by default)"),
         search_term: z.string().describe("Term to search for"),
+        column: z.string().optional().describe("Limit search to a specific column name (much faster for wide tables)"),
         max_results: z.number().default(50).describe("Maximum number of results to return"),
         force: z.boolean().default(false).describe(FORCE_DESC),
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableSearch", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const results = [];
-            const range = XLSX.utils.decode_range(worksheet['!ref'] || 'A1:A1');
-            const effectiveMax = args.force ? args.max_results : Math.min(args.max_results, DEFAULT_MAX_ROW_CAP);
-            let rowsScanned = 0;
-            let totalMatchesFound = 0;
-            for (let R = range.s.r; R <= range.e.r; ++R) {
-                rowsScanned++;
-                if (!args.force && rowsScanned > DEFAULT_MAX_ROW_CAP)
-                    break;
-                for (let C = range.s.c; C <= range.e.c; ++C) {
-                    const address = XLSX.utils.encode_cell({ r: R, c: C });
-                    const cell = worksheet[address];
-                    if (cell && cell.v !== undefined) {
-                        const cellValue = String(processCellValue(cell)).toLowerCase();
-                        if (cellValue.includes(args.search_term.toLowerCase())) {
-                            totalMatchesFound++;
-                            if (results.length < effectiveMax) {
-                                results.push({ address, value: processCellValue(cell), type: cell.t || 'unknown', row_index: R });
-                            }
-                        }
-                    }
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const totalDataRows = backend.getTotalDataRows(sheetIndex);
+                const maxRowsScan = args.force ? totalDataRows : Math.min(totalDataRows, DEFAULT_MAX_ROW_CAP);
+                const effectiveMax = args.force ? args.max_results : Math.min(args.max_results, DEFAULT_MAX_ROW_CAP);
+                const { results, totalMatchesFound, rowsScanned } = backend.search(sheetIndex, args.search_term, { column: args.column, maxResults: effectiveMax, maxRowsScan });
+                const truncated = !args.force && totalDataRows > DEFAULT_MAX_ROW_CAP;
+                const result = {
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    search_term: args.search_term,
+                    total_matches_found: totalMatchesFound,
+                    returned_count: results.length,
+                    rows_scanned: rowsScanned,
+                    results,
+                };
+                if (args.column) {
+                    result.column = args.column;
+                }
+                if (truncated) {
+                    result.truncated = true;
+                    result.message = `Scanned ${DEFAULT_MAX_ROW_CAP} rows. Set force: true to scan all rows.`;
                 }
+                return JSON.stringify(result, null, 2);
             }
-            const truncated = !args.force && rowsScanned >= DEFAULT_MAX_ROW_CAP && range.e.r >= DEFAULT_MAX_ROW_CAP;
-            const result = {
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                search_term: args.search_term,
-                total_matches_found: totalMatchesFound,
-                returned_count: results.length,
-                rows_scanned: rowsScanned,
-                results,
-            };
-            if (truncated) {
-                result.truncated = true;
-                result.message = `Scanned ${DEFAULT_MAX_ROW_CAP} rows. Set force: true to scan all rows.`;
+            finally {
+                backend.dispose();
             }
-            return JSON.stringify(result, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "search", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "search", error });
         }
     }
 });
@@ -277,53 +238,33 @@ export const tableGetRange = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableGetRange", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const range = XLSX.utils.decode_range(args.range);
-            const sheetName = args.sheet_name || workbook.SheetNames[0];
-            const sheetRef = worksheet['!ref'] ? XLSX.utils.decode_range(worksheet['!ref']) : null;
-            if (!sheetRef) {
-                return JSON.stringify({ sheet_name: sheetName, range: args.range, rows: 0, columns: 0, data: [], out_of_bounds: true }, null, 2);
-            }
-            const clamped = {
-                s: { r: Math.max(range.s.r, sheetRef.s.r), c: Math.max(range.s.c, sheetRef.s.c) },
-                e: { r: Math.min(range.e.r, sheetRef.e.r), c: Math.min(range.e.c, sheetRef.e.c) },
-            };
-            if (clamped.s.r > clamped.e.r || clamped.s.c > clamped.e.c) {
-                return JSON.stringify({ sheet_name: sheetName, range: args.range, rows: 0, columns: 0, data: [], out_of_bounds: true }, null, 2);
-            }
-            const totalCells = (clamped.e.r - clamped.s.r + 1) * (clamped.e.c - clamped.s.c + 1);
-            if (!args.force && totalCells > DEFAULT_MAX_RANGE_CELLS) {
-                throw new Error(`Range "${args.range}" exceeds ${DEFAULT_MAX_RANGE_CELLS} cell limit (${totalCells} cells). ` +
-                    `Set force: true to override.`);
-            }
-            const data = [];
-            for (let R = clamped.s.r; R <= clamped.e.r; ++R) {
-                const row = [];
-                for (let C = clamped.s.c; C <= clamped.e.c; ++C) {
-                    const address = XLSX.utils.encode_cell({ r: R, c: C });
-                    const cell = worksheet[address];
-                    row.push(processCellValue(cell));
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const rangeResult = backend.getRange(sheetIndex, args.range);
+                const result = {
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    range: args.range,
+                    rows: rangeResult.rows,
+                    columns: rangeResult.columns,
+                    data: rangeResult.data,
+                };
+                if (rangeResult.out_of_bounds) {
+                    result.out_of_bounds = true;
+                }
+                if (rangeResult.clamped_to) {
+                    result.clamped_to = rangeResult.clamped_to;
                 }
-                data.push(row);
+                return JSON.stringify(result, null, 2);
             }
-            const result = {
-                sheet_name: sheetName,
-                range: args.range,
-                rows: data.length,
-                columns: data[0]?.length || 0,
-                data,
-            };
-            if (clamped.s.r !== range.s.r || clamped.s.c !== range.s.c || clamped.e.r !== range.e.r || clamped.e.c !== range.e.c) {
-                result.clamped_to = XLSX.utils.encode_range(clamped);
+            finally {
+                backend.dispose();
             }
-            return JSON.stringify(result, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "get_range", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "get_range", error });
         }
     }
 });
@@ -337,42 +278,33 @@ export const tableSummarize = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableSummarize", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const data = XLSX.utils.sheet_to_json(worksheet);
-            const effectiveData = args.force ? data : data.slice(0, DEFAULT_MAX_ROW_CAP);
-            const columnsToAnalyze = args.columns && args.columns.length > 0 ? args.columns : Object.keys(effectiveData[0] || {});
-            const summaries = {};
-            columnsToAnalyze.forEach(col => {
-                const values = effectiveData.map(row => row[col]).filter((v) => typeof v === 'number' && !isNaN(v));
-                if (values.length > 0) {
-                    const sum = values.reduce((a, b) => a + b, 0);
-                    const avg = sum / values.length;
-                    const min = iterativeMin(values);
-                    const max = iterativeMax(values);
-                    const variance = values.reduce((acc, val) => acc + Math.pow(val - avg, 2), 0) / values.length;
-                    const stdDev = Math.sqrt(variance);
-                    summaries[col] = { sum, avg, min, max, std_dev: stdDev };
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const totalDataRows = backend.getTotalDataRows(sheetIndex);
+                const maxRowsScan = args.force ? totalDataRows : Math.min(totalDataRows, DEFAULT_MAX_ROW_CAP);
+                const { summaries, rowCount } = backend.summarize(sheetIndex, args.columns, { maxRowsScan });
+                const truncated = !args.force && totalDataRows > DEFAULT_MAX_ROW_CAP;
+                const result = {
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    row_count: rowCount,
+                    summaries,
+                };
+                if (truncated) {
+                    result.total_rows = totalDataRows;
+                    result.truncated = true;
+                    result.message = `Summarized ${DEFAULT_MAX_ROW_CAP} of ${totalDataRows} rows. Set force: true to process all rows.`;
                 }
-            });
-            const truncated = !args.force && data.length > DEFAULT_MAX_ROW_CAP;
-            const result = {
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                row_count: effectiveData.length,
-                summaries,
-            };
-            if (truncated) {
-                result.total_rows = data.length;
-                result.truncated = true;
-                result.message = `Summarized ${DEFAULT_MAX_ROW_CAP} of ${data.length} rows. Set force: true to process all rows.`;
+                return JSON.stringify(result, null, 2);
+            }
+            finally {
+                backend.dispose();
             }
-            return JSON.stringify(result, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "summarize", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "summarize", error });
         }
     }
 });
@@ -388,73 +320,36 @@ export const tableGroupBy = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableGroupBy", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const data = XLSX.utils.sheet_to_json(worksheet);
-            const effectiveData = args.force ? data : data.slice(0, DEFAULT_MAX_ROW_CAP);
-            const grouped = {};
-            effectiveData.forEach(row => {
-                const groupKey = String(row[args.group_column] || '');
-                const aggValue = row[args.agg_column];
-                if (!grouped[groupKey])
-                    grouped[groupKey] = [];
-                if (args.agg_type === 'count') {
-                    grouped[groupKey].push(1);
-                }
-                else if (typeof aggValue === 'number' && !isNaN(aggValue)) {
-                    grouped[groupKey].push(aggValue);
-                }
-            });
-            const result = {};
-            Object.keys(grouped).forEach(groupKey => {
-                const values = grouped[groupKey];
-                if (values.length === 0) {
-                    result[groupKey] = 0;
-                    return;
-                }
-                switch (args.agg_type) {
-                    case 'sum':
-                        result[groupKey] = values.reduce((a, b) => a + b, 0);
-                        break;
-                    case 'count':
-                        result[groupKey] = values.length;
-                        break;
-                    case 'avg':
-                        result[groupKey] = values.reduce((a, b) => a + b, 0) / values.length;
-                        break;
-                    case 'min': {
-                        const m = iterativeMin(values);
-                        result[groupKey] = m !== undefined ? m : 0;
-                        break;
-                    }
-                    case 'max': {
-                        const m = iterativeMax(values);
-                        result[groupKey] = m !== undefined ? m : 0;
-                        break;
-                    }
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const totalDataRows = backend.getTotalDataRows(sheetIndex);
+                const maxRowsScan = args.force ? totalDataRows : Math.min(totalDataRows, DEFAULT_MAX_ROW_CAP);
+                const { groups } = backend.groupBy(sheetIndex, args.group_column, args.agg_column, args.agg_type, { maxRowsScan });
+                const truncated = !args.force && totalDataRows > DEFAULT_MAX_ROW_CAP;
+                const response = {
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    group_column: args.group_column,
+                    agg_column: args.agg_column,
+                    agg_type: args.agg_type,
+                    groups,
+                };
+                if (truncated) {
+                    response.total_rows = totalDataRows;
+                    response.processed_rows = maxRowsScan;
+                    response.truncated = true;
+                    response.message = `Processed ${DEFAULT_MAX_ROW_CAP} of ${totalDataRows} rows. Set force: true to process all rows.`;
                 }
-            });
-            const truncated = !args.force && data.length > DEFAULT_MAX_ROW_CAP;
-            const response = {
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                group_column: args.group_column,
-                agg_column: args.agg_column,
-                agg_type: args.agg_type,
-                groups: result,
-            };
-            if (truncated) {
-                response.total_rows = data.length;
-                response.processed_rows = effectiveData.length;
-                response.truncated = true;
-                response.message = `Processed ${DEFAULT_MAX_ROW_CAP} of ${data.length} rows. Set force: true to process all rows.`;
+                return JSON.stringify(response, null, 2);
+            }
+            finally {
+                backend.dispose();
             }
-            return JSON.stringify(response, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "group_by", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "group_by", error });
         }
     }
 });
@@ -471,88 +366,38 @@ export const tablePivotSummary = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tablePivotSummary", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            const data = XLSX.utils.sheet_to_json(worksheet);
-            const effectiveData = args.force ? data : data.slice(0, DEFAULT_MAX_ROW_CAP);
-            const pivot = {};
-            const counts = {};
-            const allCols = new Set();
-            effectiveData.forEach(row => {
-                const rowKey = String(row[args.row_field] || '');
-                const colKey = String(row[args.col_field] || '');
-                allCols.add(colKey);
-                if (!pivot[rowKey])
-                    pivot[rowKey] = {};
-                if (!counts[rowKey])
-                    counts[rowKey] = {};
-                const value = row[args.value_field];
-                const isNumeric = typeof value === 'number' && !isNaN(value);
-                if (isNumeric) {
-                    if (!pivot[rowKey][colKey]) {
-                        if (args.agg === 'min') {
-                            pivot[rowKey][colKey] = Infinity;
-                        }
-                        else if (args.agg === 'max') {
-                            pivot[rowKey][colKey] = -Infinity;
-                        }
-                        else {
-                            pivot[rowKey][colKey] = 0;
-                        }
-                    }
-                    if (!counts[rowKey][colKey])
-                        counts[rowKey][colKey] = 0;
-                    counts[rowKey][colKey]++;
-                    switch (args.agg) {
-                        case 'sum':
-                        case 'avg':
-                            pivot[rowKey][colKey] += value;
-                            break;
-                        case 'min':
-                            pivot[rowKey][colKey] = Math.min(pivot[rowKey][colKey], value);
-                            break;
-                        case 'max':
-                            pivot[rowKey][colKey] = Math.max(pivot[rowKey][colKey], value);
-                            break;
-                        case 'count':
-                            pivot[rowKey][colKey]++;
-                            break;
-                    }
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                const totalDataRows = backend.getTotalDataRows(sheetIndex);
+                const maxRowsScan = args.force ? totalDataRows : Math.min(totalDataRows, DEFAULT_MAX_ROW_CAP);
+                const { columns, pivot } = backend.pivotSummary(sheetIndex, args.row_field, args.col_field, args.value_field, args.agg, { maxRowsScan });
+                const truncated = !args.force && totalDataRows > DEFAULT_MAX_ROW_CAP;
+                const response = {
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    row_field: args.row_field,
+                    col_field: args.col_field,
+                    value_field: args.value_field,
+                    agg_type: args.agg,
+                    columns,
+                    pivot,
+                };
+                if (truncated) {
+                    response.total_rows = totalDataRows;
+                    response.processed_rows = maxRowsScan;
+                    response.truncated = true;
+                    response.message = `Processed ${DEFAULT_MAX_ROW_CAP} of ${totalDataRows} rows. Set force: true to process all rows.`;
                 }
-            });
-            if (args.agg === 'avg') {
-                Object.keys(pivot).forEach(rowKey => {
-                    Object.keys(pivot[rowKey]).forEach(colKey => {
-                        const count = counts[rowKey][colKey];
-                        if (count > 0) {
-                            pivot[rowKey][colKey] /= count;
-                        }
-                    });
-                });
+                return JSON.stringify(response, null, 2);
             }
-            const truncated = !args.force && data.length > DEFAULT_MAX_ROW_CAP;
-            const response = {
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                row_field: args.row_field,
-                col_field: args.col_field,
-                value_field: args.value_field,
-                agg_type: args.agg,
-                columns: Array.from(allCols).sort(),
-                pivot,
-            };
-            if (truncated) {
-                response.total_rows = data.length;
-                response.processed_rows = effectiveData.length;
-                response.truncated = true;
-                response.message = `Processed ${DEFAULT_MAX_ROW_CAP} of ${data.length} rows. Set force: true to process all rows.`;
+            finally {
+                backend.dispose();
             }
-            return JSON.stringify(response, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "pivot_summary", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "pivot_summary", error });
         }
     }
 });
@@ -566,33 +411,26 @@ export const tableAppendRows = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableAppendRows", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            if (args.rows.length > 0 && Array.isArray(args.rows[0])) {
-                XLSX.utils.sheet_add_aoa(worksheet, args.rows, { origin: -1 });
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                backend.appendRows(sheetIndex, args.rows);
+                return JSON.stringify({
+                    success: true,
+                    file_path: args.file_path,
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    rows_appended: args.rows.length,
+                    message: `Successfully appended ${args.rows.length} rows`,
+                }, null, 2);
             }
-            else {
-                const hasExistingData = !!worksheet['!ref'];
-                const header = hasExistingData ? undefined : Object.keys(args.rows[0] || {});
-                XLSX.utils.sheet_add_json(worksheet, args.rows, {
-                    origin: -1,
-                    header,
-                });
+            finally {
+                backend.dispose();
             }
-            writeAtomic(workbook, resolvedPath);
-            return JSON.stringify({
-                success: true,
-                file_path: args.file_path,
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                rows_appended: args.rows.length,
-                message: `Successfully appended ${args.rows.length} rows`,
-            }, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "append_rows", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "append_rows", error });
         }
     }
 });
@@ -607,67 +445,37 @@ export const tableUpdateCell = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableUpdateCell", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            if (!CELL_ADDRESS_REGEX.test(args.cell_address)) {
-                throw new Error(`Invalid cell address "${args.cell_address}". Expected format like "A1", "B5", "AA123".`);
-            }
-            const resolvedPath = resolvePath(args.file_path, context.directory);
-            checkFileSize(resolvedPath, args.force);
-            const workbook = XLSX.readFile(resolvedPath);
-            const worksheet = getSheet(workbook, args.sheet_name);
-            if (args.value === null) {
-                delete worksheet[args.cell_address];
-            }
-            else {
-                let cellType;
-                if (typeof args.value === 'number')
-                    cellType = 'n';
-                else if (typeof args.value === 'boolean')
-                    cellType = 'b';
-                else
-                    cellType = 's';
-                worksheet[args.cell_address] = { v: args.value, t: cellType };
-            }
-            const newCellAddr = XLSX.utils.decode_cell(args.cell_address);
-            const currentRef = worksheet['!ref'];
-            if (currentRef) {
-                const currentRange = XLSX.utils.decode_range(currentRef);
-                const rowDifference = newCellAddr.r - currentRange.e.r;
-                const colDifference = newCellAddr.c - currentRange.e.c;
-                if (newCellAddr.r > currentRange.e.r || newCellAddr.c > currentRange.e.c) {
-                    const maxReasonableRow = Math.max(currentRange.e.r + 1000, newCellAddr.r);
-                    const maxReasonableCol = Math.max(currentRange.e.c + 26, newCellAddr.c);
-                    const updatedRange = {
-                        s: {
-                            r: Math.min(currentRange.s.r, newCellAddr.r),
-                            c: Math.min(currentRange.s.c, newCellAddr.c),
-                        },
-                        e: {
-                            r: Math.min(Math.max(currentRange.e.r, newCellAddr.r), maxReasonableRow),
-                            c: Math.min(Math.max(currentRange.e.c, newCellAddr.c), maxReasonableCol),
-                        },
-                    };
-                    worksheet['!ref'] = XLSX.utils.encode_range(updatedRange);
-                }
+            const backend = createBackend(resolvedPath, args.force);
+            try {
+                const sheetIndex = resolveSheetIndex(backend, args.sheet_name);
+                backend.updateCell(sheetIndex, args.cell_address, args.value);
+                return JSON.stringify({
+                    success: true,
+                    file_path: args.file_path,
+                    sheet_name: args.sheet_name || getSheetName(backend, sheetIndex),
+                    cell_address: args.cell_address,
+                    new_value: args.value,
+                    message: `Successfully updated cell ${args.cell_address}`,
+                }, null, 2);
             }
-            else {
-                worksheet['!ref'] = XLSX.utils.encode_range({ s: newCellAddr, e: newCellAddr });
+            finally {
+                backend.dispose();
             }
-            writeAtomic(workbook, resolvedPath);
-            return JSON.stringify({
-                success: true,
-                file_path: args.file_path,
-                sheet_name: args.sheet_name || workbook.SheetNames[0],
-                cell_address: args.cell_address,
-                new_value: args.value,
-                message: `Successfully updated cell ${args.cell_address}`,
-            }, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "update_cell", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "update_cell", error });
         }
     }
 });
+function escapeCSVField(field, delimiter) {
+    const str = String(field ?? '');
+    if (str.includes(delimiter) || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+        return '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
 export const tableCreateFile = tool({
     description: "Create a new table file from data",
     args: {
@@ -678,13 +486,14 @@ export const tableCreateFile = tool({
     },
     execute: async (args, context) => {
         await context.ask({ permission: "tableCreateFile", patterns: [args.file_path], always: ["*"], metadata: {} });
+        const resolvedPath = resolvePath(args.file_path, context.directory);
         try {
-            const resolvedPath = resolvePath(args.file_path, context.directory);
             if (fs.existsSync(resolvedPath) && !args.overwrite) {
                 throw new Error(`File already exists. Set overwrite: true to replace it.`);
             }
-            const workbook = XLSX.utils.book_new();
-            let worksheet;
+            if (args.overwrite) {
+                invalidateWorkbookCache(resolvedPath);
+            }
             let parsedData = args.data;
             if (typeof parsedData === 'string') {
                 try {
@@ -697,27 +506,51 @@ export const tableCreateFile = tool({
             if (!Array.isArray(parsedData)) {
                 throw new Error(`Data must be an array, received: ${typeof parsedData}`);
             }
-            if (parsedData.length === 0) {
-                worksheet = XLSX.utils.aoa_to_sheet([]);
-            }
-            else if (Array.isArray(parsedData[0])) {
-                worksheet = XLSX.utils.aoa_to_sheet(parsedData);
+            const ext = path.extname(resolvedPath).toLowerCase();
+            if (ext === '.csv' || ext === '.tsv' || ext === '.txt') {
+                const delimiter = ext === '.tsv' ? '\t' : ',';
+                const lines = [];
+                if (parsedData.length > 0) {
+                    if (Array.isArray(parsedData[0])) {
+                        for (const row of parsedData) {
+                            lines.push(row.map((v) => escapeCSVField(v, delimiter)).join(delimiter));
+                        }
+                    }
+                    else {
+                        const keys = Object.keys(parsedData[0]);
+                        lines.push(keys.map(k => escapeCSVField(k, delimiter)).join(delimiter));
+                        for (const row of parsedData) {
+                            lines.push(keys.map(k => escapeCSVField(row[k], delimiter)).join(delimiter));
+                        }
+                    }
+                }
+                fs.writeFileSync(resolvedPath, lines.join('\n'));
             }
             else {
-                worksheet = XLSX.utils.json_to_sheet(parsedData);
+                const workbook = XLSX.utils.book_new();
+                let worksheet;
+                if (parsedData.length === 0) {
+                    worksheet = XLSX.utils.aoa_to_sheet([]);
+                }
+                else if (Array.isArray(parsedData[0])) {
+                    worksheet = XLSX.utils.aoa_to_sheet(parsedData);
+                }
+                else {
+                    worksheet = XLSX.utils.json_to_sheet(parsedData);
+                }
+                XLSX.utils.book_append_sheet(workbook, worksheet, args.sheet_name);
+                writeAtomic(workbook, resolvedPath);
             }
-            XLSX.utils.book_append_sheet(workbook, worksheet, args.sheet_name);
-            writeAtomic(workbook, resolvedPath);
             return JSON.stringify({
                 success: true,
                 file_path: args.file_path,
                 sheet_name: args.sheet_name,
                 rows_created: parsedData.length,
-                message: `Successfully created Excel file with ${parsedData.length} rows`,
+                message: `Successfully created file with ${parsedData.length} rows`,
             }, null, 2);
         }
         catch (error) {
-            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "create_file", error });
+            return formatError({ file_path: args.file_path, resolved_path: resolvedPath, sheet_name: args.sheet_name, operation: "create_file", error });
         }
     }
 });