stagent 0.6.2 → 0.7.0

package/src/lib/chat/tools/workflow-tools.ts

@@ -1,8 +1,15 @@
 import { defineTool } from "../tool-registry";
 import { z } from "zod";
 import { db } from "@/lib/db";
-import { workflows, tasks, agentLogs, notifications, documents } from "@/lib/db/schema";
-import { eq, and, desc } from "drizzle-orm";
+import {
+  workflows,
+  tasks,
+  agentLogs,
+  notifications,
+  documents,
+  workflowDocumentInputs,
+} from "@/lib/db/schema";
+import { eq, and, desc, inArray, like } from "drizzle-orm";
 import { ok, err, type ToolContext } from "./helpers";
 
 const VALID_WORKFLOW_STATUSES = [
@@ -74,6 +81,12 @@ export function workflowTools(ctx: ToolContext) {
           .describe(
             'Workflow definition as JSON string. Must include "pattern" and "steps" array. Example: {"pattern":"sequence","steps":[{"name":"step1","prompt":"Do X","assignedAgent":"claude"}]}'
           ),
+        documentIds: z
+          .array(z.string())
+          .optional()
+          .describe(
+            "Optional array of document IDs from the project pool to attach as input context. These documents will be injected into all workflow steps at execution time."
+          ),
       },
       async (args) => {
         try {
@@ -103,6 +116,25 @@ export function workflowTools(ctx: ToolContext) {
             updatedAt: now,
           });
 
+          // Attach pool documents if provided
+          const attachedDocs: string[] = [];
+          if (args.documentIds && args.documentIds.length > 0) {
+            for (const docId of args.documentIds) {
+              try {
+                await db.insert(workflowDocumentInputs).values({
+                  id: crypto.randomUUID(),
+                  workflowId: id,
+                  documentId: docId,
+                  stepId: null,
+                  createdAt: now,
+                });
+                attachedDocs.push(docId);
+              } catch {
+                // Skip duplicates or invalid doc IDs
+              }
+            }
+          }
+
           const [workflow] = await db
             .select()
             .from(workflows)
@@ -115,6 +147,7 @@ export function workflowTools(ctx: ToolContext) {
             projectId: workflow.projectId,
             status: workflow.status,
             createdAt: workflow.createdAt,
+            attachedDocuments: attachedDocs.length,
           });
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to create workflow");
@@ -354,5 +387,115 @@ export function workflowTools(ctx: ToolContext) {
         }
       }
     ),
+
+    defineTool(
+      "find_related_documents",
+      "Search for documents in the project pool that could be used as context for a workflow. Returns output documents from completed workflows and uploaded documents. Use this proactively when creating follow-up workflows to discover relevant context.",
+      {
+        projectId: z
+          .string()
+          .optional()
+          .describe("Project ID to search in. Omit to use the active project."),
+        query: z
+          .string()
+          .optional()
+          .describe("Search query to match against document names"),
+        direction: z
+          .enum(["input", "output"])
+          .optional()
+          .describe('Filter by direction. Use "output" to find documents produced by other workflows.'),
+        sourceWorkflowId: z
+          .string()
+          .optional()
+          .describe("Filter to documents produced by a specific workflow"),
+        limit: z
+          .number()
+          .optional()
+          .describe("Maximum number of documents to return (default: 20)"),
+      },
+      async (args) => {
+        try {
+          const effectiveProjectId = args.projectId ?? ctx.projectId ?? undefined;
+          if (!effectiveProjectId) {
+            return err("No project context — specify a projectId or set an active project");
+          }
+
+          const conditions = [
+            eq(documents.projectId, effectiveProjectId),
+            eq(documents.status, "ready"),
+          ];
+
+          if (args.direction) {
+            conditions.push(eq(documents.direction, args.direction));
+          }
+
+          if (args.query) {
+            conditions.push(like(documents.originalName, `%${args.query}%`));
+          }
+
+          if (args.sourceWorkflowId) {
+            // Find task IDs belonging to the source workflow
+            const workflowTasks = await db
+              .select({ id: tasks.id })
+              .from(tasks)
+              .where(eq(tasks.workflowId, args.sourceWorkflowId));
+
+            const taskIds = workflowTasks.map((t) => t.id);
+            if (taskIds.length > 0) {
+              conditions.push(inArray(documents.taskId, taskIds));
+            } else {
+              return ok([]); // No tasks for this workflow
+            }
+          }
+
+          const result = await db
+            .select({
+              id: documents.id,
+              originalName: documents.originalName,
+              mimeType: documents.mimeType,
+              size: documents.size,
+              direction: documents.direction,
+              category: documents.category,
+              status: documents.status,
+              taskId: documents.taskId,
+              createdAt: documents.createdAt,
+            })
+            .from(documents)
+            .where(and(...conditions))
+            .orderBy(desc(documents.createdAt))
+            .limit(args.limit ?? 20);
+
+          // Enrich with source workflow name
+          const enriched = await Promise.all(
+            result.map(async (doc) => {
+              let sourceWorkflowName: string | null = null;
+              if (doc.taskId) {
+                const [task] = await db
+                  .select({ workflowId: tasks.workflowId })
+                  .from(tasks)
+                  .where(eq(tasks.id, doc.taskId));
+                if (task?.workflowId) {
+                  const [wf] = await db
+                    .select({ name: workflows.name })
+                    .from(workflows)
+                    .where(eq(workflows.id, task.workflowId));
+                  sourceWorkflowName = wf?.name ?? null;
+                }
+              }
+              return {
+                ...doc,
+                sourceWorkflow: sourceWorkflowName,
+              };
+            })
+          );
+
+          return ok(enriched);
+        } catch (e) {
+          return err(
+            e instanceof Error ? e.message : "Failed to find documents"
+          );
+        }
+      }
+    ),
   ];
 }

package/src/lib/constants/table-status.ts

@@ -0,0 +1,68 @@
+export const TABLE_SOURCES = [
+  "manual",
+  "imported",
+  "agent",
+  "template",
+] as const;
+
+export type TableSource = (typeof TABLE_SOURCES)[number];
+
+export const COLUMN_DATA_TYPES = [
+  "text",
+  "number",
+  "date",
+  "boolean",
+  "select",
+  "url",
+  "email",
+  "relation",
+  "computed",
+] as const;
+
+export type ColumnDataType = (typeof COLUMN_DATA_TYPES)[number];
+
+export const TABLE_VIEW_TYPES = ["grid", "chart", "joined"] as const;
+export type TableViewType = (typeof TABLE_VIEW_TYPES)[number];
+
+export const RELATIONSHIP_TYPES = [
+  "one_to_one",
+  "one_to_many",
+  "many_to_many",
+] as const;
+export type RelationshipType = (typeof RELATIONSHIP_TYPES)[number];
+
+export const TEMPLATE_CATEGORIES = [
+  "business",
+  "personal",
+  "pm",
+  "finance",
+  "content",
+] as const;
+export type TemplateCategory = (typeof TEMPLATE_CATEGORIES)[number];
+
+export const IMPORT_STATUSES = ["pending", "completed", "failed"] as const;
+export type ImportStatus = (typeof IMPORT_STATUSES)[number];
+
+/** Badge variant mappings for table source */
+export const tableSourceVariant: Record<
+  TableSource,
+  "default" | "secondary" | "destructive" | "outline" | "success"
+> = {
+  manual: "outline",
+  imported: "secondary",
+  agent: "default",
+  template: "success",
+};
+
+/** Display labels for column data types */
+export const columnTypeLabel: Record<ColumnDataType, string> = {
+  text: "Text",
+  number: "Number",
+  date: "Date",
+  boolean: "Checkbox",
+  select: "Select",
+  url: "URL",
+  email: "Email",
+  relation: "Relation",
+  computed: "Computed",
+};

package/src/lib/data/__tests__/clear.test.ts

@@ -11,7 +11,7 @@ import * as schema from "@/lib/db/schema";
  * corresponding db.delete() call to clear.ts in the correct FK-safe order.
  */
 describe("clearAllData coverage", () => {
-  const INTENTIONALLY_PRESERVED = ["settings"];
+  const INTENTIONALLY_PRESERVED = ["settings", "snapshots"];
 
   it("deletes every schema table (except settings)", () => {
     const clearSource = readFileSync(

package/src/lib/data/clear.ts

@@ -25,6 +25,22 @@ import {
   channelBindings,
   channelConfigs,
   agentMessages,
+  workflowDocumentInputs,
+  scheduleDocumentInputs,
+  projectDocumentDefaults,
+  userTables,
+  userTableColumns,
+  userTableRows,
+  userTableViews,
+  userTableRelationships,
+  userTableImports,
+  userTableTemplates,
+  userTableTriggers,
+  userTableRowHistory,
+  tableDocumentInputs,
+  taskTableInputs,
+  workflowTableInputs,
+  scheduleTableInputs,
 } from "@/lib/db/schema";
 import { readdirSync, unlinkSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -65,12 +81,37 @@ export function clearAllData() {
   const agentMessagesDeleted = db.delete(agentMessages).run().changes;
   const channelConfigsDeleted = db.delete(channelConfigs).run().changes;
 
+  // Snapshots are intentionally preserved — they are backups, not working data
+
   const repoImportsDeleted = db.delete(repoImports).run().changes;
   const profileTestResultsDeleted = db.delete(profileTestResults).run().changes;
   const viewsDeleted = db.delete(views).run().changes;
   const usageLedgerDeleted = db.delete(usageLedger).run().changes;
   const logsDeleted = db.delete(agentLogs).run().changes;
   const notificationsDeleted = db.delete(notifications).run().changes;
+
+  // Table junction tables — delete before user_tables, tasks, workflows, schedules
+  const tableDocInputsDeleted = db.delete(tableDocumentInputs).run().changes;
+  const taskTableInputsDeleted = db.delete(taskTableInputs).run().changes;
+  const workflowTableInputsDeleted = db.delete(workflowTableInputs).run().changes;
+  const scheduleTableInputsDeleted = db.delete(scheduleTableInputs).run().changes;
+
+  // Table children — delete before user_tables
+  const userTableImportsDeleted = db.delete(userTableImports).run().changes;
+  const userTableViewsDeleted = db.delete(userTableViews).run().changes;
+  const userTableRelationshipsDeleted = db.delete(userTableRelationships).run().changes;
+  const userTableRowsDeleted = db.delete(userTableRows).run().changes;
+  const userTableRowHistoryDeleted = db.delete(userTableRowHistory).run().changes;
+  const userTableTriggersDeleted = db.delete(userTableTriggers).run().changes;
+  const userTableColumnsDeleted = db.delete(userTableColumns).run().changes;
+  const userTablesDeleted = db.delete(userTables).run().changes;
+  const userTableTemplatesDeleted = db.delete(userTableTemplates).run().changes;
+
+  // Document junction tables — delete before documents, workflows, schedules, projects
+  const workflowDocInputsDeleted = db.delete(workflowDocumentInputs).run().changes;
+  const scheduleDocInputsDeleted = db.delete(scheduleDocumentInputs).run().changes;
+  const projectDocDefaultsDeleted = db.delete(projectDocumentDefaults).run().changes;
+
   const documentsDeleted = db.delete(documents).run().changes;
   const agentMemoryDeleted = db.delete(agentMemory).run().changes;
   const learnedContextDeleted = db.delete(learnedContext).run().changes;
@@ -130,6 +171,22 @@ export function clearAllData() {
     agentMessages: agentMessagesDeleted,
     channelBindings: channelBindingsDeleted,
     channelConfigs: channelConfigsDeleted,
+    workflowDocumentInputs: workflowDocInputsDeleted,
+    scheduleDocumentInputs: scheduleDocInputsDeleted,
+    projectDocumentDefaults: projectDocDefaultsDeleted,
+    userTables: userTablesDeleted,
+    userTableColumns: userTableColumnsDeleted,
+    userTableRows: userTableRowsDeleted,
+    userTableViews: userTableViewsDeleted,
+    userTableRelationships: userTableRelationshipsDeleted,
+    userTableImports: userTableImportsDeleted,
+    userTableTemplates: userTableTemplatesDeleted,
+    userTableTriggers: userTableTriggersDeleted,
+    userTableRowHistory: userTableRowHistoryDeleted,
+    tableDocumentInputs: tableDocInputsDeleted,
+    taskTableInputs: taskTableInputsDeleted,
+    workflowTableInputs: workflowTableInputsDeleted,
+    scheduleTableInputs: scheduleTableInputsDeleted,
     files: filesDeleted,
     screenshots: screenshotsDeleted,
   };

package/src/lib/data/seed-data/__tests__/profiles.test.ts

@@ -39,27 +39,27 @@ describe("sample profile seeds", () => {
   });
 
   it("defines stable reserved sample profile ids", () => {
-    expect(SAMPLE_PROFILE_IDS).toHaveLength(3);
+    expect(SAMPLE_PROFILE_IDS).toHaveLength(5);
     expect(SAMPLE_PROFILE_IDS.every((id) => id.startsWith("stagent-sample-"))).toBe(true);
   });
 
   it("returns realistic sample profiles with skill markdown", () => {
     const profiles = getSampleProfiles();
 
-    expect(profiles).toHaveLength(3);
+    expect(profiles).toHaveLength(5);
     expect(profiles.map((profile) => profile.config.id)).toEqual(
       Array.from(SAMPLE_PROFILE_IDS)
     );
     expect(profiles[0].skillMd).toContain("description:");
-    expect(profiles[1].config.tags).toContain("messaging");
-    expect(profiles[2].config.domain).toBe("personal");
+    expect(profiles[1].config.tags).toContain("SEO");
+    expect(profiles[4].config.domain).toBe("work");
   });
 
   it("creates missing sample profiles", () => {
     const count = upsertSampleProfiles();
 
-    expect(count).toBe(3);
-    expect(createProfile).toHaveBeenCalledTimes(3);
+    expect(count).toBe(5);
+    expect(createProfile).toHaveBeenCalledTimes(5);
     expect(updateProfile).not.toHaveBeenCalled();
   });
 
@@ -71,14 +71,14 @@ describe("sample profile seeds", () => {
 
     const count = upsertSampleProfiles();
 
-    expect(count).toBe(3);
+    expect(count).toBe(5);
     expect(updateProfile).toHaveBeenCalledTimes(1);
     expect(updateProfile).toHaveBeenCalledWith(
       SAMPLE_PROFILE_IDS[0],
       expect.objectContaining({ id: SAMPLE_PROFILE_IDS[0] }),
-      expect.stringContaining("Revenue Operations Analyst")
+      expect.stringContaining("GTM Launch Strategist")
     );
-    expect(createProfile).toHaveBeenCalledTimes(2);
+    expect(createProfile).toHaveBeenCalledTimes(4);
   });
 
   it("throws if a sample id collides with a built-in profile", () => {
@@ -92,11 +92,11 @@ describe("sample profile seeds", () => {
 
   it("deletes only existing non-builtin sample profiles", () => {
     getProfile.mockImplementation((id: string) =>
-      id === SAMPLE_PROFILE_IDS[0] || id === SAMPLE_PROFILE_IDS[2]
+      id === SAMPLE_PROFILE_IDS[0] || id === SAMPLE_PROFILE_IDS[4]
         ? ({ id } as AgentProfile)
         : undefined
     );
-    isBuiltin.mockImplementation((id: string) => id === SAMPLE_PROFILE_IDS[2]);
+    isBuiltin.mockImplementation((id: string) => id === SAMPLE_PROFILE_IDS[4]);
 
     const deleted = clearSampleProfiles();
 
@@ -109,33 +109,38 @@ describe("sample profile seeds", () => {
 describe("schedule seeds", () => {
   it("creates schedules tied to seeded projects and profile surfaces", () => {
     const projectIds = [
-      "project-investments",
       "project-launch",
-      "project-pipeline",
-      "project-trip",
-      "project-tax",
+      "project-content",
+      "project-cs",
+      "project-tvp",
+      "project-greenleaf",
+      "project-medreach",
+      "project-revops",
+      "project-compliance",
     ];
 
     const schedules = createSchedules(projectIds);
 
-    expect(schedules).toHaveLength(4);
-    expect(schedules.map((schedule) => schedule.projectId)).toEqual([
-      projectIds[0],
-      projectIds[1],
-      projectIds[2],
-      projectIds[4],
-    ]);
+    expect(schedules).toHaveLength(8);
+    // Each project gets one schedule
+    expect(schedules.map((schedule) => schedule.projectId)).toEqual(projectIds);
+    // Active schedules have a nextFireAt
     expect(
       schedules.filter((schedule) => schedule.status === "active").every(
         (schedule) => schedule.nextFireAt instanceof Date
       )
     ).toBe(true);
+    // Non-active schedules have null nextFireAt
     expect(
       schedules.filter((schedule) => schedule.status !== "active").every(
         (schedule) => schedule.nextFireAt === null
       )
     ).toBe(true);
+    // At least one schedule uses a sample profile
     expect(schedules.some((schedule) => schedule.agentProfile === SAMPLE_PROFILE_IDS[0])).toBe(true);
-    expect(schedules.some((schedule) => schedule.agentProfile === "project-manager")).toBe(true);
+    // At least one heartbeat schedule exists
+    expect(schedules.some((schedule) => schedule.type === "heartbeat")).toBe(true);
+    // At least one schedule has delivery channels
+    expect(schedules.some((schedule) => schedule.deliveryChannels !== null)).toBe(true);
   });
 });