@components-kit/open-workbook 0.1.2 → 0.1.4

package/assets/backend/dist/runtime-service.js

@@ -1,13 +1,13 @@
 import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
-import { BackupManager, BatchCompiler, DefaultPermissionPolicy, buildFormulaDependencyGraph, attachConflictGuidance, extractFormulaReferences, hashStable, LockManager, parseA1Address, PlanManager, SnapshotManager, TaskRegistry, TemplateRegistry, TransactionManager, traceDependents, tracePrecedents } from "@components-kit/open-workbook-excel-core";
+import { BackupManager, BatchCompiler, DefaultPermissionPolicy, buildFormulaDependencyGraph, attachConflictGuidance, extractFormulaReferences, hashStable, LockManager, formatA1Address, parseA1Address, PlanManager, SnapshotManager, TaskRegistry, TemplateRegistry, TransactionManager, traceDependents, tracePrecedents } from "@components-kit/open-workbook-excel-core";
 import { makeRollbackConflict } from "@components-kit/open-workbook-excel-core";
 import { getToolCatalogSummary, PromptCatalog, ResourceCatalog, makeId, runtimeError } from "@components-kit/open-workbook-protocol";
 import { SessionRegistry } from "./session-registry.js";
 import { NativeFileBridge } from "./native-file-bridge.js";
 import { RuntimeStateStore } from "./state-store.js";
-const runtimeVersion = process.env.OPEN_WORKBOOK_VERSION ?? "0.1.2";
+const runtimeVersion = process.env.OPEN_WORKBOOK_VERSION ?? "0.1.4";
 export class RuntimeService {
     sessions = new SessionRegistry();
     backups = new BackupManager();
@@ -2710,11 +2710,9 @@ export class RuntimeService {
             return cleaningError(input.workbookId, "normalize_headers", target, read.error);
         }
         const headerRowIndex = input.headerRowIndex ?? detectHeaderCandidates(read.values, 10)[0]?.rowIndex ?? 0;
-        const values = cloneMatrix(read.values);
-        const before = values[headerRowIndex] ?? [];
+        const before = read.values[headerRowIndex] ?? [];
         const normalized = dedupeHeaders(before.map((value) => normalizeHeader(String(value ?? ""))));
-        values[headerRowIndex] = normalized;
-        const result = await this.writeCleanValues(target, values, "Normalize headers");
+        const result = await this.writeCleanValues(headerRowTarget(target, headerRowIndex), [normalized], "Normalize headers");
         return cleaningReport(input.workbookId, "normalize_headers", target, changedCellCount([before], [normalized]), { headerRowIndex, headers: normalized }, result);
     }
     async cleanTrimWhitespace(input) {
@@ -3139,6 +3137,22 @@ export class RuntimeService {
     async resizeTable(request) {
         return this.mutateTable("table.resize", request, `Before resizing table ${request.tableName}`, await this.getTableBackupRanges(request));
     }
+    async reorderTableColumns(request) {
+        const infoResult = await this.getTableInfo(request);
+        const info = infoResult.info;
+        if (!info) {
+            return {
+                ok: false,
+                error: runtimeError("NOT_FOUND", `Table ${request.tableName} could not be read before column reorder.`, { retryable: false }),
+                table: infoResult
+            };
+        }
+        const validation = validateTableColumnOrder(info, request.columnOrder);
+        if (!validation.ok) {
+            return validation;
+        }
+        return this.mutateTable("table.reorder_columns", request, `Before reordering columns in table ${request.tableName}`, await this.getTableBackupRanges(request));
+    }
     async appendTableRows(request) {
         return this.mutateTable("table.append_rows", request, `Before appending rows to table ${request.tableName}`, await this.getTableBackupRanges(request));
     }
@@ -3268,15 +3282,18 @@ export class RuntimeService {
             workbookId: request.workbookId,
             goal: reason,
             scopes: tableMutationScopes(request, ranges),
-            destructiveLevel: method.includes("resize") || method.includes("copy_structure") ? "structure" : "values"
+            destructiveLevel: method.includes("resize") || method.includes("copy_structure") || method.includes("reorder_columns") ? "structure" : "values"
         }, async () => {
             const backup = await this.createWorkbookBackup({
                 workbookId: request.workbookId,
                 reason,
                 ranges
             });
+            if (!("backup" in backup)) {
+                return backup;
+            }
             const result = await client.request(method, request);
-            return { ok: true, backup, result };
+            return { ok: true, backup: backup.backup, result };
         });
     }
     async mutateFormulas(method, request, reason, validate) {
@@ -5338,6 +5355,58 @@ function pivotTemplateRequiredSourceFields(info) {
 function uniqueDefined(values) {
     return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
 }
+function validateTableColumnOrder(info, columnOrder) {
+    const issues = [];
+    if (columnOrder.length !== info.columns.length) {
+        issues.push({
+            code: "TABLE_COLUMN_ORDER_LENGTH_MISMATCH",
+            message: `Column order must include exactly ${info.columns.length} column(s).`,
+            details: { expectedCount: info.columns.length, actualCount: columnOrder.length }
+        });
+    }
+    const seen = new Set();
+    for (const requested of columnOrder) {
+        const column = typeof requested === "number"
+            ? info.columns.find((candidate) => candidate.index === requested)
+            : info.columns.find((candidate) => candidate.name === requested);
+        if (!column) {
+            issues.push({
+                code: "TABLE_COLUMN_NOT_FOUND",
+                message: `Column ${String(requested)} is not present in table ${info.tableName}.`,
+                details: { requested, availableColumns: info.columns.map((candidate) => candidate.name) }
+            });
+            continue;
+        }
+        if (seen.has(column.index)) {
+            issues.push({
+                code: "TABLE_COLUMN_ORDER_DUPLICATE",
+                message: `Column ${column.name} appears more than once in the requested order.`,
+                details: { requested, column }
+            });
+        }
+        seen.add(column.index);
+    }
+    for (const column of info.columns) {
+        if (!seen.has(column.index)) {
+            issues.push({
+                code: "TABLE_COLUMN_ORDER_MISSING_COLUMN",
+                message: `Column ${column.name} is missing from the requested order.`,
+                details: { column }
+            });
+        }
+    }
+    if (issues.length > 0) {
+        return {
+            ok: false,
+            warnings: issues,
+            error: runtimeError("INVALID_ARGUMENT", "Table column reorder requires a complete, unique column order.", {
+                retryable: false,
+                details: { issues }
+            })
+        };
+    }
+    return { ok: true };
+}
 function addExpectedPivotAxisIssues(issues, axis, expectedFields, actualFields) {
     if (!expectedFields?.length) {
         return;
@@ -5549,6 +5618,14 @@ function targetFromCleanInput(input) {
         address: input.address
     };
 }
+function headerRowTarget(target, headerRowIndex) {
+    const parsed = parseA1Address(stripSheetName(target.address));
+    const row = parsed.startRow + headerRowIndex;
+    return {
+        ...target,
+        address: formatA1Address({ startColumn: parsed.startColumn, endColumn: parsed.endColumn, startRow: row, endRow: row })
+    };
+}
 function cleaningReport(workbookId, action, target, changedCells, data, result) {
     const report = {
         ok: result ? result.ok : true,