macro-agent 0.0.14 → 0.0.16

package/references/claude-code-acp/src/tests/skills-options.test.ts

@@ -0,0 +1,187 @@
+/**
+ * Tests for skills and plugins options handling.
+ *
+ * Run with: npx vitest run src/tests/skills-options.test.ts
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import type { ClaudeAcpAgent } from "../acp-agent.js";
+
+// Mock client for testing
+const mockClient = {
+  sessionUpdate: vi.fn(),
+  extNotification: vi.fn(),
+} as any;
+
+describe("skills and plugins options", () => {
+  let agent: ClaudeAcpAgent;
+
+  beforeEach(async () => {
+    const { ClaudeAcpAgent } = await import("../acp-agent.js");
+    agent = new ClaudeAcpAgent(mockClient);
+    // Initialize the agent
+    await agent.initialize({
+      protocolVersion: 1,
+      clientInfo: { name: "test-client", version: "1.0.0" },
+    });
+  });
+
+  describe("settingSources option", () => {
+    it("should use default settingSources when not provided", async () => {
+      // We can't easily test the internal options object, but we can verify
+      // that the agent accepts a session request without settingSources
+      // This test mainly validates the code path doesn't throw
+      expect(agent).toBeDefined();
+    });
+
+    it("should accept custom settingSources in _meta", async () => {
+      // Verify that the NewSessionMeta type accepts settingSources
+      const meta = {
+        claudeCode: {
+          options: {
+            settingSources: ["project"] as const,
+          },
+        },
+      };
+      expect(meta.claudeCode.options.settingSources).toEqual(["project"]);
+    });
+
+    it("should accept all valid settingSources values", async () => {
+      const validSources = ["user", "project", "local"] as const;
+      const meta = {
+        claudeCode: {
+          options: {
+            settingSources: validSources,
+          },
+        },
+      };
+      expect(meta.claudeCode.options.settingSources).toHaveLength(3);
+    });
+  });
+
+  describe("plugins option", () => {
+    it("should accept plugins array in _meta", async () => {
+      const meta = {
+        claudeCode: {
+          options: {
+            plugins: [
+              { type: "local" as const, path: "./my-plugin" },
+              { type: "local" as const, path: "/absolute/path/to/plugin" },
+            ],
+          },
+        },
+      };
+      expect(meta.claudeCode.options.plugins).toHaveLength(2);
+      expect(meta.claudeCode.options.plugins[0].type).toBe("local");
+      expect(meta.claudeCode.options.plugins[0].path).toBe("./my-plugin");
+    });
+
+    it("should accept empty plugins array", async () => {
+      const meta = {
+        claudeCode: {
+          options: {
+            plugins: [],
+          },
+        },
+      };
+      expect(meta.claudeCode.options.plugins).toHaveLength(0);
+    });
+  });
+
+  describe("allowedTools option", () => {
+    it("should accept allowedTools array in _meta", async () => {
+      const meta = {
+        claudeCode: {
+          options: {
+            allowedTools: ["Skill", "Read", "Write", "Bash"],
+          },
+        },
+      };
+      expect(meta.claudeCode.options.allowedTools).toContain("Skill");
+      expect(meta.claudeCode.options.allowedTools).toHaveLength(4);
+    });
+
+    it("should accept Skill tool for enabling skills", async () => {
+      const meta = {
+        claudeCode: {
+          options: {
+            allowedTools: ["Skill"],
+          },
+        },
+      };
+      expect(meta.claudeCode.options.allowedTools).toContain("Skill");
+    });
+  });
+
+  describe("disallowedTools option", () => {
+    it("should accept disallowedTools array in _meta", async () => {
+      const meta = {
+        claudeCode: {
+          options: {
+            disallowedTools: ["WebSearch", "WebFetch"],
+          },
+        },
+      };
+      expect(meta.claudeCode.options.disallowedTools).toHaveLength(2);
+    });
+  });
+
+  describe("combined options", () => {
+    it("should accept full skills configuration", async () => {
+      const meta = {
+        claudeCode: {
+          options: {
+            settingSources: ["user", "project"] as const,
+            plugins: [{ type: "local" as const, path: "~/.claude/plugins/my-plugin" }],
+            allowedTools: ["Skill", "Read", "Write"],
+            disallowedTools: ["WebSearch"],
+          },
+          compaction: {
+            enabled: true,
+            contextTokenThreshold: 50000,
+          },
+        },
+      };
+
+      expect(meta.claudeCode.options.settingSources).toEqual(["user", "project"]);
+      expect(meta.claudeCode.options.plugins).toHaveLength(1);
+      expect(meta.claudeCode.options.allowedTools).toContain("Skill");
+      expect(meta.claudeCode.options.disallowedTools).toContain("WebSearch");
+      expect(meta.claudeCode.compaction?.enabled).toBe(true);
+    });
+  });
+});
+
+describe("SkillInfo type", () => {
+  it("should have correct structure", async () => {
+    const { SkillInfo } = await import("../acp-agent.js") as any;
+
+    // Test that the type structure is correct by creating a valid object
+    const skill = {
+      name: "test-skill",
+      description: "A test skill",
+      source: "project" as const,
+    };
+
+    expect(skill.name).toBe("test-skill");
+    expect(skill.description).toBe("A test skill");
+    expect(skill.source).toBe("project");
+  });
+
+  it("should allow optional fields", async () => {
+    const skill = {
+      name: "minimal-skill",
+    };
+
+    expect(skill.name).toBe("minimal-skill");
+    expect((skill as any).description).toBeUndefined();
+    expect((skill as any).source).toBeUndefined();
+  });
+
+  it("should accept all valid source values", async () => {
+    const sources = ["user", "project", "plugin"] as const;
+    sources.forEach((source) => {
+      const skill = { name: "test", source };
+      expect(skill.source).toBe(source);
+    });
+  });
+});

package/references/claude-code-acp/src/tests/tools.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect } from "vitest";
+import { AgentSideConnection } from "@agentclientprotocol/sdk";
+import { ToolResultBlockParam } from "@anthropic-ai/sdk/resources";
+import {
+  BetaMCPToolResultBlock,
+  BetaTextBlock,
+  BetaWebSearchResultBlock,
+  BetaWebSearchToolResultBlock,
+  BetaBashCodeExecutionToolResultBlock,
+  BetaBashCodeExecutionResultBlock,
+} from "@anthropic-ai/sdk/resources/beta.mjs";
+import { toAcpNotifications, ToolUseCache, Logger } from "../acp-agent.js";
+
+describe("rawOutput in tool call updates", () => {
+  const mockClient = {} as AgentSideConnection;
+  const mockLogger: Logger = { log: () => {}, error: () => {} };
+
+  it("should include rawOutput with string content for tool_result", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_123: {
+        type: "tool_use",
+        id: "toolu_123",
+        name: "Bash",
+        input: { command: "echo hello" },
+      },
+    };
+
+    const toolResult: ToolResultBlockParam = {
+      type: "tool_result",
+      tool_use_id: "toolu_123",
+      content: "hello\n",
+      is_error: false,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0].update).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "toolu_123",
+      status: "completed",
+      rawOutput: "hello\n",
+    });
+  });
+
+  it("should include rawOutput with array content for tool_result", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_456: {
+        type: "tool_use",
+        id: "toolu_456",
+        name: "Read",
+        input: { file_path: "/test/file.txt" },
+      },
+    };
+
+    // ToolResultBlockParam content can be string or array of TextBlockParam
+    const toolResult: ToolResultBlockParam = {
+      type: "tool_result",
+      tool_use_id: "toolu_456",
+      content: [{ type: "text", text: "Line 1\nLine 2\nLine 3" }],
+      is_error: false,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0].update).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "toolu_456",
+      status: "completed",
+      rawOutput: [{ type: "text", text: "Line 1\nLine 2\nLine 3" }],
+    });
+  });
+
+  it("should include rawOutput for mcp_tool_result with string content", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_789: {
+        type: "tool_use",
+        id: "toolu_789",
+        name: "mcp__server__tool",
+        input: { query: "test" },
+      },
+    };
+
+    // BetaMCPToolResultBlock content can be string or Array<BetaTextBlock>
+    const toolResult: BetaMCPToolResultBlock = {
+      type: "mcp_tool_result",
+      tool_use_id: "toolu_789",
+      content: '{"result": "success", "data": [1, 2, 3]}',
+      is_error: false,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0].update).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "toolu_789",
+      status: "completed",
+      rawOutput: '{"result": "success", "data": [1, 2, 3]}',
+    });
+  });
+
+  it("should include rawOutput for mcp_tool_result with array content", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_abc: {
+        type: "tool_use",
+        id: "toolu_abc",
+        name: "mcp__server__search",
+        input: { term: "test" },
+      },
+    };
+
+    // BetaTextBlock requires citations field
+    const arrayContent: BetaTextBlock[] = [
+      { type: "text", text: "Result 1", citations: null },
+      { type: "text", text: "Result 2", citations: null },
+    ];
+
+    const toolResult: BetaMCPToolResultBlock = {
+      type: "mcp_tool_result",
+      tool_use_id: "toolu_abc",
+      content: arrayContent,
+      is_error: false,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0].update).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "toolu_abc",
+      status: "completed",
+      rawOutput: arrayContent,
+    });
+  });
+
+  it("should include rawOutput for web_search_tool_result", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_web: {
+        type: "tool_use",
+        id: "toolu_web",
+        name: "WebSearch",
+        input: { query: "test search" },
+      },
+    };
+
+    // BetaWebSearchResultBlock from SDK
+    const searchResults: BetaWebSearchResultBlock[] = [
+      {
+        type: "web_search_result",
+        url: "https://example.com",
+        title: "Example",
+        encrypted_content: "encrypted content here",
+        page_age: "2 days ago",
+      },
+    ];
+
+    const toolResult: BetaWebSearchToolResultBlock = {
+      type: "web_search_tool_result",
+      tool_use_id: "toolu_web",
+      content: searchResults,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0].update).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "toolu_web",
+      status: "completed",
+      rawOutput: searchResults,
+    });
+  });
+
+  it("should include rawOutput for bash_code_execution_tool_result", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_bash: {
+        type: "tool_use",
+        id: "toolu_bash",
+        name: "Bash",
+        input: { command: "ls -la" },
+      },
+    };
+
+    // BetaBashCodeExecutionResultBlock from SDK
+    const bashResult: BetaBashCodeExecutionResultBlock = {
+      type: "bash_code_execution_result",
+      stdout: "file1.txt\nfile2.txt",
+      stderr: "",
+      return_code: 0,
+      content: [],
+    };
+
+    const toolResult: BetaBashCodeExecutionToolResultBlock = {
+      type: "bash_code_execution_tool_result",
+      tool_use_id: "toolu_bash",
+      content: bashResult,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0].update).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "toolu_bash",
+      status: "completed",
+      rawOutput: bashResult,
+    });
+  });
+
+  it("should set status to failed when is_error is true", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_err: {
+        type: "tool_use",
+        id: "toolu_err",
+        name: "Bash",
+        input: { command: "invalid_command" },
+      },
+    };
+
+    const toolResult: ToolResultBlockParam = {
+      type: "tool_result",
+      tool_use_id: "toolu_err",
+      content: "command not found: invalid_command",
+      is_error: true,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0].update).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "toolu_err",
+      status: "failed",
+      rawOutput: "command not found: invalid_command",
+    });
+  });
+
+  it("should not emit tool_call_update for TodoWrite (emits plan instead)", () => {
+    const toolUseCache: ToolUseCache = {
+      toolu_todo: {
+        type: "tool_use",
+        id: "toolu_todo",
+        name: "TodoWrite",
+        input: { todos: [{ content: "Test task", status: "pending" }] },
+      },
+    };
+
+    const toolResult: ToolResultBlockParam = {
+      type: "tool_result",
+      tool_use_id: "toolu_todo",
+      content: "Todos updated successfully",
+      is_error: false,
+    };
+
+    const notifications = toAcpNotifications(
+      [toolResult],
+      "assistant",
+      "test-session",
+      toolUseCache,
+      mockClient,
+      mockLogger,
+    );
+
+    // TodoWrite should not emit tool_call_update - it emits plan updates instead
+    expect(notifications).toHaveLength(0);
+  });
+});