stagent 0.1.0 → 0.1.1

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

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { ProfileConfigSchema } from "@/lib/validators/profile";
+
+describe("ProfileConfigSchema", () => {
+  const validProfile = {
+    id: "test-profile",
+    name: "Test Profile",
+    version: "1.0.0",
+    domain: "work",
+    tags: ["test", "example"],
+  };
+
+  it("accepts minimal valid profile", () => {
+    const result = ProfileConfigSchema.safeParse(validProfile);
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts full valid profile", () => {
+    const result = ProfileConfigSchema.safeParse({
+      ...validProfile,
+      allowedTools: ["Read", "Grep"],
+      mcpServers: { myServer: { url: "http://localhost:3000" } },
+      canUseToolPolicy: {
+        autoApprove: ["Read"],
+        autoDeny: ["Bash"],
+      },
+      hooks: {
+        preToolCall: ["echo pre"],
+        postToolCall: ["echo post"],
+      },
+      temperature: 0.5,
+      maxTurns: 20,
+      outputFormat: "markdown",
+      author: "stagent",
+      source: "https://github.com/stagent/profiles",
+      tests: [
+        {
+          task: "Do a thing",
+          expectedKeywords: ["thing", "done"],
+        },
+      ],
+      supportedRuntimes: ["claude-code", "openai-codex-app-server"],
+      runtimeOverrides: {
+        "openai-codex-app-server": {
+          instructions: "Use the Codex-specific prompt",
+          allowedTools: ["Read"],
+        },
+      },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects missing id", () => {
+    const { id, ...noId } = validProfile;
+    const result = ProfileConfigSchema.safeParse(noId);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects empty id", () => {
+    const result = ProfileConfigSchema.safeParse({ ...validProfile, id: "" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects invalid version format", () => {
+    const result = ProfileConfigSchema.safeParse({
+      ...validProfile,
+      version: "1.0",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects invalid domain", () => {
+    const result = ProfileConfigSchema.safeParse({
+      ...validProfile,
+      domain: "other",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects temperature out of range", () => {
+    const tooHigh = ProfileConfigSchema.safeParse({
+      ...validProfile,
+      temperature: 1.5,
+    });
+    expect(tooHigh.success).toBe(false);
+
+    const tooLow = ProfileConfigSchema.safeParse({
+      ...validProfile,
+      temperature: -0.1,
+    });
+    expect(tooLow.success).toBe(false);
+  });
+
+  it("rejects invalid source URL", () => {
+    const result = ProfileConfigSchema.safeParse({
+      ...validProfile,
+      source: "not-a-url",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts valid domain values", () => {
+    for (const domain of ["work", "personal"]) {
+      const result = ProfileConfigSchema.safeParse({
+        ...validProfile,
+        domain,
+      });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it("rejects negative maxTurns", () => {
+    const result = ProfileConfigSchema.safeParse({
+      ...validProfile,
+      maxTurns: -5,
+    });
+    expect(result.success).toBe(false);
+  });
+});

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

@@ -0,0 +1,82 @@
+import { describe, it, expect } from "vitest";
+import { createProjectSchema, updateProjectSchema } from "@/lib/validators/project";
+
+describe("createProjectSchema", () => {
+  it("accepts valid input with name only", () => {
+    const result = createProjectSchema.safeParse({ name: "My Project" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts valid input with name and description", () => {
+    const result = createProjectSchema.safeParse({
+      name: "My Project",
+      description: "A great project",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects empty name", () => {
+    const result = createProjectSchema.safeParse({ name: "" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects missing name", () => {
+    const result = createProjectSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects name exceeding 100 characters", () => {
+    const result = createProjectSchema.safeParse({ name: "a".repeat(101) });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts name at max length (100)", () => {
+    const result = createProjectSchema.safeParse({ name: "a".repeat(100) });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects description exceeding 500 characters", () => {
+    const result = createProjectSchema.safeParse({
+      name: "Test",
+      description: "a".repeat(501),
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts description at max length (500)", () => {
+    const result = createProjectSchema.safeParse({
+      name: "Test",
+      description: "a".repeat(500),
+    });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("updateProjectSchema", () => {
+  it("accepts empty object (all fields optional)", () => {
+    const result = updateProjectSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts valid status values", () => {
+    for (const status of ["active", "paused", "completed"]) {
+      const result = updateProjectSchema.safeParse({ status });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it("rejects invalid status", () => {
+    const result = updateProjectSchema.safeParse({ status: "archived" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects empty name when provided", () => {
+    const result = updateProjectSchema.safeParse({ name: "" });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts partial updates", () => {
+    const result = updateProjectSchema.safeParse({ description: "Updated" });
+    expect(result.success).toBe(true);
+  });
+});

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

@@ -0,0 +1,151 @@
+import { describe, it, expect } from "vitest";
+import {
+  updateAuthSettingsSchema,
+  updateBudgetPolicySchema,
+  updateOpenAISettingsSchema,
+} from "@/lib/validators/settings";
+
+describe("updateAuthSettingsSchema", () => {
+  it("accepts valid oauth method without apiKey", () => {
+    const result = updateAuthSettingsSchema.safeParse({ method: "oauth" });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.method).toBe("oauth");
+      expect(result.data.apiKey).toBeUndefined();
+    }
+  });
+
+  it("accepts valid api_key method without apiKey", () => {
+    const result = updateAuthSettingsSchema.safeParse({ method: "api_key" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts api_key method with valid apiKey", () => {
+    const result = updateAuthSettingsSchema.safeParse({
+      method: "api_key",
+      apiKey: "sk-ant-abc123",
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.apiKey).toBe("sk-ant-abc123");
+    }
+  });
+
+  it("rejects apiKey not starting with sk-ant-", () => {
+    const result = updateAuthSettingsSchema.safeParse({
+      method: "api_key",
+      apiKey: "invalid-key",
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const flat = result.error.flatten();
+      expect(flat.fieldErrors.apiKey).toBeDefined();
+      expect(flat.fieldErrors.apiKey![0]).toContain("sk-ant-");
+    }
+  });
+
+  it("rejects invalid method value", () => {
+    const result = updateAuthSettingsSchema.safeParse({ method: "bearer" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects missing method field", () => {
+    const result = updateAuthSettingsSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects empty apiKey string", () => {
+    const result = updateAuthSettingsSchema.safeParse({
+      method: "api_key",
+      apiKey: "",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts oauth method with valid apiKey (schema allows it)", () => {
+    const result = updateAuthSettingsSchema.safeParse({
+      method: "oauth",
+      apiKey: "sk-ant-test123",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects extra unknown fields via strict parsing", () => {
+    const result = updateAuthSettingsSchema.safeParse({
+      method: "oauth",
+      extra: "field",
+    });
+    // Zod v4 object schemas strip unknown fields by default
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("updateOpenAISettingsSchema", () => {
+  it("accepts valid OpenAI API keys", () => {
+    const result = updateOpenAISettingsSchema.safeParse({
+      apiKey: "sk-test-openai",
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects keys without the sk- prefix", () => {
+    const result = updateOpenAISettingsSchema.safeParse({
+      apiKey: "invalid",
+    });
+
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("updateBudgetPolicySchema", () => {
+  it("accepts nullable budget caps for all windows", () => {
+    const result = updateBudgetPolicySchema.safeParse({
+      overall: {
+        dailySpendCapUsd: null,
+        monthlySpendCapUsd: 50,
+      },
+      runtimes: {
+        "claude-code": {
+          dailySpendCapUsd: 10,
+          monthlySpendCapUsd: 100,
+          dailyTokenCap: 10000,
+          monthlyTokenCap: null,
+        },
+        "openai-codex-app-server": {
+          dailySpendCapUsd: null,
+          monthlySpendCapUsd: null,
+          dailyTokenCap: null,
+          monthlyTokenCap: 50000,
+        },
+      },
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects zero and negative values", () => {
+    const result = updateBudgetPolicySchema.safeParse({
+      overall: {
+        dailySpendCapUsd: 0,
+        monthlySpendCapUsd: -1,
+      },
+      runtimes: {
+        "claude-code": {
+          dailySpendCapUsd: null,
+          monthlySpendCapUsd: null,
+          dailyTokenCap: 0,
+          monthlyTokenCap: null,
+        },
+        "openai-codex-app-server": {
+          dailySpendCapUsd: null,
+          monthlySpendCapUsd: null,
+          dailyTokenCap: null,
+          monthlyTokenCap: null,
+        },
+      },
+    });
+
+    expect(result.success).toBe(false);
+  });
+});

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

@@ -0,0 +1,144 @@
+import { describe, it, expect } from "vitest";
+import { createTaskSchema, updateTaskSchema } from "@/lib/validators/task";
+
+describe("createTaskSchema", () => {
+  it("accepts minimal valid input", () => {
+    const result = createTaskSchema.safeParse({ title: "Do something" });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.priority).toBe(2); // default
+    }
+  });
+
+  it("accepts full valid input", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Task",
+      description: "Details",
+      projectId: "proj-1",
+      priority: 0,
+      assignedAgent: "claude-code",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts all supported runtime values", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Task",
+      assignedAgent: "openai-codex-app-server",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects unsupported assignedAgent values", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Task",
+      assignedAgent: "unknown-runtime",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects empty title", () => {
+    const result = createTaskSchema.safeParse({ title: "" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects title exceeding 200 characters", () => {
+    const result = createTaskSchema.safeParse({ title: "a".repeat(201) });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects description exceeding 2000 characters", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Test",
+      description: "a".repeat(2001),
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects priority below 0", () => {
+    const result = createTaskSchema.safeParse({ title: "Test", priority: -1 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects priority above 3", () => {
+    const result = createTaskSchema.safeParse({ title: "Test", priority: 4 });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts all valid priority values (0-3)", () => {
+    for (const priority of [0, 1, 2, 3]) {
+      const result = createTaskSchema.safeParse({ title: "Test", priority });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it("accepts fileIds as optional array of strings", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Test",
+      fileIds: ["abc-123", "def-456"],
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.fileIds).toEqual(["abc-123", "def-456"]);
+    }
+  });
+
+  it("accepts task without fileIds", () => {
+    const result = createTaskSchema.safeParse({ title: "Test" });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.fileIds).toBeUndefined();
+    }
+  });
+
+  it("accepts empty fileIds array", () => {
+    const result = createTaskSchema.safeParse({ title: "Test", fileIds: [] });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.fileIds).toEqual([]);
+    }
+  });
+
+  it("rejects fileIds with non-string elements", () => {
+    const result = createTaskSchema.safeParse({
+      title: "Test",
+      fileIds: [123, true],
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("updateTaskSchema", () => {
+  it("accepts empty object", () => {
+    const result = updateTaskSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts valid status transitions", () => {
+    const statuses = ["planned", "queued", "running", "completed", "failed", "cancelled"];
+    for (const status of statuses) {
+      const result = updateTaskSchema.safeParse({ status });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it("rejects invalid status", () => {
+    const result = updateTaskSchema.safeParse({ status: "pending" });
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts result and sessionId fields", () => {
+    const result = updateTaskSchema.safeParse({
+      result: "Task output here",
+      sessionId: "session-abc",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects unsupported assignedAgent values on update", () => {
+    const result = updateTaskSchema.safeParse({
+      assignedAgent: "unknown-runtime",
+    });
+    expect(result.success).toBe(false);
+  });
+});

package/src/lib/workflows/__tests__/definition-validation.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it } from "vitest";
+import type { WorkflowDefinition } from "../types";
+import { validateWorkflowDefinition } from "../definition-validation";
+
+function createValidParallelDefinition(): WorkflowDefinition {
+  return {
+    pattern: "parallel",
+    steps: [
+      {
+        id: "branch-a",
+        name: "Market scan",
+        prompt: "Research market trends.",
+      },
+      {
+        id: "branch-b",
+        name: "Customer scan",
+        prompt: "Review customer feedback.",
+      },
+      {
+        id: "join",
+        name: "Synthesize",
+        prompt: "Combine the findings.",
+        dependsOn: ["branch-a", "branch-b"],
+      },
+    ],
+  };
+}
+
+function createValidSwarmDefinition(): WorkflowDefinition {
+  return {
+    pattern: "swarm",
+    steps: [
+      {
+        id: "mayor",
+        name: "Mayor",
+        prompt: "Plan the swarm.",
+      },
+      {
+        id: "worker-a",
+        name: "Worker A",
+        prompt: "Own the first slice.",
+      },
+      {
+        id: "worker-b",
+        name: "Worker B",
+        prompt: "Own the second slice.",
+      },
+      {
+        id: "refinery",
+        name: "Refinery",
+        prompt: "Merge the results.",
+      },
+    ],
+    swarmConfig: {
+      workerConcurrencyLimit: 2,
+    },
+  };
+}
+
+describe("validateWorkflowDefinition", () => {
+  it("accepts a valid parallel fork/join definition", () => {
+    expect(validateWorkflowDefinition(createValidParallelDefinition())).toBeNull();
+  });
+
+  it("rejects a parallel definition with too few branches", () => {
+    const definition: WorkflowDefinition = {
+      pattern: "parallel",
+      steps: [
+        {
+          id: "branch-a",
+          name: "Single branch",
+          prompt: "Only one branch exists.",
+        },
+        {
+          id: "join",
+          name: "Synthesize",
+          prompt: "Combine the findings.",
+          dependsOn: ["branch-a"],
+        },
+      ],
+    };
+
+    expect(validateWorkflowDefinition(definition)).toBe(
+      "Parallel pattern requires at least 2 branch steps"
+    );
+  });
+
+  it("rejects a synthesis step that does not depend on every branch", () => {
+    const definition = createValidParallelDefinition();
+    definition.steps[2] = {
+      ...definition.steps[2],
+      dependsOn: ["branch-a"],
+    };
+
+    expect(validateWorkflowDefinition(definition)).toBe(
+      "Parallel synthesis step must depend on every branch exactly once"
+    );
+  });
+
+  it("keeps loop validation intact", () => {
+    const definition: WorkflowDefinition = {
+      pattern: "loop",
+      steps: [{ id: "loop", name: "Loop", prompt: "Keep iterating." }],
+    };
+
+    expect(validateWorkflowDefinition(definition)).toBe(
+      "Loop pattern requires loopConfig with maxIterations >= 1"
+    );
+  });
+
+  it("accepts a valid swarm definition", () => {
+    expect(validateWorkflowDefinition(createValidSwarmDefinition())).toBeNull();
+  });
+
+  it("rejects a swarm definition with too few workers", () => {
+    const definition: WorkflowDefinition = {
+      pattern: "swarm",
+      steps: [
+        {
+          id: "mayor",
+          name: "Mayor",
+          prompt: "Plan the swarm.",
+        },
+        {
+          id: "worker-a",
+          name: "Worker A",
+          prompt: "Own the only slice.",
+        },
+        {
+          id: "refinery",
+          name: "Refinery",
+          prompt: "Merge the results.",
+        },
+      ],
+    };
+
+    expect(validateWorkflowDefinition(definition)).toBe(
+      "Swarm pattern requires a mayor step, 2-5 worker steps, and a refinery step"
+    );
+  });
+
+  it("rejects swarm steps that declare dependencies", () => {
+    const definition = createValidSwarmDefinition();
+    definition.steps[1] = {
+      ...definition.steps[1],
+      dependsOn: ["mayor"],
+    };
+
+    expect(validateWorkflowDefinition(definition)).toBe(
+      "Swarm steps use fixed mayor/worker/refinery ordering and cannot declare dependencies"
+    );
+  });
+
+  it("rejects a swarm concurrency limit above worker count", () => {
+    const definition = createValidSwarmDefinition();
+    definition.swarmConfig = {
+      workerConcurrencyLimit: 3,
+    };
+
+    expect(validateWorkflowDefinition(definition)).toBe(
+      "Swarm worker concurrency limit must be between 1 and 2"
+    );
+  });
+});