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

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

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

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

@@ -0,0 +1,39 @@
+// @vitest-environment node
+
+import { describe, expect, it } from "vitest";
+
+import { QueryKey } from "../queries.js";
+
+describe.concurrent("queries", () => {
+  it("should export QueryKey enum with correct values", () => {
+    expect(QueryKey.Models).toBe("models");
+    expect(QueryKey.CreateConversation).toBe("create-conversation");
+    expect(QueryKey.GetConversation).toBe("get-conversation");
+    expect(QueryKey.Grep).toBe("grep");
+    expect(QueryKey.FileSearch).toBe("file-search");
+    expect(QueryKey.ListDir).toBe("list-dir");
+    expect(QueryKey.ReadFile).toBe("read-file");
+    expect(QueryKey.DeleteFile).toBe("delete-file");
+    expect(QueryKey.EditFile).toBe("edit-file");
+    expect(QueryKey.RunTerminal).toBe("run-terminal");
+    expect(QueryKey.GetTerminalOutput).toBe("get-terminal-output");
+    expect(QueryKey.MCPTool).toBe("mcp-tool");
+  });
+
+  it("should have all expected enum values", () => {
+    const values = Object.values(QueryKey);
+    expect(values.length).toBe(12);
+    expect(values).toContain("models");
+    expect(values).toContain("create-conversation");
+    expect(values).toContain("get-conversation");
+    expect(values).toContain("grep");
+    expect(values).toContain("file-search");
+    expect(values).toContain("list-dir");
+    expect(values).toContain("read-file");
+    expect(values).toContain("delete-file");
+    expect(values).toContain("edit-file");
+    expect(values).toContain("run-terminal");
+    expect(values).toContain("get-terminal-output");
+    expect(values).toContain("mcp-tool");
+  });
+});

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

@@ -0,0 +1,71 @@
+// @vitest-environment node
+
+import { describe, expect, it } from "vitest";
+
+import type { IMcpServerInfo } from "../types.js";
+
+import { StandaloneMcpService } from "../standaloneMcpService.js";
+
+describe.concurrent("StandaloneMcpService", () => {
+  describe.concurrent("constructor", () => {
+    it("should create instance", () => {
+      const service = new StandaloneMcpService();
+      expect(service).toBeInstanceOf(StandaloneMcpService);
+    });
+  });
+
+  describe.concurrent("listServers", () => {
+    it("should return array of servers", async () => {
+      const service = new StandaloneMcpService();
+      const servers = await service.listServers();
+      expect(Array.isArray(servers)).toBe(true);
+    });
+  });
+
+  describe.concurrent("formatServerList", () => {
+    it("should format empty server list", () => {
+      const service = new StandaloneMcpService();
+      const formatted = service.formatServerList([]);
+      expect(typeof formatted).toBe("string");
+    });
+  });
+
+  describe.concurrent("getServer", () => {
+    it("should return undefined for non-existent server", async () => {
+      const service = new StandaloneMcpService();
+      const server = await service.getServer("nonexistent-server-12345");
+      expect(server).toBeUndefined();
+    });
+  });
+
+  describe.concurrent("formatServerInfo", () => {
+    it("should format server info with stdio config", () => {
+      const service = new StandaloneMcpService();
+      const serverInfo: IMcpServerInfo = {
+        id: "test-server",
+        name: "test-server",
+        config: {
+          command: "node",
+          args: ["server.js"],
+        },
+      };
+      const formatted = service.formatServerInfo(serverInfo);
+      expect(typeof formatted).toBe("string");
+      expect(formatted).toContain("test-server");
+    });
+
+    it("should format server info with http config", () => {
+      const service = new StandaloneMcpService();
+      const serverInfo: IMcpServerInfo = {
+        id: "test-server",
+        name: "test-server",
+        config: {
+          url: "http://localhost:3000",
+        },
+      };
+      const formatted = service.formatServerInfo(serverInfo);
+      expect(typeof formatted).toBe("string");
+      expect(formatted).toContain("test-server");
+    });
+  });
+});