stagent 0.6.2 → 0.7.0

package/src/lib/db/schema.ts

@@ -37,6 +37,7 @@ export const tasks = sqliteTable(
     sourceType: text("source_type", {
       enum: ["manual", "scheduled", "heartbeat", "workflow"],
     }),
+    workflowRunNumber: integer("workflow_run_number"),
     createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
     updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
   },
@@ -59,6 +60,7 @@ export const workflows = sqliteTable("workflows", {
   })
     .default("draft")
     .notNull(),
+  runNumber: integer("run_number").default(0).notNull(),
   createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
   updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
 });
@@ -678,6 +680,407 @@ export const agentMessages = sqliteTable(
   ]
 );
 
+// ── Workflow Document Pool ───────────────────────────────────────────
+
+export const workflowDocumentInputs = sqliteTable(
+  "workflow_document_inputs",
+  {
+    id: text("id").primaryKey(),
+    workflowId: text("workflow_id")
+      .references(() => workflows.id)
+      .notNull(),
+    documentId: text("document_id")
+      .references(() => documents.id)
+      .notNull(),
+    /** null = document available to all steps; set = scoped to specific step */
+    stepId: text("step_id"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_wdi_workflow").on(table.workflowId),
+    index("idx_wdi_document").on(table.documentId),
+    uniqueIndex("idx_wdi_workflow_doc_step").on(
+      table.workflowId,
+      table.documentId,
+      table.stepId
+    ),
+  ]
+);
+
+export type WorkflowDocumentInputRow = InferSelectModel<typeof workflowDocumentInputs>;
+
+export const scheduleDocumentInputs = sqliteTable(
+  "schedule_document_inputs",
+  {
+    id: text("id").primaryKey(),
+    scheduleId: text("schedule_id")
+      .references(() => schedules.id)
+      .notNull(),
+    documentId: text("document_id")
+      .references(() => documents.id)
+      .notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_sdi_schedule").on(table.scheduleId),
+    uniqueIndex("idx_sdi_schedule_doc").on(
+      table.scheduleId,
+      table.documentId
+    ),
+  ]
+);
+
+export type ScheduleDocumentInputRow = InferSelectModel<typeof scheduleDocumentInputs>;
+
+export const projectDocumentDefaults = sqliteTable(
+  "project_document_defaults",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id")
+      .references(() => projects.id)
+      .notNull(),
+    documentId: text("document_id")
+      .references(() => documents.id)
+      .notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_pdd_project").on(table.projectId),
+    uniqueIndex("idx_pdd_project_doc").on(
+      table.projectId,
+      table.documentId
+    ),
+  ]
+);
+
+export type ProjectDocumentDefaultRow = InferSelectModel<typeof projectDocumentDefaults>;
+
+// ── User-Defined Tables (structured data) ───────────────────────────────
+
+export const userTables = sqliteTable(
+  "user_tables",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").references(() => projects.id),
+    name: text("name").notNull(),
+    description: text("description"),
+    /** JSON array of column definitions — denormalized for fast reads */
+    columnSchema: text("column_schema").notNull().default("[]"),
+    /** Denormalized row count for list views */
+    rowCount: integer("row_count").default(0).notNull(),
+    /** How this table was created */
+    source: text("source", {
+      enum: ["manual", "imported", "agent", "template"],
+    })
+      .default("manual")
+      .notNull(),
+    /** Template ID if created from a template */
+    templateId: text("template_id"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_tables_project_id").on(table.projectId),
+    index("idx_user_tables_source").on(table.source),
+  ]
+);
+
+export const userTableColumns = sqliteTable(
+  "user_table_columns",
+  {
+    id: text("id").primaryKey(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    name: text("name").notNull(),
+    displayName: text("display_name").notNull(),
+    dataType: text("data_type", {
+      enum: [
+        "text",
+        "number",
+        "date",
+        "boolean",
+        "select",
+        "url",
+        "email",
+        "relation",
+        "computed",
+      ],
+    }).notNull(),
+    position: integer("position").notNull(),
+    required: integer("required", { mode: "boolean" }).default(false).notNull(),
+    defaultValue: text("default_value"),
+    /** JSON config for type-specific settings (select options, formula, relation target, etc.) */
+    config: text("config"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_table_columns_table_id").on(table.tableId),
+    index("idx_user_table_columns_position").on(table.tableId, table.position),
+  ]
+);
+
+export const userTableRows = sqliteTable(
+  "user_table_rows",
+  {
+    id: text("id").primaryKey(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    /** JSON object with column values keyed by column name */
+    data: text("data").notNull().default("{}"),
+    position: integer("position").notNull(),
+    /** Who created this row: 'user' or agent profile ID */
+    createdBy: text("created_by").default("user"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_table_rows_table_id").on(table.tableId),
+    index("idx_user_table_rows_position").on(table.tableId, table.position),
+  ]
+);
+
+export const userTableViews = sqliteTable(
+  "user_table_views",
+  {
+    id: text("id").primaryKey(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    name: text("name").notNull(),
+    type: text("type", { enum: ["grid", "chart", "joined"] })
+      .default("grid")
+      .notNull(),
+    /** JSON config: filters, sorting, column visibility, chart config, join config */
+    config: text("config"),
+    isDefault: integer("is_default", { mode: "boolean" })
+      .default(false)
+      .notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_table_views_table_id").on(table.tableId),
+  ]
+);
+
+export const userTableRelationships = sqliteTable(
+  "user_table_relationships",
+  {
+    id: text("id").primaryKey(),
+    fromTableId: text("from_table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    fromColumn: text("from_column").notNull(),
+    toTableId: text("to_table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    toColumn: text("to_column").notNull(),
+    relationshipType: text("relationship_type", {
+      enum: ["one_to_one", "one_to_many", "many_to_many"],
+    }).notNull(),
+    /** JSON config for display column, cascade behavior, etc. */
+    config: text("config"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_table_rels_from").on(table.fromTableId),
+    index("idx_user_table_rels_to").on(table.toTableId),
+  ]
+);
+
+export const userTableTemplates = sqliteTable(
+  "user_table_templates",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    description: text("description"),
+    category: text("category", {
+      enum: ["business", "personal", "pm", "finance", "content"],
+    }).notNull(),
+    /** JSON array of column definitions */
+    columnSchema: text("column_schema").notNull(),
+    /** JSON array of sample row data */
+    sampleData: text("sample_data"),
+    scope: text("scope", { enum: ["system", "user"] })
+      .default("system")
+      .notNull(),
+    icon: text("icon"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_table_templates_category").on(table.category),
+    index("idx_user_table_templates_scope").on(table.scope),
+  ]
+);
+
+export const userTableImports = sqliteTable(
+  "user_table_imports",
+  {
+    id: text("id").primaryKey(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    documentId: text("document_id").references(() => documents.id),
+    /** Number of rows imported */
+    rowCount: integer("row_count").default(0).notNull(),
+    /** Number of rows that failed validation */
+    errorCount: integer("error_count").default(0).notNull(),
+    /** JSON array of error details */
+    errors: text("errors"),
+    status: text("status", { enum: ["pending", "completed", "failed"] })
+      .default("pending")
+      .notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_table_imports_table_id").on(table.tableId),
+  ]
+);
+
+// ── Table Junction Tables ───────────────────────────────────────────────
+
+export const tableDocumentInputs = sqliteTable(
+  "table_document_inputs",
+  {
+    id: text("id").primaryKey(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    documentId: text("document_id")
+      .references(() => documents.id)
+      .notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_tdi_table").on(table.tableId),
+    uniqueIndex("idx_tdi_table_doc").on(table.tableId, table.documentId),
+  ]
+);
+
+export const taskTableInputs = sqliteTable(
+  "task_table_inputs",
+  {
+    id: text("id").primaryKey(),
+    taskId: text("task_id")
+      .references(() => tasks.id)
+      .notNull(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_tti_task").on(table.taskId),
+    uniqueIndex("idx_tti_task_table").on(table.taskId, table.tableId),
+  ]
+);
+
+export const workflowTableInputs = sqliteTable(
+  "workflow_table_inputs",
+  {
+    id: text("id").primaryKey(),
+    workflowId: text("workflow_id")
+      .references(() => workflows.id)
+      .notNull(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    /** null = table available to all steps; set = scoped to specific step */
+    stepId: text("step_id"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_wti_workflow").on(table.workflowId),
+    uniqueIndex("idx_wti_workflow_table_step").on(
+      table.workflowId,
+      table.tableId,
+      table.stepId
+    ),
+  ]
+);
+
+export const scheduleTableInputs = sqliteTable(
+  "schedule_table_inputs",
+  {
+    id: text("id").primaryKey(),
+    scheduleId: text("schedule_id")
+      .references(() => schedules.id)
+      .notNull(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_sti_schedule").on(table.scheduleId),
+    uniqueIndex("idx_sti_schedule_table").on(
+      table.scheduleId,
+      table.tableId
+    ),
+  ]
+);
+
+// ── Table Workflow Triggers ──────────────────────────────────────────
+
+export const userTableTriggers = sqliteTable(
+  "user_table_triggers",
+  {
+    id: text("id").primaryKey(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    name: text("name").notNull(),
+    triggerEvent: text("trigger_event", {
+      enum: ["row_added", "row_updated", "row_deleted"],
+    }).notNull(),
+    /** JSON condition using filter format (null = always fire) */
+    condition: text("condition"),
+    actionType: text("action_type", {
+      enum: ["run_workflow", "create_task"],
+    }).notNull(),
+    /** JSON config: { workflowId } or { title, description, projectId } */
+    actionConfig: text("action_config").notNull(),
+    status: text("status", { enum: ["active", "paused"] })
+      .default("active")
+      .notNull(),
+    fireCount: integer("fire_count").default(0).notNull(),
+    lastFiredAt: integer("last_fired_at", { mode: "timestamp" }),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_user_table_triggers_table_id").on(table.tableId),
+    index("idx_user_table_triggers_status").on(table.status),
+  ]
+);
+
+// ── Table Row Version History ────────────────────────────────────────
+
+export const userTableRowHistory = sqliteTable(
+  "user_table_row_history",
+  {
+    id: text("id").primaryKey(),
+    rowId: text("row_id").notNull(),
+    tableId: text("table_id")
+      .references(() => userTables.id)
+      .notNull(),
+    /** JSON snapshot of the row data before the change */
+    previousData: text("previous_data").notNull(),
+    changedBy: text("changed_by").default("user"),
+    changeType: text("change_type", { enum: ["update", "delete"] }).notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_row_history_row_id").on(table.rowId),
+    index("idx_row_history_table_id").on(table.tableId),
+    index("idx_row_history_created_at").on(table.createdAt),
+  ]
+);
+
 // Shared types derived from schema — use these in components instead of `as any`
 export type ProjectRow = InferSelectModel<typeof projects>;
 export type TaskRow = InferSelectModel<typeof tasks>;
@@ -703,3 +1106,45 @@ export type ReadingProgressRow = InferSelectModel<typeof readingProgress>;
 export type BookmarkRow = InferSelectModel<typeof bookmarks>;
 export type RepoImportRow = InferSelectModel<typeof repoImports>;
 export type AgentMessageRow = InferSelectModel<typeof agentMessages>;
+export type UserTableRow = InferSelectModel<typeof userTables>;
+export type UserTableColumnRow = InferSelectModel<typeof userTableColumns>;
+export type UserTableRowRow = InferSelectModel<typeof userTableRows>;
+export type UserTableViewRow = InferSelectModel<typeof userTableViews>;
+export type UserTableRelationshipRow = InferSelectModel<typeof userTableRelationships>;
+export type UserTableTemplateRow = InferSelectModel<typeof userTableTemplates>;
+export type UserTableImportRow = InferSelectModel<typeof userTableImports>;
+export type TableDocumentInputRow = InferSelectModel<typeof tableDocumentInputs>;
+export type TaskTableInputRow = InferSelectModel<typeof taskTableInputs>;
+export type WorkflowTableInputRow = InferSelectModel<typeof workflowTableInputs>;
+export type ScheduleTableInputRow = InferSelectModel<typeof scheduleTableInputs>;
+export type UserTableTriggerRow = InferSelectModel<typeof userTableTriggers>;
+export type UserTableRowHistoryRow = InferSelectModel<typeof userTableRowHistory>;
+
+// ── Snapshots ──────────────────────────────────────────────────────────
+
+export const snapshots = sqliteTable(
+  "snapshots",
+  {
+    id: text("id").primaryKey(),
+    label: text("label").notNull(),
+    type: text("type", { enum: ["manual", "auto"] })
+      .default("manual")
+      .notNull(),
+    status: text("status", { enum: ["in_progress", "completed", "failed"] })
+      .default("in_progress")
+      .notNull(),
+    filePath: text("file_path").notNull(),
+    sizeBytes: integer("size_bytes").default(0).notNull(),
+    dbSizeBytes: integer("db_size_bytes").default(0).notNull(),
+    filesSizeBytes: integer("files_size_bytes").default(0).notNull(),
+    fileCount: integer("file_count").default(0).notNull(),
+    error: text("error"),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  },
+  (table) => [
+    index("idx_snapshots_type").on(table.type),
+    index("idx_snapshots_created_at").on(table.createdAt),
+  ]
+);
+
+export type SnapshotRow = InferSelectModel<typeof snapshots>;

package/src/lib/docs/reader.ts

@@ -1,12 +1,11 @@
 import { readFileSync, readdirSync, existsSync } from "fs";
 import { join, basename } from "path";
 import type { DocManifest, ParsedDoc } from "./types";
+import { getAppRoot } from "../utils/app-root";
 
 /** Resolve the docs directory relative to this source file (npx-safe) */
 function docsDir(): string {
-  const dir = import.meta.dirname ?? __dirname;
-  // src/lib/docs/ → project root → docs/
-  return join(dir, "..", "..", "..", "docs");
+  return join(getAppRoot(import.meta.dirname, 3), "docs");
 }
 
 /** Read and parse docs/manifest.json */

package/src/lib/documents/context-builder.ts

@@ -4,8 +4,8 @@
  */
 
 import { db } from "@/lib/db";
-import { documents } from "@/lib/db/schema";
-import { and, eq } from "drizzle-orm";
+import { documents, workflowDocumentInputs } from "@/lib/db/schema";
+import { and, eq, inArray, isNull } from "drizzle-orm";
 import type { DocumentRow } from "@/lib/db/schema";
 
 const MAX_INLINE_TEXT = 10_000;
@@ -114,3 +114,76 @@ export async function buildWorkflowDocumentContext(
     return null;
   }
 }
+
+/**
+ * Build document context from the workflow document pool (junction table).
+ * Queries workflow_document_inputs for documents bound to this workflow,
+ * optionally scoped to a specific step. Returns null if no pool documents.
+ *
+ * Includes both workflow-level bindings (stepId=null) and step-specific bindings.
+ */
+export async function buildPoolDocumentContext(
+  workflowId: string,
+  stepId?: string
+): Promise<string | null> {
+  try {
+    // Get workflow-level (stepId=null) bindings — available to all steps
+    const globalBindings = await db
+      .select({ documentId: workflowDocumentInputs.documentId })
+      .from(workflowDocumentInputs)
+      .where(
+        and(
+          eq(workflowDocumentInputs.workflowId, workflowId),
+          isNull(workflowDocumentInputs.stepId)
+        )
+      );
+
+    // If a specific step, also get step-scoped bindings
+    let stepBindings: { documentId: string }[] = [];
+    if (stepId) {
+      stepBindings = await db
+        .select({ documentId: workflowDocumentInputs.documentId })
+        .from(workflowDocumentInputs)
+        .where(
+          and(
+            eq(workflowDocumentInputs.workflowId, workflowId),
+            eq(workflowDocumentInputs.stepId, stepId)
+          )
+        );
+    }
+
+    // Deduplicate document IDs
+    const docIdSet = new Set<string>();
+    for (const b of [...globalBindings, ...stepBindings]) {
+      docIdSet.add(b.documentId);
+    }
+
+    if (docIdSet.size === 0) return null;
+
+    const docs = await db
+      .select()
+      .from(documents)
+      .where(inArray(documents.id, [...docIdSet]));
+
+    if (docs.length === 0) return null;
+
+    const sections = docs.map((doc, i) => formatDocument(doc, i));
+    let result = sections.join("\n\n");
+
+    if (result.length > MAX_WORKFLOW_DOC_CONTEXT) {
+      result = result.slice(0, MAX_WORKFLOW_DOC_CONTEXT);
+      result += `\n\n(Pool document context truncated at ${MAX_WORKFLOW_DOC_CONTEXT} chars — use Read tool for full content)`;
+    }
+
+    return [
+      "--- Workflow Pool Documents ---",
+      "",
+      result,
+      "",
+      "--- End Workflow Pool Documents ---",
+    ].join("\n");
+  } catch (error) {
+    console.error("[context-builder] Failed to build pool document context:", error);
+    return null;
+  }
+}

package/src/lib/documents/document-resolver.ts

@@ -0,0 +1,119 @@
+/**
+ * Resolve document selectors against the project document pool.
+ * Used at workflow creation time for auto-discovery of relevant documents.
+ */
+
+import { db } from "@/lib/db";
+import { documents, workflows, tasks } from "@/lib/db/schema";
+import { and, eq, desc, like, inArray } from "drizzle-orm";
+import type { DocumentRow } from "@/lib/db/schema";
+import type { DocumentSelector } from "@/lib/workflows/types";
+
+/**
+ * Resolve a DocumentSelector against the project pool, returning matching documents.
+ * Used for auto-discovery at workflow creation time (not at execution time).
+ */
+export async function resolveDocumentSelector(
+  projectId: string,
+  selector: DocumentSelector
+): Promise<DocumentRow[]> {
+  const conditions = [eq(documents.projectId, projectId)];
+
+  if (selector.direction) {
+    conditions.push(eq(documents.direction, selector.direction));
+  }
+
+  if (selector.category) {
+    conditions.push(eq(documents.category, selector.category));
+  }
+
+  if (selector.mimeType) {
+    conditions.push(eq(documents.mimeType, selector.mimeType));
+  }
+
+  if (selector.namePattern) {
+    // Convert glob pattern to SQL LIKE: * → %, ? → _
+    const likePattern = selector.namePattern
+      .replace(/\*/g, "%")
+      .replace(/\?/g, "_");
+    conditions.push(like(documents.originalName, likePattern));
+  }
+
+  // Filter by source workflow (via task → workflow relationship)
+  if (selector.fromWorkflowId) {
+    const workflowTaskIds = await db
+      .select({ id: tasks.id })
+      .from(tasks)
+      .where(eq(tasks.workflowId, selector.fromWorkflowId));
+
+    const taskIds = workflowTaskIds.map((t) => t.id);
+    if (taskIds.length === 0) return [];
+    conditions.push(inArray(documents.taskId, taskIds));
+  } else if (selector.fromWorkflowName) {
+    // Look up workflow by name, then get its task IDs
+    const matchingWorkflows = await db
+      .select({ id: workflows.id })
+      .from(workflows)
+      .where(
+        and(
+          eq(workflows.projectId, projectId),
+          like(workflows.name, `%${selector.fromWorkflowName}%`)
+        )
+      );
+
+    if (matchingWorkflows.length === 0) return [];
+
+    const wfIds = matchingWorkflows.map((w) => w.id);
+    const workflowTaskIds = await db
+      .select({ id: tasks.id })
+      .from(tasks)
+      .where(inArray(tasks.workflowId, wfIds));
+
+    const taskIds = workflowTaskIds.map((t) => t.id);
+    if (taskIds.length === 0) return [];
+    conditions.push(inArray(documents.taskId, taskIds));
+  }
+
+  // Only return ready documents (processed and available)
+  conditions.push(eq(documents.status, "ready"));
+
+  let query = db
+    .select()
+    .from(documents)
+    .where(and(...conditions))
+    .orderBy(desc(documents.createdAt));
+
+  if (selector.latest) {
+    query = query.limit(selector.latest) as typeof query;
+  }
+
+  return query;
+}
+
+/**
+ * Get all output documents from completed workflows in a project.
+ * Useful for browsing the project document pool.
+ */
+export async function getProjectDocumentPool(
+  projectId: string,
+  options?: { direction?: "input" | "output"; search?: string }
+): Promise<DocumentRow[]> {
+  const conditions = [
+    eq(documents.projectId, projectId),
+    eq(documents.status, "ready"),
+  ];
+
+  if (options?.direction) {
+    conditions.push(eq(documents.direction, options.direction));
+  }
+
+  if (options?.search) {
+    conditions.push(like(documents.originalName, `%${options.search}%`));
+  }
+
+  return db
+    .select()
+    .from(documents)
+    .where(and(...conditions))
+    .orderBy(desc(documents.createdAt));
+}

package/src/lib/documents/processors/spreadsheet.ts

@@ -6,7 +6,8 @@ export async function processSpreadsheet(filePath: string): Promise<ProcessorRes
   const ExcelJS = await import("exceljs");
   const workbook = new ExcelJS.Workbook();
   const buffer = await readFile(filePath);
-  await workbook.xlsx.load(buffer as unknown as Buffer);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await workbook.xlsx.load(buffer as any);
 
   const sheets: string[] = [];
   workbook.eachSheet((worksheet) => {