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

package/src/components/ui/input.tsx

@@ -165,7 +165,7 @@ export const Input = memo(
       [buffer, handleSubmit, onKeyDown, disabled],
     );
 
-    useInput(handleKeypress, { isActive: true });
+    useInput(handleKeypress, { isActive: !disabled });
 
     const linesToRender = buffer.viewportVisualLines;
     const [cursorVisualRowAbsolute, cursorVisualColAbsolute] = buffer.visualCursor;

package/src/components/ui/shimmer.tsx

@@ -1,6 +1,7 @@
 import { Text } from "@codellm/jar";
+import chalk from "chalk";
 import { startTransition } from "react";
-import { memo, useCallback, useEffect, useMemo, useState } from "react";
+import { memo, useEffect, useMemo, useState } from "react";
 
 interface ShimmerProps {
   text: string;
@@ -27,31 +28,22 @@ export const Shimmer = memo(({ text, color = "#94a3b8" }: ShimmerProps) => {
 
   const baseRgb = useMemo(() => parseHexColor(color), [color]);
 
-  const getCharColor = useCallback(
-    (index: number): string => {
-      const peakPosition = offset % textLength;
-
-      let distance = Math.abs(index - peakPosition);
+  const coloredText = useMemo(() => {
+    const peakPosition = offset % textLength;
+    const gradientWidth = Math.max(textLength * 0.6, 3);
+    let result = "";
+    for (let i = 0; i < textLength; i++) {
+      let distance = Math.abs(i - peakPosition);
       const wrapDistance = textLength - distance;
       const circularDistance = Math.min(distance, wrapDistance);
-
-      const gradientWidth = Math.max(textLength * 0.6, 3);
       const brightness = Math.max(0, 1 - circularDistance / gradientWidth);
+      const rgb = interpolateRgb(baseRgb, brightness);
+      result += chalk.rgb(rgb.r, rgb.g, rgb.b)(text[i]);
+    }
+    return result;
+  }, [offset, textLength, baseRgb, text]);
 
-      return interpolateColor(baseRgb, brightness);
-    },
-    [offset, textLength, baseRgb],
-  );
-
-  return (
-    <Text>
-      {text.split("").map((char, index) => (
-        <Text key={`${char}-${index}`} color={getCharColor(index)}>
-          {char}
-        </Text>
-      ))}
-    </Text>
-  );
+  return <Text>{coloredText}</Text>;
 });
 
 Shimmer.displayName = "Shimmer";
@@ -71,14 +63,14 @@ function parseHexColor(hex: string): RGB {
   };
 }
 
-function interpolateColor(base: RGB, brightness: number): string {
+function interpolateRgb(base: RGB, brightness: number): RGB {
   const minR = Math.floor(base.r * DIM_FACTOR);
   const minG = Math.floor(base.g * DIM_FACTOR);
   const minB = Math.floor(base.b * DIM_FACTOR);
 
-  const newR = Math.floor(minR + (base.r - minR) * brightness);
-  const newG = Math.floor(minG + (base.g - minG) * brightness);
-  const newB = Math.floor(minB + (base.b - minB) * brightness);
-
-  return `#${newR.toString(16).padStart(2, "0")}${newG.toString(16).padStart(2, "0")}${newB.toString(16).padStart(2, "0")}`;
+  return {
+    r: Math.floor(minR + (base.r - minR) * brightness),
+    g: Math.floor(minG + (base.g - minG) * brightness),
+    b: Math.floor(minB + (base.b - minB) * brightness),
+  };
 }

package/src/entrypoints/repl.tsx

@@ -1,7 +1,7 @@
 import type { AbacusClient } from "@codellm/api";
 
 import { AuthManager } from "@codellm/auth";
-import { View, render, Text, useInput } from "@codellm/jar";
+import { View, render, useInput } from "@codellm/jar";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import {
   Activity,
@@ -40,7 +40,6 @@ 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. */
@@ -186,15 +185,12 @@ export function App({ timing }: { timing: Timing }) {
     { isActive: expandedSnapshot === null },
   );
 
-  const { lastItem, prevItems, isTruncated } = useMemo(() => {
+  const { lastItem, prevItems } = 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,
+      lastItem: items.at(-1) ?? null,
+      prevItems: items.slice(0, -1),
     };
   }, [rawSegments]);
 
@@ -268,12 +264,6 @@ export function App({ timing }: { timing: Timing }) {
     <>
       <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" ? (
@@ -347,11 +337,6 @@ export async function runRepl({ apiClient, authManager, agentArgs }: ReplConfig)
   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}>
@@ -376,6 +361,10 @@ export async function runRepl({ apiClient, authManager, agentArgs }: ReplConfig)
     </ThemeProvider>,
     {
       exitOnCtrlC: false,
+      suspendable: true,
+      onSuspended: () => {
+        process.stderr.write("\nAbacus.AI has been suspended. Run `fg` to bring Abacus back.\n");
+      },
     },
   );
 
@@ -396,6 +385,5 @@ export async function runRepl({ apiClient, authManager, agentArgs }: ReplConfig)
 
   await app.waitUntilExit();
   process.off("exit", handleProcessExit);
-  cleanupSuspend();
   cleanup();
 }

package/src/providers/agent.tsx

@@ -142,7 +142,23 @@ function segmentsReducer(prev: HistorySegment[], action: SegmentAction): History
 
     case "TEXT_DELTA": {
       const { segId, content } = action;
-      const withoutSpinny = prev.filter((s) => !s.isSpinny);
+      const base = prev.map((s) =>
+        s.type === "code_llm_tool_call" && s.status === "transient" && !s.toolUseResult
+          ? {
+              ...s,
+              status: "completed" as const,
+              parsedResult: {
+                phase: "error" as const,
+                toolType: Array.isArray(s.toolUseRequest)
+                  ? (s.toolUseRequest[0]?.name ?? "")
+                  : (s.toolUseRequest?.name ?? ""),
+                data: {},
+                summary: "",
+              },
+            }
+          : s,
+      );
+      const withoutSpinny = base.filter((s) => !s.isSpinny);
       const existing = withoutSpinny.find((s) => s.id === segId);
       if (existing) {
         return withoutSpinny.map((s) =>
@@ -389,8 +405,10 @@ export const AgentProvider = memo(({ children, apiClient, agentArgs }: AgentProv
     return new CallbackPermissionProvider(
       async (req: PermissionRequest): Promise<PermissionDecision> => {
         const conn = connectionRef.current;
+        let permissionReq: PermissionRequest = req;
+        let editorDiffFilePath: string | null = null;
 
-        // For edit tool with VS Code connection: show diff in VS Code, show options in CLI
+        // For edit tool with VS Code connection: show diff in VS Code
         if (conn && pushServerRef.current && req.type === "edit_file") {
           const toolId = req.tool.id;
           const displayData = displayDataMapRef.current.get(toolId);
@@ -408,56 +426,8 @@ export const AgentProvider = memo(({ children, apiClient, agentArgs }: AgentProv
               toolId,
             });
             if (shown) {
-              const pushServer = pushServerRef.current;
-              const editReq: PermissionRequest = {
-                ...req,
-                diffShownInEditor: true,
-              };
-
-              const cliPromise = new Promise<PermissionDecision>((resolve) => {
-                setPendingToolPermission({
-                  request: editReq,
-                  resolve: (decision) => {
-                    setPendingToolPermission(null);
-                    const isAccept =
-                      decision === "accept" ||
-                      decision === "allowAlways" ||
-                      decision === "background" ||
-                      (typeof decision === "object" && decision.type === "accept_with_message") ||
-                      (typeof decision === "object" && decision.type === "question_answers");
-                    setAgentStatus(isAccept ? AgentStatus.ExecutingTool : AgentStatus.Submitted);
-                    resolve(decision);
-                  },
-                });
-                setAgentStatus(AgentStatus.WaitingForToolPermission);
-                void notifyActionRequired("Abacus.AI is waiting for your input");
-              });
-
-              const pushPromise = pushServer.waitForDecision(toolId).then((d) => {
-                setPendingToolPermission(null);
-                return (d === "allowAlways" ? "allowAlways" : d) as PermissionDecision;
-              });
-
-              const decision = await Promise.race([cliPromise, pushPromise]);
-
-              const simpleDecision =
-                decision === "accept" || decision === "reject" || decision === "allowAlways"
-                  ? decision
-                  : decision === "background"
-                    ? "accept"
-                    : typeof decision === "object" && decision.type === "accept_with_message"
-                      ? "accept"
-                      : typeof decision === "object" && decision.type === "reject_with_message"
-                        ? "reject"
-                        : "accept";
-              conn
-                .notifyDiffDecision({
-                  targetFile: filePath,
-                  decision: simpleDecision === "allowAlways" ? "accept" : simpleDecision,
-                })
-                .catch(() => {});
-
-              return decision;
+              permissionReq = { ...req, diffShownInEditor: true };
+              editorDiffFilePath = filePath;
             }
           }
         }
@@ -476,17 +446,14 @@ export const AgentProvider = memo(({ children, apiClient, agentArgs }: AgentProv
         }
 
         // Fallback: show CLI permission UI
-        return new Promise((resolve) => {
+        const decision = await new Promise<PermissionDecision>((resolve) => {
           setPendingToolPermission({
-            request: req,
+            request: permissionReq,
             resolve: (decision) => {
               setPendingToolPermission(null);
-              // Immediately reflect the decision in the status indicator so the running
-              // spinner appears without waiting for the event buffer to drain
               const isAccept =
                 decision === "accept" ||
                 decision === "allowAlways" ||
-                decision === "background" ||
                 (typeof decision === "object" && decision.type === "accept_with_message") ||
                 (typeof decision === "object" && decision.type === "question_answers");
               setAgentStatus(isAccept ? AgentStatus.ExecutingTool : AgentStatus.Submitted);
@@ -496,6 +463,20 @@ export const AgentProvider = memo(({ children, apiClient, agentArgs }: AgentProv
           setAgentStatus(AgentStatus.WaitingForToolPermission);
           void notifyActionRequired("Abacus.AI is waiting for your input");
         });
+
+        if (editorDiffFilePath && conn) {
+          const isReject =
+            decision === "reject" ||
+            (typeof decision === "object" && decision.type === "reject_with_message");
+          conn
+            .notifyDiffDecision({
+              targetFile: editorDiffFilePath,
+              decision: isReject ? "reject" : "accept",
+            })
+            .catch(() => {});
+        }
+
+        return decision;
       },
     );
   }, [notifyActionRequired]);
@@ -834,9 +815,16 @@ export const AgentProvider = memo(({ children, apiClient, agentArgs }: AgentProv
             }
 
             case "notification": {
-              if (event.severity === "error" || event.severity === "warning") {
-                addNotification(event.message, event.severity, false);
-              }
+              const notifSeg: HistorySegment = {
+                id: crypto.randomUUID(),
+                status: "completed",
+                source: "bot",
+                type: "code_llm_notification",
+                severity: event.severity,
+                message: event.message,
+                ...(event.actions !== undefined && { actions: event.actions }),
+              };
+              dispatchSegments({ type: "ADD_NOTIFICATION", seg: notifSeg });
               break;
             }
 

package/src/tools/utils/tool-ui-components.tsx

@@ -122,6 +122,8 @@ export interface ToolHeaderProps {
   isAwaitingPermission?: boolean;
   /** Tool call ID — used to check against PendingToolCallIdContext for auto awaiting-permission detection */
   toolCallId?: string;
+  /** When set, syntax-highlight params using this language via cli-highlight */
+  paramsLanguage?: string;
 }
 
 export function ToolHeader({
@@ -131,9 +133,9 @@ export function ToolHeader({
   showSpinner,
   isAwaitingPermission,
   toolCallId,
+  paramsLanguage,
 }: ToolHeaderProps) {
   const color = getStatusColor(status);
-  const isPending = status === "pending" || status === "executing";
 
   // Auto-detect awaiting permission via context:
   // When a tool call ID matches the pending permission, or when showSpinner is true
@@ -154,12 +156,28 @@ export function ToolHeader({
     indicator = <Text color={color}>⏺</Text>;
   }
 
+  let paramsContent: React.ReactNode = null;
+  if (params) {
+    let highlighted = params;
+    if (paramsLanguage && supportsLanguage(paramsLanguage)) {
+      try {
+        highlighted = highlight(params, { language: paramsLanguage });
+      } catch {
+        // fallback to plain text
+      }
+    }
+    paramsContent = paramsLanguage ? (
+      <Text>({highlighted})</Text>
+    ) : (
+      <Text dimColor>({params})</Text>
+    );
+  }
+
   return (
     <View flexDirection="row" alignItems="center" gap={1}>
       {indicator}
       <Text color="cyan">{name}</Text>
-      {params && <Text dimColor>({params})</Text>}
-      {isPending && <Text dimColor>...</Text>}
+      {paramsContent}
     </View>
   );
 }

package/tsconfig.json

@@ -7,5 +7,10 @@
     {
       "path": "./tsconfig.test.json"
     }
-  ]
+  ],
+  "compilerOptions": {
+    "paths": {
+      "@/package.json": ["./package.json"]
+    }
+  }
 }

package/src/terminal/suspend.ts

@@ -1,58 +0,0 @@
-/**
- * Platform-aware SIGTSTP/SIGCONT handling for Ctrl+Z suspend support.
- *
- * In raw mode, Ctrl+Z sends a `\x1a` byte rather than SIGTSTP.
- * The interrupt manager detects this byte and calls `process.kill(pid, "SIGTSTP")`.
- * This module handles the signal-level suspend/resume lifecycle.
- */
-
-export function setupSuspendHandler(options: {
-  onBeforeSuspend?: () => void;
-  onAfterResume?: () => void;
-}): () => void {
-  if (process.platform === "win32") {
-    // SIGTSTP doesn't exist on Windows
-    return () => {};
-  }
-
-  const handleSIGTSTP = () => {
-    options.onBeforeSuspend?.();
-
-    // Restore terminal defaults before suspending
-    if (process.stdout.isTTY) {
-      process.stdout.write("\x1b[?25h"); // show cursor
-    }
-    if (process.stdin.isTTY && process.stdin.isRaw) {
-      process.stdin.setRawMode(false);
-    }
-
-    process.stderr.write("\nAbacus.AI has been suspended. Run `fg` to bring Abacus back.\n");
-
-    // Re-raise SIGTSTP with default handler to actually suspend
-    process.removeListener("SIGTSTP", handleSIGTSTP);
-    process.kill(process.pid, "SIGTSTP");
-  };
-
-  const handleSIGCONT = () => {
-    // Re-enter raw mode and hide cursor after resume
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    if (process.stdout.isTTY) {
-      process.stdout.write("\x1b[?25l"); // hide cursor
-    }
-
-    // Re-register SIGTSTP handler (was removed before suspend)
-    process.on("SIGTSTP", handleSIGTSTP);
-
-    options.onAfterResume?.();
-  };
-
-  process.on("SIGTSTP", handleSIGTSTP);
-  process.on("SIGCONT", handleSIGCONT);
-
-  return () => {
-    process.removeListener("SIGTSTP", handleSIGTSTP);
-    process.removeListener("SIGCONT", handleSIGCONT);
-  };
-}