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

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

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

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

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

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