stagent 0.6.2 → 0.7.0

package/src/lib/tables/trigger-evaluator.ts

@@ -0,0 +1,146 @@
+/**
+ * Trigger evaluator — checks active triggers on row mutations
+ * and fires matching actions (create task or start workflow).
+ */
+
+import { db } from "@/lib/db";
+import { userTableTriggers } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+import type { FilterSpec } from "./types";
+
+type TriggerEvent = "row_added" | "row_updated" | "row_deleted";
+
+interface ActionConfig {
+  workflowId?: string;
+  title?: string;
+  description?: string;
+  projectId?: string;
+}
+
+/**
+ * Evaluate and fire triggers for a table event.
+ * Called from row mutation API routes after successful writes.
+ */
+export async function evaluateTriggers(
+  tableId: string,
+  event: TriggerEvent,
+  rowData: Record<string, unknown>
+): Promise<void> {
+  // Find active triggers matching this event
+  const triggers = db
+    .select()
+    .from(userTableTriggers)
+    .where(
+      and(
+        eq(userTableTriggers.tableId, tableId),
+        eq(userTableTriggers.triggerEvent, event),
+        eq(userTableTriggers.status, "active")
+      )
+    )
+    .all();
+
+  if (triggers.length === 0) return;
+
+  for (const trigger of triggers) {
+    // Evaluate condition if present
+    if (trigger.condition) {
+      const condition = JSON.parse(trigger.condition) as FilterSpec;
+      if (!matchesCondition(rowData, condition)) continue;
+    }
+
+    // Fire the action
+    try {
+      const config = JSON.parse(trigger.actionConfig) as ActionConfig;
+      await fireAction(trigger.actionType as "run_workflow" | "create_task", config, rowData);
+
+      // Update fire count
+      db.update(userTableTriggers)
+        .set({
+          fireCount: trigger.fireCount + 1,
+          lastFiredAt: new Date(),
+          updatedAt: new Date(),
+        })
+        .where(eq(userTableTriggers.id, trigger.id))
+        .run();
+    } catch (err) {
+      console.error(`[triggers] Failed to fire trigger ${trigger.id}:`, err);
+    }
+  }
+}
+
+/**
+ * Check if row data matches a filter condition.
+ * Reuses the same operator logic as the query builder.
+ */
+function matchesCondition(
+  data: Record<string, unknown>,
+  condition: FilterSpec
+): boolean {
+  const value = data[condition.column];
+  const strValue = value == null ? "" : String(value);
+
+  switch (condition.operator) {
+    case "eq":
+      return strValue === String(condition.value);
+    case "neq":
+      return strValue !== String(condition.value);
+    case "gt":
+      return Number(value) > Number(condition.value);
+    case "gte":
+      return Number(value) >= Number(condition.value);
+    case "lt":
+      return Number(value) < Number(condition.value);
+    case "lte":
+      return Number(value) <= Number(condition.value);
+    case "contains":
+      return strValue.toLowerCase().includes(String(condition.value).toLowerCase());
+    case "starts_with":
+      return strValue.toLowerCase().startsWith(String(condition.value).toLowerCase());
+    case "in":
+      return Array.isArray(condition.value) && condition.value.includes(strValue);
+    case "is_empty":
+      return value == null || strValue === "";
+    case "is_not_empty":
+      return value != null && strValue !== "";
+    default:
+      return true;
+  }
+}
+
+/**
+ * Fire a trigger action — create a task or start a workflow.
+ */
+async function fireAction(
+  actionType: "run_workflow" | "create_task",
+  config: ActionConfig,
+  rowData: Record<string, unknown>
+): Promise<void> {
+  if (actionType === "create_task") {
+    const description = config.description
+      ? `${config.description}\n\nTrigger data: ${JSON.stringify(rowData, null, 2)}`
+      : `Triggered by table row change.\n\nData: ${JSON.stringify(rowData, null, 2)}`;
+
+    await fetch(`${getBaseUrl()}/api/tasks`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        title: config.title ?? "Triggered Task",
+        description,
+        projectId: config.projectId ?? null,
+      }),
+    });
+  } else if (actionType === "run_workflow" && config.workflowId) {
+    // Start workflow execution
+    await fetch(`${getBaseUrl()}/api/workflows/${config.workflowId}/execute`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        context: `Table row data: ${JSON.stringify(rowData, null, 2)}`,
+      }),
+    });
+  }
+}
+
+function getBaseUrl(): string {
+  return process.env.NEXTAUTH_URL || process.env.NEXT_PUBLIC_APP_URL || "http://localhost:3000";
+}

package/src/lib/tables/types.ts

@@ -0,0 +1,141 @@
+import type {
+  UserTableRow,
+  UserTableColumnRow,
+  UserTableRowRow,
+  UserTableTemplateRow,
+} from "@/lib/db/schema";
+import type { ColumnDataType } from "@/lib/constants/table-status";
+
+// ── Column Definition (stored in column_schema JSON) ─────────────────
+
+export interface ColumnDef {
+  name: string;
+  displayName: string;
+  dataType: ColumnDataType;
+  position: number;
+  required?: boolean;
+  defaultValue?: string | null;
+  config?: ColumnConfig | null;
+}
+
+/** Type-specific column configuration */
+export interface ColumnConfig {
+  /** Select column: available options */
+  options?: string[];
+  /** Computed column: formula expression */
+  formula?: string;
+  /** Computed column: formula type */
+  formulaType?: "arithmetic" | "text_concat" | "date_diff" | "conditional" | "aggregate";
+  /** Computed column: expected result type */
+  resultType?: ColumnDataType;
+  /** Computed column: column names this formula depends on */
+  dependencies?: string[];
+  /** Relation column: target table ID */
+  targetTableId?: string;
+  /** Relation column: display column name in target table */
+  displayColumn?: string;
+}
+
+// ── Filter & Sort Specs ──────────────────────────────────────────────
+
+export type FilterOperator =
+  | "eq"
+  | "neq"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+  | "contains"
+  | "starts_with"
+  | "in"
+  | "is_empty"
+  | "is_not_empty";
+
+export interface FilterSpec {
+  column: string;
+  operator: FilterOperator;
+  value?: string | number | boolean | string[];
+}
+
+export interface SortSpec {
+  column: string;
+  direction: "asc" | "desc";
+}
+
+// ── Query Options ────────────────────────────────────────────────────
+
+export interface RowQueryOptions {
+  filters?: FilterSpec[];
+  sorts?: SortSpec[];
+  limit?: number;
+  offset?: number;
+}
+
+// ── Enriched Types (with joins) ──────────────────────────────────────
+
+export interface TableWithRelations extends UserTableRow {
+  projectName?: string | null;
+  columnCount: number;
+  columns?: UserTableColumnRow[];
+}
+
+export interface RowWithMeta extends UserTableRowRow {
+  parsedData: Record<string, unknown>;
+}
+
+// ── Input Types ──────────────────────────────────────────────────────
+
+export interface CreateTableInput {
+  name: string;
+  description?: string | null;
+  projectId?: string | null;
+  columns?: ColumnDef[];
+  source?: "manual" | "imported" | "agent" | "template";
+  templateId?: string | null;
+}
+
+export interface UpdateTableInput {
+  name?: string;
+  description?: string | null;
+  projectId?: string | null;
+}
+
+export interface AddColumnInput {
+  name: string;
+  displayName: string;
+  dataType: ColumnDataType;
+  required?: boolean;
+  defaultValue?: string | null;
+  config?: ColumnConfig | null;
+}
+
+export interface UpdateColumnInput {
+  displayName?: string;
+  dataType?: ColumnDataType;
+  required?: boolean;
+  defaultValue?: string | null;
+  config?: ColumnConfig | null;
+}
+
+export interface AddRowInput {
+  data: Record<string, unknown>;
+  createdBy?: string;
+}
+
+export interface UpdateRowInput {
+  data: Record<string, unknown>;
+}
+
+// ── Template Types ───────────────────────────────────────────────────
+
+export interface TemplateWithPreview extends UserTableTemplateRow {
+  parsedColumns: ColumnDef[];
+  parsedSampleData: Record<string, unknown>[];
+}
+
+export interface CloneFromTemplateInput {
+  templateId: string;
+  name: string;
+  projectId?: string | null;
+  includeSampleData?: boolean;
+}

package/src/lib/tables/validation.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import { COLUMN_DATA_TYPES, TABLE_SOURCES, TEMPLATE_CATEGORIES } from "@/lib/constants/table-status";
+
+// ── Column Definition Schema ─────────────────────────────────────────
+
+const columnConfigSchema = z.object({
+  options: z.array(z.string()).optional(),
+  formula: z.string().optional(),
+  formulaType: z.enum(["arithmetic", "text_concat", "date_diff", "conditional", "aggregate"]).optional(),
+  resultType: z.enum(COLUMN_DATA_TYPES).optional(),
+  dependencies: z.array(z.string()).optional(),
+  targetTableId: z.string().optional(),
+  displayColumn: z.string().optional(),
+}).optional();
+
+const columnDefSchema = z.object({
+  name: z.string().min(1).max(64),
+  displayName: z.string().min(1).max(128),
+  dataType: z.enum(COLUMN_DATA_TYPES),
+  position: z.number().int().min(0),
+  required: z.boolean().optional(),
+  defaultValue: z.string().nullable().optional(),
+  config: columnConfigSchema,
+});
+
+// ── Table Schemas ────────────────────────────────────────────────────
+
+export const createTableSchema = z.object({
+  name: z.string().min(1).max(256),
+  description: z.string().max(1024).nullable().optional(),
+  projectId: z.string().nullable().optional(),
+  columns: z.array(columnDefSchema).optional(),
+  source: z.enum(TABLE_SOURCES).optional(),
+  templateId: z.string().nullable().optional(),
+});
+
+export const updateTableSchema = z.object({
+  name: z.string().min(1).max(256).optional(),
+  description: z.string().max(1024).nullable().optional(),
+  projectId: z.string().nullable().optional(),
+});
+
+// ── Column Schemas ───────────────────────────────────────────────────
+
+export const addColumnSchema = z.object({
+  name: z.string().min(1).max(64),
+  displayName: z.string().min(1).max(128),
+  dataType: z.enum(COLUMN_DATA_TYPES),
+  required: z.boolean().optional(),
+  defaultValue: z.string().nullable().optional(),
+  config: columnConfigSchema,
+});
+
+export const updateColumnSchema = z.object({
+  displayName: z.string().min(1).max(128).optional(),
+  dataType: z.enum(COLUMN_DATA_TYPES).optional(),
+  required: z.boolean().optional(),
+  defaultValue: z.string().nullable().optional(),
+  config: columnConfigSchema,
+});
+
+export const reorderColumnsSchema = z.object({
+  /** Array of column IDs in the desired order */
+  columnIds: z.array(z.string()).min(1),
+});
+
+// ── Row Schemas ──────────────────────────────────────────────────────
+
+export const addRowsSchema = z.object({
+  rows: z.array(
+    z.object({
+      data: z.record(z.string(), z.unknown()),
+      createdBy: z.string().optional(),
+    })
+  ).min(1).max(1000),
+});
+
+export const updateRowSchema = z.object({
+  data: z.record(z.string(), z.unknown()),
+});
+
+// ── Query Schemas ────────────────────────────────────────────────────
+
+const filterOperators = [
+  "eq", "neq", "gt", "gte", "lt", "lte",
+  "contains", "starts_with", "in", "is_empty", "is_not_empty",
+] as const;
+
+export const filterSpecSchema = z.object({
+  column: z.string().min(1),
+  operator: z.enum(filterOperators),
+  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]).optional(),
+});
+
+export const sortSpecSchema = z.object({
+  column: z.string().min(1),
+  direction: z.enum(["asc", "desc"]),
+});
+
+export const rowQuerySchema = z.object({
+  filters: z.array(filterSpecSchema).optional(),
+  sorts: z.array(sortSpecSchema).optional(),
+  limit: z.number().int().min(1).max(1000).optional(),
+  offset: z.number().int().min(0).optional(),
+});
+
+// ── Template Schemas ─────────────────────────────────────────────────
+
+export const cloneFromTemplateSchema = z.object({
+  templateId: z.string(),
+  name: z.string().min(1).max(256),
+  projectId: z.string().nullable().optional(),
+  includeSampleData: z.boolean().optional(),
+});
+
+export const listTemplatesSchema = z.object({
+  category: z.enum(TEMPLATE_CATEGORIES).optional(),
+  scope: z.enum(["system", "user"]).optional(),
+});

package/src/lib/utils/app-root.ts

@@ -0,0 +1,20 @@
+/**
+ * Resolve the app root directory.
+ * - import.meta.dirname works under npx (real path to installed package)
+ * - Turbopack compiles it to /ROOT/... (virtual, doesn't exist) → fall back to process.cwd()
+ *
+ * Uses dynamic require() for fs/path to avoid bundling Node built-ins
+ * into client components (content.ts is shared with book-reader.tsx).
+ */
+export function getAppRoot(metaDirname: string | undefined, depth: number): string {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { existsSync } = require("fs") as typeof import("fs");
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { join } = require("path") as typeof import("path");
+
+  if (metaDirname) {
+    const candidate = join(metaDirname, ...Array(depth).fill(".."));
+    if (existsSync(join(candidate, "package.json"))) return candidate;
+  }
+  return process.cwd();
+}

package/src/lib/utils/stagent-paths.ts

@@ -20,3 +20,23 @@ export function getStagentBlueprintsDir(): string {
 export function getStagentScreenshotsDir(): string {
   return join(getStagentDataDir(), "screenshots");
 }
+
+export function getStagentSnapshotsDir(): string {
+  return join(getStagentDataDir(), "snapshots");
+}
+
+export function getStagentOutputsDir(): string {
+  return join(getStagentDataDir(), "outputs");
+}
+
+export function getStagentSessionsDir(): string {
+  return join(getStagentDataDir(), "sessions");
+}
+
+export function getStagentLogsDir(): string {
+  return join(getStagentDataDir(), "logs");
+}
+
+export function getStagentDocumentsDir(): string {
+  return join(getStagentDataDir(), "documents");
+}

package/src/lib/validators/__tests__/task.test.ts

@@ -72,40 +72,63 @@ describe("createTaskSchema", () => {
     }
   });
 
-  it("accepts fileIds as optional array of strings", () => {
+  it("accepts documentIds as optional array of strings", () => {
     const result = createTaskSchema.safeParse({
       title: "Test",
-      fileIds: ["abc-123", "def-456"],
+      documentIds: ["abc-123", "def-456"],
     });
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.data.fileIds).toEqual(["abc-123", "def-456"]);
+      expect(result.data.documentIds).toEqual(["abc-123", "def-456"]);
     }
   });
 
-  it("accepts task without fileIds", () => {
+  it("accepts task without documentIds", () => {
     const result = createTaskSchema.safeParse({ title: "Test" });
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.data.fileIds).toBeUndefined();
+      expect(result.data.documentIds).toBeUndefined();
     }
   });
 
-  it("accepts empty fileIds array", () => {
-    const result = createTaskSchema.safeParse({ title: "Test", fileIds: [] });
+  it("accepts empty documentIds array", () => {
+    const result = createTaskSchema.safeParse({ title: "Test", documentIds: [] });
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.data.fileIds).toEqual([]);
+      expect(result.data.documentIds).toEqual([]);
     }
   });
 
-  it("rejects fileIds with non-string elements", () => {
+  it("rejects documentIds with non-string elements", () => {
     const result = createTaskSchema.safeParse({
       title: "Test",
-      fileIds: [123, true],
+      documentIds: [123, true],
     });
     expect(result.success).toBe(false);
   });
+
+  it("accepts deprecated fileIds and transforms to documentIds", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Test",
+      fileIds: ["file-1", "file-2"],
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.documentIds).toEqual(["file-1", "file-2"]);
+    }
+  });
+
+  it("prefers documentIds over fileIds when both provided", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Test",
+      documentIds: ["doc-1"],
+      fileIds: ["file-1"],
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.documentIds).toEqual(["doc-1"]);
+    }
+  });
 });
 
 describe("updateTaskSchema", () => {
@@ -141,4 +164,14 @@ describe("updateTaskSchema", () => {
     });
     expect(result.success).toBe(false);
   });
+
+  it("accepts documentIds in update", () => {
+    const result = updateTaskSchema.safeParse({
+      documentIds: ["doc-1", "doc-2"],
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.documentIds).toEqual(["doc-1", "doc-2"]);
+    }
+  });
 });

package/src/lib/validators/task.ts

@@ -10,8 +10,13 @@ export const createTaskSchema = z.object({
   priority: z.number().min(0).max(3).default(2),
   assignedAgent: assignedAgentSchema.optional(),
   agentProfile: z.string().optional(),
+  documentIds: z.array(z.string()).optional(),
+  /** @deprecated Use documentIds instead */
   fileIds: z.array(z.string()).optional(),
-});
+}).transform((data) => ({
+  ...data,
+  documentIds: data.documentIds ?? data.fileIds,
+}));
 
 export const updateTaskSchema = z.object({
   title: z.string().min(1).max(200).optional(),
@@ -24,6 +29,7 @@ export const updateTaskSchema = z.object({
   agentProfile: z.string().optional(),
   result: z.string().optional(),
   sessionId: z.string().optional(),
+  documentIds: z.array(z.string()).optional(),
 });
 
 export type CreateTaskInput = z.infer<typeof createTaskSchema>;

package/src/lib/workflows/blueprints/registry.ts

@@ -3,12 +3,12 @@ import path from "node:path";
 import yaml from "js-yaml";
 import { BlueprintSchema } from "@/lib/validators/blueprint";
 import { getStagentBlueprintsDir } from "@/lib/utils/stagent-paths";
+import { getAppRoot } from "@/lib/utils/app-root";
 import type { WorkflowBlueprint } from "./types";
 
-// Use fileURLToPath for ESM compatibility in Next.js
 const BUILTINS_DIR = path.resolve(
-  import.meta.dirname ?? path.dirname(new URL(import.meta.url).pathname),
-  "builtins"
+  getAppRoot(import.meta.dirname, 4),
+  "src", "lib", "workflows", "blueprints", "builtins"
 );
 
 const USER_BLUEPRINTS_DIR = getStagentBlueprintsDir();

package/src/lib/workflows/engine.ts

@@ -20,7 +20,10 @@ import {
   openLearningSession,
   closeLearningSession,
 } from "@/lib/agents/learning-session";
-import { buildWorkflowDocumentContext } from "@/lib/documents/context-builder";
+import {
+  buildWorkflowDocumentContext,
+  buildPoolDocumentContext,
+} from "@/lib/documents/context-builder";
 
 /**
  * Execute a workflow by advancing through its steps according to the pattern.
@@ -359,7 +362,8 @@ async function executeParallel(
         step.prompt,
         step.assignedAgent,
         step.agentProfile,
-        parentTaskId
+        parentTaskId,
+        step.id
       );
 
       const completedAt = new Date().toISOString();
@@ -433,7 +437,8 @@ async function executeParallel(
     synthesisPrompt,
     synthesisStep.assignedAgent,
     synthesisStep.agentProfile,
-    parentTaskId
+    parentTaskId,
+    synthesisStep.id
   );
 
   await commitState((draft) => {
@@ -559,7 +564,8 @@ async function executeSwarm(
         workerPrompt,
         step.assignedAgent,
         step.agentProfile,
-        parentTaskId
+        parentTaskId,
+        step.id
       );
 
       const completedAt = new Date().toISOString();
@@ -680,7 +686,8 @@ async function runSwarmRefinery(input: {
     refineryPrompt,
     refineryStep.assignedAgent,
     refineryStep.agentProfile,
-    parentTaskId
+    parentTaskId,
+    refineryStep.id
   );
 
   refineryState.taskId = refineryResult.taskId;
@@ -716,7 +723,8 @@ export async function executeChildTask(
   prompt: string,
   assignedAgent?: string,
   agentProfile?: string,
-  parentTaskId?: string
+  parentTaskId?: string,
+  stepId?: string
 ): Promise<{ taskId: string; status: string; result?: string; error?: string }> {
   const [workflow] = await db
     .select()
@@ -735,10 +743,16 @@ export async function executeChildTask(
   if (parentTaskId) {
     const docContext = await buildWorkflowDocumentContext(parentTaskId);
     if (docContext) {
-      enrichedPrompt = `${docContext}\n\n${prompt}`;
+      enrichedPrompt = `${docContext}\n\n${enrichedPrompt}`;
     }
   }
 
+  // Inject pool document context from workflow_document_inputs junction table
+  const poolContext = await buildPoolDocumentContext(workflowId, stepId);
+  if (poolContext) {
+    enrichedPrompt = `${poolContext}\n\n${enrichedPrompt}`;
+  }
+
   const taskId = crypto.randomUUID();
   await db.insert(tasks).values({
     id: taskId,
@@ -751,6 +765,7 @@ export async function executeChildTask(
     priority: 1,
     assignedAgent: assignedAgent ?? null,
     agentProfile: resolvedProfile ?? null,
+    workflowRunNumber: workflow?.runNumber ?? null,
     createdAt: new Date(),
     updatedAt: new Date(),
   });
@@ -807,7 +822,8 @@ async function executeStep(
     prompt,
     assignedAgent,
     agentProfile,
-    parentTaskId
+    parentTaskId,
+    stepId
   );
 
   stepState.taskId = result.taskId;