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

package/src/hooks/use-agent.ts

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

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

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

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

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

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

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

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