stagent 0.10.0 → 0.11.1

package/src/lib/chat/tools/__tests__/skill-tools.test.ts

@@ -0,0 +1,474 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+/** Mutable test state shared across module-level mocks. */
+const { mockState } = vi.hoisted(() => ({
+  mockState: {
+    skills: [] as Array<{
+      id: string;
+      name: string;
+      tool: string;
+      scope: string;
+      preview: string;
+      sizeBytes: number;
+      absPath: string;
+      content: string;
+    }>,
+    conversations: new Map<string, {
+      id: string;
+      activeSkillId: string | null;
+      activeSkillIds: string[];
+      runtimeId: string;
+    }>(),
+    lastUpdateId: null as string | null,
+    lastUpdateValues: null as Record<string, unknown> | null,
+    lastSelectedId: null as string | null,
+  },
+}));
+
+vi.mock("@/lib/environment/list-skills", () => ({
+  listSkills: () => mockState.skills.map(({ content: _content, ...rest }) => rest),
+  getSkill: (id: string) => {
+    const hit = mockState.skills.find((s) => s.id === id);
+    return hit ?? null;
+  },
+}));
+
+vi.mock("@/lib/db", () => {
+  const selectBuilder = {
+    from() {
+      return this;
+    },
+    where() {
+      return this;
+    },
+    get() {
+      const id = mockState.lastSelectedId;
+      return Promise.resolve(
+        id ? mockState.conversations.get(id) : undefined
+      );
+    },
+  };
+  // Hoisted fields for the select chain — updated from the eq() stub
+  mockState.lastSelectedId = null;
+  return {
+    db: {
+      select: () => selectBuilder,
+      update: () => ({
+        set: (values: Record<string, unknown>) => {
+          mockState.lastUpdateValues = values;
+          return {
+            where: () => {
+              // Apply the update to the tracked conversation so follow-up
+              // reads see the new state.
+              if (mockState.lastUpdateId) {
+                const row = mockState.conversations.get(mockState.lastUpdateId);
+                if (row) {
+                  mockState.conversations.set(mockState.lastUpdateId, {
+                    ...row,
+                    activeSkillId:
+                      "activeSkillId" in values
+                        ? (values.activeSkillId as string | null)
+                        : row.activeSkillId,
+                    activeSkillIds:
+                      "activeSkillIds" in values
+                        ? (values.activeSkillIds as string[])
+                        : row.activeSkillIds,
+                  });
+                }
+              }
+              return Promise.resolve();
+            },
+          };
+        },
+      }),
+    },
+  };
+});
+
+vi.mock("@/lib/db/schema", () => ({
+  conversations: {
+    id: "id",
+    activeSkillId: "activeSkillId",
+    activeSkillIds: "activeSkillIds",
+    runtimeId: "runtimeId",
+  },
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: (_col: unknown, val: unknown) => {
+    // Side channel so the select/update chains know which row to touch.
+    const id = typeof val === "string" ? val : null;
+    mockState.lastSelectedId = id;
+    mockState.lastUpdateId = id;
+    return {};
+  },
+}));
+
+vi.mock("@/lib/agents/runtime/catalog", () => ({
+  getRuntimeFeatures: (runtimeId: string) => {
+    if (runtimeId === "ollama") {
+      return { supportsSkillComposition: false, maxActiveSkills: 1 };
+    }
+    if (
+      runtimeId === "claude-code" ||
+      runtimeId === "openai-codex-app-server" ||
+      runtimeId === "anthropic-direct" ||
+      runtimeId === "openai-direct"
+    ) {
+      return { supportsSkillComposition: true, maxActiveSkills: 3 };
+    }
+    throw new Error(`Unknown runtime: ${runtimeId}`);
+  },
+}));
+
+import { skillTools } from "../skill-tools";
+
+function getTool(name: string) {
+  const tools = skillTools({ projectId: "proj-1" } as never);
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) throw new Error(`Tool not found: ${name}`);
+  return tool;
+}
+
+async function call(toolName: string, args: Record<string, unknown> = {}) {
+  const tool = getTool(toolName);
+  return tool.handler(args);
+}
+
+function parse(result: {
+  content: Array<{ type: string; text: string }>;
+  isError?: boolean;
+}) {
+  return {
+    data: JSON.parse(result.content[0].text) as Record<string, unknown>,
+    isError: result.isError ?? false,
+  };
+}
+
+beforeEach(() => {
+  mockState.skills = [];
+  mockState.conversations.clear();
+  mockState.lastUpdateId = null;
+  mockState.lastUpdateValues = null;
+  mockState.lastSelectedId = null;
+});
+
+describe("skill-tools", () => {
+  describe("list_skills", () => {
+    it("returns all discoverable skills with id/name/tool/scope/preview/size, no absPath", async () => {
+      mockState.skills = [
+        {
+          id: ".claude/skills/capture",
+          name: "capture",
+          tool: "claude-code",
+          scope: "project",
+          preview: "Capture web content as markdown.",
+          sizeBytes: 2048,
+          absPath: "/abs/.claude/skills/capture/SKILL.md",
+          content: "# capture\n\nBody.",
+        },
+      ];
+      const { data, isError } = parse(await call("list_skills"));
+      expect(isError).toBe(false);
+      expect(data.count).toBe(1);
+      const skills = data.skills as Array<Record<string, unknown>>;
+      expect(skills[0]).toMatchObject({
+        id: ".claude/skills/capture",
+        name: "capture",
+        tool: "claude-code",
+        scope: "project",
+        sizeBytes: 2048,
+      });
+      expect("absPath" in skills[0]).toBe(false); // never surface to LLM
+    });
+
+    it("returns count=0 when no skills are discovered", async () => {
+      const { data } = parse(await call("list_skills"));
+      expect(data.count).toBe(0);
+      expect(data.skills).toEqual([]);
+    });
+  });
+
+  describe("get_skill", () => {
+    it("returns full SKILL.md content for a known id", async () => {
+      mockState.skills = [
+        {
+          id: ".agents/skills/codegen",
+          name: "codegen",
+          tool: "codex",
+          scope: "user",
+          preview: "Codegen helper.",
+          sizeBytes: 1000,
+          absPath: "/abs/.agents/skills/codegen/SKILL.md",
+          content: "# codegen\n\nFull body here.",
+        },
+      ];
+      const { data, isError } = parse(
+        await call("get_skill", { id: ".agents/skills/codegen" })
+      );
+      expect(isError).toBe(false);
+      expect(data.content).toContain("Full body here");
+      expect(data.name).toBe("codegen");
+    });
+
+    it("returns an error when the id is not found", async () => {
+      const { data, isError } = parse(
+        await call("get_skill", { id: "nope" })
+      );
+      expect(isError).toBe(true);
+      expect(data.error).toContain("Skill not found");
+    });
+  });
+
+  describe("activate_skill", () => {
+    it("binds a skill to a conversation and returns confirmation", async () => {
+      mockState.skills = [
+        {
+          id: ".claude/skills/capture",
+          name: "capture",
+          tool: "claude-code",
+          scope: "project",
+          preview: "…",
+          sizeBytes: 500,
+          absPath: "/abs/path",
+          content: "# capture",
+        },
+      ];
+      mockState.conversations.set("conv-1", { id: "conv-1", activeSkillId: null, activeSkillIds: [], runtimeId: "claude-code" });
+
+      const { data, isError } = parse(
+        await call("activate_skill", {
+          conversationId: "conv-1",
+          skillId: ".claude/skills/capture",
+        })
+      );
+      expect(isError).toBe(false);
+      expect(data.activatedSkillId).toBe(".claude/skills/capture");
+      expect(data.skillName).toBe("capture");
+      expect(mockState.lastUpdateValues).toMatchObject({
+        activeSkillId: ".claude/skills/capture",
+      });
+      expect(mockState.conversations.get("conv-1")?.activeSkillId).toBe(
+        ".claude/skills/capture"
+      );
+    });
+
+    it("errors on unknown conversation", async () => {
+      mockState.skills = [
+        {
+          id: ".claude/skills/capture",
+          name: "capture",
+          tool: "claude-code",
+          scope: "project",
+          preview: "…",
+          sizeBytes: 500,
+          absPath: "/abs/path",
+          content: "# capture",
+        },
+      ];
+      const { data, isError } = parse(
+        await call("activate_skill", {
+          conversationId: "ghost",
+          skillId: ".claude/skills/capture",
+        })
+      );
+      expect(isError).toBe(true);
+      expect(data.error).toContain("Conversation not found");
+    });
+
+    it("errors on unknown skill id (validates before writing)", async () => {
+      mockState.conversations.set("conv-1", { id: "conv-1", activeSkillId: null, activeSkillIds: [], runtimeId: "claude-code" });
+      const { data, isError } = parse(
+        await call("activate_skill", {
+          conversationId: "conv-1",
+          skillId: "not-a-real-skill",
+        })
+      );
+      expect(isError).toBe(true);
+      expect(data.error).toContain("Skill not found");
+      expect(mockState.lastUpdateValues).toBeNull(); // no write happened
+    });
+
+    it("replaces a previously active skill (single-active rule)", async () => {
+      mockState.skills = [
+        {
+          id: "first",
+          name: "first",
+          tool: "claude-code",
+          scope: "project",
+          preview: "",
+          sizeBytes: 100,
+          absPath: "/a",
+          content: "# first",
+        },
+        {
+          id: "second",
+          name: "second",
+          tool: "claude-code",
+          scope: "project",
+          preview: "",
+          sizeBytes: 100,
+          absPath: "/b",
+          content: "# second",
+        },
+      ];
+      mockState.conversations.set("conv-1", {
+        id: "conv-1",
+        activeSkillId: "first",
+        activeSkillIds: [],
+        runtimeId: "claude-code",
+      });
+
+      await call("activate_skill", {
+        conversationId: "conv-1",
+        skillId: "second",
+      });
+      expect(mockState.conversations.get("conv-1")?.activeSkillId).toBe("second");
+    });
+
+    it("mode:add appends a second skill on a composition-capable runtime", async () => {
+      mockState.skills = [
+        { id: "first-skill", name: "first", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/a", content: "# first\nUse foo." },
+        { id: "second-skill", name: "second", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/b", content: "# second\nUse bar." },
+      ];
+      mockState.conversations.set("conv-1", {
+        id: "conv-1",
+        activeSkillId: "first-skill",
+        activeSkillIds: [],
+        runtimeId: "claude-code",
+      });
+      const { data, isError } = parse(
+        await call("activate_skill", {
+          conversationId: "conv-1",
+          skillId: "second-skill",
+          mode: "add",
+          force: true,
+        })
+      );
+      expect(isError).toBe(false);
+      expect(data.activeSkillIds).toEqual(["first-skill", "second-skill"]);
+    });
+
+    it("mode:add fails on Ollama with capability hint", async () => {
+      mockState.skills = [
+        { id: "any", name: "any", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/a", content: "# any" },
+      ];
+      mockState.conversations.set("conv-1", {
+        id: "conv-1",
+        activeSkillId: null,
+        activeSkillIds: [],
+        runtimeId: "ollama",
+      });
+      const { data, isError } = parse(
+        await call("activate_skill", {
+          conversationId: "conv-1",
+          skillId: "any",
+          mode: "add",
+        })
+      );
+      expect(isError).toBe(true);
+      expect(data.error).toMatch(/composition/i);
+    });
+
+    it("mode:add enforces maxActiveSkills (Claude allows 3)", async () => {
+      mockState.skills = [
+        { id: "a", name: "a", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/a", content: "" },
+        { id: "b", name: "b", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/b", content: "" },
+        { id: "c", name: "c", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/c", content: "" },
+        { id: "d", name: "d", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/d", content: "" },
+      ];
+      mockState.conversations.set("conv-1", {
+        id: "conv-1",
+        activeSkillId: "a",
+        activeSkillIds: ["b", "c"],
+        runtimeId: "claude-code",
+      });
+      const { data, isError } = parse(
+        await call("activate_skill", {
+          conversationId: "conv-1",
+          skillId: "d",
+          mode: "add",
+          force: true,
+        })
+      );
+      expect(isError).toBe(true);
+      expect(data.error).toMatch(/max active skills/i);
+    });
+
+    it("mode:add returns conflicts without writing when conflicts detected (no force)", async () => {
+      mockState.skills = [
+        { id: "tdd", name: "tdd", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/a", content: "Always write tests first." },
+        { id: "spike", name: "spike", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/b", content: "Never write tests during a spike." },
+      ];
+      mockState.conversations.set("conv-1", {
+        id: "conv-1",
+        activeSkillId: "tdd",
+        activeSkillIds: [],
+        runtimeId: "claude-code",
+      });
+      const { data, isError } = parse(
+        await call("activate_skill", {
+          conversationId: "conv-1",
+          skillId: "spike",
+          mode: "add",
+        })
+      );
+      expect(isError).toBe(false);
+      expect(data.requiresConfirmation).toBe(true);
+      expect(Array.isArray(data.conflicts)).toBe(true);
+      // Must NOT have written
+      expect(mockState.conversations.get("conv-1")?.activeSkillIds).toEqual([]);
+    });
+
+    it("default mode:replace clears prior composed skills (back-compat)", async () => {
+      mockState.skills = [
+        { id: "new", name: "new", tool: "x", scope: "project", preview: "", sizeBytes: 100, absPath: "/n", content: "" },
+      ];
+      mockState.conversations.set("conv-1", {
+        id: "conv-1",
+        activeSkillId: "old",
+        activeSkillIds: ["other"],
+        runtimeId: "claude-code",
+      });
+      await call("activate_skill", { conversationId: "conv-1", skillId: "new" });
+      expect(mockState.conversations.get("conv-1")?.activeSkillId).toBe("new");
+      expect(mockState.conversations.get("conv-1")?.activeSkillIds).toEqual([]);
+    });
+  });
+
+  describe("deactivate_skill", () => {
+    it("clears the active skill and returns the previous id", async () => {
+      mockState.conversations.set("conv-1", {
+        id: "conv-1",
+        activeSkillId: ".claude/skills/capture",
+        activeSkillIds: [],
+        runtimeId: "claude-code",
+      });
+      const { data, isError } = parse(
+        await call("deactivate_skill", { conversationId: "conv-1" })
+      );
+      expect(isError).toBe(false);
+      expect(data.previousSkillId).toBe(".claude/skills/capture");
+      expect(data.activeSkillId).toBeNull();
+      expect(mockState.conversations.get("conv-1")?.activeSkillId).toBeNull();
+    });
+
+    it("is idempotent when no skill was active", async () => {
+      mockState.conversations.set("conv-1", { id: "conv-1", activeSkillId: null, activeSkillIds: [], runtimeId: "claude-code" });
+      const { data, isError } = parse(
+        await call("deactivate_skill", { conversationId: "conv-1" })
+      );
+      expect(isError).toBe(false);
+      expect(data.previousSkillId).toBeNull();
+      expect(data.activeSkillId).toBeNull();
+    });
+
+    it("errors on unknown conversation", async () => {
+      const { data, isError } = parse(
+        await call("deactivate_skill", { conversationId: "ghost" })
+      );
+      expect(isError).toBe(true);
+      expect(data.error).toContain("Conversation not found");
+    });
+  });
+});

package/src/lib/chat/tools/__tests__/task-tools.test.ts

@@ -282,6 +282,53 @@ describe("execute_task stale agentProfile surfacing", () => {
   });
 });
 
+describe("create_task assignedAgent runtime validation", () => {
+  it("returns a descriptive error listing valid runtime ids when assignedAgent is invalid", async () => {
+    const result = await callHandler("create_task", {
+      title: "test task",
+      assignedAgent: "claude-bogus",
+    });
+    expect(result.isError).toBe(true);
+    const text = getToolResultText(result);
+    expect(text).toContain("claude-bogus");
+    expect(text).toMatch(/Invalid runtime/i);
+    expect(text).toMatch(/anthropic-direct|openai-direct|claude/);
+  });
+
+  it("inserts with the given assignedAgent when it is a valid runtime id", async () => {
+    const result = await callHandler("create_task", {
+      title: "test task",
+      assignedAgent: "anthropic-direct",
+    });
+    expect(result.isError).toBeFalsy();
+    expect(mockState.lastInsertValues?.assignedAgent).toBe("anthropic-direct");
+  });
+});
+
+describe("execute_task assignedAgent runtime validation", () => {
+  beforeEach(() => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "existing",
+      status: "planned",
+      projectId: null,
+      agentProfile: null,
+      assignedAgent: null,
+    } as TaskRow];
+  });
+
+  it("returns an error listing valid runtime ids when the passed assignedAgent is invalid", async () => {
+    const result = await callHandler("execute_task", {
+      taskId: "task-1",
+      assignedAgent: "claude-bogus",
+    });
+    expect(result.isError).toBe(true);
+    const text = getToolResultText(result);
+    expect(text).toContain("claude-bogus");
+    expect(text).toMatch(/Invalid runtime/i);
+  });
+});
+
 describe("list_tasks empty-result note", () => {
   it("returns an envelope with note when a project filter is active and zero rows result", async () => {
     mockState.rows = [];

package/src/lib/chat/tools/__tests__/workflow-tools-dedup.test.ts

@@ -214,4 +214,138 @@ describe("findSimilarWorkflows", () => {
     expect(result).toHaveLength(1);
     expect(result[0].similarity).toBe(1); // exact name match
   });
+
+  // ── Legitimate variant tolerance ────────────────────────────────────
+  //
+  // Regression tests for the concern flagged in the code review of
+  // commit b5ed09b: that WORKFLOW_DEDUP_THRESHOLD = 0.7 on a pooled
+  // Jaccard over keywords would flag legitimate target-entity variants
+  // (e.g. "Enrich contacts" vs "Enrich accounts") as duplicates,
+  // eroding trust in the guardrail. Each pair here shares a dominant
+  // verb and most of the step structure — the only difference is the
+  // target entity noun.
+  //
+  // Success criterion per spec:
+  //   - the two "positive-variant" cases must return [] (no match)
+  //   - the two "guard" cases must still flag duplicates (similarity >=
+  //     WORKFLOW_DEDUP_THRESHOLD, or exact-name match)
+  describe("legitimate variant tolerance", () => {
+    it("allows Enrich contacts and Enrich accounts as distinct workflows", async () => {
+      setRows([
+        {
+          id: "wf1",
+          name: "Enrich contacts",
+          definition: JSON.stringify({
+            pattern: "sequence",
+            steps: [
+              { id: "s1", name: "Load rows from contacts table", prompt: "Select rows from the contacts table" },
+              { id: "s2", name: "Call enrichment agent", prompt: "Invoke enrichment agent on each row" },
+              { id: "s3", name: "Write back to table", prompt: "Write enriched data back to the contacts table" },
+            ],
+          }),
+          projectId: "proj_a",
+        },
+      ]);
+
+      const result = await findSimilarWorkflows(
+        "proj_a",
+        "Enrich accounts",
+        JSON.stringify({
+          pattern: "sequence",
+          steps: [
+            { id: "s1", name: "Load rows from accounts table", prompt: "Select rows from the accounts table" },
+            { id: "s2", name: "Call enrichment agent", prompt: "Invoke enrichment agent on each row" },
+            { id: "s3", name: "Write back to table", prompt: "Write enriched data back to the accounts table" },
+          ],
+        })
+      );
+
+      expect(result).toEqual([]);
+    });
+
+    it("allows Daily standup digest and Weekly standup digest as distinct workflows", async () => {
+      setRows([
+        {
+          id: "wf1",
+          name: "Daily standup digest",
+          definition: JSON.stringify({
+            pattern: "sequence",
+            steps: [
+              { id: "s1", name: "Fetch standup messages", prompt: "Pull daily standup messages from the team channel" },
+              { id: "s2", name: "Summarize daily topics", prompt: "Write a daily digest of key topics and blockers" },
+              { id: "s3", name: "Post digest to channel", prompt: "Post the daily summary digest to the #ops channel" },
+            ],
+          }),
+          projectId: "proj_a",
+        },
+      ]);
+
+      const result = await findSimilarWorkflows(
+        "proj_a",
+        "Weekly standup digest",
+        JSON.stringify({
+          pattern: "sequence",
+          steps: [
+            { id: "s1", name: "Fetch standup messages", prompt: "Pull weekly standup messages from the team channel" },
+            { id: "s2", name: "Summarize weekly topics", prompt: "Write a weekly digest of key topics and blockers" },
+            { id: "s3", name: "Post digest to channel", prompt: "Post the weekly summary digest to the #ops channel" },
+          ],
+        })
+      );
+
+      expect(result).toEqual([]);
+    });
+
+    it("still blocks exact case-insensitive name matches (guard)", async () => {
+      setRows([
+        {
+          id: "wf1",
+          name: "Enrich contacts",
+          definition: JSON.stringify({
+            pattern: "sequence",
+            steps: [
+              { id: "s1", name: "Load rows from contacts table", prompt: "Select rows from the contacts table" },
+            ],
+          }),
+          projectId: "proj_a",
+        },
+      ]);
+
+      const result = await findSimilarWorkflows(
+        "proj_a",
+        "ENRICH CONTACTS", // same name, different case
+        JSON.stringify({ pattern: "sequence", steps: [] })
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0].similarity).toBe(1);
+      expect(result[0].reason).toContain("Same name");
+    });
+
+    it("still blocks near-identical step content with near-identical name (guard)", async () => {
+      const sharedSteps = [
+        { id: "s1", name: "Fetch customer segments list", prompt: "Load the customer segments list from BigQuery warehouse" },
+        { id: "s2", name: "Classify each segment bucket", prompt: "Classify each customer segment bucket using ML model" },
+        { id: "s3", name: "Write segments back warehouse", prompt: "Write segment classifications back into BigQuery warehouse" },
+      ];
+      setRows([
+        {
+          id: "wf1",
+          name: "Classify customer segments v1",
+          definition: JSON.stringify({ pattern: "sequence", steps: sharedSteps }),
+          projectId: "proj_a",
+        },
+      ]);
+
+      const result = await findSimilarWorkflows(
+        "proj_a",
+        "Classify customer segments v2",
+        JSON.stringify({ pattern: "sequence", steps: sharedSteps })
+      );
+
+      expect(result.length).toBeGreaterThanOrEqual(1);
+      expect(result[0].id).toBe("wf1");
+      expect(result[0].similarity).toBeGreaterThanOrEqual(0.7);
+    });
+  });
 });