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

package/src/context/agent-mode.tsx

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

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

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

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

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

@@ -1,38 +0,0 @@
-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>;
-}