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

package/src/hooks/use-agent.ts

@@ -0,0 +1,15 @@
+import { use } from "react";
+
+import { AgentContext, AgentProvider } from "../providers/agent.js";
+
+export function useAgent() {
+  const agent = use(AgentContext);
+
+  if (!agent) {
+    throw new Error(
+      `Agent context not found. Did you forget to wrap your component in <${AgentProvider.name}>?`,
+    );
+  }
+
+  return agent;
+}

package/src/hooks/use-api-client.ts

@@ -0,0 +1 @@
+export { useApiClient } from "../providers/api-client.js";

package/src/hooks/use-available-height.ts

@@ -0,0 +1,8 @@
+import { useShellSize } from "../context/shell-size.js";
+
+const RESERVED_COMPOSER_ROWS = 3;
+
+export function useAvailableHeight(): number {
+  const { height: terminalHeight } = useShellSize();
+  return Math.max(0, terminalHeight - RESERVED_COMPOSER_ROWS);
+}

package/src/hooks/use-cleanup.ts

@@ -0,0 +1,29 @@
+import { useEffect, useRef } from "react";
+
+export function useCleanup(callback: () => void) {
+  const cleaningUpRef = useRef(false);
+  const callbackRef = useRef(callback);
+
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+
+  useEffect(() => {
+    const cleanup = () => {
+      if (cleaningUpRef.current) {
+        return;
+      }
+      cleaningUpRef.current = true;
+      callbackRef.current();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    return () => {
+      cleanup();
+      process.off("exit", cleanup);
+      process.off("SIGINT", cleanup);
+      process.off("SIGTERM", cleanup);
+    };
+  }, []);
+}

package/src/hooks/use-interrupt-manager.ts

@@ -0,0 +1,242 @@
+import { useInput, type Key } from "@codellm/jar";
+import { useCallback, useEffect, useEffectEvent, useRef, useState } from "react";
+
+import { AgentStatus } from "../providers/agent.js";
+
+export interface InterruptHints {
+  /** "ESC again to clear" shown bottom-right of composer */
+  escClear: boolean;
+  /** "Press Ctrl+C/D again to exit" shown bottom-left */
+  exitKey: "c" | "d" | null;
+}
+
+type InterruptContext =
+  | "tool-executing"
+  | "streaming"
+  | "permission-ui"
+  | "idle-with-text"
+  | "idle-empty";
+
+interface UseInterruptManagerProps {
+  agentStatus: AgentStatus;
+  hasPendingPermission: boolean;
+  composerHasText: () => boolean;
+  hasQueuedMessages: () => boolean;
+  // Actions
+  stopAgent: () => void;
+  rejectPermission: () => void;
+  saveAndClearComposer: () => void;
+  clearComposer: () => void;
+  dequeueOne: () => void; // pop one queued message (for ESC)
+  clearQueue: () => void; // clear all queued messages (for Ctrl+C/D)
+  exitApp: () => void;
+}
+
+const HINT_TIMEOUT = 2_000;
+
+function deriveContext(
+  agentStatus: AgentStatus,
+  hasPendingPermission: boolean,
+  composerHasText: () => boolean,
+): InterruptContext {
+  if (agentStatus === AgentStatus.ExecutingTool) return "tool-executing";
+  if (agentStatus === AgentStatus.Submitted || agentStatus === AgentStatus.Streaming)
+    return "streaming";
+  if (agentStatus === AgentStatus.WaitingForToolPermission && hasPendingPermission)
+    return "permission-ui";
+  if (composerHasText()) return "idle-with-text";
+  return "idle-empty";
+}
+
+export function useInterruptManager(props: UseInterruptManagerProps): InterruptHints {
+  const {
+    agentStatus,
+    hasPendingPermission,
+    composerHasText,
+    hasQueuedMessages,
+    stopAgent,
+    rejectPermission,
+    saveAndClearComposer,
+    clearComposer,
+    dequeueOne,
+    clearQueue,
+    exitApp,
+  } = props;
+
+  const [escClear, setEscClear] = useState(false);
+  const [exitKey, setExitKey] = useState<"c" | "d" | null>(null);
+
+  const escTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const exitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const clearEscHint = useCallback(() => {
+    setEscClear(false);
+    if (escTimerRef.current) {
+      clearTimeout(escTimerRef.current);
+      escTimerRef.current = null;
+    }
+  }, []);
+
+  const clearExitHint = useCallback(() => {
+    setExitKey(null);
+    if (exitTimerRef.current) {
+      clearTimeout(exitTimerRef.current);
+      exitTimerRef.current = null;
+    }
+  }, []);
+
+  const clearAllHints = useCallback(() => {
+    clearEscHint();
+    clearExitHint();
+  }, [clearEscHint, clearExitHint]);
+
+  // Clear hints when context changes away from idle
+  const context = deriveContext(agentStatus, hasPendingPermission, composerHasText);
+  const prevContextRef = useRef(context);
+
+  useEffect(() => {
+    const prev = prevContextRef.current;
+    prevContextRef.current = context;
+
+    if (prev !== context) {
+      clearAllHints();
+    }
+  }, [context, clearAllHints]);
+
+  const handleInput = useEffectEvent((input: string, key: Key) => {
+    // Ctrl+Z → suspend (Unix only)
+    if (key.ctrl && input === "z") {
+      if (process.platform !== "win32") {
+        process.kill(process.pid, "SIGTSTP");
+      }
+      return;
+    }
+
+    const isEsc = key.escape;
+    const isCtrlC = key.ctrl && input === "c";
+    const isCtrlD = key.ctrl && input === "d";
+
+    if (!isEsc && !isCtrlC && !isCtrlD) return;
+
+    const ctx = deriveContext(agentStatus, hasPendingPermission, composerHasText);
+
+    // ── Active contexts: immediate action, no hints ──
+    if (ctx === "tool-executing" || ctx === "streaming") {
+      clearAllHints();
+      stopAgent();
+      return;
+    }
+
+    if (ctx === "permission-ui") {
+      clearAllHints();
+      rejectPermission();
+      return;
+    }
+
+    // ── Idle with text ──
+    if (ctx === "idle-with-text") {
+      if (isEsc) {
+        if (escClear) {
+          // Second ESC → clear composer
+          clearComposer();
+          clearAllHints();
+        } else {
+          // First ESC → show hint
+          clearExitHint();
+          setEscClear(true);
+          escTimerRef.current = setTimeout(() => {
+            setEscClear(false);
+            escTimerRef.current = null;
+          }, HINT_TIMEOUT);
+        }
+        return;
+      }
+
+      // Ctrl+C or Ctrl+D
+      const pressedKey = isCtrlC ? "c" : "d";
+      if (exitKey === pressedKey) {
+        // Same key pressed again → exit
+        clearAllHints();
+        exitApp();
+        return;
+      }
+
+      if (exitKey !== null) {
+        // Different key → reset to new key
+        clearExitHint();
+        setExitKey(pressedKey);
+        exitTimerRef.current = setTimeout(() => {
+          setExitKey(null);
+          exitTimerRef.current = null;
+        }, HINT_TIMEOUT);
+        return;
+      }
+
+      // First press → save text to history, clear composer, show exit hint
+      clearEscHint();
+      saveAndClearComposer();
+      if (hasQueuedMessages()) {
+        clearQueue();
+      }
+      setExitKey(pressedKey);
+      exitTimerRef.current = setTimeout(() => {
+        setExitKey(null);
+        exitTimerRef.current = null;
+      }, HINT_TIMEOUT);
+      return;
+    }
+
+    // ── Idle empty ──
+    if (ctx === "idle-empty") {
+      if (isEsc) {
+        // Dequeue one message at a time
+        if (hasQueuedMessages()) {
+          dequeueOne();
+        }
+        // Otherwise no-op
+        return;
+      }
+
+      // Ctrl+C or Ctrl+D
+      const pressedKey = isCtrlC ? "c" : "d";
+      if (exitKey === pressedKey) {
+        clearAllHints();
+        exitApp();
+        return;
+      }
+
+      if (exitKey !== null) {
+        // Different key → reset
+        clearExitHint();
+        setExitKey(pressedKey);
+        exitTimerRef.current = setTimeout(() => {
+          setExitKey(null);
+          exitTimerRef.current = null;
+        }, HINT_TIMEOUT);
+        return;
+      }
+
+      // Clear all queued messages on first Ctrl+C/D
+      if (hasQueuedMessages()) {
+        clearQueue();
+      }
+      setExitKey(pressedKey);
+      exitTimerRef.current = setTimeout(() => {
+        setExitKey(null);
+        exitTimerRef.current = null;
+      }, HINT_TIMEOUT);
+    }
+  });
+
+  useInput(handleInput, { isActive: true });
+
+  // Cleanup timers on unmount
+  useEffect(() => {
+    return () => {
+      if (escTimerRef.current) clearTimeout(escTimerRef.current);
+      if (exitTimerRef.current) clearTimeout(exitTimerRef.current);
+    };
+  }, []);
+
+  return { escClear, exitKey };
+}

package/src/hooks/use-models.ts

@@ -0,0 +1,22 @@
+import { AbacusClient, ILLMOption } from "@codellm/api";
+import { useSuspenseQuery } from "@tanstack/react-query";
+
+import { QueryKey } from "../lib/queries.js";
+
+export function useModels(apiClient: AbacusClient) {
+  return useSuspenseQuery<ILLMOption[]>({
+    queryKey: [QueryKey.Models],
+    queryFn: async () => {
+      try {
+        const response = await apiClient.listLLMModels();
+        return response?.result ?? [];
+      } catch {
+        return [];
+      }
+    },
+    staleTime: 5 * 60 * 1000,
+    retry: 1,
+    refetchOnMount: "always",
+    refetchOnWindowFocus: false,
+  });
+}

package/src/index.ts

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+import { AbacusClient } from "@codellm/api";
+export type { AbacusClient };
+import { AuthManager } from "@codellm/auth";
+import { product } from "@codellm/product";
+import chalk from "chalk";
+import { parseArgs } from "node:util";
+
+import packageJson from "@/package.json" with { type: "json" };
+
+import type { AgentArgs } from "./args.js";
+
+import { runPrintMode } from "./entrypoints/print-mode.js";
+import { runRepl } from "./entrypoints/repl.js";
+import { logger } from "./services/logger.js";
+import { gracefulExit } from "./terminal/exit.js";
+
+/**
+ * Centralized error handling function
+ */
+function handleError(message: string, exitCode = 1): never {
+  console.error(chalk.red(message));
+  gracefulExit(exitCode);
+  throw new Error(message);
+}
+
+/**
+ * Validates URL format and returns a new URL instance
+ */
+function validateUrl(urlString: string): URL {
+  try {
+    return new URL(urlString);
+  } catch {
+    handleError(`Invalid ${product.envPrefix}BASE_URL: ${urlString}`);
+  }
+}
+
+/**
+ * Validates agent arguments for print mode requirements
+ */
+function validatePrintModeArgs(agentArgs?: AgentArgs): void {
+  const hasFormatFlags = agentArgs?.["output-format"] || agentArgs?.["input-format"];
+  if (hasFormatFlags && !agentArgs?.print) {
+    handleError("--output-format and --input-format flags can only be used with --print mode");
+  }
+}
+
+/**
+ * Reads input from stdin asynchronously
+ */
+async function readStdinInput(): Promise<string> {
+  const stdin = process.stdin;
+
+  if (stdin.isTTY) {
+    handleError(
+      "No prompt provided and no piped input detected. Either provide a prompt or pipe input.",
+    );
+  }
+
+  let inputData = "";
+  for await (const chunk of stdin) {
+    inputData += chunk;
+  }
+
+  const trimmed = inputData.trim();
+  if (!trimmed) {
+    handleError("No input provided");
+  }
+
+  return trimmed;
+}
+
+/**
+ * Resolves the input prompt from args or stdin
+ */
+async function resolveInputPrompt(agentArgs?: AgentArgs): Promise<string> {
+  if (agentArgs?.prompt) {
+    return agentArgs.prompt;
+  }
+  return readStdinInput();
+}
+
+/**
+ * Configures API client with custom base URL if provided
+ */
+async function configureApiClient(apiClient: AbacusClient): Promise<void> {
+  const baseUrl = process.env[`${product.envPrefix}BASE_URL`];
+  if (!baseUrl) {
+    return;
+  }
+
+  validateUrl(baseUrl);
+  apiClient.setUrl(baseUrl);
+  apiClient.resetEndpoints();
+  await apiClient.getApiEndpoint();
+}
+
+/**
+ * Resolve --resume <id> or --continue into a conversation ID.
+ * --resume uses the provided ID directly.
+ * --continue fetches the most recently updated conversation from the API.
+ */
+async function resolveConversationId(
+  agentArgs: AgentArgs | undefined,
+  apiClient: AbacusClient,
+): Promise<string | undefined> {
+  if (agentArgs?.resume) {
+    return agentArgs.resume;
+  }
+  if (agentArgs?.continue) {
+    try {
+      const result = await apiClient.getConversationsList(product.agentType);
+      const conversations = result?.result ?? [];
+      const latest = conversations.sort((a, b) => {
+        const aTime = a.lastEventCreatedAt ? new Date(a.lastEventCreatedAt).getTime() : 0;
+        const bTime = b.lastEventCreatedAt ? new Date(b.lastEventCreatedAt).getTime() : 0;
+        return bTime - aTime;
+      })[0];
+      return latest?.deploymentConversationId;
+    } catch {
+      // fall through — start fresh
+    }
+  }
+  return undefined;
+}
+
+async function main(agentArgs?: AgentArgs): Promise<void> {
+  if (agentArgs?.version) {
+    console.log(`Abacus.AI CLI version ${packageJson.version}`);
+    gracefulExit(0);
+    return;
+  }
+
+  validatePrintModeArgs(agentArgs);
+
+  if (agentArgs?.print) {
+    const inputPrompt = await resolveInputPrompt(agentArgs);
+    // For print mode the API client is created inside runPrintMode, so resolve
+    // conversation ID there — pass raw args through.
+    await runPrintMode({ agentArgs: { ...agentArgs, prompt: inputPrompt } });
+  } else {
+    const authManager = await AuthManager.create();
+
+    // Auth is fully managed by AuthManager.create() — no env access needed here.
+
+    const cliLogger = {
+      error: (message: string | Error, ...args: unknown[]) => logger.error(message, ...args),
+      debug: (...message: unknown[]) => logger.debug(...message),
+      warn: (message: string, ...args: unknown[]) => logger.warn(message, ...args),
+    };
+
+    const apiClient = new AbacusClient(authManager, cliLogger);
+
+    await configureApiClient(apiClient);
+
+    // Resolve --resume / --continue into a single conversationId before dispatch.
+    // Downstream consumers (AgentProvider) read agentArgs.conversationId — they
+    // don't know or care how it was resolved.
+    const conversationId = await resolveConversationId(agentArgs, apiClient);
+    const resolvedArgs: AgentArgs = { ...agentArgs, ...(conversationId && { conversationId }) };
+
+    await runRepl({
+      apiClient,
+      authManager,
+      agentArgs: resolvedArgs,
+    });
+  }
+}
+
+const HELP_TEXT = `
+Usage: abacus [options] [prompt]
+
+Options:
+  --help                          Show this help message
+  --version                       Show version number
+  --model <model>                 Model to use (-m)
+  --print                         Print mode, non-interactive (-p)
+  --resume <id>                   Resume a specific conversation by ID
+  --continue                      Continue the most recent conversation (-c)
+  --output-format <format>        Output format: text (default), stream-json
+  --auto-accept-edits             Automatically accept edits
+  --dangerously-skip-permissions  Skip permission checks
+  --plan-mode                     Enable plan mode
+`.trim();
+
+const { values, positionals } = parseArgs({
+  options: {
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" },
+    model: { type: "string", short: "m" },
+    print: { type: "boolean", short: "p" },
+    resume: { type: "string" },
+    continue: { type: "boolean", short: "c" },
+    "output-format": { type: "string" },
+    "input-format": { type: "string" },
+    "allow-editing": { type: "string" },
+    "auto-accept-edits": { type: "boolean" },
+    "dangerously-skip-permissions": { type: "boolean" },
+    "plan-mode": { type: "boolean" },
+  },
+  allowPositionals: true,
+  strict: true,
+});
+
+if (values.help) {
+  console.log(HELP_TEXT);
+  process.exit(0);
+}
+
+main({
+  ...values,
+  prompt: positionals.length > 0 ? positionals.join(" ") : null,
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});