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

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

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

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

package/src/lib/__tests__/text-buffer.test.ts

@@ -1,328 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it } from "vitest";
-
-import {
-  isWordCharStrict,
-  isWhitespace,
-  isCombiningMark,
-  isWordCharWithCombining,
-  getCharScript,
-  isDifferentScript,
-  findNextWordStartInLine,
-  findPrevWordStartInLine,
-  findWordEndInLine,
-  offsetToLogicalPos,
-  logicalPosToOffset,
-  pushUndo,
-  replaceRangeInternal,
-  type TextBufferState,
-} from "../text-buffer.js";
-
-describe.concurrent("text-buffer", () => {
-  describe.concurrent("isWordCharStrict", () => {
-    it("should identify word characters", () => {
-      expect(isWordCharStrict("a")).toBe(true);
-      expect(isWordCharStrict("Z")).toBe(true);
-      expect(isWordCharStrict("5")).toBe(true);
-      expect(isWordCharStrict("_")).toBe(true);
-    });
-
-    it("should identify non-word characters", () => {
-      expect(isWordCharStrict(" ")).toBe(false);
-      expect(isWordCharStrict(".")).toBe(false);
-      expect(isWordCharStrict("!")).toBe(false);
-    });
-  });
-
-  describe.concurrent("isWhitespace", () => {
-    it("should identify whitespace characters", () => {
-      expect(isWhitespace(" ")).toBe(true);
-      expect(isWhitespace("\t")).toBe(true);
-      expect(isWhitespace("\n")).toBe(true);
-    });
-
-    it("should identify non-whitespace characters", () => {
-      expect(isWhitespace("a")).toBe(false);
-      expect(isWhitespace("1")).toBe(false);
-    });
-  });
-
-  describe.concurrent("isCombiningMark", () => {
-    it("should identify combining marks", () => {
-      // Combining marks like diacritics
-      expect(isCombiningMark("\u0300")).toBe(true); // Combining grave accent
-    });
-
-    it("should identify non-combining characters", () => {
-      expect(isCombiningMark("a")).toBe(false);
-      expect(isCombiningMark("1")).toBe(false);
-    });
-  });
-
-  describe.concurrent("isWordCharWithCombining", () => {
-    it("should identify word characters including combining marks", () => {
-      expect(isWordCharWithCombining("a")).toBe(true);
-      expect(isWordCharWithCombining("\u0300")).toBe(true); // Combining mark
-    });
-
-    it("should identify non-word characters", () => {
-      expect(isWordCharWithCombining(" ")).toBe(false);
-      expect(isWordCharWithCombining(".")).toBe(false);
-    });
-  });
-
-  describe.concurrent("getCharScript", () => {
-    it("should identify Latin script", () => {
-      expect(getCharScript("a")).toBe("latin");
-      expect(getCharScript("A")).toBe("latin");
-    });
-
-    it("should identify other scripts", () => {
-      expect(getCharScript("中")).toBe("han");
-      expect(getCharScript("ا")).toBe("arabic");
-    });
-
-    it("should return other for unknown scripts", () => {
-      expect(getCharScript(" ")).toBe("other");
-    });
-  });
-
-  describe.concurrent("isDifferentScript", () => {
-    it("should detect different scripts", () => {
-      expect(isDifferentScript("a", "中")).toBe(true);
-    });
-
-    it("should detect same script", () => {
-      expect(isDifferentScript("a", "b")).toBe(false);
-    });
-
-    it("should return false for non-word characters", () => {
-      expect(isDifferentScript(" ", "a")).toBe(false);
-    });
-  });
-
-  describe.concurrent("findNextWordStartInLine", () => {
-    it("should find next word start", () => {
-      const result = findNextWordStartInLine("hello world", 0);
-      expect(result).toBe(6);
-    });
-
-    it("should return null at end of line", () => {
-      const result = findNextWordStartInLine("hello", 0);
-      expect(result).toBeNull();
-    });
-
-    it("should handle empty line", () => {
-      const result = findNextWordStartInLine("", 0);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe.concurrent("findPrevWordStartInLine", () => {
-    it("should find previous word start", () => {
-      const result = findPrevWordStartInLine("hello world", 11);
-      expect(result).toBe(6);
-    });
-
-    it("should return null at start of line", () => {
-      const result = findPrevWordStartInLine("hello", 0);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe.concurrent("findWordEndInLine", () => {
-    it("should find word end", () => {
-      const result = findWordEndInLine("hello world", 0);
-      expect(result).toBe(4);
-    });
-
-    it("should return null when no word found", () => {
-      const result = findWordEndInLine("   ", 0);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe.concurrent("offsetToLogicalPos", () => {
-    it("should convert offset to position", () => {
-      const [row, col] = offsetToLogicalPos("hello\nworld", 0);
-      expect(row).toBe(0);
-      expect(col).toBe(0);
-    });
-
-    it("should handle offset in middle of line", () => {
-      const [row, col] = offsetToLogicalPos("hello\nworld", 3);
-      expect(row).toBe(0);
-      expect(col).toBe(3);
-    });
-
-    it("should handle offset across lines", () => {
-      const [row, col] = offsetToLogicalPos("hello\nworld", 7);
-      expect(row).toBe(1);
-      expect(col).toBe(1);
-    });
-
-    it("should handle empty text", () => {
-      const [row, col] = offsetToLogicalPos("", 0);
-      expect(row).toBe(0);
-      expect(col).toBe(0);
-    });
-  });
-
-  describe.concurrent("logicalPosToOffset", () => {
-    it("should convert position to offset", () => {
-      const offset = logicalPosToOffset(["hello", "world"], 0, 0);
-      expect(offset).toBe(0);
-    });
-
-    it("should handle position in middle of line", () => {
-      const offset = logicalPosToOffset(["hello", "world"], 0, 3);
-      expect(offset).toBe(3);
-    });
-
-    it("should handle position across lines", () => {
-      const offset = logicalPosToOffset(["hello", "world"], 1, 2);
-      expect(offset).toBe(8); // 5 (hello) + 1 (newline) + 2 (wo)
-    });
-
-    it("should be inverse of offsetToLogicalPos", () => {
-      // TODO: VERIFICATION - The functions are documented as inverse operations,
-      // but this round-trip test should verify they work correctly for all cases,
-      // especially with Unicode characters, empty lines, and edge positions.
-      // Current test only covers basic case - should add more comprehensive tests.
-      const lines = ["hello", "world", "test"];
-      const text = lines.join("\n");
-      const [row, col] = offsetToLogicalPos(text, 8);
-      const offset = logicalPosToOffset(lines, row, col);
-      expect(offset).toBe(8);
-    });
-  });
-
-  describe.concurrent("pushUndo", () => {
-    it("should add state to undo stack", () => {
-      const state: TextBufferState = {
-        lines: ["hello"],
-        cursorRow: 0,
-        cursorCol: 5,
-        preferredCol: null,
-        undoStack: [],
-        redoStack: [],
-        clipboard: null,
-        selectionAnchor: null,
-        viewportWidth: 80,
-        viewportHeight: 24,
-        visualLayout: {
-          visualLines: ["hello"],
-          logicalToVisualMap: [[[0, 0]]],
-          visualToLogicalMap: [[0, 0]],
-        },
-      };
-
-      const newState = pushUndo(state);
-      expect(newState.undoStack.length).toBe(1);
-      expect(newState.redoStack.length).toBe(0);
-    });
-
-    it("should clear redo stack", () => {
-      const state: TextBufferState = {
-        lines: ["hello"],
-        cursorRow: 0,
-        cursorCol: 5,
-        preferredCol: null,
-        undoStack: [],
-        redoStack: [{ lines: ["old"], cursorRow: 0, cursorCol: 3 }],
-        clipboard: null,
-        selectionAnchor: null,
-        viewportWidth: 80,
-        viewportHeight: 24,
-        visualLayout: {
-          visualLines: ["hello"],
-          logicalToVisualMap: [[[0, 0]]],
-          visualToLogicalMap: [[0, 0]],
-        },
-      };
-
-      const newState = pushUndo(state);
-      expect(newState.redoStack.length).toBe(0);
-    });
-  });
-
-  describe.concurrent("replaceRangeInternal", () => {
-    it("should replace text in range", () => {
-      const state: TextBufferState = {
-        lines: ["hello world"],
-        cursorRow: 0,
-        cursorCol: 5,
-        preferredCol: null,
-        undoStack: [],
-        redoStack: [],
-        clipboard: null,
-        selectionAnchor: null,
-        viewportWidth: 80,
-        viewportHeight: 24,
-        visualLayout: {
-          visualLines: ["hello world"],
-          logicalToVisualMap: [[[0, 0]]],
-          visualToLogicalMap: [[0, 0]],
-        },
-      };
-
-      const newState = replaceRangeInternal(state, 0, 0, 0, 5, "hi");
-      expect(newState.lines[0]).toBe("hi world");
-    });
-
-    it("should handle multi-line replacement", () => {
-      const state: TextBufferState = {
-        lines: ["hello", "world"],
-        cursorRow: 0,
-        cursorCol: 0,
-        preferredCol: null,
-        undoStack: [],
-        redoStack: [],
-        clipboard: null,
-        selectionAnchor: null,
-        viewportWidth: 80,
-        viewportHeight: 24,
-        visualLayout: {
-          visualLines: ["hello", "world"],
-          logicalToVisualMap: [[[0, 0]], [[1, 0]]],
-          visualToLogicalMap: [
-            [0, 0],
-            [1, 0],
-          ],
-        },
-      };
-
-      const newState = replaceRangeInternal(state, 0, 0, 1, 5, "test");
-      expect(newState.lines).toEqual(["test"]);
-    });
-
-    it("should return original state for invalid range", () => {
-      // TODO: DESIGN ISSUE - replaceRangeInternal silently fails for invalid ranges
-      // by returning the original state unchanged. This makes it impossible to
-      // distinguish between "no change needed" and "invalid input".
-      // Consider: Throwing an error, returning a result object with success flag,
-      // or at least logging a warning for invalid ranges.
-      const state: TextBufferState = {
-        lines: ["hello"],
-        cursorRow: 0,
-        cursorCol: 0,
-        preferredCol: null,
-        undoStack: [],
-        redoStack: [],
-        clipboard: null,
-        selectionAnchor: null,
-        viewportWidth: 80,
-        viewportHeight: 24,
-        visualLayout: {
-          visualLines: ["hello"],
-          logicalToVisualMap: [[[0, 0]]],
-          visualToLogicalMap: [[0, 0]],
-        },
-      };
-
-      const newState = replaceRangeInternal(state, 10, 0, 10, 0, "test");
-      expect(newState).toBe(state);
-    });
-  });
-});

package/src/lib/__tests__/text-utils.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { getAsciiArtWidth, toCodePoints } from "../text-utils.js";
-
-describe.concurrent("text-utils", () => {
-  describe.concurrent("getAsciiArtWidth", () => {
-    it("should return 0 for empty string", () => {
-      expect(getAsciiArtWidth("")).toBe(0);
-    });
-
-    it("should return the width of a single line", () => {
-      expect(getAsciiArtWidth("hello")).toBe(5);
-    });
-
-    it("should return the maximum width of multiple lines", () => {
-      const asciiArt = "hello\nworld\nhi";
-      expect(getAsciiArtWidth(asciiArt)).toBe(5);
-    });
-  });
-
-  describe.concurrent("toCodePoints", () => {
-    it("should split ASCII string into characters", () => {
-      expect(toCodePoints("abc")).toEqual(["a", "b", "c"]);
-    });
-
-    it("should handle emoji correctly", () => {
-      const result = toCodePoints("👋");
-      expect(result.length).toBe(1);
-      expect(result[0]).toBe("👋");
-    });
-  });
-});

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

@@ -1,78 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it, vi, beforeEach } from "vitest";
-
-import { Timing } from "../timing.js";
-
-describe.concurrent("Timing", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  it("should initialize with current time", () => {
-    const timing = new Timing();
-    expect(timing.getElapsedMs()).toBe(0);
-    expect(timing.getElapsedSeconds()).toBe(0);
-  });
-
-  it("should calculate elapsed time in milliseconds", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(100);
-    expect(timing.getElapsedMs()).toBe(100);
-  });
-
-  it("should calculate elapsed time in seconds", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(2500);
-    expect(timing.getElapsedSeconds()).toBe(2.5);
-  });
-
-  it("should format duration correctly", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(1234);
-    const formatted = timing.getFormattedDuration();
-    expect(formatted).toBe("1s");
-  });
-
-  it("should format duration with minutes", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(125000); // 2 minutes 5 seconds
-    const formatted = timing.getFormattedDuration();
-    expect(formatted).toBe("2m 5s");
-  });
-
-  it("should format duration with hours", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(3665000); // 1 hour 1 minute 5 seconds
-    const formatted = timing.getFormattedDuration();
-    expect(formatted).toBe("1h 1m 5s");
-  });
-
-  it("should reset the timer", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(1000);
-    expect(timing.getElapsedMs()).toBeGreaterThan(0);
-
-    timing.reset();
-    expect(timing.getElapsedMs()).toBe(0);
-    expect(timing.getElapsedSeconds()).toBe(0);
-  });
-
-  it("should continue timing after reset", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(1000);
-    timing.reset();
-    vi.advanceTimersByTime(500);
-    expect(timing.getElapsedMs()).toBe(500);
-  });
-
-  it("should handle multiple resets", () => {
-    const timing = new Timing();
-    vi.advanceTimersByTime(1000);
-    timing.reset();
-    vi.advanceTimersByTime(500);
-    timing.reset();
-    vi.advanceTimersByTime(250);
-    expect(timing.getElapsedMs()).toBe(250);
-  });
-});