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

package/src/entrypoints/repl.tsx

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

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