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

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

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

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

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

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

@@ -0,0 +1,238 @@
+// @vitest-environment node
+
+import { describe, expect, it } from "vitest";
+
+import { clamp, deepClone, createDeferredPromise, getSegmentContent, isWindows } from "../utils.js";
+
+describe.concurrent("utils", () => {
+  describe.concurrent("clamp", () => {
+    it("should return value when within range", () => {
+      expect(clamp(5, 0, 10)).toBe(5);
+    });
+
+    it("should return min when value is less than min", () => {
+      expect(clamp(-5, 0, 10)).toBe(0);
+    });
+
+    it("should return max when value is greater than max", () => {
+      expect(clamp(15, 0, 10)).toBe(10);
+    });
+
+    it("should handle edge cases", () => {
+      expect(clamp(0, 0, 10)).toBe(0);
+      expect(clamp(10, 0, 10)).toBe(10);
+    });
+
+    it("should handle negative ranges", () => {
+      expect(clamp(-15, -10, -5)).toBe(-10);
+      expect(clamp(-3, -10, -5)).toBe(-5);
+      expect(clamp(-7, -10, -5)).toBe(-7);
+    });
+  });
+
+  describe.concurrent("deepClone", () => {
+    it("should clone primitive values", () => {
+      expect(deepClone(5)).toBe(5);
+      expect(deepClone("test")).toBe("test");
+      expect(deepClone(true)).toBe(true);
+      expect(deepClone(null)).toBe(null);
+      expect(deepClone(undefined)).toBe(undefined);
+    });
+
+    it("should clone arrays", () => {
+      const original = [1, 2, 3];
+      const cloned = deepClone(original);
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      cloned.push(4);
+      expect(original).toHaveLength(3);
+    });
+
+    it("should clone objects", () => {
+      const original: Record<string, number> = { a: 1, b: 2 };
+      const cloned = deepClone(original);
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      cloned.c = 3;
+      expect(original).not.toHaveProperty("c");
+    });
+
+    it("should deep clone nested objects", () => {
+      const original = { a: { b: { c: 1 } } };
+      const cloned = deepClone(original);
+      expect(cloned).toEqual(original);
+      expect(cloned.a).not.toBe(original.a);
+      expect(cloned.a.b).not.toBe(original.a.b);
+      cloned.a.b.c = 2;
+      expect(original.a.b.c).toBe(1);
+    });
+
+    it("should deep clone nested arrays", () => {
+      const original = [
+        [1, 2],
+        [3, 4],
+      ];
+      const cloned = deepClone(original);
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned[0]).not.toBe(original[0]);
+      cloned[0].push(5);
+      expect(original[0]).toHaveLength(2);
+    });
+
+    it("should handle mixed nested structures", () => {
+      const original = { a: [1, { b: 2 }], c: { d: [3, 4] } };
+      const cloned = deepClone(original);
+      expect(cloned).toEqual(original);
+      (cloned.a[1] as { b: number }).b = 5;
+      expect((original.a[1] as { b: number }).b).toBe(2);
+    });
+
+    it("should return RegExp as-is", () => {
+      // TODO: LIMITATION - RegExp objects are returned as-is (not cloned).
+      // This means mutations to the cloned object's regex will affect the original.
+      // Consider: Whether this is intentional or if RegExp should be cloned.
+      const regex = /test/gi;
+      const cloned = deepClone(regex);
+      expect(cloned).toBe(regex);
+    });
+
+    it("should handle empty objects and arrays", () => {
+      expect(deepClone({})).toEqual({});
+      expect(deepClone([])).toEqual([]);
+    });
+
+    it("should handle Date objects", () => {
+      // TODO: BUG - deepClone does not properly handle Date objects.
+      // Dates will be cloned as plain objects, losing their Date prototype methods.
+      // Fix: Add Date handling: if (obj instanceof Date) return new Date(obj.getTime())
+      const date = new Date("2023-01-01");
+      const cloned = deepClone(date);
+      // Current behavior: cloned is a plain object, not a Date
+      expect(cloned).not.toBeInstanceOf(Date);
+      expect(typeof cloned).toBe("object");
+    });
+
+    it("should handle circular references", () => {
+      // TODO: BUG - deepClone will cause infinite recursion with circular references.
+      // Fix: Add a WeakSet to track visited objects and skip circular references.
+      // This test documents the current broken behavior - it will stack overflow.
+      const obj: any = { a: 1 };
+      obj.self = obj; // Circular reference
+      // Note: This will cause a stack overflow in the current implementation
+      // Uncomment the expect below to verify the bug, but it will crash the test
+      // expect(() => deepClone(obj)).toThrow();
+    });
+
+    it("should handle Map and Set", () => {
+      // TODO: LIMITATION - deepClone does not handle Map or Set objects.
+      // They will be cloned as plain objects, losing their Map/Set behavior.
+      // Fix: Add Map/Set handling similar to arrays.
+      const map = new Map([["key", "value"]]);
+      const cloned = deepClone(map);
+      expect(cloned).not.toBeInstanceOf(Map);
+      expect(typeof cloned).toBe("object");
+    });
+  });
+
+  describe.concurrent("createDeferredPromise", () => {
+    it("should create a promise with resolve and reject functions", async () => {
+      const deferred = createDeferredPromise<string>();
+      expect(deferred).toHaveProperty("promise");
+      expect(deferred).toHaveProperty("resolve");
+      expect(deferred).toHaveProperty("reject");
+      expect(typeof deferred.resolve).toBe("function");
+      expect(typeof deferred.reject).toBe("function");
+    });
+
+    it("should resolve the promise when resolve is called", async () => {
+      const deferred = createDeferredPromise<string>();
+      deferred.resolve("test");
+      await expect(deferred.promise).resolves.toBe("test");
+    });
+
+    it("should reject the promise when reject is called", async () => {
+      const deferred = createDeferredPromise<string>();
+      const error = new Error("test error");
+      deferred.reject(error);
+      await expect(deferred.promise).rejects.toBe(error);
+    });
+
+    it("should work with void type", async () => {
+      const deferred = createDeferredPromise<void>();
+      deferred.resolve();
+      await expect(deferred.promise).resolves.toBeUndefined();
+    });
+
+    it("should work with object types", async () => {
+      const deferred = createDeferredPromise<{ value: number }>();
+      deferred.resolve({ value: 42 });
+      await expect(deferred.promise).resolves.toEqual({ value: 42 });
+    });
+  });
+
+  describe.concurrent("getSegmentContent", () => {
+    it("should return string when segment is a string", () => {
+      expect(getSegmentContent("test")).toBe("test");
+    });
+
+    it("should return segment property when segment is an object", () => {
+      expect(getSegmentContent({ segment: "test" })).toBe("test");
+    });
+
+    it("should return null when segment is undefined", () => {
+      expect(getSegmentContent(undefined)).toBe(null);
+    });
+
+    it("should return null when segment is null", () => {
+      expect(getSegmentContent(null as unknown as undefined)).toBe(null);
+    });
+
+    it("should return null when segment is an object without segment property", () => {
+      expect(getSegmentContent({ other: "value" } as unknown as { segment: string })).toBe(null);
+    });
+
+    it("should handle empty strings", () => {
+      expect(getSegmentContent("")).toBe("");
+      expect(getSegmentContent({ segment: "" })).toBe("");
+    });
+  });
+
+  describe.concurrent("isWindows", () => {
+    it("should return true on Windows platform", () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", {
+        value: "win32",
+        writable: true,
+        configurable: true,
+      });
+      expect(isWindows()).toBe(true);
+      Object.defineProperty(process, "platform", {
+        value: originalPlatform,
+        writable: true,
+        configurable: true,
+      });
+    });
+
+    it("should return false on non-Windows platforms", () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, "platform", {
+        value: "linux",
+        writable: true,
+        configurable: true,
+      });
+      expect(isWindows()).toBe(false);
+      Object.defineProperty(process, "platform", {
+        value: "darwin",
+        writable: true,
+        configurable: true,
+      });
+      expect(isWindows()).toBe(false);
+      Object.defineProperty(process, "platform", {
+        value: originalPlatform,
+        writable: true,
+        configurable: true,
+      });
+    });
+  });
+});