stagent 0.1.11 → 0.1.12

package/src/__tests__/e2e/parallel-workflow.test.ts

@@ -0,0 +1,120 @@
+/**
+ * E2E: Parallel workflow execution.
+ *
+ * Tests that parallel workflows run branches concurrently and
+ * synthesis steps wait for all dependencies before executing.
+ */
+
+import {
+  setupE2E,
+  teardownE2E,
+  testProjectId,
+  claudeAvailable,
+  codexAvailable,
+} from "./setup";
+import {
+  createWorkflow,
+  executeWorkflow,
+  pollWorkflowUntilDone,
+} from "./helpers";
+
+beforeAll(async () => {
+  await setupE2E();
+});
+
+afterAll(async () => {
+  await teardownE2E();
+});
+
+describe("Parallel Workflow — Claude Code", () => {
+  it.skipIf(!claudeAvailable)(
+    "runs branches concurrently with synthesis",
+    async () => {
+      const { ok, data: workflow } = await createWorkflow({
+        name: "E2E Parallel Test",
+        projectId: testProjectId,
+        definition: {
+          pattern: "parallel",
+          steps: [
+            {
+              id: "metrics",
+              name: "Code Metrics",
+              prompt:
+                "Count the number of TypeScript files and total lines of code in the project.",
+              agentProfile: "general",
+            },
+            {
+              id: "deps",
+              name: "Dependency Check",
+              prompt:
+                "List all dependencies and devDependencies from package.json with their versions.",
+              agentProfile: "general",
+            },
+            {
+              id: "synthesize",
+              name: "Summary Report",
+              prompt:
+                "Combine the code metrics and dependency information into a brief project summary.",
+              agentProfile: "document-writer",
+              dependsOn: ["metrics", "deps"],
+            },
+          ],
+        },
+      });
+      expect(ok).toBe(true);
+
+      const exec = await executeWorkflow(workflow!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollWorkflowUntilDone(workflow!.id);
+      expect(result.status).toBe("completed");
+    }
+  );
+});
+
+describe("Parallel Workflow — Codex", () => {
+  it.skipIf(!codexAvailable)(
+    "runs parallel branches via Codex runtime",
+    async () => {
+      const { ok, data: workflow } = await createWorkflow({
+        name: "E2E Codex Parallel Test",
+        projectId: testProjectId,
+        definition: {
+          pattern: "parallel",
+          steps: [
+            {
+              id: "files",
+              name: "List Files",
+              prompt: "List all files in the project directory.",
+              assignedAgent: "codex",
+              agentProfile: "general",
+            },
+            {
+              id: "structure",
+              name: "Describe Structure",
+              prompt: "Describe the project directory structure and purpose of each file.",
+              assignedAgent: "codex",
+              agentProfile: "general",
+            },
+            {
+              id: "combine",
+              name: "Combined Report",
+              prompt:
+                "Combine the file list and structure description into a single overview.",
+              assignedAgent: "codex",
+              agentProfile: "document-writer",
+              dependsOn: ["files", "structure"],
+            },
+          ],
+        },
+      });
+      expect(ok).toBe(true);
+
+      const exec = await executeWorkflow(workflow!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollWorkflowUntilDone(workflow!.id);
+      expect(result.status).toBe("completed");
+    }
+  );
+});

package/src/__tests__/e2e/sequence-workflow.test.ts

@@ -0,0 +1,109 @@
+/**
+ * E2E: Sequence workflow execution.
+ *
+ * Tests that multi-step sequence workflows execute steps in order,
+ * pass context between steps, and produce combined results.
+ */
+
+import {
+  setupE2E,
+  teardownE2E,
+  testProjectId,
+  claudeAvailable,
+  codexAvailable,
+} from "./setup";
+import {
+  createWorkflow,
+  executeWorkflow,
+  pollWorkflowUntilDone,
+  createTask,
+  getTask,
+} from "./helpers";
+
+beforeAll(async () => {
+  await setupE2E();
+});
+
+afterAll(async () => {
+  await teardownE2E();
+});
+
+describe("Sequence Workflow — Claude Code", () => {
+  it.skipIf(!claudeAvailable)(
+    "executes steps in order with context passing",
+    async () => {
+      const { ok, data: workflow } = await createWorkflow({
+        name: "E2E Sequence Test",
+        projectId: testProjectId,
+        definition: {
+          pattern: "sequence",
+          steps: [
+            {
+              id: "analyze",
+              name: "Analyze Code",
+              prompt:
+                "Analyze the TypeScript code in the project. List the main functions and any bugs you find.",
+              agentProfile: "general",
+            },
+            {
+              id: "suggest",
+              name: "Suggest Tests",
+              prompt:
+                "Based on the analysis from the previous step, suggest specific test cases that would catch the bugs identified.",
+              agentProfile: "code-reviewer",
+              dependsOn: ["analyze"],
+            },
+          ],
+        },
+      });
+      expect(ok).toBe(true);
+
+      const exec = await executeWorkflow(workflow!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollWorkflowUntilDone(workflow!.id);
+      expect(result.status).toBe("completed");
+    }
+  );
+});
+
+describe("Sequence Workflow — Codex", () => {
+  it.skipIf(!codexAvailable)(
+    "executes sequence steps via Codex runtime",
+    async () => {
+      const { ok, data: workflow } = await createWorkflow({
+        name: "E2E Codex Sequence Test",
+        projectId: testProjectId,
+        definition: {
+          pattern: "sequence",
+          steps: [
+            {
+              id: "describe",
+              name: "Describe Code",
+              prompt:
+                "Describe the TypeScript code in the project. List the main functions.",
+              assignedAgent: "codex",
+              agentProfile: "general",
+            },
+            {
+              id: "review",
+              name: "Review Code",
+              prompt:
+                "Based on the description from the previous step, review the code for bugs.",
+              assignedAgent: "codex",
+              agentProfile: "code-reviewer",
+              dependsOn: ["describe"],
+            },
+          ],
+        },
+      });
+      expect(ok).toBe(true);
+
+      const exec = await executeWorkflow(workflow!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollWorkflowUntilDone(workflow!.id);
+      expect(result.status).toBe("completed");
+    }
+  );
+});

package/src/__tests__/e2e/setup.ts

@@ -0,0 +1,156 @@
+/**
+ * E2E test setup — creates a test project and sandbox, tears down after all tests.
+ *
+ * This file is imported by test files that need a shared project context.
+ * It does NOT run as a vitest setupFile — each test suite imports it explicitly.
+ */
+
+import { mkdirSync, rmSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  createProject,
+  deleteProject,
+  isServerReachable,
+  isRuntimeAvailable,
+} from "./helpers";
+
+// ---------------------------------------------------------------------------
+// Shared test state
+// ---------------------------------------------------------------------------
+
+export let testProjectId = "";
+export let sandboxDir = "";
+export let claudeAvailable = false;
+export let codexAvailable = false;
+
+// ---------------------------------------------------------------------------
+// Sandbox files — minimal TypeScript project for agents to analyze
+// ---------------------------------------------------------------------------
+
+const SANDBOX_FILES: Record<string, string> = {
+  "package.json": JSON.stringify(
+    {
+      name: "stagent-e2e-sandbox",
+      version: "1.0.0",
+      scripts: { build: "tsc" },
+      devDependencies: { typescript: "^5.5.0" },
+    },
+    null,
+    2
+  ),
+  "tsconfig.json": JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        outDir: "dist",
+        strict: true,
+      },
+      include: ["src"],
+    },
+    null,
+    2
+  ),
+  "src/index.ts": `
+export interface Task {
+  id: number;
+  title: string;
+  completed: boolean;
+}
+
+const tasks: Task[] = [];
+
+export function addTask(title: string): Task {
+  // Deliberate bug: ID based on array length → duplicates after deletion
+  const task: Task = { id: tasks.length, title, completed: false };
+  tasks.push(task);
+  return task;
+}
+
+export function completeTask(id: number): boolean {
+  const task = tasks.find((t) => t.id === id);
+  if (task) {
+    task.completed = true;
+    return true;
+  }
+  return false;
+}
+
+export function getIncompleteTasks(): Task[] {
+  return tasks.filter((t) => !t.completed);
+}
+`.trimStart(),
+  "src/utils.ts": `
+export function formatDate(date: Date): string {
+  // Deliberate bug: getMonth() is zero-based
+  return \`\${date.getFullYear()}-\${date.getMonth()}-\${date.getDate()}\`;
+}
+
+export function parseCSV(csv: string): string[][] {
+  // Deliberate bug: naive parsing — no quoted field support
+  return csv.split("\\n").map((line) => line.split(","));
+}
+
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/\\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "");
+}
+`.trimStart(),
+};
+
+// ---------------------------------------------------------------------------
+// Setup & Teardown
+// ---------------------------------------------------------------------------
+
+export async function setupE2E(): Promise<void> {
+  // 1. Check server reachability
+  const reachable = await isServerReachable();
+  if (!reachable) {
+    throw new Error(
+      "Stagent server is not reachable at the configured URL. " +
+        "Start the dev server with `npm run dev` before running E2E tests."
+    );
+  }
+
+  // 2. Create sandbox directory with test files
+  sandboxDir = join(tmpdir(), `stagent-e2e-${Date.now()}`);
+  mkdirSync(join(sandboxDir, "src"), { recursive: true });
+
+  for (const [relativePath, content] of Object.entries(SANDBOX_FILES)) {
+    const fullPath = join(sandboxDir, relativePath);
+    const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(fullPath, content, "utf-8");
+  }
+
+  // 3. Create test project pointing at the sandbox
+  const { ok, data } = await createProject({
+    name: `E2E Test ${new Date().toISOString().slice(0, 19)}`,
+    description: "Automated E2E test project — safe to delete",
+    workingDirectory: sandboxDir,
+  });
+  if (!ok || !data?.id) {
+    throw new Error("Failed to create E2E test project");
+  }
+  testProjectId = data.id;
+
+  // 4. Detect runtime availability
+  claudeAvailable = await isRuntimeAvailable("claude-code");
+  codexAvailable = await isRuntimeAvailable("openai-codex-app-server");
+}
+
+export async function teardownE2E(): Promise<void> {
+  // Clean up test project
+  if (testProjectId) {
+    await deleteProject(testProjectId).catch(() => {});
+  }
+
+  // Clean up sandbox directory
+  if (sandboxDir && existsSync(sandboxDir)) {
+    rmSync(sandboxDir, { recursive: true, force: true });
+  }
+}

package/src/__tests__/e2e/single-task.test.ts

@@ -0,0 +1,170 @@
+/**
+ * E2E: Single task execution across profiles and runtimes.
+ *
+ * Tests that individual tasks execute and produce results via both
+ * Claude Code and Codex runtimes with different agent profiles.
+ */
+
+import {
+  setupE2E,
+  teardownE2E,
+  testProjectId,
+  claudeAvailable,
+  codexAvailable,
+} from "./setup";
+import {
+  createTask,
+  executeTask,
+  pollTaskUntilDone,
+  updateTask,
+} from "./helpers";
+
+beforeAll(async () => {
+  await setupE2E();
+});
+
+afterAll(async () => {
+  await teardownE2E();
+});
+
+// ---------------------------------------------------------------------------
+// Claude Code runtime
+// ---------------------------------------------------------------------------
+
+describe("Single Task — Claude Code", () => {
+  beforeAll(() => {
+    if (!claudeAvailable) {
+      console.warn("Skipping Claude Code tests — runtime not available");
+    }
+  });
+
+  it.skipIf(!claudeAvailable)(
+    "general profile describes code",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Describe the TypeScript code in src/",
+        description:
+          "Read the TypeScript files in the project and describe what the code does.",
+        projectId: testProjectId,
+        agentProfile: "general",
+      });
+      expect(ok).toBe(true);
+
+      // Queue → execute
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      // Poll until done
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+      expect(result.result!.length).toBeGreaterThan(50);
+    }
+  );
+
+  it.skipIf(!claudeAvailable)(
+    "code-reviewer profile finds bugs",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Review code for bugs",
+        description:
+          "Review all TypeScript files in the project. Find bugs and report them with severity levels.",
+        projectId: testProjectId,
+        agentProfile: "code-reviewer",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+      // Code reviewer should find at least some issues
+      expect(result.result!.length).toBeGreaterThan(100);
+    }
+  );
+
+  it.skipIf(!claudeAvailable)(
+    "document-writer profile generates overview",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Write a technical overview document",
+        description:
+          "Generate a technical overview of this project including structure, modules, and dependencies.",
+        projectId: testProjectId,
+        agentProfile: "document-writer",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+    }
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Codex runtime
+// ---------------------------------------------------------------------------
+
+describe("Single Task — Codex", () => {
+  beforeAll(() => {
+    if (!codexAvailable) {
+      console.warn("Skipping Codex tests — runtime not available");
+    }
+  });
+
+  it.skipIf(!codexAvailable)(
+    "general profile describes code via Codex",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Describe the TypeScript code in src/",
+        description:
+          "Read the TypeScript files in the project and describe what the code does.",
+        projectId: testProjectId,
+        assignedAgent: "codex",
+        agentProfile: "general",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+      expect(result.result!.length).toBeGreaterThan(50);
+    }
+  );
+
+  it.skipIf(!codexAvailable)(
+    "code-reviewer profile finds bugs via Codex",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Review code for bugs",
+        description:
+          "Review all TypeScript files in the project. Find bugs and report them with severity levels.",
+        projectId: testProjectId,
+        assignedAgent: "codex",
+        agentProfile: "code-reviewer",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+    }
+  );
+});

package/src/app/api/command-palette/recent/route.ts

@@ -2,30 +2,53 @@ import { NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { projects, tasks } from "@/lib/db/schema";
 import { desc } from "drizzle-orm";
+import { getManifest } from "@/lib/docs/reader";
 
 export async function GET() {
-  const recentProjects = await db
-    .select({
-      id: projects.id,
-      name: projects.name,
-      status: projects.status,
-    })
-    .from(projects)
-    .orderBy(desc(projects.updatedAt))
-    .limit(5);
+  const [recentProjects, recentTasks] = await Promise.all([
+    db
+      .select({
+        id: projects.id,
+        name: projects.name,
+        status: projects.status,
+      })
+      .from(projects)
+      .orderBy(desc(projects.updatedAt))
+      .limit(5),
+    db
+      .select({
+        id: tasks.id,
+        title: tasks.title,
+        status: tasks.status,
+      })
+      .from(tasks)
+      .orderBy(desc(tasks.updatedAt))
+      .limit(5),
+  ]);
 
-  const recentTasks = await db
-    .select({
-      id: tasks.id,
-      title: tasks.title,
-      status: tasks.status,
-    })
-    .from(tasks)
-    .orderBy(desc(tasks.updatedAt))
-    .limit(5);
+  // Read playbook items from manifest
+  let playbook: { slug: string; title: string; tags: string[] }[] = [];
+  try {
+    const manifest = getManifest();
+    playbook = [
+      ...manifest.sections.map((s) => ({
+        slug: s.slug,
+        title: s.title,
+        tags: s.tags,
+      })),
+      ...manifest.journeys.map((j) => ({
+        slug: j.slug,
+        title: j.title,
+        tags: [j.persona, j.difficulty],
+      })),
+    ];
+  } catch {
+    // docs/manifest.json may not exist — graceful fallback
+  }
 
   return NextResponse.json({
     projects: recentProjects,
     tasks: recentTasks,
+    playbook,
   });
 }

package/src/app/api/context/batch/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  batchApproveProposals,
+  batchRejectProposals,
+} from "@/lib/agents/learning-session";
+
+const batchSchema = z.object({
+  proposalIds: z.array(z.string().min(1)).min(1),
+  action: z.enum(["approve", "reject"]),
+});
+
+/**
+ * POST /api/context/batch — batch approve or reject context proposals.
+ *
+ * Used by the batch proposal review UI after workflow completion.
+ * Accepts an array of learned_context row IDs and an action.
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const parsed = batchSchema.safeParse(body);
+
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: "proposalIds (string[]) and action ('approve'|'reject') are required" },
+        { status: 400 }
+      );
+    }
+
+    const { proposalIds, action } = parsed.data;
+
+    const count =
+      action === "approve"
+        ? await batchApproveProposals(proposalIds)
+        : await batchRejectProposals(proposalIds);
+
+    return NextResponse.json({ success: true, action, count });
+  } catch (err: unknown) {
+    const message =
+      err instanceof Error ? err.message : "Batch operation failed";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}