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

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

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

package/src/lib/__tests__/vim-buffer-actions.test.ts

@@ -1,154 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it } from "vitest";
-
-import type { TextBufferState } from "../text-buffer.js";
-
-import { handleVimAction, assumeExhaustive } from "../vim-buffer-actions.js";
-
-describe.concurrent("vim-buffer-actions", () => {
-  const createState = (
-    lines: string[] = ["hello world"],
-    cursorRow = 0,
-    cursorCol = 0,
-  ): TextBufferState => ({
-    lines,
-    cursorRow,
-    cursorCol,
-    preferredCol: null,
-    undoStack: [],
-    redoStack: [],
-    clipboard: null,
-    selectionAnchor: null,
-    viewportWidth: 80,
-    viewportHeight: 24,
-    visualLayout: {
-      visualLines: lines,
-      logicalToVisualMap: lines.map((_, i) => [[i, 0]]),
-      visualToLogicalMap: lines.map((_, i) => [i, 0]),
-    },
-  });
-
-  describe.concurrent("assumeExhaustive", () => {
-    it("should be a function", () => {
-      expect(typeof assumeExhaustive).toBe("function");
-    });
-
-    it("should not throw when called", () => {
-      expect(() => assumeExhaustive(null as never)).not.toThrow();
-    });
-  });
-
-  describe.concurrent("handleVimAction", () => {
-    it("should handle vim_move_left", () => {
-      const state = createState(["hello"], 0, 5);
-      const newState = handleVimAction(state, { type: "vim_move_left", payload: { count: 1 } });
-      expect(newState.cursorCol).toBe(4);
-    });
-
-    it("should handle vim_move_right", () => {
-      const state = createState(["hello"], 0, 0);
-      const newState = handleVimAction(state, { type: "vim_move_right", payload: { count: 1 } });
-      expect(newState.cursorCol).toBe(1);
-    });
-
-    it("should handle vim_move_to_line_start", () => {
-      const state = createState(["hello world"], 0, 5);
-      const newState = handleVimAction(state, { type: "vim_move_to_line_start" });
-      expect(newState.cursorCol).toBe(0);
-    });
-
-    it("should handle vim_move_to_line_end", () => {
-      // TODO: IMPROVEMENT - Test should verify exact position. For "hello" (5 chars),
-      // cursor should be at position 4 (last character), not just > 0.
-      // Current implementation: lineLength > 0 ? lineLength - 1 : 0
-      const state = createState(["hello"], 0, 0);
-      const newState = handleVimAction(state, { type: "vim_move_to_line_end" });
-      expect(newState.cursorCol).toBeGreaterThan(0);
-    });
-
-    it("should handle vim_move_to_first_nonwhitespace", () => {
-      const state = createState(["   hello"], 0, 0);
-      const newState = handleVimAction(state, { type: "vim_move_to_first_nonwhitespace" });
-      expect(newState.cursorCol).toBe(3);
-    });
-
-    it("should handle vim_move_to_first_line", () => {
-      const state = createState(["line1", "line2", "line3"], 2, 0);
-      const newState = handleVimAction(state, { type: "vim_move_to_first_line" });
-      expect(newState.cursorRow).toBe(0);
-    });
-
-    it("should handle vim_move_to_last_line", () => {
-      const state = createState(["line1", "line2", "line3"], 0, 0);
-      const newState = handleVimAction(state, { type: "vim_move_to_last_line" });
-      expect(newState.cursorRow).toBe(2);
-    });
-
-    it("should handle vim_move_to_line", () => {
-      // TODO: CLARIFICATION - The API is confusing: lineNumber is 1-indexed (user-facing)
-      // but internally converted to 0-indexed. Consider documenting this clearly or
-      // using a more explicit parameter name like `lineNumberOneIndexed`.
-      // Current behavior: lineNumber 2 -> row index 1 (second line)
-      const state = createState(["line1", "line2", "line3"], 0, 0);
-      const newState = handleVimAction(state, {
-        type: "vim_move_to_line",
-        payload: { lineNumber: 2 },
-      });
-      expect(newState.cursorRow).toBe(1); // 0-indexed
-    });
-
-    it("should handle vim_delete_char", () => {
-      const state = createState(["hello"], 0, 2);
-      const newState = handleVimAction(state, { type: "vim_delete_char", payload: { count: 1 } });
-      expect(newState.lines[0].length).toBeLessThan(state.lines[0].length);
-    });
-
-    it("should handle vim_move_word_forward", () => {
-      const state = createState(["hello world test"], 0, 0);
-      const newState = handleVimAction(state, {
-        type: "vim_move_word_forward",
-        payload: { count: 1 },
-      });
-      expect(newState.cursorCol).toBeGreaterThan(0);
-    });
-
-    it("should handle vim_move_word_backward", () => {
-      const state = createState(["hello world"], 0, 11);
-      const newState = handleVimAction(state, {
-        type: "vim_move_word_backward",
-        payload: { count: 1 },
-      });
-      expect(newState.cursorCol).toBeLessThan(11);
-    });
-
-    it("should handle vim_delete_word_forward", () => {
-      const state = createState(["hello world"], 0, 0);
-      const newState = handleVimAction(state, {
-        type: "vim_delete_word_forward",
-        payload: { count: 1 },
-      });
-      expect(newState.lines[0]).not.toContain("hello");
-    });
-
-    it("should handle vim_delete_to_end_of_line", () => {
-      const state = createState(["hello world"], 0, 5);
-      const newState = handleVimAction(state, { type: "vim_delete_to_end_of_line" });
-      expect(newState.lines[0]).toBe("hello");
-    });
-
-    it("should handle vim_open_line_below", () => {
-      const state = createState(["line1"], 0, 5);
-      const newState = handleVimAction(state, { type: "vim_open_line_below" });
-      expect(newState.lines.length).toBe(2);
-      expect(newState.cursorRow).toBe(1);
-    });
-
-    it("should handle vim_open_line_above", () => {
-      const state = createState(["line1"], 0, 5);
-      const newState = handleVimAction(state, { type: "vim_open_line_above" });
-      expect(newState.lines.length).toBe(2);
-      expect(newState.cursorRow).toBe(0);
-    });
-  });
-});

package/src/lib/ansi.ts

@@ -1,150 +0,0 @@
-export enum ANSI {
-  ESC = "\x1b",
-  BEL = "\x07",
-  ST = "\x1b\\",
-  ENABLE_FOCUS_REPORTING = `${ANSI.ESC}[?1004h`,
-  DISABLE_FOCUS_REPORTING = `${ANSI.ESC}[?1004l`,
-  FOCUS_IN = `${ANSI.ESC}[I`,
-  FOCUS_OUT = `${ANSI.ESC}[O`,
-  SHOW_CURSOR = `${ANSI.ESC}[?25h`,
-  HIDE_CURSOR = `${ANSI.ESC}[?25l`,
-  SET_TITLE = `${ANSI.ESC}]2;`,
-  RESET_SGR = `${ANSI.ESC}[0m`,
-  SOFT_RESET = `${ANSI.ESC}[!p`,
-  HARD_RESET = `${ANSI.ESC}c`,
-  ENABLE_BRACKETED_PASTE = `${ANSI.ESC}[?2004h`,
-  DISABLE_BRACKETED_PASTE = `${ANSI.ESC}[?2004l`,
-  PASTE_MODE_PREFIX = `${ANSI.ESC}[200~`,
-  PASTE_MODE_SUFFIX = `${ANSI.ESC}[201~`,
-  DIM = `${ANSI.ESC}[2m`,
-  BOLD = `${ANSI.ESC}[1m`,
-  RESET_BOLD = `${ANSI.ESC}[22m`,
-  ITALIC = `${ANSI.ESC}[3m`,
-  RESET_ITALIC = `${ANSI.ESC}[23m`,
-  STRIKETHROUGH = `${ANSI.ESC}[9m`,
-  RESET_STRIKETHROUGH = `${ANSI.ESC}[29m`,
-  UNDERLINE = `${ANSI.ESC}[4m`,
-  RESET_UNDERLINE = `${ANSI.ESC}[24m`,
-}
-
-/**
- * OSC 9 - iTerm2 notification
- * Format: ESC ] 9 ; message BEL
- */
-export function osc9(message: string): string {
-  return `${ANSI.ESC}]9;\n\n${message}${ANSI.BEL}`;
-}
-
-/**
- * OSC 777 - Ghostty/urxvt notification
- * Format: ESC ] 777 ; notify ; title ; body BEL
- */
-export function osc777(title: string, body: string): string {
-  return `${ANSI.ESC}]777;notify;${title};${body}${ANSI.BEL}`;
-}
-
-/**
- * OSC 99 - Kitty desktop notification
- * Format: ESC ] 99 ; metadata ; payload ST
- */
-export function osc99(title: string, body: string): string {
-  const notificationId = Math.floor(Math.random() * 10000);
-  const titlePart = `${ANSI.ESC}]99;i=${notificationId}:d=0:p=title;${title}${ANSI.ST}`;
-  const bodyPart = `${ANSI.ESC}]99;i=${notificationId}:p=body;${body}${ANSI.ST}`;
-  const donePart = `${ANSI.ESC}]99;i=${notificationId}:d=1:a=focus;${ANSI.ST}`;
-  return titlePart + bodyPart + donePart;
-}
-
-export type ProgressState = 0 | 1 | 2 | 3 | 4;
-
-/**
- * OSC 9;4 - Progress bar (ConEmu/Ghostty/iTerm2 style)
- * Format: ESC ] 9 ; 4 ; state ; progress [BEL/ST]
- * @param state - 0 (hide), 1 (default), 2 (error), 3 (indeterminate), 4 (warning)
- * @param progress - Progress percentage (0-100), required when state is 1, 2, or 4
- */
-export function osc9Progress(state: ProgressState, progress?: number): string {
-  const p = progress !== undefined ? Math.max(0, Math.min(100, Math.round(progress))) : 0;
-  const payload = `9;4;${state};${p}`;
-  // Emit both terminators for maximum compatibility (iTerm2 prefers BEL, Ghostty prefers ST)
-  return `${ANSI.ESC}]${payload}${ANSI.BEL}${ANSI.ESC}]${payload}${ANSI.ST}`;
-}
-
-/**
- * OSC 1337 - iTerm2 Progress indicator
- */
-function sanitizeItermValue(value: string): string {
-  return value
-    .replaceAll("\x1b", "")
-    .replaceAll("\x07", "")
-    .replaceAll("\n", " ")
-    .replaceAll("\r", " ")
-    .replaceAll(";", ":")
-    .trim()
-    .slice(0, 120);
-}
-
-function itermOsc(payload: string): string {
-  // Emit both terminators for maximum compatibility: BEL and ST.
-  return `${ANSI.ESC}]${payload}${ANSI.BEL}${ANSI.ESC}]${payload}${ANSI.ST}`;
-}
-
-export function osc1337ProgressClear(): string {
-  return itermOsc("1337;Progress=");
-}
-
-export function osc1337ProgressState(state: 0 | 1 | 2): string {
-  return itermOsc(`1337;Progress=${state}`);
-}
-
-export function osc1337ProgressPercent(percent: number, message?: string): string {
-  const progressValue = Math.max(0, Math.min(100, Math.round(percent)));
-  const msg = message ? sanitizeItermValue(message) : "";
-
-  if (msg) {
-    return (
-      itermOsc(`1337;Progress=${progressValue};${msg}`) +
-      itermOsc(`1337;Progress=message=${msg};percent=${progressValue}`)
-    );
-  }
-
-  return itermOsc(`1337;Progress=${progressValue}`);
-}
-
-/**
- * Creates a regex pattern that matches ANSI escape sequences
- * @param options.onlyFirst - If true, matches only the first occurrence
- * @returns Regular expression for matching ANSI sequences
- */
-export function ansiRegex({ onlyFirst = false } = {}): RegExp {
-  // Valid string terminator sequences are BEL, ESC\, and 0x9c
-  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-
-  // OSC sequences only: ESC ] ... ST (non-greedy until the first ST)
-  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
-
-  // CSI and related: ESC/C1, optional intermediates, optional params (supports ; and :) then final byte
-  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
-
-  const pattern = `${osc}|${csi}`;
-
-  return new RegExp(pattern, onlyFirst ? undefined : "g");
-}
-
-const stripAnsiRegex = ansiRegex();
-
-/**
- * Strip ANSI escape codes from a string
- * @param string - The string to strip ANSI codes from
- * @returns The string with ANSI codes removed
- */
-export function stripAnsi(string: string): string {
-  if (typeof string !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
-  }
-
-  // Even though the regex is global, we don't need to reset the `.lastIndex`
-  // because unlike `.exec()` and `.test()`, `.replace()` does it automatically
-  // and doing it manually has a performance penalty.
-  return string.replace(stripAnsiRegex, "");
-}

package/src/lib/cli-push-server.ts

@@ -1,112 +0,0 @@
-import type { SocketServer } from "@codellm/comms";
-
-import { cliContract, createSocketServer } from "@codellm/comms";
-import { product } from "@codellm/product";
-import { implement } from "@orpc/server";
-import { StandardRPCHandler } from "@orpc/server/standard";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-export interface EditorState {
-  file: string | undefined;
-  startLine: number | undefined;
-  endLine: number | undefined;
-}
-
-export type ToolDecisionValue = "accept" | "reject" | "allowAlways";
-
-export class CliPushServer {
-  private socketServer: SocketServer | undefined;
-  readonly socketPath: string;
-  private editorState: EditorState = {
-    file: undefined,
-    startLine: undefined,
-    endLine: undefined,
-  };
-  private onEditorStateCallback: ((state: EditorState) => void) | null = null;
-  private pendingDecisions = new Map<
-    string,
-    { resolve: (d: ToolDecisionValue) => void; cleanup: () => void }
-  >();
-
-  constructor() {
-    const socketDir = path.join(os.homedir(), product.configDirName, "cli");
-    this.socketPath = path.join(socketDir, `${process.pid}.sock`);
-  }
-
-  getEditorState(): EditorState {
-    return { ...this.editorState };
-  }
-
-  onEditorChange(callback: (state: EditorState) => void): void {
-    this.onEditorStateCallback = callback;
-  }
-
-  waitForDecision(toolId: string, signal?: AbortSignal): Promise<ToolDecisionValue> {
-    return new Promise<ToolDecisionValue>((resolve, reject) => {
-      if (signal?.aborted) {
-        reject(new Error("Aborted"));
-        return;
-      }
-
-      const cleanup = () => {
-        signal?.removeEventListener("abort", onAbort);
-        this.pendingDecisions.delete(toolId);
-      };
-      const onAbort = () => {
-        cleanup();
-        reject(new Error("Aborted"));
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-
-      this.pendingDecisions.set(toolId, {
-        resolve: (d) => {
-          cleanup();
-          resolve(d);
-        },
-        cleanup,
-      });
-    });
-  }
-
-  async start(): Promise<void> {
-    const socketDir = path.dirname(this.socketPath);
-    if (!fs.existsSync(socketDir)) {
-      fs.mkdirSync(socketDir, { recursive: true });
-    }
-
-    const cc = implement(cliContract);
-
-    type EditorStateInput = { file: string | null; startLine?: number; endLine?: number };
-    type ToolDecisionInput = { toolId: string; decision: "accept" | "reject" | "allowAlways" };
-
-    const router = cc.router({
-      editorStateChanged: cc.editorStateChanged.handler(
-        async ({ input }: { input: EditorStateInput }) => {
-          this.editorState = {
-            file: input.file ?? undefined,
-            startLine: input.startLine,
-            endLine: input.endLine,
-          };
-          this.onEditorStateCallback?.(this.editorState);
-          return { ok: true };
-        },
-      ),
-      toolDecision: cc.toolDecision.handler(async ({ input }: { input: ToolDecisionInput }) => {
-        const pending = this.pendingDecisions.get(input.toolId);
-        if (pending) pending.resolve(input.decision);
-        return { ok: true };
-      }),
-    });
-
-    this.socketServer = await createSocketServer(this.socketPath, new StandardRPCHandler(router));
-  }
-
-  dispose(): void {
-    for (const [, entry] of this.pendingDecisions) entry.cleanup();
-    this.pendingDecisions.clear();
-    this.socketServer?.dispose();
-    this.socketServer = undefined;
-  }
-}

package/src/lib/cli.ts

@@ -1,44 +0,0 @@
-import { spawn } from "child_process";
-
-export async function* runCli(command: string, args: string[]): AsyncGenerator<string> {
-  const proc = spawn(command, args, {
-    stdio: ["ignore", "pipe", "pipe"],
-    cwd: process.cwd(),
-  });
-
-  const streams = [proc.stdout, proc.stderr];
-
-  const readers = streams.map((stream) => stream[Symbol.asyncIterator]());
-
-  try {
-    while (true) {
-      const results = await Promise.all(readers.map((reader) => reader.next()));
-      let doneCount = 0;
-      for (let i = 0; i < results.length; i++) {
-        const { value, done } = results[i];
-        if (done) {
-          doneCount++;
-          continue;
-        }
-        if (value) {
-          yield value.toString();
-        }
-      }
-      if (doneCount === readers.length) {
-        break;
-      }
-    }
-  } finally {
-    // Attempt graceful shutdown
-    proc.kill("SIGTERM");
-
-    const timeout = setTimeout(() => {
-      // Force termination if still running
-      if (!proc.killed) {
-        proc.kill("SIGKILL");
-      }
-    }, 5000);
-
-    proc.on("close", () => clearTimeout(timeout));
-  }
-}