macro-agent 0.0.10 → 0.0.12

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

@@ -1,103 +0,0 @@
-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

@@ -1,335 +0,0 @@
-/**
- * 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"];
-    });
-  });
-});