opencode-bioresearcher-plugin 1.0.0

package/dist/table-tools/tools.js

@@ -0,0 +1,558 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as XLSX from 'xlsx';
+import { z } from 'zod';
+import { processCellValue, formatError, resolvePath, getSheet } from './utils';
+export const tableGetSheetPreview = tool({
+    description: "Get first 6 rows of a worksheet to preview data structure",
+    args: {
+        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)")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const data = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
+            const previewRows = data.slice(0, 6);
+            return JSON.stringify({
+                sheet_name: args.sheet_name || workbook.SheetNames[0],
+                total_rows: data.length,
+                preview: previewRows
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "get_sheet_preview", error });
+        }
+    }
+});
+export const tableListSheets = tool({
+    description: "List all worksheet names in a table file",
+    args: {
+        file_path: z.string().describe("Path to table file (supports .xlsx, .ods, .csv formats)")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            return JSON.stringify({ sheets: workbook.SheetNames }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, operation: "list_sheets", error });
+        }
+    }
+});
+export const tableGetHeaders = tool({
+    description: "Get column headers (first row) from a worksheet",
+    args: {
+        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)")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const data = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
+            const headers = data[0] || [];
+            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 });
+        }
+    }
+});
+export const tableGetCell = tool({
+    description: "Get value of a single cell by address (e.g., 'A1', 'B5')",
+    args: {
+        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)"),
+        cell_address: z.string().describe("Cell address (e.g., 'A1', 'B5')")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            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 });
+        }
+    }
+});
+export const tableFilterRows = tool({
+    description: "Filter rows based on a condition (e.g., {column: 'Age', operator: '>', value: 25})",
+    args: {
+        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)"),
+        column: z.string().describe("Column name to filter on"),
+        operator: z.enum(['=', '!=', '>', '<', '>=', '<=', 'contains']).describe("Comparison operator"),
+        value: z.any().describe("Value to compare against"),
+        max_results: z.number().default(100).describe("Maximum number of results to return")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const data = XLSX.utils.sheet_to_json(worksheet);
+            const filteredRows = data.filter(row => {
+                let cellValue = row[args.column];
+                let comparisonValue = args.value;
+                // Type coercion for numeric comparisons
+                if (typeof cellValue === 'string' && cellValue.trim() !== '' && !isNaN(Number(cellValue))) {
+                    cellValue = Number(cellValue);
+                }
+                if (typeof comparisonValue === 'string' && comparisonValue.trim() !== '' && !isNaN(Number(comparisonValue))) {
+                    comparisonValue = Number(comparisonValue);
+                }
+                switch (args.operator) {
+                    case '=': return cellValue === comparisonValue;
+                    case '!=': return cellValue !== comparisonValue;
+                    case '>': return cellValue > comparisonValue;
+                    case '<': return cellValue < comparisonValue;
+                    case '>=': return cellValue >= comparisonValue;
+                    case '<=': return cellValue <= comparisonValue;
+                    case 'contains': return String(cellValue).includes(String(comparisonValue));
+                    default: return false;
+                }
+            }).slice(0, args.max_results);
+            return JSON.stringify({
+                sheet_name: args.sheet_name || workbook.SheetNames[0],
+                filter: { column: args.column, operator: args.operator, value: args.value },
+                total_matches: filteredRows.length,
+                matched_rows: filteredRows
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "filter_rows", error });
+        }
+    }
+});
+export const tableSearch = tool({
+    description: "Search for a term across all cells in a worksheet",
+    args: {
+        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"),
+        max_results: z.number().default(50).describe("Maximum number of results to return")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const results = [];
+            const range = XLSX.utils.decode_range(worksheet['!ref'] || 'A1:A1');
+            for (let R = range.s.r; R <= range.e.r; ++R) {
+                for (let C = range.s.c; C <= range.e.c; ++C) {
+                    if (results.length >= args.max_results)
+                        break;
+                    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())) {
+                            results.push({ address, value: processCellValue(cell), type: cell.t || 'unknown' });
+                        }
+                    }
+                }
+                if (results.length >= args.max_results)
+                    break;
+            }
+            return JSON.stringify({
+                sheet_name: args.sheet_name || workbook.SheetNames[0],
+                search_term: args.search_term,
+                total_found: results.length,
+                results
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "search", error });
+        }
+    }
+});
+export const tableGetRange = tool({
+    description: "Get data from a specific range (e.g., 'A1:C10')",
+    args: {
+        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)"),
+        range: z.string().describe("Cell range (e.g., 'A1:C10', 'A1:B20')")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const range = XLSX.utils.decode_range(args.range);
+            const data = [];
+            for (let R = range.s.r; R <= range.e.r; ++R) {
+                const row = [];
+                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];
+                    row.push(processCellValue(cell));
+                }
+                data.push(row);
+            }
+            return JSON.stringify({
+                sheet_name: args.sheet_name || workbook.SheetNames[0],
+                range: args.range,
+                rows: data.length,
+                columns: data[0]?.length || 0,
+                data
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "get_range", error });
+        }
+    }
+});
+export const tableSummarize = tool({
+    description: "Get statistical summary (sum, avg, min, max, std_dev) for numeric columns",
+    args: {
+        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)"),
+        columns: z.array(z.string()).optional().describe("Specific columns to summarize (empty = all numeric columns)")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const data = XLSX.utils.sheet_to_json(worksheet);
+            const columnsToAnalyze = args.columns && args.columns.length > 0 ? args.columns : Object.keys(data[0] || {});
+            const summaries = {};
+            columnsToAnalyze.forEach(col => {
+                const values = data.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 = Math.min(...values);
+                    const max = Math.max(...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 };
+                }
+            });
+            return JSON.stringify({
+                sheet_name: args.sheet_name || workbook.SheetNames[0],
+                row_count: data.length,
+                summaries
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "summarize", error });
+        }
+    }
+});
+export const tableGroupBy = tool({
+    description: "Group data by a column and calculate aggregation",
+    args: {
+        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)"),
+        group_column: z.string().describe("Column to group by"),
+        agg_column: z.string().describe("Column to aggregate"),
+        agg_type: z.enum(['sum', 'count', 'avg', 'min', 'max']).default('sum').describe("Aggregation type")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const data = XLSX.utils.sheet_to_json(worksheet);
+            const grouped = {};
+            data.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];
+                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':
+                        result[groupKey] = Math.min(...values);
+                        break;
+                    case 'max':
+                        result[groupKey] = Math.max(...values);
+                        break;
+                }
+            });
+            return JSON.stringify({
+                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
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "group_by", error });
+        }
+    }
+});
+export const tablePivotSummary = tool({
+    description: "Create pivot table summary (row groups vs column groups)",
+    args: {
+        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)"),
+        row_field: z.string().describe("Field for row grouping"),
+        col_field: z.string().describe("Field for column grouping"),
+        value_field: z.string().describe("Field to aggregate"),
+        agg: z.enum(['sum', 'count', 'avg', 'min', 'max']).default('sum').describe("Aggregation type")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            const data = XLSX.utils.sheet_to_json(worksheet);
+            const pivot = {};
+            const allCols = new Set();
+            data.forEach(row => {
+                const rowKey = String(row[args.row_field] || '');
+                const colKey = String(row[args.col_field] || '');
+                allCols.add(colKey);
+                if (!pivot[rowKey])
+                    pivot[rowKey] = {};
+                const value = row[args.value_field];
+                if (typeof value === 'number' && !isNaN(value)) {
+                    if (!pivot[rowKey][colKey]) {
+                        if (args.agg === 'min') {
+                            pivot[rowKey][colKey] = Infinity;
+                        }
+                        else {
+                            pivot[rowKey][colKey] = 0;
+                        }
+                    }
+                    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;
+                    }
+                }
+            });
+            if (args.agg === 'avg') {
+                const counts = {};
+                data.forEach(row => {
+                    const rowKey = String(row[args.row_field] || '');
+                    const colKey = String(row[args.col_field] || '');
+                    if (!counts[rowKey])
+                        counts[rowKey] = {};
+                    if (!counts[rowKey][colKey])
+                        counts[rowKey][colKey] = 0;
+                    counts[rowKey][colKey]++;
+                });
+                Object.keys(pivot).forEach(rowKey => {
+                    Object.keys(pivot[rowKey]).forEach(colKey => {
+                        pivot[rowKey][colKey] /= counts[rowKey][colKey];
+                    });
+                });
+            }
+            return JSON.stringify({
+                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
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "pivot_summary", error });
+        }
+    }
+});
+export const tableAppendRows = tool({
+    description: "Append rows to an existing table file",
+    args: {
+        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)"),
+        rows: z.array(z.union([z.array(z.any()), z.record(z.string(), z.any())])).describe("Rows to append (array of arrays or array of objects)")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            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 });
+            }
+            else {
+                // Check if sheet already has data (to avoid duplicate headers for object format)
+                const existingData = XLSX.utils.sheet_to_json(worksheet);
+                const hasExistingData = existingData.length > 0;
+                // Only add header if sheet is empty
+                const header = hasExistingData ? undefined : Object.keys(args.rows[0] || {});
+                XLSX.utils.sheet_add_json(worksheet, args.rows, {
+                    origin: -1,
+                    header
+                });
+            }
+            XLSX.writeFile(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 });
+        }
+    }
+});
+export const tableUpdateCell = tool({
+    description: "Update a single cell value in a table file",
+    args: {
+        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)"),
+        cell_address: z.string().describe("Cell address (e.g., 'A1', 'B5')"),
+        value: z.any().describe("Value to set")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.readFile(resolvedPath);
+            const worksheet = getSheet(workbook, args.sheet_name);
+            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);
+                // Only expand range if new cell is significantly beyond current data
+                // Avoid creating sparse sheets by checking if expansion is reasonable
+                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) {
+                    // Limit expansion to avoid creating sparse sheets
+                    // Only expand if the new cell is reasonably close to existing data
+                    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);
+                }
+            }
+            else {
+                worksheet['!ref'] = XLSX.utils.encode_range({ s: newCellAddr, e: newCellAddr });
+            }
+            XLSX.writeFile(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 });
+        }
+    }
+});
+export const tableCreateFile = tool({
+    description: "Create a new table file from data",
+    args: {
+        file_path: z.string().describe("Path for new table file (supports .xlsx, .ods, .csv formats)"),
+        sheet_name: z.string().default("Sheet1").describe("Worksheet name"),
+        data: z.any().describe("Data to write (array of arrays or array of objects)")
+    },
+    execute: async (args, context) => {
+        try {
+            const resolvedPath = resolvePath(args.file_path, context.directory);
+            const workbook = XLSX.utils.book_new();
+            let worksheet;
+            let parsedData = args.data;
+            if (typeof args.data === 'string') {
+                try {
+                    parsedData = JSON.parse(args.data);
+                }
+                catch (e) {
+                    throw new Error(`Failed to parse data string as JSON: ${e}`);
+                }
+            }
+            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);
+            }
+            else {
+                worksheet = XLSX.utils.json_to_sheet(parsedData);
+            }
+            XLSX.utils.book_append_sheet(workbook, worksheet, args.sheet_name);
+            XLSX.writeFile(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`
+            }, null, 2);
+        }
+        catch (error) {
+            return formatError({ file_path: args.file_path, sheet_name: args.sheet_name, operation: "create_file", error });
+        }
+    }
+});

package/dist/table-tools/utils.d.ts

@@ -0,0 +1,11 @@
+import * as XLSX from 'xlsx';
+declare function processCellValue(cell: XLSX.CellObject | undefined): any;
+declare function formatError(context: {
+    file_path: string;
+    sheet_name?: string;
+    operation: string;
+    error: any;
+}): string;
+declare function resolvePath(filePath: string, workingDir: string): string;
+declare function getSheet(workbook: XLSX.WorkBook, sheetName?: string): XLSX.WorkSheet;
+export { processCellValue, formatError, resolvePath, getSheet };

package/dist/table-tools/utils.js

@@ -0,0 +1,43 @@
+import * as path from 'path';
+function convertExcelDate(excelDate) {
+    const daysSinceEpoch = excelDate - 25569;
+    const timestamp = daysSinceEpoch * 86400 * 1000;
+    const date = new Date(timestamp);
+    return date.toISOString().split('T')[0];
+}
+function processCellValue(cell) {
+    if (!cell)
+        return "";
+    switch (cell.t) {
+        case 'd': return convertExcelDate(cell.v);
+        case 'n': return cell.v;
+        case 'b': return cell.v;
+        case 's': return cell.v;
+        case 'e': return cell.w || cell.v;
+        case 'z': return "";
+        default: return cell.w || cell.v || "";
+    }
+}
+function formatError(context) {
+    return `Error: ${context.error.message || 'Unknown error'}
+Details:
+- File: ${context.file_path}
+${context.sheet_name ? `- Sheet: ${context.sheet_name}` : ''}
+- Operation: ${context.operation}`;
+}
+function resolvePath(filePath, workingDir) {
+    if (path.isAbsolute(filePath)) {
+        return filePath;
+    }
+    return path.resolve(workingDir, filePath);
+}
+function getSheet(workbook, sheetName) {
+    if (!sheetName) {
+        return workbook.Sheets[workbook.SheetNames[0]];
+    }
+    if (!workbook.Sheets[sheetName]) {
+        throw new Error(`Sheet "${sheetName}" not found`);
+    }
+    return workbook.Sheets[sheetName];
+}
+export { processCellValue, formatError, resolvePath, getSheet };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "opencode-bioresearcher-plugin",
+  "version": "1.0.0",
+  "description": "OpenCode plugin that adds a bioresearcher agent",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "bioresearch",
+    "biomcp",
+    "agent"
+  ],
+  "author": "Ye Yuan",
+  "license": "CC-BY-NC-ND-4.0",
+  "files": [
+    "dist/",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.0",
+    "xlsx": "^0.18.5",
+    "zod": "^4.1.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.9.3"
+  }
+}