stagent 0.1.0 → 0.1.1

package/src/lib/workflows/__tests__/engine.test.ts

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+  mockWhere,
+  mockFrom,
+  mockSelect,
+  mockUpdateWhere,
+  mockSet,
+  mockUpdate,
+  mockInsertValues,
+  mockInsert,
+} = vi.hoisted(() => {
+  const mockWhere = vi.fn();
+  const mockFrom = vi.fn().mockReturnValue({ where: mockWhere });
+  const mockSelect = vi.fn().mockReturnValue({ from: mockFrom });
+  const mockUpdateWhere = vi.fn().mockResolvedValue(undefined);
+  const mockSet = vi.fn().mockReturnValue({ where: mockUpdateWhere });
+  const mockUpdate = vi.fn().mockReturnValue({ set: mockSet });
+  const mockInsertValues = vi.fn().mockResolvedValue(undefined);
+  const mockInsert = vi.fn().mockReturnValue({ values: mockInsertValues });
+
+  return {
+    mockWhere,
+    mockFrom,
+    mockSelect,
+    mockUpdateWhere,
+    mockSet,
+    mockUpdate,
+    mockInsertValues,
+    mockInsert,
+  };
+});
+
+const { mockExecuteTaskWithRuntime } = vi.hoisted(() => ({
+  mockExecuteTaskWithRuntime: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    select: mockSelect,
+    update: mockUpdate,
+    insert: mockInsert,
+  },
+}));
+
+vi.mock("@/lib/db/schema", () => ({
+  workflows: {
+    id: "workflows.id",
+  },
+  tasks: {
+    id: "tasks.id",
+  },
+  agentLogs: {},
+  notifications: {},
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: vi.fn((column: string, value: unknown) => ({ column, value })),
+}));
+
+vi.mock("@/lib/agents/runtime", () => ({
+  executeTaskWithRuntime: mockExecuteTaskWithRuntime,
+}));
+
+describe("executeWorkflow", () => {
+  beforeEach(() => {
+    mockWhere.mockReset();
+    mockFrom.mockClear();
+    mockSelect.mockClear();
+    mockUpdateWhere.mockReset();
+    mockSet.mockReset();
+    mockSet.mockReturnValue({ where: mockUpdateWhere });
+    mockUpdate.mockClear();
+    mockInsertValues.mockReset();
+    mockInsertValues.mockResolvedValue(undefined);
+    mockInsert.mockClear();
+    mockExecuteTaskWithRuntime.mockClear();
+    mockExecuteTaskWithRuntime.mockResolvedValue(undefined);
+  });
+
+  it("persists failed workflow executions with failed top-level status", async () => {
+    const workflowId = "workflow-1";
+    const workflow = {
+      id: workflowId,
+      name: "Parallel workflow",
+      projectId: null,
+      definition: JSON.stringify({
+        pattern: "sequence",
+        steps: [{ id: "step-1", name: "Step 1", prompt: "Do the work." }],
+      }),
+      status: "draft",
+    };
+    const failedTask = {
+      id: "task-1",
+      status: "failed",
+      result: "Provider runtime error",
+    };
+
+    mockWhere
+      .mockResolvedValueOnce([workflow])
+      .mockResolvedValueOnce([workflow])
+      .mockResolvedValueOnce([workflow])
+      .mockResolvedValueOnce([workflow])
+      .mockResolvedValueOnce([failedTask])
+      .mockResolvedValueOnce([workflow])
+      .mockResolvedValueOnce([workflow]);
+
+    const { executeWorkflow } = await import("../engine");
+
+    await executeWorkflow(workflowId);
+
+    expect(mockSet.mock.calls.at(-1)?.[0]).toMatchObject({ status: "failed" });
+  });
+});

package/src/lib/workflows/__tests__/loop-executor.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import {
+  buildIterationPrompt,
+  detectCompletionSignal,
+} from "../loop-executor";
+
+describe("buildIterationPrompt", () => {
+  it("formats the first iteration without previous output", () => {
+    const result = buildIterationPrompt("Write a poem", "", 1, 5);
+    expect(result).toContain("Iteration 1 of 5.");
+    expect(result).toContain("Write a poem");
+    expect(result).toContain("LOOP_COMPLETE");
+    expect(result).not.toContain("Previous iteration output:");
+  });
+
+  it("includes previous output for subsequent iterations", () => {
+    const result = buildIterationPrompt("Write a poem", "Roses are red...", 2, 5);
+    expect(result).toContain("Iteration 2 of 5.");
+    expect(result).toContain("Previous iteration output:\nRoses are red...");
+    expect(result).toContain("Write a poem");
+    expect(result).toContain("LOOP_COMPLETE");
+  });
+
+  it("shows correct iteration and max in the header", () => {
+    const result = buildIterationPrompt("Do something", "", 7, 10);
+    expect(result).toContain("Iteration 7 of 10.");
+  });
+});
+
+describe("detectCompletionSignal", () => {
+  it("detects LOOP_COMPLETE by default", () => {
+    expect(detectCompletionSignal("Result: all done. LOOP_COMPLETE")).toBe(true);
+  });
+
+  it("is case-insensitive", () => {
+    expect(detectCompletionSignal("loop_complete")).toBe(true);
+    expect(detectCompletionSignal("Loop_Complete")).toBe(true);
+  });
+
+  it("returns false when signal is absent", () => {
+    expect(detectCompletionSignal("Still working on it...")).toBe(false);
+  });
+
+  it("detects custom signals", () => {
+    const signals = ["DONE", "FINISHED"];
+    expect(detectCompletionSignal("I am DONE now.", signals)).toBe(true);
+    expect(detectCompletionSignal("Task finished successfully", signals)).toBe(true);
+    expect(detectCompletionSignal("Not there yet", signals)).toBe(false);
+  });
+
+  it("uses defaults when signals array is empty", () => {
+    expect(detectCompletionSignal("LOOP_COMPLETE", [])).toBe(true);
+  });
+});

package/src/lib/workflows/__tests__/parallel.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import type { WorkflowDefinition } from "../types";
+import {
+  buildParallelSynthesisPrompt,
+  getParallelWorkflowStructure,
+} from "../parallel";
+
+describe("getParallelWorkflowStructure", () => {
+  it("extracts branch and synthesis steps from a parallel workflow", () => {
+    const definition: WorkflowDefinition = {
+      pattern: "parallel",
+      steps: [
+        {
+          id: "branch-a",
+          name: "Competitor scan",
+          prompt: "Research direct competitors.",
+        },
+        {
+          id: "branch-b",
+          name: "User interviews",
+          prompt: "Review interview transcripts.",
+        },
+        {
+          id: "join",
+          name: "Synthesize",
+          prompt: "Combine the branch findings into a recommendation.",
+          dependsOn: ["branch-a", "branch-b"],
+        },
+      ],
+    };
+
+    const structure = getParallelWorkflowStructure(definition);
+
+    expect(structure?.branchSteps.map((step) => step.id)).toEqual([
+      "branch-a",
+      "branch-b",
+    ]);
+    expect(structure?.synthesisStep.id).toBe("join");
+  });
+
+  it("returns null when a parallel workflow does not have exactly one synthesis step", () => {
+    const definition: WorkflowDefinition = {
+      pattern: "parallel",
+      steps: [
+        { id: "branch-a", name: "A", prompt: "A" },
+        { id: "branch-b", name: "B", prompt: "B" },
+      ],
+    };
+
+    expect(getParallelWorkflowStructure(definition)).toBeNull();
+  });
+});
+
+describe("buildParallelSynthesisPrompt", () => {
+  it("formats labeled branch outputs ahead of the synthesis prompt", () => {
+    const prompt = buildParallelSynthesisPrompt({
+      branchOutputs: [
+        {
+          stepName: "Competitor scan",
+          result: "Competitors cluster around speed and reliability claims.",
+        },
+        {
+          stepName: "Customer interviews",
+          result: "Users mostly complain about setup complexity.",
+        },
+      ],
+      synthesisPrompt: "Write a concise synthesis and recommendation.",
+    });
+
+    expect(prompt).toContain("Parallel branch outputs:");
+    expect(prompt).toContain("Branch 1 - Competitor scan:");
+    expect(prompt).toContain("Branch 2 - Customer interviews:");
+    expect(prompt).toContain("Write a concise synthesis and recommendation.");
+  });
+});

package/src/lib/workflows/__tests__/swarm.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import type { WorkflowDefinition } from "../types";
+import {
+  buildSwarmRefineryPrompt,
+  buildSwarmWorkerPrompt,
+  getSwarmWorkflowStructure,
+} from "../swarm";
+
+function createValidSwarmDefinition(): WorkflowDefinition {
+  return {
+    pattern: "swarm",
+    steps: [
+      {
+        id: "mayor",
+        name: "Mayor plan",
+        prompt: "Break the goal into worker assignments.",
+      },
+      {
+        id: "worker-a",
+        name: "Worker A",
+        prompt: "Handle the customer research slice.",
+      },
+      {
+        id: "worker-b",
+        name: "Worker B",
+        prompt: "Handle the competitor analysis slice.",
+      },
+      {
+        id: "refinery",
+        name: "Refine and merge",
+        prompt: "Merge the swarm output into one recommendation.",
+      },
+    ],
+    swarmConfig: {
+      workerConcurrencyLimit: 1,
+    },
+  };
+}
+
+describe("getSwarmWorkflowStructure", () => {
+  it("extracts mayor, workers, refinery, and concurrency from a swarm workflow", () => {
+    const structure = getSwarmWorkflowStructure(createValidSwarmDefinition());
+
+    expect(structure?.mayorStep.id).toBe("mayor");
+    expect(structure?.workerSteps.map((step) => step.id)).toEqual([
+      "worker-a",
+      "worker-b",
+    ]);
+    expect(structure?.refineryStep.id).toBe("refinery");
+    expect(structure?.workerConcurrencyLimit).toBe(1);
+  });
+
+  it("returns null when a swarm workflow does not have a mayor, workers, and refinery", () => {
+    const definition: WorkflowDefinition = {
+      pattern: "swarm",
+      steps: [
+        { id: "mayor", name: "Mayor", prompt: "Plan" },
+        { id: "worker", name: "Worker", prompt: "Do one slice" },
+        { id: "refinery", name: "Refinery", prompt: "Merge" },
+      ],
+    };
+
+    expect(getSwarmWorkflowStructure(definition)).toBeNull();
+  });
+});
+
+describe("swarm prompt builders", () => {
+  it("formats a worker prompt with mayor context", () => {
+    const prompt = buildSwarmWorkerPrompt({
+      mayorName: "Mayor plan",
+      mayorResult: "Worker A handles customers. Worker B handles competitors.",
+      workerName: "Worker A",
+      workerPrompt: "Analyze customer interviews.",
+    });
+
+    expect(prompt).toContain("Mayor plan:");
+    expect(prompt).toContain("Worker A assignment:");
+    expect(prompt).toContain("Analyze customer interviews.");
+  });
+
+  it("formats a refinery prompt with labeled worker outputs", () => {
+    const prompt = buildSwarmRefineryPrompt({
+      mayorName: "Mayor plan",
+      mayorResult: "Split the work across two workers.",
+      workerOutputs: [
+        { stepName: "Worker A", result: "Customer pain points center on setup." },
+        { stepName: "Worker B", result: "Competitors compete on speed." },
+      ],
+      refineryPrompt: "Produce one final recommendation.",
+    });
+
+    expect(prompt).toContain("Worker outputs:");
+    expect(prompt).toContain("Worker 1 - Worker A:");
+    expect(prompt).toContain("Worker 2 - Worker B:");
+    expect(prompt).toContain("Produce one final recommendation.");
+  });
+});

package/src/test/setup.ts

@@ -0,0 +1,10 @@
+import "@testing-library/jest-dom/vitest";
+import { mkdtempSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+if (!process.env.STAGENT_DATA_DIR) {
+  const tempDataDir = mkdtempSync(join(tmpdir(), "stagent-vitest-"));
+  mkdirSync(tempDataDir, { recursive: true });
+  process.env.STAGENT_DATA_DIR = tempDataDir;
+}