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

package/src/hooks/use-models.ts

@@ -1,22 +0,0 @@
-import { AbacusClient, ILLMOption } from "@codellm/api";
-import { useSuspenseQuery } from "@tanstack/react-query";
-
-import { QueryKey } from "../lib/queries.js";
-
-export function useModels(apiClient: AbacusClient) {
-  return useSuspenseQuery<ILLMOption[]>({
-    queryKey: [QueryKey.Models],
-    queryFn: async () => {
-      try {
-        const response = await apiClient.listLLMModels();
-        return response?.result ?? [];
-      } catch {
-        return [];
-      }
-    },
-    staleTime: 5 * 60 * 1000,
-    retry: 1,
-    refetchOnMount: "always",
-    refetchOnWindowFocus: false,
-  });
-}

package/src/index.ts

@@ -1,217 +0,0 @@
-#!/usr/bin/env node
-
-import { AbacusClient } from "@codellm/api";
-export type { AbacusClient };
-import { AuthManager } from "@codellm/auth";
-import { product } from "@codellm/product";
-import chalk from "chalk";
-import { parseArgs } from "node:util";
-
-import packageJson from "@/package.json" with { type: "json" };
-
-import type { AgentArgs } from "./args.js";
-
-import { runPrintMode } from "./entrypoints/print-mode.js";
-import { runRepl } from "./entrypoints/repl.js";
-import { logger } from "./services/logger.js";
-import { gracefulExit } from "./terminal/exit.js";
-
-/**
- * Centralized error handling function
- */
-function handleError(message: string, exitCode = 1): never {
-  console.error(chalk.red(message));
-  gracefulExit(exitCode);
-  throw new Error(message);
-}
-
-/**
- * Validates URL format and returns a new URL instance
- */
-function validateUrl(urlString: string): URL {
-  try {
-    return new URL(urlString);
-  } catch {
-    handleError(`Invalid ${product.envPrefix}BASE_URL: ${urlString}`);
-  }
-}
-
-/**
- * Validates agent arguments for print mode requirements
- */
-function validatePrintModeArgs(agentArgs?: AgentArgs): void {
-  const hasFormatFlags = agentArgs?.["output-format"] || agentArgs?.["input-format"];
-  if (hasFormatFlags && !agentArgs?.print) {
-    handleError("--output-format and --input-format flags can only be used with --print mode");
-  }
-}
-
-/**
- * Reads input from stdin asynchronously
- */
-async function readStdinInput(): Promise<string> {
-  const stdin = process.stdin;
-
-  if (stdin.isTTY) {
-    handleError(
-      "No prompt provided and no piped input detected. Either provide a prompt or pipe input.",
-    );
-  }
-
-  let inputData = "";
-  for await (const chunk of stdin) {
-    inputData += chunk;
-  }
-
-  const trimmed = inputData.trim();
-  if (!trimmed) {
-    handleError("No input provided");
-  }
-
-  return trimmed;
-}
-
-/**
- * Resolves the input prompt from args or stdin
- */
-async function resolveInputPrompt(agentArgs?: AgentArgs): Promise<string> {
-  if (agentArgs?.prompt) {
-    return agentArgs.prompt;
-  }
-  return readStdinInput();
-}
-
-/**
- * Configures API client with custom base URL if provided
- */
-async function configureApiClient(apiClient: AbacusClient): Promise<void> {
-  const baseUrl = process.env[`${product.envPrefix}BASE_URL`];
-  if (!baseUrl) {
-    return;
-  }
-
-  validateUrl(baseUrl);
-  apiClient.setUrl(baseUrl);
-  apiClient.resetEndpoints();
-  await apiClient.getApiEndpoint();
-}
-
-/**
- * Resolve --resume <id> or --continue into a conversation ID.
- * --resume uses the provided ID directly.
- * --continue fetches the most recently updated conversation from the API.
- */
-async function resolveConversationId(
-  agentArgs: AgentArgs | undefined,
-  apiClient: AbacusClient,
-): Promise<string | undefined> {
-  if (agentArgs?.resume) {
-    return agentArgs.resume;
-  }
-  if (agentArgs?.continue) {
-    try {
-      const result = await apiClient.getConversationsList(product.agentType);
-      const conversations = result?.result ?? [];
-      const latest = conversations.sort((a, b) => {
-        const aTime = a.lastEventCreatedAt ? new Date(a.lastEventCreatedAt).getTime() : 0;
-        const bTime = b.lastEventCreatedAt ? new Date(b.lastEventCreatedAt).getTime() : 0;
-        return bTime - aTime;
-      })[0];
-      return latest?.deploymentConversationId;
-    } catch {
-      // fall through — start fresh
-    }
-  }
-  return undefined;
-}
-
-async function main(agentArgs?: AgentArgs): Promise<void> {
-  if (agentArgs?.version) {
-    console.log(`Abacus.AI CLI version ${packageJson.version}`);
-    gracefulExit(0);
-    return;
-  }
-
-  validatePrintModeArgs(agentArgs);
-
-  if (agentArgs?.print) {
-    const inputPrompt = await resolveInputPrompt(agentArgs);
-    // For print mode the API client is created inside runPrintMode, so resolve
-    // conversation ID there — pass raw args through.
-    await runPrintMode({ agentArgs: { ...agentArgs, prompt: inputPrompt } });
-  } else {
-    const authManager = await AuthManager.create();
-
-    // Auth is fully managed by AuthManager.create() — no env access needed here.
-
-    const cliLogger = {
-      error: (message: string | Error, ...args: unknown[]) => logger.error(message, ...args),
-      debug: (...message: unknown[]) => logger.debug(...message),
-      warn: (message: string, ...args: unknown[]) => logger.warn(message, ...args),
-    };
-
-    const apiClient = new AbacusClient(authManager, cliLogger);
-
-    await configureApiClient(apiClient);
-
-    // Resolve --resume / --continue into a single conversationId before dispatch.
-    // Downstream consumers (AgentProvider) read agentArgs.conversationId — they
-    // don't know or care how it was resolved.
-    const conversationId = await resolveConversationId(agentArgs, apiClient);
-    const resolvedArgs: AgentArgs = { ...agentArgs, ...(conversationId && { conversationId }) };
-
-    await runRepl({
-      apiClient,
-      authManager,
-      agentArgs: resolvedArgs,
-    });
-  }
-}
-
-const HELP_TEXT = `
-Usage: abacus [options] [prompt]
-
-Options:
-  --help                          Show this help message
-  --version                       Show version number
-  --model <model>                 Model to use (-m)
-  --print                         Print mode, non-interactive (-p)
-  --resume <id>                   Resume a specific conversation by ID
-  --continue                      Continue the most recent conversation (-c)
-  --output-format <format>        Output format: text (default), stream-json
-  --auto-accept-edits             Automatically accept edits
-  --dangerously-skip-permissions  Skip permission checks
-  --plan-mode                     Enable plan mode
-`.trim();
-
-const { values, positionals } = parseArgs({
-  options: {
-    help: { type: "boolean", short: "h" },
-    version: { type: "boolean", short: "v" },
-    model: { type: "string", short: "m" },
-    print: { type: "boolean", short: "p" },
-    resume: { type: "string" },
-    continue: { type: "boolean", short: "c" },
-    "output-format": { type: "string" },
-    "input-format": { type: "string" },
-    "allow-editing": { type: "string" },
-    "auto-accept-edits": { type: "boolean" },
-    "dangerously-skip-permissions": { type: "boolean" },
-    "plan-mode": { type: "boolean" },
-  },
-  allowPositionals: true,
-  strict: true,
-});
-
-if (values.help) {
-  console.log(HELP_TEXT);
-  process.exit(0);
-}
-
-main({
-  ...values,
-  prompt: positionals.length > 0 ? positionals.join(" ") : null,
-}).catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/src/lib/__tests__/ansi.test.ts

@@ -1,255 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  ANSI,
-  osc9,
-  osc777,
-  osc99,
-  osc9Progress,
-  osc1337ProgressClear,
-  osc1337ProgressState,
-  osc1337ProgressPercent,
-  ansiRegex,
-  stripAnsi,
-} from "../ansi.js";
-
-describe.concurrent("ansi", () => {
-  describe.concurrent("ANSI enum", () => {
-    it("should have correct escape character", () => {
-      expect(ANSI.ESC).toBe("\x1b");
-    });
-
-    it("should have correct bell character", () => {
-      expect(ANSI.BEL).toBe("\x07");
-    });
-
-    it("should have correct string terminator", () => {
-      expect(ANSI.ST).toBe("\x1b\\");
-    });
-
-    it("should construct focus reporting sequences correctly", () => {
-      expect(ANSI.ENABLE_FOCUS_REPORTING).toBe("\x1b[?1004h");
-      expect(ANSI.DISABLE_FOCUS_REPORTING).toBe("\x1b[?1004l");
-      expect(ANSI.FOCUS_IN).toBe("\x1b[I");
-      expect(ANSI.FOCUS_OUT).toBe("\x1b[O");
-    });
-
-    it("should construct cursor sequences correctly", () => {
-      expect(ANSI.SHOW_CURSOR).toBe("\x1b[?25h");
-      expect(ANSI.HIDE_CURSOR).toBe("\x1b[?25l");
-    });
-
-    it("should construct reset sequences correctly", () => {
-      expect(ANSI.RESET_SGR).toBe("\x1b[0m");
-      expect(ANSI.SOFT_RESET).toBe("\x1b[!p");
-      expect(ANSI.HARD_RESET).toBe("\x1bc");
-    });
-
-    it("should construct paste mode sequences correctly", () => {
-      expect(ANSI.ENABLE_BRACKETED_PASTE).toBe("\x1b[?2004h");
-      expect(ANSI.DISABLE_BRACKETED_PASTE).toBe("\x1b[?2004l");
-      expect(ANSI.PASTE_MODE_PREFIX).toBe("\x1b[200~");
-      expect(ANSI.PASTE_MODE_SUFFIX).toBe("\x1b[201~");
-    });
-
-    it("should construct style sequences correctly", () => {
-      expect(ANSI.DIM).toBe("\x1b[2m");
-      expect(ANSI.BOLD).toBe("\x1b[1m");
-    });
-  });
-
-  describe.concurrent("osc9", () => {
-    it("should format OSC 9 notification correctly", () => {
-      const result = osc9("test message");
-      expect(result).toBe("\x1b]9;\n\ntest message\x07");
-    });
-
-    it("should handle empty message", () => {
-      const result = osc9("");
-      expect(result).toBe("\x1b]9;\n\n\x07");
-    });
-  });
-
-  describe.concurrent("osc777", () => {
-    it("should format OSC 777 notification correctly", () => {
-      const result = osc777("Title", "Body");
-      expect(result).toBe("\x1b]777;notify;Title;Body\x07");
-    });
-
-    it("should handle empty title and body", () => {
-      const result = osc777("", "");
-      expect(result).toBe("\x1b]777;notify;;\x07");
-    });
-  });
-
-  describe.concurrent("osc99", () => {
-    it("should format OSC 99 notification correctly", () => {
-      // Mock Math.random to get predictable notification ID
-      const mockRandom = vi.spyOn(Math, "random").mockReturnValue(0.1234);
-      const result = osc99("Title", "Body");
-
-      // Should contain title and body parts
-      expect(result).toContain("]99;i=1234:d=0:p=title;Title\x1b\\");
-      expect(result).toContain("]99;i=1234:p=body;Body\x1b\\");
-      expect(result).toContain("]99;i=1234:d=1:a=focus;\x1b\\");
-
-      mockRandom.mockRestore();
-    });
-  });
-
-  describe.concurrent("osc9Progress", () => {
-    it("should format progress with state 0 (hide)", () => {
-      const result = osc9Progress(0);
-      expect(result).toBe("\x1b]9;4;0;0\x07\x1b]9;4;0;0\x1b\\");
-    });
-
-    it("should format progress with state 1 and percentage", () => {
-      const result = osc9Progress(1, 50);
-      expect(result).toBe("\x1b]9;4;1;50\x07\x1b]9;4;1;50\x1b\\");
-    });
-
-    it("should clamp progress to 0-100", () => {
-      expect(osc9Progress(1, -10)).toBe("\x1b]9;4;1;0\x07\x1b]9;4;1;0\x1b\\");
-      expect(osc9Progress(1, 150)).toBe("\x1b]9;4;1;100\x07\x1b]9;4;1;100\x1b\\");
-    });
-
-    it("should round progress values", () => {
-      expect(osc9Progress(1, 50.7)).toBe("\x1b]9;4;1;51\x07\x1b]9;4;1;51\x1b\\");
-    });
-  });
-
-  describe.concurrent("osc1337ProgressClear", () => {
-    it("should clear progress indicator", () => {
-      const result = osc1337ProgressClear();
-      expect(result).toBe("\x1b]1337;Progress=\x07\x1b]1337;Progress=\x1b\\");
-    });
-  });
-
-  describe.concurrent("osc1337ProgressState", () => {
-    it("should set progress state 0", () => {
-      const result = osc1337ProgressState(0);
-      expect(result).toBe("\x1b]1337;Progress=0\x07\x1b]1337;Progress=0\x1b\\");
-    });
-
-    it("should set progress state 1", () => {
-      const result = osc1337ProgressState(1);
-      expect(result).toBe("\x1b]1337;Progress=1\x07\x1b]1337;Progress=1\x1b\\");
-    });
-
-    it("should set progress state 2", () => {
-      const result = osc1337ProgressState(2);
-      expect(result).toBe("\x1b]1337;Progress=2\x07\x1b]1337;Progress=2\x1b\\");
-    });
-  });
-
-  describe.concurrent("osc1337ProgressPercent", () => {
-    it("should format progress with percentage only", () => {
-      const result = osc1337ProgressPercent(50);
-      expect(result).toBe("\x1b]1337;Progress=50\x07\x1b]1337;Progress=50\x1b\\");
-    });
-
-    it("should format progress with percentage and message", () => {
-      const result = osc1337ProgressPercent(75, "Loading...");
-      expect(result).toContain("]1337;Progress=75;Loading...\x07");
-      expect(result).toContain("]1337;Progress=message=Loading...;percent=75\x07");
-    });
-
-    it("should clamp percentage to 0-100", () => {
-      expect(osc1337ProgressPercent(-10)).toBe(
-        "\x1b]1337;Progress=0\x07\x1b]1337;Progress=0\x1b\\",
-      );
-      expect(osc1337ProgressPercent(150)).toBe(
-        "\x1b]1337;Progress=100\x07\x1b]1337;Progress=100\x1b\\",
-      );
-    });
-
-    it("should round percentage values", () => {
-      expect(osc1337ProgressPercent(50.7)).toBe(
-        "\x1b]1337;Progress=51\x07\x1b]1337;Progress=51\x1b\\",
-      );
-    });
-
-    it("should sanitize message content", () => {
-      const result = osc1337ProgressPercent(50, "test\x1b\x07\n\r;message");
-      // The sanitized message should not contain control chars or semicolons
-      // (they're replaced/removed in the message part, but \x1b is still in OSC wrapper)
-      expect(result).toContain("test  :message"); // \x1b and \x07 removed, \n\r become spaces, ; becomes :
-      // The message part should not have raw control characters
-      const messagePart = result.match(
-        new RegExp("Progress=\\d+;(.+?)[" + String.fromCharCode(7) + String.fromCharCode(27) + "]"),
-      )?.[1];
-      expect(messagePart).not.toContain("\x07");
-      expect(messagePart).not.toContain("\n");
-      expect(messagePart).not.toContain("\r");
-      expect(messagePart).not.toContain(";"); // Should be replaced with :
-    });
-
-    it("should truncate long messages", () => {
-      const longMessage = "a".repeat(200);
-      const result = osc1337ProgressPercent(50, longMessage);
-      // Message is truncated to 120 chars, but result includes OSC sequences
-      // Extract the message part to verify truncation
-      const messagePart = result.match(
-        new RegExp("Progress=\\d+;(.+?)[" + String.fromCharCode(7) + String.fromCharCode(27) + "]"),
-      )?.[1];
-      expect(messagePart?.length).toBeLessThanOrEqual(120);
-    });
-  });
-
-  describe.concurrent("ansiRegex", () => {
-    it("should match ANSI escape sequences", () => {
-      const regex = ansiRegex();
-      expect("\x1b[31mtest\x1b[0m".match(regex)).toHaveLength(2);
-    });
-
-    it("should match OSC sequences", () => {
-      const regex = ansiRegex();
-      expect("\x1b]0;title\x07".match(regex)).toHaveLength(1);
-    });
-
-    it("should match only first occurrence when onlyFirst is true", () => {
-      const regex = ansiRegex({ onlyFirst: true });
-      const matches = "\x1b[31mtest\x1b[0m".match(regex);
-      expect(matches).toHaveLength(1);
-    });
-
-    it("should match all occurrences when onlyFirst is false", () => {
-      const regex = ansiRegex({ onlyFirst: false });
-      const matches = "\x1b[31mtest\x1b[0m".match(regex);
-      expect(matches).toHaveLength(2);
-    });
-  });
-
-  describe.concurrent("stripAnsi", () => {
-    it("should strip ANSI codes from string", () => {
-      expect(stripAnsi("\x1b[31mtest\x1b[0m")).toBe("test");
-    });
-
-    it("should handle strings without ANSI codes", () => {
-      expect(stripAnsi("plain text")).toBe("plain text");
-    });
-
-    it("should handle empty strings", () => {
-      expect(stripAnsi("")).toBe("");
-    });
-
-    it("should throw error for non-string input", () => {
-      expect(() => stripAnsi(null as unknown as string)).toThrow(
-        "Expected a `string`, got `object`",
-      );
-      expect(() => stripAnsi(123 as unknown as string)).toThrow(
-        "Expected a `string`, got `number`",
-      );
-    });
-
-    it("should strip multiple ANSI codes", () => {
-      expect(stripAnsi("\x1b[31mred\x1b[0m \x1b[32mgreen\x1b[0m")).toBe("red green");
-    });
-
-    it("should strip OSC sequences", () => {
-      expect(stripAnsi("\x1b]0;title\x07")).toBe("");
-    });
-  });
-});

package/src/lib/__tests__/cli.test.ts

@@ -1,122 +0,0 @@
-// @vitest-environment node
-
-import { describe, expect, it } from "vitest";
-
-import { runCli } from "../cli.js";
-
-// TODO: The runCli function doesn't handle spawn errors (ENOENT).
-// When a non-existent command is spawned, the error is emitted asynchronously
-// and not caught by the generator, causing unhandled promise rejections.
-// Consider adding error handling to runCli to catch and handle spawn errors
-// (e.g., proc.on('error', ...) to yield error information or throw).
-
-describe.concurrent("cli", () => {
-  describe.concurrent("runCli", () => {
-    it("should yield output from stdout", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args = ["hello world"];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // On Unix, echo outputs to stdout; on Windows, we might need different handling
-      // The output might include newlines, so we check if it contains our message
-      // Should have received some output
-      expect(outputs.length).toBeGreaterThanOrEqual(0);
-    }, 10000);
-
-    it("should yield output from stderr", async () => {
-      // Use a command that outputs to stderr
-      const command = process.platform === "win32" ? "cmd" : "sh";
-      const args =
-        process.platform === "win32" ? ["/c", "echo error >&2"] : ["-c", "echo error >&2"];
-
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should have received some output
-      expect(outputs.length).toBeGreaterThanOrEqual(0);
-    }, 10000);
-
-    it("should handle commands that exit immediately", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args = ["test"];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should complete without hanging
-      expect(true).toBe(true);
-    }, 10000);
-
-    it("should handle empty args array", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args: string[] = [];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should complete without error
-      expect(true).toBe(true);
-    }, 10000);
-
-    it("should handle multiple output chunks", async () => {
-      // Use a command that outputs multiple lines
-      const command = process.platform === "win32" ? "echo" : "printf";
-      const args =
-        process.platform === "win32"
-          ? ["line1\nline2\nline3"]
-          : ["%s\n%s\n%s\n", "line1", "line2", "line3"];
-
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should have received output
-      expect(outputs.length).toBeGreaterThanOrEqual(0);
-    }, 10000);
-
-    it("should terminate process on completion", async () => {
-      const command = process.platform === "win32" ? "echo" : "echo";
-      const args = ["test"];
-
-      // This test verifies the process is cleaned up
-      // We can't easily verify the process is killed, but we can verify
-      // the generator completes
-      const generator = runCli(command, args);
-      const outputs: string[] = [];
-
-      for await (const output of generator) {
-        outputs.push(output);
-      }
-
-      // Generator should complete
-      expect(true).toBe(true);
-    }, 10000);
-
-    it("should work with different command types", async () => {
-      // Test with a simple command available on most systems
-      const command = process.platform === "win32" ? "where" : "which";
-      const args = process.platform === "win32" ? ["echo"] : ["echo"];
-      const outputs: string[] = [];
-
-      for await (const output of runCli(command, args)) {
-        outputs.push(output);
-      }
-
-      // Should complete without error
-      expect(true).toBe(true);
-    }, 10000);
-  });
-});