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

package/src/hooks/use-models.ts

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

@@ -0,0 +1,217 @@
+#!/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

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

@@ -0,0 +1,122 @@
+// @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);
+  });
+});