macro-agent 0.0.14 → 0.0.16

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

@@ -0,0 +1,103 @@
+import { describe, it, expect } from "vitest";
+import { extractLinesWithByteLimit } from "../utils.js";
+
+describe("extractLinesWithByteLimit", () => {
+  const simpleContent = "Line 1\nLine 2\nLine 3\nLine 4\nLine 5";
+
+  it("should extract all lines when under byte limit", () => {
+    const result = extractLinesWithByteLimit(simpleContent, 1000);
+
+    expect(result.content).toBe(simpleContent);
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(5);
+  });
+
+  it("should limit output when exceeding byte limit", () => {
+    // Create content that will exceed byte limit
+    const longLine = "x".repeat(100);
+    const manyLines = Array(10).fill(longLine).join("\n");
+
+    const result = extractLinesWithByteLimit(manyLines, 250);
+
+    expect(result.wasLimited).toBe(true);
+    expect(result.linesRead).toBe(2);
+  });
+
+  it("should handle empty content", () => {
+    const result = extractLinesWithByteLimit("", 1000);
+
+    expect(result.content).toBe("");
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(1); // We read the one empty line
+  });
+
+  it("should handle single line file", () => {
+    const singleLine = "This is a single line without newline";
+    const result = extractLinesWithByteLimit(singleLine, 1000);
+
+    expect(result.content).toBe(singleLine);
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(1);
+  });
+
+  it("should correctly count bytes with multi-byte characters", () => {
+    const unicodeContent = "Hello 世界\n你好 World\nEmoji: 🌍\nNormal line";
+    const result = extractLinesWithByteLimit(unicodeContent, 1000);
+
+    expect(result.content).toBe(unicodeContent);
+    expect(result.linesRead).toBe(4);
+  });
+
+  it("should stop at byte limit even with one more line available", () => {
+    // Create lines where adding one more would exceed limit
+    const line1 = "a".repeat(40);
+    const line2 = "b".repeat(40);
+    const line3 = "c".repeat(40);
+    const content = `${line1}\n${line2}\n${line3}`;
+
+    const result = extractLinesWithByteLimit(content, 85);
+
+    expect(result.content).toBe(`${line1}\n${line2}\n`);
+    expect(result.wasLimited).toBe(true);
+    expect(result.linesRead).toBe(2);
+  });
+
+  it("should read exactly to limit when possible", () => {
+    const exactContent = "12345\n67890\n12345"; // 17 bytes total
+    const result = extractLinesWithByteLimit(exactContent, 17);
+
+    expect(result.content).toBe(exactContent);
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(3);
+  });
+
+  it("should handle Windows-style line endings", () => {
+    const windowsContent = "Line 1\r\nLine 2\r\nLine 3";
+    const result = extractLinesWithByteLimit(windowsContent, 1000);
+
+    // Note: split("\n") will keep the \r characters
+    expect(result.content).toBe("Line 1\r\nLine 2\r\nLine 3");
+    expect(result.linesRead).toBe(3);
+  });
+
+  it("should handle very large files efficiently", () => {
+    // Create a 100KB file
+    const largeLine = "x".repeat(1000);
+    const largeContent = Array(110).fill(largeLine).join("\n");
+
+    const result = extractLinesWithByteLimit(largeContent, 50000);
+
+    expect(result.wasLimited).toBe(true);
+  });
+
+  it("should allow at least one line even if it exceeds byte limit", () => {
+    const veryLongLine = "x".repeat(100000); // 100KB line
+    const result = extractLinesWithByteLimit(veryLongLine, 50000);
+
+    // Should return the line even though it exceeds the byte limit
+    // because we always allow at least one line if no lines have been added yet
+    expect(result.content).toBe(veryLongLine);
+    expect(result.linesRead).toBe(1);
+    expect(result.wasLimited).toBe(false);
+  });
+});

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

@@ -0,0 +1,335 @@
+/**
+ * Tests for session management functionality (fork and load).
+ *
+ * Run with: npx vitest run src/tests/fork-session.test.ts
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import type { ClaudeAcpAgent } from "../acp-agent.js";
+
+// Mock client for testing
+const mockClient = {} as any;
+
+describe("session management", () => {
+  let agent: ClaudeAcpAgent;
+
+  beforeEach(async () => {
+    const { ClaudeAcpAgent } = await import("../acp-agent.js");
+    agent = new ClaudeAcpAgent(mockClient);
+  });
+
+  describe("capability advertisement", () => {
+    it("advertises sessionCapabilities.fork", async () => {
+      const response = await agent.initialize({
+        protocolVersion: 1,
+        clientInfo: { name: "test-client", version: "1.0.0" },
+      });
+
+      expect(response.agentCapabilities?.sessionCapabilities?.fork).toEqual({});
+    });
+
+    it("advertises loadSession capability", async () => {
+      const response = await agent.initialize({
+        protocolVersion: 1,
+        clientInfo: { name: "test-client", version: "1.0.0" },
+      });
+
+      expect(response.agentCapabilities?.loadSession).toBe(true);
+    });
+
+    it("includes all expected agent capabilities", async () => {
+      const response = await agent.initialize({
+        protocolVersion: 1,
+        clientInfo: { name: "test-client", version: "1.0.0" },
+      });
+
+      expect(response.agentCapabilities).toMatchObject({
+        promptCapabilities: {
+          image: true,
+          embeddedContext: true,
+        },
+        mcpCapabilities: {
+          http: true,
+          sse: true,
+        },
+        sessionCapabilities: {
+          fork: {},
+          resume: {},
+        },
+        loadSession: true,
+      });
+    });
+  });
+
+  describe("forkSession", () => {
+    it("method exists on ClaudeAcpAgent", () => {
+      expect(typeof agent.forkSession).toBe("function");
+    });
+
+    it("accepts ForkSessionRequest params with sessionId", () => {
+      // Verify method signature accepts minimal params
+      expect(agent.forkSession).toBeInstanceOf(Function);
+      expect(agent.forkSession.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("accepts optional _meta with cwd and mcpServers", () => {
+      // Verify method can handle extended params via _meta
+      expect(agent.forkSession).toBeInstanceOf(Function);
+    });
+  });
+
+  describe("loadSession", () => {
+    it("method exists on ClaudeAcpAgent", () => {
+      expect(typeof agent.loadSession).toBe("function");
+    });
+
+    it("accepts LoadSessionRequest params", () => {
+      // Verify method signature accepts params (sessionId, cwd, mcpServers)
+      expect(agent.loadSession).toBeInstanceOf(Function);
+      expect(agent.loadSession.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe("deprecated methods", () => {
+    it("unstable_forkSession delegates to forkSession", () => {
+      expect(typeof agent.unstable_forkSession).toBe("function");
+    });
+
+    it("unstable_resumeSession delegates to loadSession", () => {
+      expect(typeof agent.unstable_resumeSession).toBe("function");
+    });
+  });
+
+  describe("extMethod _session/inject", () => {
+    it("extMethod exists on ClaudeAcpAgent", () => {
+      expect(typeof agent.extMethod).toBe("function");
+    });
+
+    it("returns error for non-existent session", async () => {
+      const result = await agent.extMethod("_session/inject", {
+        sessionId: "non-existent-session",
+        message: "test message",
+      });
+
+      expect(result).toEqual({
+        success: false,
+        error: "Session non-existent-session not found",
+      });
+    });
+
+    it("throws for unknown extension methods", async () => {
+      await expect(
+        agent.extMethod("_unknown/method", {}),
+      ).rejects.toThrow();
+    });
+
+    it("accepts string messages", async () => {
+      // Mock a session in the agent's sessions map
+      const mockSession = {
+        query: {} as any,
+        input: {
+          push: () => {},
+          end: () => {},
+        },
+        cancelled: false,
+        permissionMode: "default" as const,
+        settingsManager: {} as any,
+        abortController: new AbortController(),
+        cwd: "/tmp",
+      };
+      (agent as any).sessions["test-session"] = mockSession;
+
+      const result = await agent.extMethod("_session/inject", {
+        sessionId: "test-session",
+        message: "test message",
+      });
+
+      expect(result).toEqual({ success: true });
+
+      // Cleanup
+      delete (agent as any).sessions["test-session"];
+    });
+
+    it("accepts ContentBlock array messages", async () => {
+      // Mock a session
+      const mockSession = {
+        query: {} as any,
+        input: {
+          push: () => {},
+          end: () => {},
+        },
+        cancelled: false,
+        permissionMode: "default" as const,
+        settingsManager: {} as any,
+        abortController: new AbortController(),
+        cwd: "/tmp",
+      };
+      (agent as any).sessions["test-session"] = mockSession;
+
+      const result = await agent.extMethod("_session/inject", {
+        sessionId: "test-session",
+        message: [
+          { type: "text", text: "first part" },
+          { type: "text", text: "second part" },
+        ],
+      });
+
+      expect(result).toEqual({ success: true });
+
+      // Cleanup
+      delete (agent as any).sessions["test-session"];
+    });
+
+    it("returns error for cancelled session", async () => {
+      // Mock a cancelled session
+      const mockSession = {
+        query: {} as any,
+        input: {
+          push: () => {},
+          end: () => {},
+        },
+        cancelled: true, // Session is cancelled
+        permissionMode: "default" as const,
+        settingsManager: {} as any,
+        abortController: new AbortController(),
+        cwd: "/tmp",
+      };
+      (agent as any).sessions["cancelled-session"] = mockSession;
+
+      const result = await agent.extMethod("_session/inject", {
+        sessionId: "cancelled-session",
+        message: "test message",
+      });
+
+      expect(result).toEqual({
+        success: false,
+        error: "Session cancelled-session is cancelled",
+      });
+
+      // Cleanup
+      delete (agent as any).sessions["cancelled-session"];
+    });
+
+    it("actually pushes message to session input", async () => {
+      // Track what was pushed
+      const pushedMessages: any[] = [];
+      const mockSession = {
+        query: {} as any,
+        input: {
+          push: (msg: any) => pushedMessages.push(msg),
+          end: () => {},
+        },
+        cancelled: false,
+        permissionMode: "default" as const,
+        settingsManager: {} as any,
+        abortController: new AbortController(),
+        cwd: "/tmp",
+      };
+      (agent as any).sessions["push-test-session"] = mockSession;
+
+      await agent.extMethod("_session/inject", {
+        sessionId: "push-test-session",
+        message: "hello world",
+      });
+
+      expect(pushedMessages.length).toBe(1);
+      expect(pushedMessages[0].type).toBe("user");
+      expect(pushedMessages[0].message.role).toBe("user");
+      expect(pushedMessages[0].message.content).toContainEqual({
+        type: "text",
+        text: "hello world",
+      });
+
+      // Cleanup
+      delete (agent as any).sessions["push-test-session"];
+    });
+  });
+
+  describe("extMethod _session/listSkills", () => {
+    it("returns error for non-existent session", async () => {
+      const result = await agent.extMethod("_session/listSkills", {
+        sessionId: "non-existent-session",
+      });
+
+      expect(result).toEqual({
+        success: false,
+        error: "Session non-existent-session not found",
+      });
+    });
+
+    it("returns empty skills array when session has no skills", async () => {
+      // Mock a session without skills
+      const mockSession = {
+        query: {} as any,
+        input: {
+          push: () => {},
+          end: () => {},
+        },
+        cancelled: false,
+        permissionMode: "default" as const,
+        settingsManager: {} as any,
+        abortController: new AbortController(),
+        cwd: "/tmp",
+        compaction: {
+          enabled: false,
+          threshold: 100000,
+          currentTokens: 0,
+          isCompacting: false,
+        },
+        // No skills field
+      };
+      (agent as any).sessions["test-session"] = mockSession;
+
+      const result = await agent.extMethod("_session/listSkills", {
+        sessionId: "test-session",
+      });
+
+      expect(result).toEqual({
+        success: true,
+        skills: [],
+      });
+
+      // Cleanup
+      delete (agent as any).sessions["test-session"];
+    });
+
+    it("returns skills array when session has skills", async () => {
+      // Mock a session with skills
+      const mockSkills = [
+        { name: "pdf-processor", description: "Process PDF files", source: "project" },
+        { name: "code-reviewer", description: "Review code changes", source: "user" },
+      ];
+      const mockSession = {
+        query: {} as any,
+        input: {
+          push: () => {},
+          end: () => {},
+        },
+        cancelled: false,
+        permissionMode: "default" as const,
+        settingsManager: {} as any,
+        abortController: new AbortController(),
+        cwd: "/tmp",
+        compaction: {
+          enabled: false,
+          threshold: 100000,
+          currentTokens: 0,
+          isCompacting: false,
+        },
+        skills: mockSkills,
+      };
+      (agent as any).sessions["skills-session"] = mockSession;
+
+      const result = await agent.extMethod("_session/listSkills", {
+        sessionId: "skills-session",
+      });
+
+      expect(result).toEqual({
+        success: true,
+        skills: mockSkills,
+      });
+
+      // Cleanup
+      delete (agent as any).sessions["skills-session"];
+    });
+  });
+});