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

package/src/context/agent-mode.tsx

@@ -0,0 +1,95 @@
+import React, { createContext, use, useEffect, useMemo, useReducer } from "react";
+
+import { AgentMode } from "../components/composer/types.js";
+
+interface AgentModeContextValue {
+  agentMode: AgentMode;
+  setAgentMode: (mode: AgentMode) => void;
+  cycleAgentMode: () => void;
+  isWaitingForYoloConfirm: boolean;
+  resetToNormal: () => void;
+}
+
+const AgentModeContext = createContext<AgentModeContextValue | null>(null);
+
+export const useAgentMode = () => {
+  const ctx = use(AgentModeContext);
+  if (!ctx) {
+    throw new Error(`${useAgentMode.name} must be used within ${AgentModeProvider.name}`);
+  }
+  return ctx;
+};
+
+const YOLO_CONFIRM_DELAY = 3_000;
+
+const MODE_CYCLE_ORDER: AgentMode[] = [AgentMode.Normal, AgentMode.AcceptEdits, AgentMode.PlanMode];
+
+type State = { agentMode: AgentMode; isWaitingForYoloConfirm: boolean };
+type Action =
+  | { type: "CYCLE" }
+  | { type: "SET"; mode: AgentMode }
+  | { type: "RESET" }
+  | { type: "YOLO_TIMEOUT" };
+
+function reducer(state: State, action: Action): State {
+  switch (action.type) {
+    case "CYCLE": {
+      if (state.isWaitingForYoloConfirm) {
+        // Second press while waiting → confirm YOLO
+        return { agentMode: AgentMode.Yolo, isWaitingForYoloConfirm: false };
+      }
+      if (state.agentMode === AgentMode.Yolo) {
+        // Cycling from YOLO goes back to Normal
+        return { agentMode: AgentMode.Normal, isWaitingForYoloConfirm: false };
+      }
+      const currentIndex = MODE_CYCLE_ORDER.indexOf(state.agentMode);
+      if (currentIndex === -1) {
+        return { agentMode: AgentMode.Normal, isWaitingForYoloConfirm: false };
+      }
+      if (currentIndex === MODE_CYCLE_ORDER.length - 1) {
+        // At end of cycle order → ask for YOLO confirmation
+        return { agentMode: state.agentMode, isWaitingForYoloConfirm: true };
+      }
+      return { agentMode: MODE_CYCLE_ORDER[currentIndex + 1]!, isWaitingForYoloConfirm: false };
+    }
+    case "SET": {
+      return { agentMode: action.mode, isWaitingForYoloConfirm: false };
+    }
+    case "RESET": {
+      return { agentMode: AgentMode.Normal, isWaitingForYoloConfirm: false };
+    }
+    case "YOLO_TIMEOUT": {
+      return { ...state, isWaitingForYoloConfirm: false };
+    }
+  }
+}
+
+interface AgentModeProviderProps extends React.PropsWithChildren {
+  initialMode?: AgentMode;
+}
+
+export function AgentModeProvider({ children, initialMode }: AgentModeProviderProps) {
+  const [{ agentMode, isWaitingForYoloConfirm }, dispatch] = useReducer(reducer, {
+    agentMode: initialMode ?? AgentMode.Normal,
+    isWaitingForYoloConfirm: false,
+  });
+
+  useEffect(() => {
+    if (!isWaitingForYoloConfirm) return;
+    const id = setTimeout(() => dispatch({ type: "YOLO_TIMEOUT" }), YOLO_CONFIRM_DELAY);
+    return () => clearTimeout(id);
+  }, [isWaitingForYoloConfirm]);
+
+  const value = useMemo<AgentModeContextValue>(
+    () => ({
+      agentMode,
+      setAgentMode: (mode) => dispatch({ type: "SET", mode }),
+      cycleAgentMode: () => dispatch({ type: "CYCLE" }),
+      isWaitingForYoloConfirm,
+      resetToNormal: () => dispatch({ type: "RESET" }),
+    }),
+    [agentMode, isWaitingForYoloConfirm],
+  );
+
+  return <AgentModeContext.Provider value={value}>{children}</AgentModeContext.Provider>;
+}

package/src/context/extension-file.tsx

@@ -0,0 +1,136 @@
+import { createContext, use, useEffect, useRef, useState } from "react";
+
+import type { EditorState } from "../lib/cli-push-server.js";
+
+import { CliPushServer } from "../lib/cli-push-server.js";
+import { ExtensionConnection } from "../lib/extension-connection.js";
+
+interface ExtensionFileContextValue {
+  currentFile: string | undefined;
+  selectionStartLine: number | undefined;
+  selectionEndLine: number | undefined;
+  connection: ExtensionConnection | null;
+  pushServer: CliPushServer | null;
+}
+
+const ExtensionFileContext = createContext<ExtensionFileContextValue | null>(null);
+
+export function useExtensionFile() {
+  const ctx = use(ExtensionFileContext);
+  if (!ctx) {
+    throw new Error("useExtensionFile must be used within ExtensionFileProvider");
+  }
+  return ctx;
+}
+
+export function ExtensionFileProvider({
+  children,
+  initialFile,
+}: React.PropsWithChildren<{ initialFile?: string }>) {
+  const [currentFile, setCurrentFile] = useState<string | undefined>(initialFile);
+  const [selectionStartLine, setSelectionStartLine] = useState<number | undefined>(undefined);
+  const [selectionEndLine, setSelectionEndLine] = useState<number | undefined>(undefined);
+  const [connection, setConnection] = useState<ExtensionConnection | null>(null);
+  const [pushServer, setPushServer] = useState<CliPushServer | null>(null);
+  const connectionRef = useRef<ExtensionConnection | null>(null);
+  const pushServerRef = useRef<CliPushServer | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    const connectToExtension = async () => {
+      // Start the CLI push server first so the extension can connect back to us
+      const ps = new CliPushServer();
+      try {
+        await ps.start();
+      } catch {
+        // Push server failed to start — continue without it
+      }
+
+      if (cancelled) {
+        ps.dispose();
+        return;
+      }
+
+      pushServerRef.current = ps;
+      setPushServer(ps);
+
+      // Wire push-based state updates
+      ps.onEditorChange((state: EditorState) => {
+        setCurrentFile(state.file);
+        setSelectionStartLine(state.startLine);
+        setSelectionEndLine(state.endLine);
+      });
+
+      // Retry for up to 10 seconds with exponential backoff (covers extension startup delay)
+      const delays = [500, 1000, 2000, 3000, 4000];
+      for (const delay of [0, ...delays]) {
+        if (cancelled) return;
+        if (delay > 0) {
+          await new Promise((r) => setTimeout(r, delay));
+        }
+        if (cancelled) return;
+
+        try {
+          const conn = new ExtensionConnection(ps);
+          const connected = await conn.connect();
+
+          if (connected) {
+            if (cancelled) {
+              conn.dispose();
+              return;
+            }
+
+            // Set initial state from push server (extension pushes state on register)
+            const state = ps.getEditorState();
+            setCurrentFile(state.file);
+            setSelectionStartLine(state.startLine);
+            setSelectionEndLine(state.endLine);
+
+            conn.onFileChange((file, startLine, endLine) => {
+              setCurrentFile(file);
+              setSelectionStartLine(startLine);
+              setSelectionEndLine(endLine);
+            });
+
+            connectionRef.current = conn;
+            setConnection(conn);
+            return; // Connected — stop retrying
+          }
+        } catch {
+          // ignore, retry
+        }
+      }
+    };
+
+    void connectToExtension();
+
+    return () => {
+      cancelled = true;
+      if (connectionRef.current) {
+        connectionRef.current.dispose();
+        connectionRef.current = null;
+        setConnection(null);
+      }
+      if (pushServerRef.current) {
+        pushServerRef.current.dispose();
+        pushServerRef.current = null;
+        setPushServer(null);
+      }
+    };
+  }, []);
+
+  return (
+    <ExtensionFileContext.Provider
+      value={{
+        currentFile,
+        selectionStartLine,
+        selectionEndLine,
+        connection,
+        pushServer,
+      }}
+    >
+      {children}
+    </ExtensionFileContext.Provider>
+  );
+}

package/src/context/network-activity.tsx

@@ -0,0 +1,45 @@
+import { createContext, use, useMemo, useState, type ReactNode } from "react";
+
+export type NetworkActivity = "upload" | "download" | "idle";
+
+interface NetworkActivityContextValue {
+  activity: NetworkActivity;
+  setActivity: (activity: NetworkActivity) => void;
+  startUpload: () => void;
+  startDownload: () => void;
+  stopActivity: () => void;
+}
+
+const NetworkActivityContext = createContext<NetworkActivityContextValue | null>(null);
+
+export function NetworkActivityProvider({ children }: { children: ReactNode }) {
+  const [activity, setActivity] = useState<NetworkActivity>("idle");
+
+  const startUpload = () => setActivity("upload");
+  const startDownload = () => setActivity("download");
+  const stopActivity = () => setActivity("idle");
+
+  const value = useMemo(
+    () => ({
+      activity,
+      setActivity,
+      startUpload,
+      startDownload,
+      stopActivity,
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [activity],
+  );
+
+  return (
+    <NetworkActivityContext.Provider value={value}>{children}</NetworkActivityContext.Provider>
+  );
+}
+
+export function useNetworkActivity() {
+  const context = use(NetworkActivityContext);
+  if (!context) {
+    throw new Error("useNetworkActivity must be used within NetworkActivityProvider");
+  }
+  return context;
+}

package/src/context/notification.tsx

@@ -0,0 +1,62 @@
+import { useFocusState } from "@codellm/jar";
+import { createContext, useCallback, use, useMemo } from "react";
+
+import { notify, notifyAction, notifyComplete } from "../terminal/notification.js";
+
+interface NotificationContextValue {
+  notifyIfUnfocused: (message: string, title?: string) => Promise<void>;
+  notifyActionRequired: (message: string) => Promise<void>;
+  notifyTaskComplete: (message: string) => Promise<void>;
+}
+
+const NotificationContext = createContext<NotificationContextValue | null>(null);
+
+export const useNotification = () => {
+  const context = use(NotificationContext);
+  if (!context) {
+    throw new Error("useNotification must be used within NotificationProvider");
+  }
+  return context;
+};
+
+export const NotificationProvider = ({ children }: React.PropsWithChildren) => {
+  const { isFocused } = useFocusState();
+
+  const notifyIfUnfocused = useCallback(
+    async (message: string, title?: string) => {
+      if (!isFocused) {
+        await notify({ message, title });
+      }
+    },
+    [isFocused],
+  );
+
+  const notifyActionRequired = useCallback(
+    async (message: string) => {
+      if (!isFocused) {
+        await notifyAction(message);
+      }
+    },
+    [isFocused],
+  );
+
+  const notifyTaskComplete = useCallback(
+    async (message: string) => {
+      if (!isFocused) {
+        await notifyComplete(message);
+      }
+    },
+    [isFocused],
+  );
+
+  const value = useMemo(
+    () => ({
+      notifyIfUnfocused,
+      notifyActionRequired,
+      notifyTaskComplete,
+    }),
+    [notifyIfUnfocused, notifyActionRequired, notifyTaskComplete],
+  );
+
+  return <NotificationContext.Provider value={value}>{children}</NotificationContext.Provider>;
+};

package/src/context/shell-size.tsx

@@ -0,0 +1,49 @@
+import { createContext, use, useCallback, useLayoutEffect, useMemo, useState } from "react";
+
+const SHELL_PADDING_X = 8;
+
+interface ShellSizeContextValue {
+  width: number;
+  height: number;
+}
+
+export const ShellSizeContext = createContext<ShellSizeContextValue | null>(null);
+
+export const useShellSize = () => {
+  const ctx = use(ShellSizeContext);
+  if (!ctx) {
+    throw new Error(`${useShellSize.name} must be used within a ${ShellSizeProvider.name}`);
+  }
+  return ctx;
+};
+
+export function ShellSizeProvider({ children }: React.PropsWithChildren) {
+  const [size, setSize] = useState({
+    columns: process.stdout.columns - SHELL_PADDING_X,
+    rows: process.stdout.rows,
+  });
+
+  const handleResize = useCallback(() => {
+    setSize({
+      columns: process.stdout.columns - SHELL_PADDING_X,
+      rows: process.stdout.rows,
+    });
+  }, []);
+
+  useLayoutEffect(() => {
+    process.stdout.on("resize", handleResize);
+    return () => {
+      process.stdout.off("resize", handleResize);
+    };
+  }, [handleResize]);
+
+  const value = useMemo<ShellSizeContextValue>(
+    () => ({
+      width: size.columns,
+      height: size.rows,
+    }),
+    [size.columns, size.rows],
+  );
+
+  return <ShellSizeContext.Provider value={value}>{children}</ShellSizeContext.Provider>;
+}

package/src/context/shell-title.tsx

@@ -0,0 +1,38 @@
+import { createContext, useCallback, use } from "react";
+
+import { useCleanup } from "../hooks/use-cleanup.js";
+import { ANSI } from "../lib/ansi.js";
+
+interface ShellTitleContextValue {
+  setTitle: (title: string) => void;
+}
+
+const ShellTitleContext = createContext<ShellTitleContextValue | null>(null);
+
+export const useShellTitle = () => {
+  const ctx = use(ShellTitleContext);
+  if (!ctx) {
+    throw new Error(`${useShellTitle.name} must be used within a ${ShellTitleProvider.name}`);
+  }
+  return ctx;
+};
+
+export function ShellTitleProvider({ children }: React.PropsWithChildren) {
+  const setTitle = useCallback((title: string) => {
+    // Remove C0 control characters (U+0000-U+001F) and DEL (U+007F)
+    const cleanedTitle = title
+      .split("")
+      .filter((ch) => {
+        const code = ch.codePointAt(0)!;
+        return !(code <= 0x1f || code === 0x7f);
+      })
+      .join("");
+    process.stdout.write(`${ANSI.SET_TITLE}${cleanedTitle}${ANSI.BEL}`);
+  }, []);
+
+  useCleanup(() => {
+    process.stdout.write(`${ANSI.SET_TITLE}${ANSI.BEL}`);
+  });
+
+  return <ShellTitleContext.Provider value={{ setTitle }}>{children}</ShellTitleContext.Provider>;
+}