@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/lib/__tests__/markdown.test.tsx

@@ -0,0 +1,348 @@
+import styles from "ansi-styles";
+import React from "react";
+import stripAnsi from "strip-ansi";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { ThemeProvider } from "../../theme/context.js";
+import { CodeBlock } from "../markdown/code-block.js";
+import { Link } from "../markdown/link.js";
+import { Markdown } from "../markdown/markdown.js";
+import { cleanup, logInk, render } from "../test-utils.js";
+
+const TestWrapper = ({ children }: React.PropsWithChildren) => (
+  <ThemeProvider>{children}</ThemeProvider>
+);
+
+describe.concurrent("markdown components", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe.concurrent("Link", () => {
+    it("should render link with href and children", () => {
+      const ink = render(
+        <TestWrapper>
+          <Link href="https://example.com">Example Link</Link>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+
+      expect(output).toContain("Example Link");
+    });
+
+    it("should render link with different href", () => {
+      const ink = render(
+        <TestWrapper>
+          <Link href="https://test.com">Test</Link>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("Test");
+    });
+
+    it("should handle empty children", () => {
+      const ink = render(
+        <TestWrapper>
+          <Link href="https://example.com">{""}</Link>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      // Should render without error
+      expect(output).toBeDefined();
+    });
+  });
+
+  describe.concurrent("CodeBlock", () => {
+    it("should render code block with children", () => {
+      const ink = render(
+        <TestWrapper>
+          <CodeBlock language="javascript">const x = 1;</CodeBlock>
+        </TestWrapper>,
+      );
+      // Code is syntax highlighted, so strip ANSI codes for comparison
+      logInk(ink);
+      const frame = ink.lastFrame();
+      expect(frame).toBeDefined();
+      const output = stripAnsi(frame!);
+      expect(output).toContain("const x = 1;");
+    });
+
+    it("should render code block without language", () => {
+      const ink = render(
+        <TestWrapper>
+          <CodeBlock>plain code</CodeBlock>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("plain code");
+    });
+
+    it("should handle unsupported language", () => {
+      const ink = render(
+        <TestWrapper>
+          <CodeBlock language="nonexistent-lang">code</CodeBlock>
+        </TestWrapper>,
+      );
+      // Should fallback to plain text
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("code");
+    });
+
+    it("should handle empty code", () => {
+      const ink = render(
+        <TestWrapper>
+          <CodeBlock language="javascript"></CodeBlock>
+        </TestWrapper>,
+      );
+      // Should render without error
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toBeDefined();
+    });
+  });
+
+  describe.concurrent("Markdown", () => {
+    it("should render simple markdown text", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>Hello world</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("Hello world");
+    });
+
+    it("should render markdown with code span", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>This is `code` inline</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("code");
+    });
+
+    it("should render markdown with code block", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>
+            {`\`\`\`javascript
+const x = 1;
+\`\`\``}
+          </Markdown>
+        </TestWrapper>,
+      );
+      // Code is syntax highlighted, so strip ANSI codes for comparison
+      logInk(ink);
+      const frame = ink.lastFrame();
+      expect(frame).toBeDefined();
+      const output = stripAnsi(frame!);
+      expect(output).toContain("const x = 1;");
+    });
+
+    it("should render markdown with link", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>[Example](https://example.com)</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("Example");
+      expect(output).toContain("https://example.com");
+    });
+
+    it("should render markdown with headers", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown># Header 1\n## Header 2</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("Header 1");
+      expect(output).toContain("Header 2");
+    });
+
+    it("should render markdown with list", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>
+            {`- Item 1
+- Item 2
+- Item 3`}
+          </Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("Item 1");
+      expect(output).toContain("Item 2");
+      expect(output).toContain("Item 3");
+    });
+
+    it("should render markdown with numbered list", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>
+            {`1. First
+2. Second
+3. Third`}
+          </Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("First");
+      expect(output).toContain("Second");
+      expect(output).toContain("Third");
+    });
+
+    it("should render markdown with blockquote", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>{"> This is a quote"}</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("This is a quote");
+    });
+
+    it("should render markdown with bold", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>**text1** text2</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain(`${styles.bold.open}text1${styles.bold.close} text2`);
+    });
+
+    it("should render markdown with italic", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>*text1* text2</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain(`${styles.italic.open}text1${styles.italic.close} text2`);
+    });
+
+    it("should render markdown with strikethrough", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>~text1~ text2</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain(
+        `${styles.strikethrough.open}text1${styles.strikethrough.close} text2`,
+      );
+    });
+
+    it("should render markdown with italic using underscore", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>_text1_ text2</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain(`${styles.italic.open}text1${styles.italic.close} text2`);
+    });
+
+    it("should render markdown with bold, italic, and strikethrough text", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>**text1** *text2* _text3_ ~text4~ text5</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      const outputs = output?.split(" ");
+      expect(outputs).toBeDefined();
+      expect(outputs![0]).toContain(`${styles.bold.open}text1${styles.bold.close}`);
+      expect(outputs![1]).toContain(`${styles.italic.open}text2${styles.italic.close}`);
+      expect(outputs![2]).toContain(`${styles.italic.open}text3${styles.italic.close}`);
+      expect(outputs![3]).toContain(
+        `${styles.strikethrough.open}text4${styles.strikethrough.close}`,
+      );
+      expect(outputs![4]).toContain("text5");
+    });
+
+    it("should handle nested formatting correctly (italic with bold inside)", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>_**bold**_</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      // The outer _ should render as italic, inner ** as bold
+      expect(output).toContain(styles.italic.open);
+      expect(output).toContain(styles.bold.open);
+      expect(output).toContain("bold");
+    });
+
+    it("should handle nested formatting correctly (italic with bold inside using asterisk)", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>*__bold__*</Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      // The outer * should render as italic, inner __ as bold
+      expect(output).toContain(styles.italic.open);
+      expect(output).toContain(styles.bold.open);
+      expect(output).toContain("bold");
+    });
+
+    it("should handle empty markdown", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>{""}</Markdown>
+        </TestWrapper>,
+      );
+      // Should render without error
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toBeDefined();
+    });
+
+    it("should handle complex markdown", () => {
+      const ink = render(
+        <TestWrapper>
+          <Markdown>
+            {`# Title
+
+This is a paragraph with **bold** and *italic* text.
+
+\`\`\`javascript
+const code = 'example';
+\`\`\`
+
+[Link](https://example.com)`}
+          </Markdown>
+        </TestWrapper>,
+      );
+      logInk(ink);
+      const output = ink.lastFrame();
+      expect(output).toContain("Title");
+      expect(output).toContain("paragraph");
+      expect(output).toContain("code");
+      expect(output).toContain("Link");
+    });
+  });
+});

package/src/lib/__tests__/mcpCommandHandler.test.ts

@@ -0,0 +1,173 @@
+// @vitest-environment node
+
+import { describe, expect, it, beforeEach, vi } from "vitest";
+
+import { McpCommandHandler, helpText } from "../mcpCommandHandler.js";
+
+describe.concurrent("McpCommandHandler", () => {
+  let mockMcp: any;
+  let handler: McpCommandHandler;
+
+  beforeEach(() => {
+    mockMcp = {
+      listServers: vi.fn().mockReturnValue([]),
+      addServer: vi.fn().mockResolvedValue([]),
+      removeServer: vi.fn().mockResolvedValue(undefined),
+      callTool: vi.fn().mockResolvedValue(undefined),
+      getTools: vi.fn().mockReturnValue([]),
+      refresh: vi.fn().mockResolvedValue(undefined),
+    };
+    handler = new McpCommandHandler(mockMcp);
+  });
+
+  describe.concurrent("constructor", () => {
+    it("should create instance without mcp", () => {
+      const handler = new McpCommandHandler();
+      expect(handler).toBeInstanceOf(McpCommandHandler);
+    });
+
+    it("should create instance with mcp", () => {
+      const handler = new McpCommandHandler(mockMcp);
+      expect(handler).toBeInstanceOf(McpCommandHandler);
+    });
+  });
+
+  describe.concurrent("listServers", () => {
+    it("should list servers and return formatted string", async () => {
+      const result = await handler.listServers();
+      expect(typeof result).toBe("string");
+    });
+
+    it("should handle empty server list", async () => {
+      const result = await handler.listServers();
+      // Should return a string even if empty
+      expect(typeof result).toBe("string");
+    });
+  });
+
+  describe.sequential("addServer", () => {
+    it("should add server and refresh mcp", async () => {
+      await handler.addServer("test-server-1", "command", []);
+      // refresh is called in background, just ensure no throw
+      expect(true).toBe(true);
+    });
+
+    it("should add server with extra args", async () => {
+      await handler.addServer("test-server-2", "command", ["arg1", "arg2"]);
+      expect(true).toBe(true);
+    });
+
+    it("should work without tuiMcpService", async () => {
+      const handlerWithoutService = new McpCommandHandler();
+      await handlerWithoutService.addServer("test-server-3", "command", []);
+      // Should not throw
+      expect(true).toBe(true);
+    });
+  });
+
+  describe.sequential("removeServer", () => {
+    // TODO: These tests rely on file system state and need proper isolation/mocking
+    // Skipping for now as they require integration test setup with temp directories
+    it.skip("should remove server and reload connections", async () => {
+      // This test relies on 'test-server-1' being added by the addServer tests above
+      await handler.removeServer("test-server-1");
+      expect(true).toBe(true);
+    });
+
+    it.skip("should work without tuiMcpService", async () => {
+      const handlerWithoutService = new McpCommandHandler();
+      // This test relies on 'test-server-2' being added by the addServer tests above
+      await handlerWithoutService.removeServer("test-server-2");
+      // Should not throw
+      expect(true).toBe(true);
+    });
+
+    it("should throw error when removing non-existent server", async () => {
+      const handlerWithoutService = new McpCommandHandler();
+      // TODO: Consider making removeServer return a boolean or handle
+      // non-existent servers more gracefully instead of throwing.
+      await expect(handlerWithoutService.removeServer("nonexistent-server")).rejects.toThrow();
+    });
+  });
+
+  describe.concurrent("getServer", () => {
+    it("should return formatted server info when server exists", async () => {
+      // First add a server
+      await handler.addServer("test-server", "command", []);
+      const result = await handler.getServer("test-server");
+      expect(result).toBeDefined();
+      if (result) {
+        expect(typeof result).toBe("string");
+      }
+    });
+
+    it("should return null when server does not exist", async () => {
+      const result = await handler.getServer("nonexistent-server");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe.concurrent("addServerFromJson", () => {
+    it("should add server from JSON and refresh mcp", async () => {
+      const jsonConfig = JSON.stringify({
+        type: "stdio",
+        command: "node",
+        args: ["server.js"],
+      });
+      await handler.addServerFromJson("test-server", jsonConfig);
+      expect(true).toBe(true);
+    });
+
+    it("should work without tuiMcpService", async () => {
+      const handlerWithoutService = new McpCommandHandler();
+      const jsonConfig = JSON.stringify({
+        type: "stdio",
+        command: "node",
+        args: ["server.js"],
+      });
+      await handlerWithoutService.addServerFromJson("test-server", jsonConfig);
+      // Should not throw
+      expect(true).toBe(true);
+    });
+
+    it("should handle invalid JSON gracefully", async () => {
+      // TODO: The addServerFromJson method should validate JSON and throw
+      // a meaningful error for invalid JSON. Currently it may throw
+      // a generic error from JSON.parse.
+      try {
+        await handler.addServerFromJson("test-server", "invalid json");
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe.concurrent("formatHelp", () => {
+    it("should return help text", () => {
+      const result = handler.formatHelp();
+      expect(result).toBe(helpText);
+    });
+
+    it("should return help text with MCP commands", () => {
+      const result = handler.formatHelp();
+      expect(result).toContain("MCP");
+      expect(result).toContain("/mcp list");
+      expect(result).toContain("/mcp add");
+    });
+  });
+
+  describe.concurrent("helpText export", () => {
+    it("should export help text constant", () => {
+      expect(typeof helpText).toBe("string");
+      expect(helpText.length).toBeGreaterThan(0);
+    });
+
+    it("should contain expected command descriptions", () => {
+      expect(helpText).toContain("list");
+      expect(helpText).toContain("add");
+      expect(helpText).toContain("remove");
+      expect(helpText).toContain("get");
+      expect(helpText).toContain("add-json");
+    });
+  });
+});

package/src/lib/__tests__/mcpManagement.test.ts

@@ -0,0 +1,38 @@
+// @vitest-environment node
+
+import { describe, expect, it } from "vitest";
+
+import { McpManagementService } from "../mcpManagement.js";
+
+describe.concurrent("McpManagementService", () => {
+  describe.concurrent("constructor", () => {
+    it("should create instance", () => {
+      const service = new McpManagementService();
+      expect(service).toBeInstanceOf(McpManagementService);
+    });
+  });
+
+  describe.concurrent("listServers", () => {
+    it("should return array of servers", async () => {
+      const service = new McpManagementService();
+      const servers = await service.listServers();
+      expect(Array.isArray(servers)).toBe(true);
+    });
+  });
+
+  describe.concurrent("formatServerList", () => {
+    it("should format empty server list", () => {
+      const service = new McpManagementService();
+      const formatted = service.formatServerList([]);
+      expect(typeof formatted).toBe("string");
+    });
+  });
+
+  describe.concurrent("getServer", () => {
+    it("should return undefined for non-existent server", async () => {
+      const service = new McpManagementService();
+      const server = await service.getServer("nonexistent-server-12345");
+      expect(server).toBeUndefined();
+    });
+  });
+});

package/src/lib/__tests__/path-paste.test.ts

@@ -0,0 +1,144 @@
+// @vitest-environment node
+
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+
+import { stripFileProtocol } from "../clipboard.js";
+import {
+  splitDragAndDropPaths,
+  parsePastedPaths,
+  escapePathForMention,
+  isImagePath,
+} from "../path-paste.js";
+
+describe.concurrent("path-paste", () => {
+  describe.concurrent("splitDragAndDropPaths", () => {
+    it("should parse a bare POSIX path", () => {
+      const results = [...splitDragAndDropPaths("/usr/local/bin/node")];
+      expect(results).toEqual(["/usr/local/bin/node"]);
+    });
+
+    it("should parse backslash-escaped spaces", () => {
+      const results = [...splitDragAndDropPaths("/path/to/my\\ file.txt")];
+      expect(results).toEqual(["/path/to/my file.txt"]);
+    });
+
+    it("should parse single-quoted paths", () => {
+      const results = [...splitDragAndDropPaths("'/path/to/my file.txt'")];
+      expect(results).toEqual(["/path/to/my file.txt"]);
+    });
+
+    it("should parse double-quoted Windows paths", () => {
+      const results = [...splitDragAndDropPaths('"C:\\Users\\test\\file.txt"')];
+      expect(results.length).toBe(1);
+      expect(results[0]).toMatch(/file\.txt$/);
+    });
+
+    it("should parse file:// URIs with percent-encoding", () => {
+      const results = [...splitDragAndDropPaths("file:///path/to/my%20file.txt")];
+      expect(results).toEqual(["/path/to/my file.txt"]);
+    });
+
+    it("should parse PowerShell & 'path' syntax", () => {
+      const results = [...splitDragAndDropPaths("& '/path/to/my file.txt'")];
+      expect(results).toEqual(["/path/to/my file.txt"]);
+    });
+
+    it("should parse multiple space-separated bare paths", () => {
+      const results = [...splitDragAndDropPaths("/a/b.txt /c/d.txt")];
+      expect(results).toEqual(["/a/b.txt", "/c/d.txt"]);
+    });
+
+    it("should parse multiple single-quoted paths", () => {
+      const results = [...splitDragAndDropPaths("'/a/b c.txt' '/d/e f.txt'")];
+      expect(results).toEqual(["/a/b c.txt", "/d/e f.txt"]);
+    });
+
+    it("should return nothing for non-path text", () => {
+      const results = [...splitDragAndDropPaths("hello world")];
+      expect(results).toEqual([]);
+    });
+
+    it("should handle Windows UNC paths", () => {
+      const results = [...splitDragAndDropPaths("\\\\Mac\\Home\\file.txt")];
+      expect(results.length).toBe(1);
+    });
+
+    it("should handle quoted paths starting with quotes", () => {
+      const results = [...splitDragAndDropPaths("'/tmp/test.txt'")];
+      expect(results).toEqual(["/tmp/test.txt"]);
+    });
+  });
+
+  describe.concurrent("parsePastedPaths", () => {
+    it("should return null for non-path text", () => {
+      expect(parsePastedPaths("hello world")).toBeNull();
+    });
+
+    it("should return null when paths don't exist on disk", () => {
+      expect(parsePastedPaths("/nonexistent/path/xyz123.txt")).toBeNull();
+    });
+
+    it("should return formatted @mentions for paths that exist", () => {
+      const thisFile = path.resolve(__dirname, "path-paste.test.ts");
+      const result = parsePastedPaths(thisFile);
+      expect(result).not.toBeNull();
+      expect(result).toContain("@");
+      expect(result!.endsWith(" ")).toBe(true);
+    });
+  });
+
+  describe.concurrent("escapePathForMention", () => {
+    it("should return path as-is when no spaces", () => {
+      expect(escapePathForMention("./src/foo.ts")).toBe("./src/foo.ts");
+    });
+
+    it("should wrap paths with spaces in single quotes", () => {
+      expect(escapePathForMention("./my file.ts")).toBe("'./my file.ts'");
+    });
+
+    it("should escape single quotes within paths", () => {
+      const result = escapePathForMention("./it's a file.ts");
+      expect(result).toContain("'\\''");
+    });
+  });
+
+  describe.concurrent("isImagePath", () => {
+    it("should detect png files", () => {
+      expect(isImagePath("screenshot.png")).toBe(true);
+    });
+
+    it("should detect jpg files", () => {
+      expect(isImagePath("photo.jpg")).toBe(true);
+      expect(isImagePath("photo.jpeg")).toBe(true);
+    });
+
+    it("should detect webp files", () => {
+      expect(isImagePath("image.webp")).toBe(true);
+    });
+
+    it("should return false for non-image files", () => {
+      expect(isImagePath("readme.md")).toBe(false);
+      expect(isImagePath("script.ts")).toBe(false);
+    });
+  });
+});
+
+describe.concurrent("stripFileProtocol", () => {
+  it("should strip file:// prefix", () => {
+    expect(stripFileProtocol("file:///path/to/file.txt")).toBe("/path/to/file.txt");
+  });
+
+  it("should decode percent-encoded characters", () => {
+    expect(stripFileProtocol("file:///path/to/my%20file.txt")).toBe("/path/to/my file.txt");
+  });
+
+  it("should return non-file:// strings unchanged", () => {
+    expect(stripFileProtocol("/plain/path.txt")).toBe("/plain/path.txt");
+  });
+
+  it("should handle malformed percent-encoding gracefully", () => {
+    const result = stripFileProtocol("file:///path/%ZZ/bad");
+    expect(typeof result).toBe("string");
+  });
+});