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

package/src/entrypoints/repl.tsx

@@ -0,0 +1,401 @@
+import type { AbacusClient } from "@codellm/api";
+
+import { AuthManager } from "@codellm/auth";
+import { View, render, Text, useInput } from "@codellm/jar";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+  Activity,
+  useEffect,
+  useState,
+  useDeferredValue,
+  useMemo,
+  useCallback,
+  useRef,
+} from "react";
+
+import type { AgentArgs } from "../args.js";
+import type { HistorySegment } from "../lib/types.js";
+
+import { Composer, type ComposerHandle } from "../components/composer/index.js";
+import { AgentMode } from "../components/composer/types.js";
+import { ExitMessage } from "../components/exit-message.js";
+import { ExpandedView } from "../components/expanded-view.js";
+import { Header } from "../components/header.js";
+import { Segment } from "../components/segments.js";
+import { StatusIndicator } from "../components/status-indicator.js";
+import { GROUPABLE_TOOLS, ToolGroupSummary } from "../components/tool-group-summary.js";
+import { ToolPermissionUI } from "../components/tool-permissions/tool-permission-ui.js";
+import { PendingToolCallIdContext } from "../components/tools/shared/index.js";
+import { AgentModeProvider } from "../context/agent-mode.js";
+import { ExtensionFileProvider } from "../context/extension-file.js";
+import { NetworkActivityProvider } from "../context/network-activity.js";
+import { NotificationProvider } from "../context/notification.js";
+import { ShellSizeProvider } from "../context/shell-size.js";
+import { ShellTitleProvider, useShellTitle } from "../context/shell-title.js";
+import { useAgent } from "../hooks/use-agent.js";
+import { useApiClient } from "../hooks/use-api-client.js";
+import { useInterruptManager } from "../hooks/use-interrupt-manager.js";
+import { ANSI } from "../lib/ansi.js";
+import { Timing } from "../lib/timing.js";
+import { AgentProvider, AgentStatus } from "../providers/agent.js";
+import { ApiClientProvider } from "../providers/api-client.js";
+import { onExit, gracefulExit } from "../terminal/exit.js";
+import { setupSuspendHandler } from "../terminal/suspend.js";
+import { ThemeProvider } from "../theme/index.js";
+
+/** Group consecutive "groupable" tool call segments together for compact rendering. */
+type RenderItem =
+  | { kind: "segment"; segment: HistorySegment }
+  | { kind: "tool-group"; id: string; segments: HistorySegment[] };
+
+function isToolSeg(seg: HistorySegment): boolean {
+  return seg.type === "code_llm_tool_call" || seg.type === "code_llm_agent_tool_request";
+}
+
+function hasToolError(seg: HistorySegment): boolean {
+  const result = seg.toolUseResult as { rejected?: boolean; content?: string } | undefined;
+  return !!(result?.rejected || result?.content?.startsWith("Error:"));
+}
+
+function groupSegments(segments: HistorySegment[]): RenderItem[] {
+  const items: RenderItem[] = [];
+  let i = 0;
+  while (i < segments.length) {
+    const seg = segments[i];
+
+    // Thinking segments render inline (visible while active + 2s after completion)
+    if (seg.type === "thinking") {
+      items.push({ kind: "segment", segment: seg });
+      i++;
+      continue;
+    }
+
+    if (isToolSeg(seg) && GROUPABLE_TOOLS.has(getToolName(seg))) {
+      // Collect all consecutive groupable tool calls, treating thinking as transparent gaps
+      // Break the group at any completed tool that returned an error
+      const group: HistorySegment[] = [seg];
+      let j = i + 1;
+      while (j < segments.length) {
+        const next = segments[j];
+        if (next.type === "thinking") {
+          // Thinking between tool calls is transparent — skip without breaking the group
+          j++;
+          continue;
+        }
+        // If the last tool in the group errored, start a new group from here
+        if (hasToolError(group[group.length - 1]!)) {
+          break;
+        }
+        if (isToolSeg(next) && GROUPABLE_TOOLS.has(getToolName(next))) {
+          group.push(next);
+          j++;
+        } else {
+          break;
+        }
+      }
+      if (group.length === 1) {
+        items.push({ kind: "segment", segment: group[0] });
+      } else {
+        items.push({ kind: "tool-group", id: group[0].id, segments: group });
+      }
+      i = j;
+      continue;
+    }
+
+    items.push({ kind: "segment", segment: seg });
+    i++;
+  }
+  return items;
+}
+
+function getToolName(seg: HistorySegment): string {
+  const req = seg.toolUseRequest;
+  if (!req) return "";
+  if (Array.isArray(req)) return (req[0] as { name?: string })?.name ?? "";
+  return (req as { name?: string }).name ?? "";
+}
+
+/** Derive the most recent thinking timing from segments for the status indicator. */
+function getThinkingTiming(segments: HistorySegment[]): {
+  thinkingStartTime: number | null;
+  thinkingEndTime: number | null;
+} {
+  // Find the last thinking segment
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const seg = segments[i];
+    if (seg.type === "thinking") {
+      return {
+        thinkingStartTime: seg.thinkingStartTime ?? null,
+        thinkingEndTime: seg.thinkingEndTime ?? null,
+      };
+    }
+  }
+  return { thinkingStartTime: null, thinkingEndTime: null };
+}
+
+export function App({ timing }: { timing: Timing }) {
+  const { setTitle } = useShellTitle();
+
+  const {
+    segments: rawSegments,
+    agentStatus,
+    pendingToolPermission,
+    conversationTitle,
+    conversationId,
+    addNotification,
+    stop,
+    rejectPendingPermission,
+    removeFirstFromQueue,
+    clearQueue,
+    retryState,
+    networkOnline,
+  } = useAgent();
+
+  const composerRef = useRef<ComposerHandle>(null);
+
+  const { authExpired, clearAuthExpired } = useApiClient();
+
+  // Show a notification segment when session expires
+  useEffect(() => {
+    if (authExpired) {
+      addNotification("Session expired — use /login to authenticate again.", "error");
+      clearAuthExpired();
+    }
+  }, [authExpired, addNotification, clearAuthExpired]);
+
+  // Expanded view: snapshot taken at moment of Ctrl+O
+  const [expandedSnapshot, setExpandedSnapshot] = useState<HistorySegment[] | null>(null);
+
+  const toggleExpand = useCallback(() => {
+    setExpandedSnapshot((prev) => {
+      if (prev !== null) return null; // close
+      // Snapshot: exclude transient/spinny
+      return rawSegments.filter((s) => !s.temp && !s.isSpinny);
+    });
+  }, [rawSegments]);
+
+  // Global Ctrl+O handler — only active when NOT in expanded mode.
+  // When expanded, ExpandedView's own useInput handles the key.
+  // Both handlers firing would cause a toggle → re-open race.
+  useInput(
+    (input, key) => {
+      if ((key.ctrl || key.super) && input === "o") {
+        toggleExpand();
+      }
+    },
+    { isActive: expandedSnapshot === null },
+  );
+
+  const { lastItem, prevItems, isTruncated } = useMemo(() => {
+    const filtered = rawSegments.filter((s) => !s.temp && !s.isSpinny);
+    const items = groupSegments(filtered);
+    const truncated = items.length > 100;
+    const visible = truncated ? items.slice(-100) : items;
+    return {
+      lastItem: visible.at(-1) ?? null,
+      prevItems: visible.slice(0, -1),
+      isTruncated: truncated,
+    };
+  }, [rawSegments]);
+
+  const deferredPrevItems = useDeferredValue(prevItems);
+
+  // Thinking timing for status indicator
+  const { thinkingStartTime, thinkingEndTime } = useMemo(
+    () => getThinkingTiming(rawSegments),
+    [rawSegments],
+  );
+
+  const isWaitingForPermission =
+    agentStatus === AgentStatus.WaitingForToolPermission && pendingToolPermission !== null;
+
+  const [exiting, setExiting] = useState(false);
+  const [exitDuration, setExitDuration] = useState("0");
+  const [exitCredits, setExitCredits] = useState(0);
+
+  useEffect(() => {
+    if (conversationTitle) {
+      setTitle(`${conversationTitle} • Abacus.AI CLI`);
+    } else {
+      setTitle("Abacus.AI CLI");
+    }
+  }, [conversationTitle, setTitle]);
+
+  useEffect(() => {
+    const unsubscribe = onExit(
+      async () => {
+        const duration = timing.getFormattedDuration();
+
+        setExitCredits(0);
+        setExitDuration(duration);
+        setExiting(true);
+
+        await new Promise<void>((resolve) => setTimeout(resolve, 100));
+      },
+      { wait: 2000, streams: [process.stdout, process.stderr] },
+    );
+
+    return unsubscribe;
+  }, [timing]);
+
+  const hints = useInterruptManager({
+    agentStatus,
+    hasPendingPermission: pendingToolPermission !== null,
+    composerHasText: () => composerRef.current?.hasText() ?? false,
+    hasQueuedMessages: () => composerRef.current?.hasQueue() ?? false,
+    stopAgent: stop,
+    rejectPermission: rejectPendingPermission,
+    saveAndClearComposer: () => composerRef.current?.saveAndClear(),
+    clearComposer: () => composerRef.current?.clear(),
+    dequeueOne: removeFirstFromQueue,
+    clearQueue,
+    exitApp: () => gracefulExit(0),
+  });
+
+  const shouldShowStatusIndicator =
+    (agentStatus !== AgentStatus.Idle && agentStatus !== AgentStatus.WaitingForToolPermission) ||
+    retryState !== null ||
+    !networkOnline;
+
+  const pendingToolCallId = pendingToolPermission?.request.tool.id ?? null;
+
+  // Expanded mode: show static snapshot instead of normal UI
+  if (expandedSnapshot !== null) {
+    return <ExpandedView snapshot={expandedSnapshot} onClose={() => setExpandedSnapshot(null)} />;
+  }
+
+  return (
+    <>
+      <View flexDirection="column" gap={1} paddingBottom={1} width="95%">
+        <Header />
+        {isTruncated && (
+          <Text dimColor>
+            — Output limited to the last 100 items for performance. Use /new to start a fresh
+            conversation. —
+          </Text>
+        )}
+        <PendingToolCallIdContext.Provider value={pendingToolCallId}>
+          {deferredPrevItems.map((item) =>
+            item.kind === "segment" ? (
+              <Segment key={item.segment.id} segment={item.segment} />
+            ) : (
+              <ToolGroupSummary key={item.id} segments={item.segments} />
+            ),
+          )}
+          {lastItem &&
+            (lastItem.kind === "segment" ? (
+              <Segment key={lastItem.segment.id} segment={lastItem.segment} />
+            ) : (
+              <ToolGroupSummary key={lastItem.id} segments={lastItem.segments} />
+            ))}
+        </PendingToolCallIdContext.Provider>
+        {shouldShowStatusIndicator && (
+          <StatusIndicator
+            status={agentStatus}
+            thinkingStartTime={thinkingStartTime}
+            thinkingEndTime={thinkingEndTime}
+            retryState={retryState}
+            networkOnline={networkOnline}
+          />
+        )}
+      </View>
+
+      {exiting ? (
+        <ExitMessage
+          duration={exitDuration}
+          credits={exitCredits}
+          conversationId={conversationId}
+        />
+      ) : (
+        <>
+          {isWaitingForPermission && <ToolPermissionUI pendingTool={pendingToolPermission} />}
+          <Activity mode={isWaitingForPermission ? "hidden" : "visible"}>
+            <Composer hints={hints} composerRef={composerRef} />
+          </Activity>
+        </>
+      )}
+    </>
+  );
+}
+
+export interface ReplConfig {
+  apiClient: AbacusClient;
+  authManager: AuthManager;
+  agentArgs?: AgentArgs;
+}
+
+export async function runRepl({ apiClient, authManager, agentArgs }: ReplConfig) {
+  const queryClient = new QueryClient();
+  const timing = new Timing();
+
+  let initialAgentMode: AgentMode | undefined;
+  if (agentArgs?.["dangerously-skip-permissions"]) {
+    initialAgentMode = AgentMode.Yolo;
+  } else if (agentArgs?.["auto-accept-edits"]) {
+    initialAgentMode = AgentMode.AcceptEdits;
+  } else if (agentArgs?.["plan-mode"]) {
+    initialAgentMode = AgentMode.PlanMode;
+  }
+
+  const stdout = process.stdout;
+  const write = (s: string) => {
+    if (stdout && stdout.writable) {
+      stdout.write(s);
+    }
+  };
+  const hideCursor = () => write(ANSI.HIDE_CURSOR);
+  const showCursor = () => write(ANSI.SHOW_CURSOR);
+
+  hideCursor();
+  const cleanupSuspend = setupSuspendHandler({
+    onAfterResume: () => {
+      // Ink will re-render automatically when stdin resumes
+    },
+  });
+  const app = render(
+    <ThemeProvider>
+      <ApiClientProvider client={apiClient} authManager={authManager}>
+        <QueryClientProvider client={queryClient}>
+          <ShellSizeProvider>
+            <ShellTitleProvider>
+              <NotificationProvider>
+                <ExtensionFileProvider>
+                  <AgentModeProvider initialMode={initialAgentMode}>
+                    <NetworkActivityProvider>
+                      <AgentProvider apiClient={apiClient} agentArgs={agentArgs}>
+                        <App timing={timing} />
+                      </AgentProvider>
+                    </NetworkActivityProvider>
+                  </AgentModeProvider>
+                </ExtensionFileProvider>
+              </NotificationProvider>
+            </ShellTitleProvider>
+          </ShellSizeProvider>
+        </QueryClientProvider>
+      </ApiClientProvider>
+    </ThemeProvider>,
+    {
+      exitOnCtrlC: false,
+    },
+  );
+
+  let cleanedUp = false;
+  const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    showCursor();
+  };
+
+  const handleProcessExit = () => {
+    if (!cleanedUp) {
+      cleanedUp = true;
+      app.cleanupTerminal();
+    }
+  };
+  process.once("exit", handleProcessExit);
+
+  await app.waitUntilExit();
+  process.off("exit", handleProcessExit);
+  cleanupSuspend();
+  cleanup();
+}

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 };
+}