@abacus-ai/cli 2.0.0-canary.1 → 2.0.0-canary.11

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");
-  });
-});

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

@@ -1,300 +0,0 @@
-// @vitest-environment node
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it, vi, afterEach } from "vitest";
-
-import {
-  SHELL_SPECIAL_CHARS,
-  unescapePath,
-  abbreviateHome,
-  abbreviateCwd,
-  convertAbsoluteToRelativePath,
-} from "../path.js";
-
-describe.concurrent("path", () => {
-  describe.concurrent("SHELL_SPECIAL_CHARS", () => {
-    it("should match spaces", () => {
-      expect(SHELL_SPECIAL_CHARS.test(" ")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("file name.txt")).toBe(true);
-    });
-
-    it("should match parentheses", () => {
-      expect(SHELL_SPECIAL_CHARS.test("(")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test(")")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("file(name).txt")).toBe(true);
-    });
-
-    it("should match brackets", () => {
-      expect(SHELL_SPECIAL_CHARS.test("[")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("]")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("file[name].txt")).toBe(true);
-    });
-
-    it("should match braces", () => {
-      expect(SHELL_SPECIAL_CHARS.test("{")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("}")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("file{name}.txt")).toBe(true);
-    });
-
-    it("should match semicolons", () => {
-      expect(SHELL_SPECIAL_CHARS.test(";")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("file;name.txt")).toBe(true);
-    });
-
-    it("should match other special characters", () => {
-      expect(SHELL_SPECIAL_CHARS.test("|")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("*")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("?")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("$")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("`")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("'")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test('"')).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("#")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("&")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("<")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test(">")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("!")).toBe(true);
-      expect(SHELL_SPECIAL_CHARS.test("~")).toBe(true);
-    });
-
-    it("should not match regular alphanumeric characters", () => {
-      expect(SHELL_SPECIAL_CHARS.test("abc123")).toBe(false);
-      expect(SHELL_SPECIAL_CHARS.test("file.txt")).toBe(false);
-    });
-  });
-
-  describe.concurrent("unescapePath", () => {
-    it("should unescape spaces", () => {
-      expect(unescapePath("file\\ name.txt")).toBe("file name.txt");
-    });
-
-    it("should unescape parentheses", () => {
-      expect(unescapePath("file\\(name\\).txt")).toBe("file(name).txt");
-    });
-
-    it("should unescape brackets", () => {
-      expect(unescapePath("file\\[name\\].txt")).toBe("file[name].txt");
-    });
-
-    it("should unescape braces", () => {
-      expect(unescapePath("file\\{name\\}.txt")).toBe("file{name}.txt");
-    });
-
-    it("should unescape semicolons", () => {
-      expect(unescapePath("file\\;name.txt")).toBe("file;name.txt");
-    });
-
-    it("should unescape multiple special characters", () => {
-      expect(unescapePath("file\\ name\\[1\\].txt")).toBe("file name[1].txt");
-    });
-
-    it("should handle paths without escaping", () => {
-      expect(unescapePath("filename.txt")).toBe("filename.txt");
-    });
-
-    it("should handle empty strings", () => {
-      expect(unescapePath("")).toBe("");
-    });
-  });
-
-  describe.concurrent("abbreviateHome", () => {
-    const actualHome = os.homedir();
-
-    it("should abbreviate home directory to ~", () => {
-      expect(abbreviateHome(actualHome)).toBe("~");
-    });
-
-    it("should abbreviate paths under home directory", () => {
-      const testPath = path.join(actualHome, "documents", "file.txt");
-      const result = abbreviateHome(testPath);
-      expect(result).toBe("~/documents/file.txt");
-    });
-
-    it("should not abbreviate paths outside home directory", () => {
-      // Use a path that's definitely outside home
-      const testPath = process.platform === "win32" ? "C:\\Windows\\System32" : "/usr/bin";
-      const result = abbreviateHome(testPath);
-      expect(result).toBe(path.resolve(testPath));
-      expect(result).not.toContain("~");
-    });
-
-    it("should handle relative paths by resolving them first", () => {
-      // Create a relative path that resolves to home
-      expect(abbreviateHome(".", actualHome)).toBe("~");
-
-      expect(abbreviateHome("./documents/file.txt", actualHome)).toBe("~/documents/file.txt");
-      expect(abbreviateHome("./file.txt", actualHome)).toBe("~/file.txt");
-    });
-
-    it("if relative path is outside home directory, it should not be abbreviated", () => {
-      expect(abbreviateHome("../documents/file.txt", actualHome)).toBe(
-        path.join(path.dirname(actualHome), "documents", "file.txt"),
-      );
-    });
-
-    it("should use forward slashes in abbreviated paths", () => {
-      const testPath = path.join(actualHome, "documents", "file.txt");
-      const result = abbreviateHome(testPath);
-      expect(result).toBe("~/documents/file.txt");
-      expect(result).not.toContain("\\");
-    });
-  });
-
-  describe.concurrent("abbreviateCwd", () => {
-    // TODO: LIMITATION - Mocking process.cwd() in ESM modules may not work reliably.
-    // The tests mock process.cwd as a function, but in ESM, process.cwd is a getter/setter
-    // that might not be mockable this way. The tests may pass but could be fragile.
-    // Consider: Using a wrapper function that can be injected, or using vi.stubGlobal.
-    const originalCwd = process.cwd.bind(process);
-
-    afterEach(() => {
-      process.cwd = originalCwd;
-    });
-
-    it('should return "." for current directory', () => {
-      const mockCwd = "/home/user/project";
-      process.cwd = vi.fn(() => mockCwd);
-      expect(abbreviateCwd(mockCwd)).toBe(".");
-    });
-
-    it("should abbreviate paths relative to current directory", () => {
-      const mockCwd = "/home/user/project";
-      process.cwd = vi.fn(() => mockCwd);
-      expect(abbreviateCwd("/home/user/project/src/file.txt")).toBe("./src/file.txt");
-    });
-
-    it("should handle paths outside current directory", () => {
-      const mockCwd = "/home/user/project";
-      process.cwd = vi.fn(() => mockCwd);
-      const result = abbreviateCwd("/home/user/other/file.txt");
-      expect(result).toContain("../other/file.txt");
-    });
-
-    it("should use forward slashes in relative paths", () => {
-      const mockCwd = "/home/user/project";
-      process.cwd = vi.fn(() => mockCwd);
-      const result = abbreviateCwd("/home/user/project/src/file.txt");
-      expect(result).toBe("./src/file.txt");
-      expect(result).not.toContain("\\");
-    });
-
-    it('should handle paths that already start with "."', () => {
-      const mockCwd = "/home/user/project";
-      process.cwd = vi.fn(() => mockCwd);
-      const result = abbreviateCwd("/home/user/project/../other");
-      expect(result).toMatch(/^\.\./);
-    });
-
-    it("should resolve relative paths before abbreviating", () => {
-      const mockCwd = "/home/user/project";
-      process.cwd = vi.fn(() => mockCwd);
-      const result = abbreviateCwd("./src/file.txt");
-      expect(result).toBe("./src/file.txt");
-    });
-  });
-
-  describe.concurrent("convertAbsoluteToRelativePath", () => {
-    it("should convert path within workspace", () => {
-      const result = convertAbsoluteToRelativePath(
-        "/home/user/code/src/file.py",
-        "/home/user/code",
-      );
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.relativePath).toBe(path.join("src", "file.py"));
-      }
-    });
-
-    it("should reject path outside workspace", () => {
-      const result = convertAbsoluteToRelativePath("/other/path/file.py", "/home/user/code");
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.reason).toBe("outside_workspace");
-      }
-    });
-
-    it("should handle file at workspace root", () => {
-      const result = convertAbsoluteToRelativePath("/home/user/code/file.py", "/home/user/code");
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.relativePath).toBe("file.py");
-      }
-    });
-
-    it("should handle symlinks when workspace is symlink", () => {
-      // Create temporary test directory structure with symlink
-      const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), "test-symlink-"));
-      try {
-        const realDir = path.join(tmpBase, "real");
-        const symlinkDir = path.join(tmpBase, "symlink");
-        fs.mkdirSync(realDir);
-        fs.symlinkSync(realDir, symlinkDir);
-
-        // Test: workspace is symlink, file uses real path
-        const result = convertAbsoluteToRelativePath(path.join(realDir, "file.py"), symlinkDir);
-        expect(result.success).toBe(true);
-        if (result.success) {
-          expect(result.relativePath).toBe("file.py");
-        }
-      } finally {
-        // Cleanup
-        fs.rmSync(tmpBase, { recursive: true, force: true });
-      }
-    });
-
-    it("should handle symlinks when file path is symlink", () => {
-      // Create temporary test directory structure with symlink
-      const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), "test-symlink-"));
-      try {
-        const realDir = path.join(tmpBase, "real");
-        const symlinkDir = path.join(tmpBase, "symlink");
-        fs.mkdirSync(realDir);
-        fs.symlinkSync(realDir, symlinkDir);
-
-        // Test: workspace is real, file uses symlink path
-        const result = convertAbsoluteToRelativePath(path.join(symlinkDir, "file.py"), realDir);
-        expect(result.success).toBe(true);
-        if (result.success) {
-          expect(result.relativePath).toBe("file.py");
-        }
-      } finally {
-        // Cleanup
-        fs.rmSync(tmpBase, { recursive: true, force: true });
-      }
-    });
-
-    it("should handle nested paths", () => {
-      const result = convertAbsoluteToRelativePath(
-        "/home/user/code/a/b/c/file.py",
-        "/home/user/code",
-      );
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.relativePath).toBe(path.join("a", "b", "c", "file.py"));
-      }
-    });
-
-    it("should handle paths with same prefix but different directories", () => {
-      // /home/user/code-test is not inside /home/user/code
-      const result = convertAbsoluteToRelativePath(
-        "/home/user/code-test/file.py",
-        "/home/user/code",
-      );
-      expect(result.success).toBe(false);
-    });
-
-    it("should normalize paths before comparison", () => {
-      // Paths with . and .. should be normalized
-      const result = convertAbsoluteToRelativePath(
-        "/home/user/code/./src/../lib/file.py",
-        "/home/user/code",
-      );
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.relativePath).toBe(path.join("lib", "file.py"));
-      }
-    });
-  });
-});