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

package/src/__e2e__/file-creation.e2e.test.tsx

@@ -1,149 +0,0 @@
-import React from "react";
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-import { stripAnsi } from "../lib/ansi.js";
-import { sleep } from "../lib/utils.js";
-import { renderWithProviders, waitForFrame } from "./helpers/test-helpers.js";
-
-// Mock the shell-size context to provide consistent terminal dimensions in tests
-vi.mock("../context/shell-size.js", async () => {
-  const { createContext } = await import("react");
-  const ShellSizeContext = createContext<{ width: number; height: number } | null>({
-    width: 120,
-    height: 40,
-  });
-  return {
-    ShellSizeContext,
-    ShellSizeProvider: ({ children }: { children: React.ReactNode }) => children,
-    useShellSize: () => ({ width: 120, height: 40 }),
-  };
-});
-
-import { simulateText, simulateEnter, simulateKeypress } from "./helpers/test-helpers.js";
-
-describe.sequential("File Creation Permission E2E Tests", () => {
-  beforeEach(() => {
-    vi.spyOn(process, "exit").mockImplementation(() => {
-      throw new Error("process.exit called");
-    });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("should show file creation permission dialog with options", async () => {
-    const { App } = await import("../entrypoints/repl.js");
-    const { Timing } = await import("../lib/timing.js");
-
-    const timing = new Timing();
-
-    const { lastFrame, stdin, unmount } = renderWithProviders(React.createElement(App, { timing }));
-
-    // Wait for FULL TUI to render - look for the input prompt indicator
-    await waitForFrame(
-      lastFrame,
-      (frame) => {
-        const plain = stripAnsi(frame);
-        return plain.includes("for shortcuts") || plain.includes("shift+tab");
-      },
-      30000,
-    );
-    await sleep(100);
-
-    // Type the message using jar's stdin.write()
-    const message = "Create a helloWorld.py file";
-    simulateText(stdin, message);
-    await waitForFrame(lastFrame, (frame) => stripAnsi(frame).includes("helloWorld.py"), 5000);
-
-    simulateEnter(stdin);
-
-    // Wait for the permission dialog to appear (increase timeout for CI)
-    // The mock has a 2500ms delay before sending the tool request
-    // IMPORTANT: Only wait for '1. Yes' which is unique to the permission dialog
-    // Do NOT use 'helloWorld.py' as that matches the user's input message too early
-    await waitForFrame(
-      lastFrame,
-      (frame) => {
-        const plain = stripAnsi(frame);
-        return plain.includes("1. Yes") || plain.includes("Tab to add additional instructions");
-      },
-      60000,
-    );
-
-    let frame = stripAnsi(lastFrame() || "");
-    expect(frame).toContain("helloWorld.py");
-    expect(frame).toContain("1. Yes");
-    expect(frame).toContain("2. Yes, and enable auto-edit mode");
-    expect(frame).toContain("3. No");
-    expect(frame).toContain("Tab to add additional instructions");
-    expect(frame).toMatch(/Esc to (reject|cancel)/);
-
-    // Press Enter to accept
-    simulateEnter(stdin);
-    await sleep(100);
-
-    unmount();
-  }, 120000);
-
-  it("should allow adding instructions via Tab key", async () => {
-    const { App } = await import("../entrypoints/repl.js");
-    const { Timing } = await import("../lib/timing.js");
-
-    const timing = new Timing();
-
-    const { lastFrame, stdin, unmount } = renderWithProviders(React.createElement(App, { timing }));
-
-    // Wait for FULL TUI to render - look for the input prompt indicator
-    await waitForFrame(
-      lastFrame,
-      (frame) => {
-        const plain = stripAnsi(frame);
-        return plain.includes("for shortcuts") || plain.includes("shift+tab");
-      },
-      30000,
-    );
-    await sleep(100);
-
-    simulateText(stdin, "Create a helloWorld.py file");
-    await waitForFrame(lastFrame, (frame) => stripAnsi(frame).includes("helloWorld.py"), 5000);
-
-    simulateEnter(stdin);
-
-    // Wait for the permission dialog to appear (increase timeout for CI)
-    // The mock has a 2500ms delay before sending the tool request
-    // IMPORTANT: Only wait for permission dialog text, not 'helloWorld.py' which matches user input
-    await waitForFrame(
-      lastFrame,
-      (frame) => {
-        const plain = stripAnsi(frame);
-        return plain.includes("Tab to add additional instructions");
-      },
-      60000,
-    );
-
-    let frame = stripAnsi(lastFrame() || "");
-    expect(frame).toContain("helloWorld.py");
-    expect(frame).toContain("Tab to add additional instructions");
-
-    simulateKeypress(stdin, "\t");
-    await waitForFrame(
-      lastFrame,
-      (f) => stripAnsi(f).includes("Type here to tell AbacusAI what to do differently"),
-      5000,
-    );
-
-    frame = stripAnsi(lastFrame() || "");
-    expect(frame).toContain("Type here to tell AbacusAI what to do differently");
-
-    simulateText(stdin, "its good");
-    await waitForFrame(lastFrame, (f) => stripAnsi(f).includes("1. Yes, its good"), 5000);
-
-    frame = stripAnsi(lastFrame() || "");
-    expect(frame).toContain("1. Yes, its good");
-    expect(frame).not.toContain("Tab to add additional instructions");
-    expect(frame).toMatch(/Esc to (reject|cancel)/);
-
-    unmount();
-  }, 120000);
-});

package/src/__e2e__/helpers/test-helpers.ts

@@ -1,449 +0,0 @@
-import type { ClientLogger, HeadersProvider } from "@codellm/api";
-
-import { AbacusClient, type SSEEvent } from "@codellm/api";
-import { AuthManager } from "@codellm/auth";
-import { renderForTest } from "@codellm/jar";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import React, { type ReactElement } from "react";
-import { vi, type Mock } from "vitest";
-
-/** Maps each function property of T to Mock<fn>, keeping non-function props as-is. */
-type MockOf<T> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? Mock<T[K]> : T[K];
-};
-
-import type {
-  FileSystemTools,
-  ITerminalService,
-  IAbacusBrowserService,
-  ICommand,
-  ICommandResult,
-} from "../../lib/types.js";
-import type { ToolExecutionContext } from "../../tools/types.ts";
-
-import { AgentMode } from "../../components/composer/types.ts";
-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 { ShellSizeContext } from "../../context/shell-size.js";
-import { ShellTitleProvider } from "../../context/shell-title.js";
-import { AgentProvider } from "../../providers/agent.js";
-import { ApiClientProvider } from "../../providers/api-client.js";
-import { ThemeProvider } from "../../theme/index.js";
-
-// MockShellSizeProvider for tests - provides consistent terminal dimensions via the real ShellSizeContext
-function MockShellSizeProvider({ children }: React.PropsWithChildren) {
-  const value = { width: 120, height: 40 };
-  return React.createElement(ShellSizeContext.Provider, { value }, children);
-}
-
-export interface E2ETestContext {
-  lastFrame: () => string;
-  stdin: {
-    write: (data: string) => void;
-  };
-  frames: string[];
-  unmount: () => void;
-}
-
-/**
- * Render a React element for E2E tests using jar's reconciler.
- * Returns a context with `lastFrame()`, `frames`, `stdin.write()`, and `unmount()`.
- */
-export function renderE2E(component: ReactElement): E2ETestContext {
-  return renderForTest(component);
-}
-
-/**
- * Render a React element wrapped in all required test providers (QueryClient, API client,
- * ShellSize, ShellTitle, Theme, Agent, etc.).
- *
- * Use this when testing components that rely on app-level contexts (e.g. App from repl.js),
- * instead of renderE2E() which does not supply any providers.
- *
- * @example
- * const { lastFrame, stdin, unmount } = renderWithProviders(
- *   React.createElement(App, { timing })
- * );
- */
-export function renderWithProviders(component: ReactElement): E2ETestContext {
-  const Wrapper = createTestWrapper();
-  return renderForTest(React.createElement(Wrapper, { children: component }));
-}
-
-export function simulateKeypress(stdin: { write: (data: string) => void }, key: string) {
-  stdin.write(key);
-}
-
-export function simulateEnter(stdin: { write: (data: string) => void }) {
-  stdin.write("\r");
-}
-
-export function simulateText(stdin: { write: (data: string) => void }, text: string) {
-  for (const char of text) {
-    stdin.write(char);
-  }
-}
-
-export function simulateCtrlC(stdin: { write: (data: string) => void }) {
-  stdin.write("\x03");
-}
-
-export function simulateEscape(stdin: { write: (data: string) => void }) {
-  stdin.write("\x1b");
-}
-
-export function simulateUpArrow(stdin: { write: (data: string) => void }) {
-  stdin.write("\x1b[A");
-}
-
-export function simulateDownArrow(stdin: { write: (data: string) => void }) {
-  stdin.write("\x1b[B");
-}
-
-export function simulateRightArrow(stdin: { write: (data: string) => void }) {
-  stdin.write("\x1b[C");
-}
-
-export function simulateLeftArrow(stdin: { write: (data: string) => void }) {
-  stdin.write("\x1b[D");
-}
-
-export function waitForFrame(
-  lastFrame: () => string,
-  predicate: (frame: string) => boolean,
-  timeout = 5000,
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-    const interval = setInterval(() => {
-      const frame = lastFrame();
-      if (predicate(frame)) {
-        clearInterval(interval);
-        resolve();
-      } else if (Date.now() - startTime > timeout) {
-        clearInterval(interval);
-        reject(new Error(`Timeout waiting for frame matching predicate. Last frame:\n${frame}`));
-      }
-    }, 50);
-  });
-}
-
-export function mockApiClient(): { chat: Mock; listModels: Mock } {
-  return {
-    chat: vi.fn().mockResolvedValue({
-      choices: [
-        {
-          message: {
-            content: "Mock response",
-          },
-        },
-      ],
-    }),
-    listModels: vi.fn().mockResolvedValue([{ id: "test-model", name: "Test Model" }]),
-  };
-}
-
-export function mockConfigService(): { get: Mock; set: Mock; has: Mock } {
-  return {
-    get: vi.fn().mockImplementation((key: string) => {
-      const config: Record<string, any> = {
-        apiKey: "test-api-key",
-        model: "test-model",
-      };
-      return config[key];
-    }),
-    set: vi.fn(),
-    has: vi.fn().mockReturnValue(true),
-  };
-}
-
-const mockHeadersProvider: HeadersProvider = {
-  getHeaders: vi.fn().mockResolvedValue({ APIKEY: "test-api-key" }),
-};
-
-const mockLogger: ClientLogger = {
-  error: vi.fn(),
-  debug: vi.fn(),
-  warn: vi.fn(),
-};
-
-export function createMockAbacusClient() {
-  const client = new AbacusClient(mockHeadersProvider, mockLogger);
-
-  client.getUserInfo = vi.fn().mockResolvedValue({ result: { email: "test@test.com" } });
-  client.getConversationsList = vi.fn().mockResolvedValue({ result: [] });
-  client.listExternalApplications = vi.fn().mockResolvedValue({ success: true, result: [] });
-  client.recordUserAction = vi.fn().mockResolvedValue({});
-  client.setUrl = vi.fn().mockResolvedValue(undefined);
-  client.setChatWebDomain = vi.fn().mockResolvedValue(undefined);
-  client.getChatWebDomain = vi.fn().mockResolvedValue(null);
-  client.clearDeploymentConversation = vi.fn().mockResolvedValue(null);
-  client.getCodeEdit = vi.fn().mockResolvedValue(null);
-  client.listLLMModels = vi.fn().mockResolvedValue(null);
-  client.getConstantsAutocomplete = vi.fn().mockResolvedValue(null);
-  client.getCodeAutocompleteResponse = vi.fn().mockResolvedValue(null);
-  client.getAutocompleteEditPrediction = vi.fn().mockResolvedValue(null);
-  client.resetEndpoints = vi.fn().mockResolvedValue(undefined);
-  client.getDeploymentConversation = vi
-    .fn()
-    .mockResolvedValue({ success: true, result: { history: [] } });
-  client.createCodellmDeploymentConversation = vi
-    .fn()
-    .mockResolvedValue({ success: true, result: { deploymentConversationId: "test-convo-id" } });
-
-  // Mock streamAgentMessage as an async generator that yields SSE events
-  // Use setTimeout delays to ensure React useEffect hooks have run first
-  client.streamAgentMessage = vi.fn().mockImplementation(function () {
-    async function* generate(): AsyncGenerator<SSEEvent> {
-      // Delay to ensure all React useEffect hooks have run
-      await new Promise((r) => setTimeout(r, 2000));
-
-      // First event: text segment
-      yield {
-        segment: "I will create a file helloWorld.py for you.",
-        counter: 1,
-        message_id: "test-message-id",
-      };
-
-      // Small delay to ensure proper processing
-      await new Promise((r) => setTimeout(r, 500));
-
-      // Second event: tool request
-      yield {
-        toolUseRequest: {
-          id: "tool-1",
-          type: "builtin",
-          name: "edit",
-          input: {
-            targetFile: "helloWorld.py",
-            codeEdit: 'print("Hello, World!")',
-            overwriteFile: true,
-            instructions: "Creating helloWorld.py file",
-          },
-        },
-        counter: 2,
-        message_id: "test-message-id",
-      };
-    }
-    return generate();
-  });
-
-  // Mock streamChatMessage as an async generator
-  client.streamChatMessage = vi.fn().mockImplementation(function () {
-    async function* generate(): AsyncGenerator<SSEEvent> {
-      await new Promise((r) => setTimeout(r, 2000));
-      yield {
-        segment: "I will create a file helloWorld.py for you.",
-        counter: 1,
-        message_id: "test-message-id",
-      };
-    }
-    return generate();
-  });
-
-  return client as AbacusClient & {
-    getUserInfo: Mock<typeof client.getUserInfo>;
-    getConversationsList: Mock<typeof client.getConversationsList>;
-    listExternalApplications: Mock<typeof client.listExternalApplications>;
-    recordUserAction: Mock<typeof client.recordUserAction>;
-    setUrl: Mock<typeof client.setUrl>;
-    setChatWebDomain: Mock<typeof client.setChatWebDomain>;
-    getChatWebDomain: Mock<typeof client.getChatWebDomain>;
-    clearDeploymentConversation: Mock<typeof client.clearDeploymentConversation>;
-    getCodeEdit: Mock<typeof client.getCodeEdit>;
-    listLLMModels: Mock<typeof client.listLLMModels>;
-    getConstantsAutocomplete: Mock<typeof client.getConstantsAutocomplete>;
-    getCodeAutocompleteResponse: Mock<typeof client.getCodeAutocompleteResponse>;
-    getAutocompleteEditPrediction: Mock<typeof client.getAutocompleteEditPrediction>;
-    resetEndpoints: Mock<typeof client.resetEndpoints>;
-    getDeploymentConversation: Mock<typeof client.getDeploymentConversation>;
-    createCodellmDeploymentConversation: Mock<typeof client.createCodellmDeploymentConversation>;
-    streamAgentMessage: Mock<typeof client.streamAgentMessage>;
-    streamChatMessage: Mock<typeof client.streamChatMessage>;
-  };
-}
-
-export function createMockNotificationService(): { error: ReturnType<typeof vi.fn> } {
-  return {
-    error: vi.fn(),
-  };
-}
-
-type MockToolExcecutionContext = Omit<
-  ToolExecutionContext,
-  "fileSystemTools" | "terminalService" | "abacusBrowserService" | "apiClient"
-> & {
-  fileSystemTools: ReturnType<typeof createMockFileSystemTools>;
-  terminalService: ReturnType<typeof createMockTerminalService>;
-  abacusBrowserService: ReturnType<typeof createMockBrowserService>;
-  apiClient: ReturnType<typeof createMockAbacusClient>;
-};
-
-export function createMockContext(
-  overrides?: Partial<MockToolExcecutionContext>,
-): MockToolExcecutionContext {
-  return {
-    fileSystemTools: createMockFileSystemTools(),
-    terminalService: createMockTerminalService(),
-    abacusBrowserService: createMockBrowserService(),
-    apiClient: createMockAbacusClient(),
-    mcpService: undefined,
-    extensionConnection: undefined,
-
-    abortController: new AbortController(),
-    workspacePath: "/test/workspace",
-    conversationId: "test-conversation",
-    agentMode: AgentMode.Normal,
-    toolCallId: "test-tool-call",
-    status: "pending",
-    vsCodeAppliedChanges: false,
-
-    uploadedDocs: new Set(),
-    allowEditingPaths: [],
-
-    addDiff: vi.fn().mockReturnValue(undefined),
-    onOutputUpdate: vi.fn().mockReturnValue(undefined),
-    ...overrides,
-  } satisfies MockToolExcecutionContext;
-}
-
-export function createMockAuthManager(): MockOf<HeadersProvider> {
-  return {
-    getHeaders: vi.fn().mockResolvedValue({ APIKEY: "test-api-key" }),
-  } satisfies HeadersProvider;
-}
-
-export function createMockFileSystemTools(): MockOf<FileSystemTools> {
-  return {
-    ls: vi.fn().mockResolvedValue(""),
-    mkdir: vi.fn().mockResolvedValue({ undo: vi.fn() }),
-    view: vi.fn().mockResolvedValue(""),
-    readRawFile: vi.fn().mockResolvedValue(""),
-    create: vi.fn().mockResolvedValue({ undo: vi.fn() }),
-    readFile: vi.fn().mockResolvedValue(""),
-    deleteFile: vi.fn().mockResolvedValue(undefined),
-    listDir: vi.fn().mockResolvedValue(""),
-    strReplace: vi.fn().mockResolvedValue({ undo: vi.fn() }),
-    grep: vi.fn().mockResolvedValue({
-      matches: [],
-      metadata: {
-        offset: 0,
-        limit: 0,
-        totalMatches: 0,
-        hasMore: false,
-      },
-    }),
-    grepFile: vi.fn().mockResolvedValue([]),
-    grepTextFile: vi.fn().mockResolvedValue([]),
-  } satisfies FileSystemTools;
-}
-
-type MockTerminalServiceOpts = {
-  executedCommand?: ICommand;
-  output?: ICommandResult[];
-};
-
-export function createMockTerminalService(
-  opts: MockTerminalServiceOpts = {},
-): MockOf<ITerminalService> {
-  return {
-    executeCommand: vi.fn().mockResolvedValue(
-      opts.executedCommand ?? {
-        result: {
-          get: vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 }),
-        },
-      },
-    ),
-    getOutput: vi.fn().mockReturnValue(opts.output ?? []),
-    stopCommand: vi.fn().mockResolvedValue(true),
-    closeTerminal: vi.fn().mockResolvedValue(undefined),
-    dispose: vi.fn(),
-  } satisfies ITerminalService;
-}
-
-export function createMockBrowserService(): MockOf<IAbacusBrowserService> {
-  return {
-    navigateTo: vi.fn().mockResolvedValue(undefined),
-    openTab: vi.fn().mockResolvedValue(1),
-    switchActiveTab: vi.fn().mockResolvedValue(undefined),
-    closeTab: vi.fn().mockResolvedValue(undefined),
-    refreshTab: vi.fn().mockResolvedValue(undefined),
-    getTabContent: vi.fn().mockResolvedValue({
-      text: "",
-      metadata: { offset: 0, limit: 0, totalLength: 0, hasMore: false },
-    }),
-    do: vi.fn().mockResolvedValue({ content: { text: "", images: [] } }),
-    getInteractiveElements: vi.fn().mockResolvedValue(""),
-    doOnElementId: vi.fn().mockResolvedValue({ content: { text: "", images: [] } }),
-  } satisfies IAbacusBrowserService;
-}
-
-export interface TestWrapperProps {
-  children: ReactElement;
-}
-
-export function createTestWrapper(): React.FC<TestWrapperProps> {
-  const queryClient = new QueryClient({
-    defaultOptions: {
-      queries: {
-        retry: false,
-      },
-    },
-  });
-  const apiClient = createMockAbacusClient();
-  // Create a minimal AuthManager-shaped mock for test contexts
-  const mockSecureStorage = {
-    getSecret: vi.fn().mockResolvedValue(null),
-    setSecret: vi.fn().mockResolvedValue(undefined),
-    deleteSecret: vi.fn().mockResolvedValue(undefined),
-  };
-  const mockAuthManager = new AuthManager(mockSecureStorage);
-
-  return function TestWrapper({ children }: TestWrapperProps) {
-    return React.createElement(
-      ThemeProvider,
-      null,
-      React.createElement(
-        ApiClientProvider,
-        { client: apiClient, authManager: mockAuthManager },
-        React.createElement(
-          QueryClientProvider,
-          { client: queryClient },
-          React.createElement(
-            MockShellSizeProvider,
-            null,
-            React.createElement(
-              ShellTitleProvider,
-              null,
-              React.createElement(
-                NotificationProvider,
-                null,
-                React.createElement(
-                  ExtensionFileProvider,
-                  null,
-                  React.createElement(
-                    NetworkActivityProvider,
-                    null,
-                    React.createElement(
-                      AgentModeProvider,
-                      null,
-                      React.createElement(
-                        AgentProvider,
-                        {
-                          apiClient,
-                        },
-                        children,
-                      ),
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-  };
-}

package/src/__e2e__/keyboard-navigation.e2e.test.tsx

@@ -1,34 +0,0 @@
-import React from "react";
-import { describe, it, expect } from "vitest";
-
-import { App } from "../entrypoints/repl.js";
-import { Timing } from "../lib/timing.js";
-import {
-  renderWithProviders,
-  simulateText,
-  simulateEscape,
-  waitForFrame,
-} from "./helpers/test-helpers.js";
-
-describe.concurrent("Keyboard Navigation E2E Tests", () => {
-  it("double ESC resets composer", async () => {
-    const timing = new Timing();
-
-    const { lastFrame, stdin, unmount } = renderWithProviders(React.createElement(App, { timing }));
-
-    await waitForFrame(lastFrame, (frame) => frame.length > 0, 5000);
-
-    simulateText(stdin, "Some text in composer");
-
-    const frameBeforeEsc = lastFrame();
-    expect(frameBeforeEsc.length).toBeGreaterThan(0);
-
-    simulateEscape(stdin);
-    simulateEscape(stdin);
-
-    const frameAfterEsc = lastFrame();
-    expect(frameAfterEsc.length).toBeGreaterThan(0);
-
-    unmount();
-  });
-});