macro-agent 0.0.10 → 0.0.12

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

@@ -1,187 +0,0 @@
-/**
- * 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

@@ -1,318 +0,0 @@
-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);
-  });
-});