stagent 0.6.2 → 0.6.3

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) => {

package/src/lib/schedules/scheduler.ts

@@ -12,7 +12,7 @@
  */
 
 import { db } from "@/lib/db";
-import { schedules, tasks, agentLogs } from "@/lib/db/schema";
+import { schedules, tasks, agentLogs, scheduleDocumentInputs, documents } from "@/lib/db/schema";
 import { eq, and, lte, inArray, sql } from "drizzle-orm";
 import { computeNextFireTime } from "./interval-parser";
 import { executeTaskWithRuntime } from "@/lib/agents/runtime";
@@ -178,6 +178,21 @@ async function fireSchedule(
     updatedAt: now,
   });
 
+  // Link schedule's documents to the created task
+  try {
+    const schedDocs = await db
+      .select({ documentId: scheduleDocumentInputs.documentId })
+      .from(scheduleDocumentInputs)
+      .where(eq(scheduleDocumentInputs.scheduleId, schedule.id));
+    for (const { documentId } of schedDocs) {
+      await db.update(documents)
+        .set({ taskId, projectId: schedule.projectId, updatedAt: now })
+        .where(eq(documents.id, documentId));
+    }
+  } catch (err) {
+    console.error(`[scheduler] Document linking failed for schedule ${schedule.id}:`, err);
+  }
+
   // Update schedule counters
   const isOneShot = !schedule.recurs;
   const reachedMax =
@@ -335,6 +350,21 @@ async function fireHeartbeat(
     updatedAt: now,
   });
 
+  // Link schedule's documents to the heartbeat task
+  try {
+    const schedDocs = await db
+      .select({ documentId: scheduleDocumentInputs.documentId })
+      .from(scheduleDocumentInputs)
+      .where(eq(scheduleDocumentInputs.scheduleId, schedule.id));
+    for (const { documentId } of schedDocs) {
+      await db.update(documents)
+        .set({ taskId: evalTaskId, projectId: schedule.projectId, updatedAt: now })
+        .where(eq(documents.id, documentId));
+    }
+  } catch (err) {
+    console.error(`[scheduler] Document linking failed for heartbeat ${schedule.id}:`, err);
+  }
+
   // 5. Execute and wait for result (with timeout)
   try {
     await executeTaskWithRuntime(evalTaskId);

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/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;

package/src/lib/workflows/types.ts

@@ -14,6 +14,20 @@ export interface WorkflowStep {
   dependsOn?: string[];
   assignedAgent?: string;
   agentProfile?: string;
+  /** Document IDs from the project pool to inject as context for this step */
+  documentIds?: string[];
+}
+
+/** Selector for auto-discovering documents from the project pool */
+export interface DocumentSelector {
+  fromWorkflowId?: string;
+  fromWorkflowName?: string;
+  category?: string;
+  direction?: "input" | "output";
+  mimeType?: string;
+  namePattern?: string;
+  /** Take only the N most recent matching documents */
+  latest?: number;
 }
 
 export interface LoopConfig {

package/public/icon.svg

@@ -1,13 +0,0 @@
-<svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <rect width="512" height="512" rx="112" fill="#0f172a"/>
-  <defs>
-    <linearGradient id="s-grad" x1="150" y1="80" x2="362" y2="432" gradientUnits="userSpaceOnUse">
-      <stop offset="0%" stop-color="#22d3ee"/>
-      <stop offset="50%" stop-color="#3b82f6"/>
-      <stop offset="100%" stop-color="#2563eb"/>
-    </linearGradient>
-  </defs>
-  <path d="M340 130c0 0-60-10-110 30s-50 90-10 115c40 25 70 30 70 30s50 15 30 65c-20 50-80 40-80 40" stroke="url(#s-grad)" stroke-width="56" stroke-linecap="round" fill="none"/>
-  <circle cx="340" cy="130" r="36" fill="#22d3ee"/>
-  <circle cx="240" cy="410" r="36" fill="#2563eb"/>
-</svg>

package/src/components/tasks/file-upload.tsx

@@ -1,120 +0,0 @@
-"use client";
-
-import { useState, useRef } from "react";
-import { Button } from "@/components/ui/button";
-import { Upload, X, FileText, Image, FileCode } from "lucide-react";
-
-interface UploadedFile {
-  id: string;
-  filename: string;
-  originalName: string;
-  size: number;
-  type: string;
-}
-
-interface FileUploadProps {
-  onUploaded: (file: UploadedFile) => void;
-  uploads: UploadedFile[];
-  onRemove: (id: string) => void;
-}
-
-function formatSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-function getFileIcon(type: string) {
-  if (type.startsWith("image/")) return Image;
-  if (type.includes("pdf") || type.includes("document") || type.includes("text")) return FileText;
-  if (type.includes("javascript") || type.includes("typescript") || type.includes("json") || type.includes("xml")) return FileCode;
-  return FileText;
-}
-
-export function FileUpload({ onUploaded, uploads, onRemove }: FileUploadProps) {
-  const [uploading, setUploading] = useState(false);
-  const inputRef = useRef<HTMLInputElement>(null);
-
-  async function handleFile(file: File) {
-    setUploading(true);
-    try {
-      const formData = new FormData();
-      formData.append("file", file);
-
-      const res = await fetch("/api/uploads", {
-        method: "POST",
-        body: formData,
-      });
-
-      if (res.ok) {
-        const data = await res.json();
-        onUploaded(data);
-      }
-    } finally {
-      setUploading(false);
-    }
-  }
-
-  function handleChange(e: React.ChangeEvent<HTMLInputElement>) {
-    const file = e.target.files?.[0];
-    if (file) handleFile(file);
-    e.target.value = "";
-  }
-
-  function handleDrop(e: React.DragEvent) {
-    e.preventDefault();
-    const file = e.dataTransfer.files?.[0];
-    if (file) handleFile(file);
-  }
-
-  return (
-    <div className="space-y-2">
-      <div
-        role="button"
-        tabIndex={0}
-        aria-label="Upload a file — click or drag and drop"
-        className="border-2 border-dashed rounded-lg p-4 text-center cursor-pointer hover:bg-accent/50 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-        onClick={() => inputRef.current?.click()}
-        onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); inputRef.current?.click(); } }}
-        onDrop={handleDrop}
-        onDragOver={(e) => e.preventDefault()}
-      >
-        <Upload className="h-5 w-5 mx-auto text-muted-foreground mb-1" />
-        <p className="text-xs text-muted-foreground">
-          {uploading ? "Uploading..." : "Click or drop a file"}
-        </p>
-        <p className="text-xs text-muted-foreground mt-0.5">Max 50MB per file</p>
-        <input
-          ref={inputRef}
-          type="file"
-          className="hidden"
-          onChange={handleChange}
-        />
-      </div>
-      {uploads.length > 0 && (
-        <div className="space-y-1">
-          {uploads.map((f) => {
-            const Icon = getFileIcon(f.type);
-            return (
-            <div key={f.id} className="flex items-center gap-2 text-sm">
-              <Icon className="h-3 w-3 text-muted-foreground" />
-              <span className="flex-1 truncate">{f.originalName}</span>
-              <span className="text-xs text-muted-foreground">{formatSize(f.size)}</span>
-              <Button
-                type="button"
-                variant="ghost"
-                size="icon"
-                className="h-5 w-5"
-                onClick={() => onRemove(f.id)}
-                aria-label={`Remove ${f.originalName}`}
-              >
-                <X className="h-3 w-3" />
-              </Button>
-            </div>
-            );
-          })}
-        </div>
-      )}
-    </div>
-  );
-}