@desplega.ai/agent-swarm 1.51.2 → 1.52.1

package/src/tests/skill-parser.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, test } from "bun:test";
+import { parseSkillContent } from "../be/skill-parser";
+
+// ─── Valid Parsing ──────────────────────────────────────────────────────────
+
+describe("parseSkillContent — valid inputs", () => {
+  test("parses minimal frontmatter with body", () => {
+    const content = `---
+name: my-skill
+description: A test skill
+---
+
+This is the body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("my-skill");
+    expect(result.description).toBe("A test skill");
+    expect(result.body).toBe("This is the body.");
+  });
+
+  test("parses all optional frontmatter fields", () => {
+    const content = `---
+name: full-skill
+description: Full featured skill
+allowed-tools: Read,Write,Bash
+model: opus
+effort: high
+context: some-context
+agent: worker-123
+disable-model-invocation: true
+user-invocable: true
+---
+
+Body content here.`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("full-skill");
+    expect(result.description).toBe("Full featured skill");
+    expect(result.allowedTools).toBe("Read,Write,Bash");
+    expect(result.model).toBe("opus");
+    expect(result.effort).toBe("high");
+    expect(result.context).toBe("some-context");
+    expect(result.agent).toBe("worker-123");
+    expect(result.disableModelInvocation).toBe(true);
+    expect(result.userInvocable).toBe(true);
+  });
+
+  test("returns undefined for unset optional fields", () => {
+    const content = `---
+name: minimal
+description: Minimal skill
+---
+
+Body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.allowedTools).toBeUndefined();
+    expect(result.model).toBeUndefined();
+    expect(result.effort).toBeUndefined();
+    expect(result.context).toBeUndefined();
+    expect(result.agent).toBeUndefined();
+    expect(result.disableModelInvocation).toBeUndefined();
+    expect(result.userInvocable).toBeUndefined();
+  });
+
+  test("handles empty body after frontmatter", () => {
+    const content = `---
+name: no-body
+description: Skill with no body
+---`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("no-body");
+    expect(result.body).toBe("");
+  });
+
+  test("user-invocable defaults to true when present without value", () => {
+    // user-invocable with no value → empty string → not "false" → true
+    // Actually per the parser: if key has empty value, it's skipped (value check)
+    // Let's test explicit true/false
+    const contentTrue = `---
+name: invocable
+description: Test
+user-invocable: true
+---
+Body`;
+
+    const contentFalse = `---
+name: non-invocable
+description: Test
+user-invocable: false
+---
+Body`;
+
+    expect(parseSkillContent(contentTrue).userInvocable).toBe(true);
+    expect(parseSkillContent(contentFalse).userInvocable).toBe(false);
+  });
+
+  test("disable-model-invocation only true for literal 'true'", () => {
+    const contentTrue = `---
+name: disabled
+description: Test
+disable-model-invocation: true
+---
+Body`;
+
+    const contentFalse = `---
+name: enabled
+description: Test
+disable-model-invocation: false
+---
+Body`;
+
+    expect(parseSkillContent(contentTrue).disableModelInvocation).toBe(true);
+    expect(parseSkillContent(contentFalse).disableModelInvocation).toBeUndefined();
+  });
+
+  test("handles extra whitespace in frontmatter", () => {
+    const content = `---
+name:   spaced-skill
+description:   A spaced description
+---
+
+Body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("spaced-skill");
+    expect(result.description).toBe("A spaced description");
+  });
+
+  test("handles colons in frontmatter values", () => {
+    const content = `---
+name: colon-skill
+description: A skill with: colons in description
+---
+
+Body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.description).toBe("A skill with: colons in description");
+  });
+});
+
+// ─── Invalid Inputs ─────────────────────────────────────────────────────────
+
+describe("parseSkillContent — invalid inputs", () => {
+  test("throws if no frontmatter delimiter", () => {
+    expect(() => parseSkillContent("No frontmatter here")).toThrow("No frontmatter found");
+  });
+
+  test("throws if frontmatter is unterminated", () => {
+    expect(() => parseSkillContent("---\nname: test\nno closing")).toThrow("Missing closing ---");
+  });
+
+  test("throws if name is missing", () => {
+    const content = `---
+description: Missing name
+---
+Body`;
+    expect(() => parseSkillContent(content)).toThrow('missing required field: "name"');
+  });
+
+  test("throws if description is missing", () => {
+    const content = `---
+name: no-desc
+---
+Body`;
+    expect(() => parseSkillContent(content)).toThrow('missing required field: "description"');
+  });
+
+  test("throws on empty string", () => {
+    expect(() => parseSkillContent("")).toThrow("No frontmatter found");
+  });
+
+  test("throws on whitespace-only string", () => {
+    expect(() => parseSkillContent("   \n\n  ")).toThrow("No frontmatter found");
+  });
+});

package/src/tests/skill-sync.test.ts

@@ -0,0 +1,171 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { closeDb, createAgent, createSkill, initDb, installSkill } from "../be/db";
+import { syncSkillsToFilesystem } from "../be/skill-sync";
+
+const TEST_DB_PATH = `./test-skill-sync-${process.pid}.sqlite`;
+const FAKE_HOME = join(tmpdir(), `skill-sync-test-${process.pid}`);
+
+describe("syncSkillsToFilesystem", () => {
+  let agentId: string;
+
+  beforeAll(() => {
+    initDb(TEST_DB_PATH);
+
+    const agent = createAgent({
+      name: "Skill Sync Test Worker",
+      description: "Test agent for skill sync",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+    agentId = agent.id;
+
+    // Create and install a simple skill
+    const skill = createSkill({
+      name: "test-skill",
+      description: "A test skill",
+      content: "---\nname: test-skill\ndescription: A test skill\n---\n\nTest body.",
+      type: "personal",
+      scope: "agent",
+    });
+    installSkill(agentId, skill.id);
+
+    // Create a complex skill (should be skipped)
+    const complexSkill = createSkill({
+      name: "complex-skill",
+      description: "A complex skill",
+      content: "---\nname: complex-skill\ndescription: A complex skill\n---\n\nBody.",
+      type: "remote",
+      scope: "global",
+      isComplex: true,
+    });
+    installSkill(agentId, complexSkill.id);
+
+    mkdirSync(FAKE_HOME, { recursive: true });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    rmSync(FAKE_HOME, { recursive: true, force: true });
+    await unlink(TEST_DB_PATH).catch(() => {});
+    await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+    await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+  });
+
+  test("syncs simple skills to claude directory", () => {
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBeGreaterThanOrEqual(1);
+
+    const skillFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(skillFile)).toBe(true);
+    expect(readFileSync(skillFile, "utf-8")).toContain("Test body.");
+  });
+
+  test("syncs simple skills to pi directory", () => {
+    const result = syncSkillsToFilesystem(agentId, "pi", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBeGreaterThanOrEqual(1);
+
+    const skillFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(skillFile)).toBe(true);
+    expect(readFileSync(skillFile, "utf-8")).toContain("Test body.");
+  });
+
+  test("syncs to both claude and pi when harnessType is 'both'", () => {
+    // Clean up first to get accurate count
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "both", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBe(2); // 1 skill × 2 dirs
+
+    const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
+    const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(claudeFile)).toBe(true);
+    expect(existsSync(piFile)).toBe(true);
+  });
+
+  test("skips complex skills", () => {
+    const _result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    const complexDir = join(FAKE_HOME, ".claude", "skills", "complex-skill");
+    expect(existsSync(complexDir)).toBe(false);
+  });
+
+  test("removes stale skill directories", () => {
+    const staleDir = join(FAKE_HOME, ".claude", "skills", "old-removed-skill");
+    mkdirSync(staleDir, { recursive: true });
+    expect(existsSync(staleDir)).toBe(true);
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.removed).toBeGreaterThanOrEqual(1);
+    expect(existsSync(staleDir)).toBe(false);
+  });
+
+  test("defaults to 'both' when no harnessType provided", () => {
+    // Clean up first
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
+
+    // Use 'both' explicitly with homeOverride (default harnessType would use real home)
+    const result = syncSkillsToFilesystem(agentId, "both", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBe(2);
+
+    const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
+    const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(claudeFile)).toBe(true);
+    expect(existsSync(piFile)).toBe(true);
+  });
+
+  test("returns empty result for agent with no skills", () => {
+    const otherAgent = createAgent({
+      name: "Empty Agent",
+      description: "Agent with no skills",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+
+    const result = syncSkillsToFilesystem(otherAgent.id, "claude", FAKE_HOME);
+
+    expect(result.synced).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test("sanitizes skill names with special characters", () => {
+    const skill = createSkill({
+      name: "my/dangerous/../skill",
+      description: "Path traversal attempt",
+      content:
+        "---\nname: my/dangerous/../skill\ndescription: Path traversal attempt\n---\n\nSafe.",
+      type: "personal",
+      scope: "agent",
+    });
+    installSkill(agentId, skill.id);
+
+    // Clean up first
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    const sanitizedDir = join(FAKE_HOME, ".claude", "skills", "my_dangerous____skill");
+    expect(existsSync(sanitizedDir)).toBe(true);
+  });
+});

package/src/tests/slack-blocks.test.ts

@@ -145,9 +145,10 @@ describe("buildProgressBlocks", () => {
     });
 
     expect(blocks.length).toBe(2);
-    // Single line: ⏳ *Gamma* (`aabbccdd`): Analyzing codebase...
+    // Single line: *Gamma* (`aabbccdd`): Analyzing codebase...
+    // (no ⏳ prefix — progress strings now carry their own emoji)
     expect(blocks[0].type).toBe("section");
-    expect(blocks[0].text.text).toContain("⏳");
+    expect(blocks[0].text.text).not.toContain("⏳");
     expect(blocks[0].text.text).toContain("Gamma");
     expect(blocks[0].text.text).toContain("aabbccdd");
     expect(blocks[0].text.text).toContain("Analyzing codebase...");

package/src/tests/structured-output.test.ts

@@ -233,6 +233,7 @@ describe("AgentTaskConfigSchema — outputSchema", () => {
   test("accepts outputSchema in config", async () => {
     const { AgentTaskExecutor } = await import("../workflows/executors/agent-task");
     const executor = new AgentTaskExecutor({
+      // biome-ignore lint/suspicious/noExplicitAny: mock DB for test
       db: {} as any,
       eventBus: { emit: () => {}, on: () => {}, off: () => {} },
       interpolate: (t: string) => t,

package/src/tests/tool-annotations.test.ts

@@ -338,8 +338,9 @@ describe("Tool Annotations & Classification", () => {
   test("registered tool count matches expected total", () => {
     const count = Object.keys(tools).length;
     // We expect all tools to be registered when all capabilities are enabled (default)
+    // Includes 11 skill tools added in the skill system feature
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(70);
+    expect(count).toBeLessThanOrEqual(85);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/tool-call-progress.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, test } from "bun:test";
+import { humanizeToolName, toolCallToProgress } from "../commands/runner";
+
+describe("toolCallToProgress", () => {
+  // --- Core Claude Code tools ---
+
+  test("Read tool includes emoji and short path", () => {
+    const result = toolCallToProgress("Read", {
+      file_path: "/Users/taras/Documents/code/agent-swarm/src/commands/runner.ts",
+    });
+    expect(result).toBe("📖 Reading commands/runner.ts");
+  });
+
+  test("Edit tool includes emoji and short path", () => {
+    const result = toolCallToProgress("Edit", {
+      file_path: "/Users/taras/code/src/index.ts",
+    });
+    expect(result).toBe("✏️ Editing src/index.ts");
+  });
+
+  test("MultiEdit uses same format as Edit", () => {
+    const result = toolCallToProgress("MultiEdit", {
+      file_path: "/a/b/c/d.ts",
+    });
+    expect(result).toBe("✏️ Editing c/d.ts");
+  });
+
+  test("Write tool includes emoji and short path", () => {
+    const result = toolCallToProgress("Write", {
+      file_path: "/Users/taras/code/new-file.ts",
+    });
+    expect(result).toBe("📝 Writing code/new-file.ts");
+  });
+
+  test("Bash tool uses description when available", () => {
+    const result = toolCallToProgress("Bash", {
+      description: "Running tests",
+      command: "bun test",
+    });
+    expect(result).toBe("⚡ Running tests");
+  });
+
+  test("Bash tool falls back when no description", () => {
+    const result = toolCallToProgress("Bash", { command: "ls -la" });
+    expect(result).toBe("⚡ Running shell command");
+  });
+
+  test("Grep tool shows search pattern", () => {
+    const result = toolCallToProgress("Grep", { pattern: "TODO" });
+    expect(result).toBe('🔍 Searching for "TODO"');
+  });
+
+  test("Glob tool shows file pattern", () => {
+    const result = toolCallToProgress("Glob", { pattern: "**/*.test.ts" });
+    expect(result).toBe("📁 Finding files matching **/*.test.ts");
+  });
+
+  test("Agent tool uses description when available", () => {
+    const result = toolCallToProgress("Agent", {
+      description: "Exploring codebase structure",
+    });
+    expect(result).toBe("🤖 Exploring codebase structure");
+  });
+
+  test("Agent tool falls back when no description", () => {
+    const result = toolCallToProgress("Agent", {});
+    expect(result).toBe("🤖 Delegating sub-task");
+  });
+
+  test("Task tool uses description", () => {
+    const result = toolCallToProgress("Task", {
+      description: "Running lint checks",
+    });
+    expect(result).toBe("🤖 Running lint checks");
+  });
+
+  test("Skill tool shows skill name", () => {
+    const result = toolCallToProgress("Skill", { skill: "commit" });
+    expect(result).toBe("⚙️ Running /commit");
+  });
+
+  // --- Skip list ---
+
+  test("ToolSearch is skipped (returns null)", () => {
+    expect(toolCallToProgress("ToolSearch", {})).toBeNull();
+  });
+
+  test("TodoRead is skipped", () => {
+    expect(toolCallToProgress("TodoRead", {})).toBeNull();
+  });
+
+  test("TodoWrite is skipped", () => {
+    expect(toolCallToProgress("TodoWrite", {})).toBeNull();
+  });
+
+  // --- Unknown default tools ---
+
+  test("unknown tool gets fallback with emoji", () => {
+    const result = toolCallToProgress("SomeNewTool", {});
+    expect(result).toBe("🔧 SomeNewTool");
+  });
+
+  // --- Agent-swarm MCP tools (with pretty labels) ---
+
+  test("agent-swarm:get-task-details has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__get-task-details", {});
+    expect(result).toBe("📋 Reviewing task details");
+  });
+
+  test("agent-swarm:send-task has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__send-task", {});
+    expect(result).toBe("📤 Delegating task");
+  });
+
+  test("agent-swarm:post-message has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__post-message", {});
+    expect(result).toBe("💬 Sending message");
+  });
+
+  test("agent-swarm:store-progress is skipped (meta/noise)", () => {
+    expect(toolCallToProgress("mcp__agent-swarm__store-progress", {})).toBeNull();
+  });
+
+  test("agent-swarm:poll-task has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__poll-task", {});
+    expect(result).toBe("📡 Polling for tasks");
+  });
+
+  test("agent-swarm:request-human-input has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__request-human-input", {});
+    expect(result).toBe("🙋 Requesting human input");
+  });
+
+  test("agent-swarm:memory-search has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__memory-search", {});
+    expect(result).toBe("🧠 Searching memory");
+  });
+
+  test("agent-swarm:tracker-status has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__tracker-status", {});
+    expect(result).toBe("📊 Checking tracker status");
+  });
+
+  test("agent-swarm:trigger-workflow has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__trigger-workflow", {});
+    expect(result).toBe("⚙️ Triggering workflow");
+  });
+
+  test("agent-swarm:slack-post has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__slack-post", {});
+    expect(result).toBe("💬 Posting to Slack");
+  });
+
+  // --- Agent-swarm MCP tool NOT in lookup (humanized fallback) ---
+
+  test("unknown agent-swarm tool gets humanized fallback", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__some-new-tool", {});
+    expect(result).toBe("🔌 Some new tool");
+  });
+
+  // --- Other MCP servers ---
+
+  test("other MCP server tool gets server prefix + humanized name", () => {
+    const result = toolCallToProgress("mcp__linear__list-issues", {});
+    expect(result).toBe("🔌 linear: List issues");
+  });
+
+  test("other MCP server with simple tool name", () => {
+    const result = toolCallToProgress("mcp__github__search", {});
+    expect(result).toBe("🔌 github: Search");
+  });
+
+  test("MCP tool with double underscores in tool name", () => {
+    const result = toolCallToProgress("mcp__context7__query-docs", {});
+    expect(result).toBe("🔌 context7: Query docs");
+  });
+
+  // --- Short path helper (tested implicitly) ---
+
+  test("Read with short path (<=2 segments) keeps full path", () => {
+    const result = toolCallToProgress("Read", { file_path: "file.ts" });
+    expect(result).toBe("📖 Reading file.ts");
+  });
+
+  test("Read with missing file_path shows empty", () => {
+    const result = toolCallToProgress("Read", {});
+    expect(result).toBe("📖 Reading ");
+  });
+});
+
+describe("humanizeToolName", () => {
+  test("converts kebab-case to sentence case", () => {
+    expect(humanizeToolName("get-task-details")).toBe("Get task details");
+  });
+
+  test("single word gets capitalized", () => {
+    expect(humanizeToolName("search")).toBe("Search");
+  });
+
+  test("multi-word kebab-case", () => {
+    expect(humanizeToolName("list-all-workflow-runs")).toBe("List all workflow runs");
+  });
+
+  test("empty string returns empty", () => {
+    expect(humanizeToolName("")).toBe("");
+  });
+});