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

package/src/providers/api-client.tsx

@@ -1,43 +0,0 @@
-import { AbacusClient } from "@codellm/api";
-import { AuthManager } from "@codellm/auth";
-import { createContext, memo, use, useMemo, useState } from "react";
-
-export interface ApiClientContextValue {
-  apiClient: AbacusClient;
-  authManager: AuthManager;
-  authExpired: boolean;
-  setAuthExpired: (expired: boolean) => void;
-  clearAuthExpired: () => void;
-}
-
-export const ApiClientContext = createContext<ApiClientContextValue | null>(null);
-
-export const useApiClient = () => {
-  const ctx = use(ApiClientContext);
-  if (!ctx) throw new Error("useApiClient must be used within ApiClientProvider");
-  return ctx;
-};
-
-export const ApiClientProvider = memo(
-  ({
-    children,
-    client,
-    authManager,
-  }: React.PropsWithChildren<{
-    client: AbacusClient;
-    authManager: AuthManager;
-  }>) => {
-    const [authExpired, setAuthExpired] = useState(false);
-
-    const clearAuthExpired = () => setAuthExpired(false);
-
-    const value = useMemo(
-      () => ({ apiClient: client, authManager, authExpired, setAuthExpired, clearAuthExpired }),
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      [authExpired, client, authManager],
-    );
-
-    return <ApiClientContext.Provider value={value}>{children}</ApiClientContext.Provider>;
-  },
-);
-ApiClientProvider.displayName = "ApiClientProvider";

package/src/services/logger.ts

@@ -1,85 +0,0 @@
-import { product } from "@codellm/product";
-import { appendFileSync, mkdirSync, existsSync } from "node:fs";
-import { homedir } from "node:os";
-import path from "node:path";
-
-export interface Logger {
-  error(message: string | Error, ...args: unknown[]): void;
-  warn(message: string, ...args: unknown[]): void;
-  info(message: string, ...args: unknown[]): void;
-  debug(...message: unknown[]): void;
-  trace(message: string, ...args: unknown[]): void;
-}
-
-const LOG_DIR = path.join(homedir(), product.configDirName, product.logsDirName);
-const LOG_FILE = path.join(LOG_DIR, "cli.log");
-
-let dirEnsured = false;
-
-function ensureLogDir(): void {
-  if (dirEnsured) {
-    return;
-  }
-  try {
-    if (!existsSync(LOG_DIR)) {
-      mkdirSync(LOG_DIR, { recursive: true });
-    }
-    dirEnsured = true;
-  } catch {
-    // Silently fail — logging should never crash the app
-  }
-}
-
-function formatArgs(args: unknown[]): string {
-  if (args.length === 0) {
-    return "";
-  }
-  return (
-    " " +
-    args
-      .map((a) => {
-        if (typeof a === "string") {
-          return a;
-        }
-        try {
-          return JSON.stringify(a);
-        } catch {
-          return String(a);
-        }
-      })
-      .join(" ")
-  );
-}
-
-function write(level: string, message: unknown, args: unknown[]): void {
-  ensureLogDir();
-  const timestamp = new Date().toISOString();
-  const msg =
-    message instanceof Error
-      ? `${message.message}${message.stack ? "\n" + message.stack : ""}`
-      : String(message);
-  const line = `[${timestamp}] [${level}] ${msg}${formatArgs(args)}\n`;
-  try {
-    appendFileSync(LOG_FILE, line);
-  } catch {
-    // Silently fail
-  }
-}
-
-export const logger: Logger = {
-  error(message: string | Error, ...args: unknown[]) {
-    write("ERROR", message, args);
-  },
-  warn(message: string, ...args: unknown[]) {
-    write("WARN", message, args);
-  },
-  info(message: string, ...args: unknown[]) {
-    write("INFO", message, args);
-  },
-  debug(...message: unknown[]) {
-    write("DEBUG", message[0] ?? "", message.slice(1));
-  },
-  trace(message: string, ...args: unknown[]) {
-    write("TRACE", message, args);
-  },
-};

package/src/terminal/detection.ts

@@ -1,187 +0,0 @@
-import process from "node:process";
-
-import type { TerminalType } from "./types.js";
-
-const JETBRAIN_IDES = [
-  "pycharm",
-  "intellij",
-  "webstorm",
-  "phpstorm",
-  "rubymine",
-  "clion",
-  "goland",
-  "rider",
-  "datagrip",
-  "appcode",
-  "dataspell",
-  "aqua",
-  "gateway",
-  "fleet",
-  "jetbrains",
-  "androidstudio",
-];
-
-export function getTerminal(logger?: { debug?: (message: string) => void }): TerminalType {
-  if (process.env.CURSOR_TRACE_ID) {
-    logger?.debug?.("Detected Cursor terminal via CURSOR_TRACE_ID");
-    return "cursor";
-  }
-  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("/.cursor-server/")) {
-    logger?.debug?.("Detected Cursor terminal via VSCODE_GIT_ASKPASS_MAIN");
-    return "cursor";
-  }
-  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("/.windsurf-server/")) {
-    logger?.debug?.("Detected Windsurf terminal");
-    return "windsurf";
-  }
-
-  const BUNDLE_ID = process.env.__CFBundleIdentifier?.toLowerCase();
-  if (BUNDLE_ID?.includes("vscodium")) {
-    return "codium";
-  }
-  if (BUNDLE_ID?.includes("windsurf")) {
-    return "windsurf";
-  }
-  if (BUNDLE_ID?.includes("com.google.android.studio")) {
-    return "androidstudio";
-  }
-  if (BUNDLE_ID) {
-    for (const IDE of JETBRAIN_IDES) {
-      if (BUNDLE_ID.includes(IDE)) {
-        return IDE;
-      }
-    }
-  }
-
-  if (process.env.VisualStudioVersion) {
-    return "visualstudio";
-  }
-  if (process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm") {
-    return "pycharm";
-  }
-  if (process.env.TERM === "xterm-ghostty") {
-    return "ghostty";
-  }
-  if (process.env.TERM?.includes("kitty")) {
-    return "kitty";
-  }
-  if (process.env.WEZTERM_PANE) {
-    return "WezTerm";
-  }
-  if (process.env.ITERM_SESSION_ID) {
-    return "iTerm.app";
-  }
-  if (process.env.TERM_PROGRAM === "Apple_Terminal") {
-    return "Apple_Terminal";
-  }
-  if (process.env.TERM_PROGRAM) {
-    return process.env.TERM_PROGRAM;
-  }
-  if (process.env.STY) {
-    return "screen";
-  }
-  if (process.env.KONSOLE_VERSION) {
-    return "konsole";
-  }
-  if (process.env.GNOME_TERMINAL_SERVICE) {
-    return "gnome-terminal";
-  }
-  if (process.env.XTERM_VERSION) {
-    return "xterm";
-  }
-  if (process.env.VTE_VERSION) {
-    return "vte-based";
-  }
-  if (process.env.TERMINATOR_UUID) {
-    return "terminator";
-  }
-  if (process.env.KITTY_WINDOW_ID) {
-    return "kitty";
-  }
-  if (process.env.ALACRITTY_LOG) {
-    return "alacritty";
-  }
-  if (process.env.TILIX_ID) {
-    return "tilix";
-  }
-  if (process.env.WT_SESSION) {
-    return "windows-terminal";
-  }
-  if (process.env.SESSIONNAME && process.env.TERM === "cygwin") {
-    return "cygwin";
-  }
-  if (process.env.MSYSTEM) {
-    return process.env.MSYSTEM.toLowerCase();
-  }
-  if (process.env.ConEmuANSI || process.env.ConEmuPID || process.env.ConEmuTask) {
-    return "conemu";
-  }
-  if (process.env.WSL_DISTRO_NAME) {
-    return `wsl-${process.env.WSL_DISTRO_NAME}`;
-  }
-  if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY) {
-    return "ssh-session";
-  }
-  if (process.env.TERM) {
-    const ENV_TERM = process.env.TERM;
-    if (ENV_TERM.includes("alacritty")) {
-      return "alacritty";
-    }
-    if (ENV_TERM.includes("rxvt")) {
-      return "rxvt";
-    }
-    if (ENV_TERM.includes("termite")) {
-      return "termite";
-    }
-    return process.env.TERM;
-  }
-  if (!process.stdout.isTTY) {
-    logger?.debug?.("Non-interactive terminal detected");
-    return "non-interactive";
-  }
-  logger?.debug?.("Could not detect terminal type");
-  return null;
-}
-
-export function isTerminalSetupSupported(): boolean {
-  const terminal = getTerminal();
-  if (process.platform === "darwin") {
-    return [
-      "iTerm.app",
-      "Apple_Terminal",
-      "vscode",
-      "cursor",
-      "windsurf",
-      "ghostty",
-      "WezTerm",
-    ].includes(terminal ?? "");
-  }
-  return ["vscode", "cursor", "windsurf", "ghostty", "WezTerm", "kitty"].includes(terminal ?? "");
-}
-
-export function getPasteKeyInstruction(): string {
-  if (process.platform === "darwin") return "Cmd+V";
-  if (process.platform === "win32") return "Ctrl+V";
-  return "Ctrl+Shift+V"; // Linux xterm/VTE convention
-}
-
-export function getNewlineInstructions(): string {
-  const terminal = getTerminal();
-
-  switch (terminal) {
-    case "Apple_Terminal":
-      return "Option+Enter";
-    case "cursor":
-    case "windsurf":
-    case "vscode":
-    case "codium":
-    case "iTerm.app":
-    case "ghostty":
-    case "WezTerm":
-    case "kitty":
-    case "alacritty":
-      return "Shift+Enter";
-    default:
-      return "backslash (\\) + Enter";
-  }
-}

package/src/terminal/exit.ts

@@ -1,279 +0,0 @@
-import type { Writable } from "node:stream";
-
-import process from "node:process";
-
-interface ExitHookOptions {
-  wait?: number;
-  streams?: Writable[];
-  logger?: {
-    debug?: (message: string, meta?: any) => void;
-  };
-}
-
-type ExitCallback = (exitCode: number) => void | Promise<void>;
-
-const asyncCallbacks = new Set<[ExitCallback, number]>();
-const syncCallbacks = new Set<ExitCallback>();
-const streamsToDrain = new Set<Writable>();
-
-let isExiting = false;
-let isRegistered = false;
-let originalExit: ((code?: number) => never) | null = null;
-let firstExitCode: number | undefined;
-
-async function drainStreams(streams: Writable[]): Promise<void> {
-  const drainPromises = streams.map((stream) => {
-    return new Promise<void>((resolve) => {
-      const writableLength =
-        "writableLength" in stream ? (stream as { writableLength: number }).writableLength : 0;
-      const bufferSize =
-        "bufferSize" in stream ? (stream as { bufferSize: number }).bufferSize : writableLength;
-
-      if (bufferSize === 0) {
-        resolve();
-        return;
-      }
-
-      const originalWrite = stream.write.bind(stream);
-      let isDrained = false;
-
-      const checkDrain = () => {
-        const currentLength =
-          "writableLength" in stream ? (stream as { writableLength: number }).writableLength : 0;
-        const currentBufferSize =
-          "bufferSize" in stream ? (stream as { bufferSize: number }).bufferSize : currentLength;
-
-        if (currentBufferSize === 0 && !isDrained) {
-          isDrained = true;
-          stream.write = originalWrite;
-          resolve();
-        }
-      };
-
-      stream.once("drain", checkDrain);
-
-      stream.write("", "utf-8", () => {
-        checkDrain();
-      });
-
-      stream.write = function () {
-        return false;
-      };
-    });
-  });
-
-  await Promise.all(drainPromises);
-}
-
-async function executeExit(
-  shouldManuallyExit: boolean,
-  isSynchronous: boolean,
-  signal: number,
-  logger?: { debug?: (message: string, meta?: any) => void },
-): Promise<void> {
-  if (isExiting) {
-    return;
-  }
-
-  logger?.debug?.("Executing exit handlers", {
-    shouldManuallyExit,
-    isSynchronous,
-    signal,
-    asyncCallbacks: asyncCallbacks.size,
-    syncCallbacks: syncCallbacks.size,
-  });
-
-  isExiting = true;
-
-  if (asyncCallbacks.size > 0 && isSynchronous) {
-    console.error(
-      [
-        "SYNCHRONOUS TERMINATION NOTICE:",
-        "When explicitly exiting the process via process.exit or via a parent process,",
-        "asynchronous tasks in your exitHooks will not run. Either remove these tasks,",
-        "use gracefulExit() instead of process.exit(), or ensure your parent process",
-        "sends a SIGINT to the process running this code.",
-      ].join(" "),
-    );
-  }
-
-  let exitCode = 0;
-
-  if (signal > 0) {
-    exitCode = 128 + signal;
-  } else if (firstExitCode !== undefined) {
-    exitCode = firstExitCode;
-  } else if (typeof process.exitCode === "number" || typeof process.exitCode === "string") {
-    exitCode = Number(process.exitCode);
-  }
-
-  const done = (force = false) => {
-    if (force || shouldManuallyExit) {
-      if (originalExit) {
-        originalExit.call(process, exitCode);
-      } else {
-        process.exit(exitCode);
-      }
-    }
-  };
-
-  for (const callback of syncCallbacks) {
-    try {
-      void callback(exitCode);
-    } catch (error) {
-      console.error("Error in synchronous exit hook:", error);
-    }
-  }
-
-  if (isSynchronous) {
-    done();
-    return;
-  }
-
-  const promises: Promise<void>[] = [];
-  let maxWait = 0;
-
-  for (const [callback, wait] of asyncCallbacks) {
-    maxWait = Math.max(maxWait, wait);
-    promises.push(
-      Promise.resolve(callback(exitCode)).catch((error) => {
-        console.error("Error in asynchronous exit hook:", error);
-      }),
-    );
-  }
-
-  const streams = Array.from(streamsToDrain);
-  if (streams.length > 0) {
-    promises.push(drainStreams(streams));
-  }
-
-  const asyncTimer = setTimeout(() => {
-    done(true);
-  }, maxWait);
-
-  try {
-    await Promise.all(promises);
-    clearTimeout(asyncTimer);
-    done();
-  } catch (error) {
-    clearTimeout(asyncTimer);
-    console.error("Error during exit cleanup:", error);
-    done(true);
-  }
-}
-
-function registerExitHandlers(): void {
-  if (isRegistered) {
-    return;
-  }
-
-  isRegistered = true;
-
-  process.once("beforeExit", () => {
-    void executeExit(true, false, -128);
-  });
-
-  process.once("SIGINT", () => {
-    void executeExit(true, false, 2);
-  });
-
-  process.once("SIGTERM", () => {
-    void executeExit(true, false, 15);
-  });
-
-  process.once("exit", () => {
-    void executeExit(false, true, 0);
-  });
-
-  process.on("message", (message) => {
-    if (message === "shutdown") {
-      void executeExit(true, true, -128);
-    }
-  });
-
-  if (!originalExit) {
-    originalExit = process.exit.bind(process) as (code?: number) => never;
-
-    const exitHandler = function (code?: number) {
-      if (firstExitCode === undefined) {
-        firstExitCode = code ?? 0;
-      }
-
-      if (asyncCallbacks.size === 0 && streamsToDrain.size === 0) {
-        if (originalExit) {
-          originalExit(code ?? 0);
-          return;
-        }
-        process.exit(code ?? 0);
-      }
-
-      executeExit(true, false, -128).catch((error) => {
-        console.error("Error during exit:", error);
-        if (originalExit) {
-          originalExit(1);
-        } else {
-          process.exit(1);
-        }
-      });
-    };
-
-    process.exit = exitHandler as typeof process.exit;
-  }
-}
-
-export function onExit(callback: ExitCallback, options?: ExitHookOptions): () => void {
-  if (typeof callback !== "function") {
-    throw new TypeError("callback must be a function");
-  }
-
-  if (isExiting) {
-    throw new Error("Cannot install exit hook while exit handlers are running");
-  }
-
-  options?.logger?.debug?.("Registering exit hook", {
-    wait: options?.wait,
-    hasStreams: options?.streams !== undefined,
-  });
-
-  registerExitHandlers();
-
-  const wait = options?.wait ?? 0;
-  const streams = options?.streams ?? [process.stdout, process.stderr];
-
-  if (wait > 0) {
-    const callbackConfig: [ExitCallback, number] = [callback, wait];
-    asyncCallbacks.add(callbackConfig);
-
-    for (const stream of streams) {
-      streamsToDrain.add(stream);
-    }
-
-    return () => {
-      asyncCallbacks.delete(callbackConfig);
-      for (const stream of streams) {
-        streamsToDrain.delete(stream);
-      }
-    };
-  }
-
-  syncCallbacks.add(callback);
-
-  return () => {
-    syncCallbacks.delete(callback);
-  };
-}
-
-export function gracefulExit(signal?: number): void {
-  if (signal !== undefined) {
-    process.exitCode = signal;
-  }
-
-  void executeExit(true, false, -128);
-}
-
-export function releaseExit(): void {
-  if (originalExit) {
-    process.exit = originalExit;
-    originalExit = null;
-  }
-}

package/src/terminal/notification.ts

@@ -1,83 +0,0 @@
-import process from "node:process";
-
-import { ANSI, osc9, osc777, osc99 } from "../lib/ansi.js";
-import { getTerminal } from "./detection.js";
-
-export interface NotificationOptions {
-  title?: string;
-  message: string;
-  sound?: boolean;
-}
-
-function writeToTerminal(data: string): void {
-  if (process.stdout.isTTY) {
-    process.stdout.write(data);
-  }
-}
-
-function notifyIterm2(title: string, message: string): void {
-  const fullMessage = title ? `${title}:\n${message}` : message;
-  writeToTerminal(osc9(fullMessage));
-}
-
-function notifyKitty(title: string, message: string): void {
-  writeToTerminal(osc99(title, message));
-}
-
-function notifyGhostty(title: string, message: string): void {
-  writeToTerminal(osc777(title, message));
-}
-
-function notifyWindows(_title: string, _message: string): void {
-  // Windows notifications via PowerShell - simplified version
-  // Full implementation would require executing PowerShell script
-  // For now, just ring the bell
-  writeToTerminal(ANSI.BEL);
-}
-
-export async function notify(options: NotificationOptions): Promise<void> {
-  const { title = "Abacus.AI", message } = options;
-  const terminal = getTerminal();
-
-  switch (terminal) {
-    case "iTerm.app":
-      notifyIterm2(title, message);
-      break;
-    case "kitty":
-      notifyKitty(title, message);
-      break;
-    case "ghostty":
-      notifyGhostty(title, message);
-      break;
-    case "WezTerm":
-      notifyIterm2(title, message);
-      break;
-    default:
-      if (process.platform === "win32") {
-        notifyWindows(title, message);
-      }
-      break;
-  }
-}
-
-export async function notifyAction(
-  message: string,
-  options?: Omit<NotificationOptions, "message">,
-): Promise<void> {
-  await notify({
-    ...options,
-    message,
-    title: options?.title ?? "Action Required",
-  });
-}
-
-export async function notifyComplete(
-  message: string,
-  options?: Omit<NotificationOptions, "message">,
-): Promise<void> {
-  await notify({
-    ...options,
-    message,
-    title: options?.title ?? "Task Complete",
-  });
-}