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

package/src/entrypoints/print-mode.ts

@@ -0,0 +1,312 @@
+import { AgentMode, AgentSession, AutoAcceptProvider, PromptHistory } from "@codellm/agent";
+import { AbacusClient } from "@codellm/api";
+import { AuthManager } from "@codellm/auth";
+import { product } from "@codellm/product";
+
+import type { AgentArgs } from "../args.js";
+
+import { logger } from "../services/logger.js";
+import { onExit } from "../terminal/exit.js";
+
+async function createApiClient(): Promise<{ apiClient: AbacusClient; authManager: AuthManager }> {
+  const authManager = await AuthManager.create();
+  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),
+  };
+  return { apiClient: new AbacusClient(authManager, cliLogger), authManager };
+}
+
+/**
+ * Enhanced instructions for high quality / deep-agent mode.
+ */
+const HIGH_QUALITY_INSTRUCTIONS = `
+IMPORTANT INSTRUCTIONS: Your task is to follow the <task_description> EXACTLY and verify the solution within the FIXED TIME LIMIT.
+A few things to keep in mind (Add Relevant ONES BELOW AS TODOS):
+1. You are in a docker container without user interaction and fixed time limit. Assume HIGHEST permissions are available to the user.
+2. Check running servers in the docker container e.g. with \`ps aux | grep python\` and \`docker ps -a\`
+3. If the task requires a server to run in the background, use \`nohup\` to start it so that tests can access it.
+4. Check the installed packages with \`pip list\`. Use already installed packages unless explicity mentioned to install new ones in the task_description.
+5. Extract ALL filenames and IMPORTANT KEYWORDS mentioned in the task description.
+6. Extract EVERY specific constraint (versions, paths, file locations, values) and list them as checkable assertions
+7. Check all files and folders in the current directory with \`find . -type f \\( -name "*.py" -o -name "*.pyx" -o -name "*.pxd" -o -name "*.txt" \\) | head -20\`
+8. When file names are not specified in the task description, use generic names like app.py etc.
+9. Do NOT do manual conflict resolution when merging files.
+10. When working with .ppm files, Do NOT use \`head -20\` or similar commands with .ppm files
+11. For counting tokens, check both deepseek_solution and deepseek_reasoning and tokenize both separately when asked about deepseek
+12. *CRITICAL*: Write a test script to validate ALL THE CONSTRAINTS, ALL THE POSSIBLE CASES AND SCENARIOS AND REQUIREMENTS for the task and MAKE SURE THEY PASS before declaring COMPLETION. IF ANY FAIL, DEBUG AND FIX AND DO NOT STOP UNTIL ALL TESTS PASS. ** VERY CRITICAL **: Your test scripts must invoke tools/binaries EXACTLY as specified in the task requirements
+13. Follow task instructions precisely, especially file paths and naming conventions specified.
+14. When creating the tar archive, ensure that when it's later extracted, the files will be found at the exact same absolute paths they currently exist at in the filesystem. The archive structure must preserve the full directory hierarchy for validation.
+15. BEFORE claiming completion:
+     - STOP and re-read the FULL ORIGINAL task description
+     - For EACH constraint you listed in step 3:
+       a. Run a command to CHECK it
+       b. Record the actual result
+       c. Compare to expected result
+     - Create a validation table:
+       | Requirement | Expected | Actual | Pass/Fail |
+     - If ANY constraint fails: web_search for correct examples before proceeding AND FIX IT. Do not declare success.
+Follow TASK instructions EXACTLY. Do NOT take shortcuts that bypass task requirements. Add "Re-read ALL requirements from task description and CONFIRM they are met" 2 times to the list of todos.`;
+
+/** Write a JSON line to stdout (stream-json format). */
+function emitJson(obj: Record<string, unknown>): void {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+
+/**
+ * Authenticate for print mode: env vars first, then stored credentials.
+ */
+async function handleAuth(authManager: AuthManager, apiClient: AbacusClient): Promise<void> {
+  // Env-based auth (ephemeral) or stored credentials are both valid
+  if (authManager.isAuthenticated()) return;
+
+  try {
+    const userInfo = await apiClient.getUserInfo();
+    if (userInfo?.result?.email) return;
+  } catch {
+    // not authenticated
+  }
+
+  console.error(
+    `Error: Not authenticated. Please set ${product.envPrefix}API_KEY environment variable.`,
+  );
+  console.error("You can obtain your API key by visiting: https://abacus.ai/app/abacusai-cli");
+  console.error(
+    `\nUsage: ${product.envPrefix}API_KEY=your_key_here abacusai --print "your prompt"`,
+  );
+  process.exit(1);
+}
+
+/**
+ * Fuzzy model name matching.
+ */
+function findBestMatchingModel(
+  models: { name?: string; llmName: string }[],
+  requested: string,
+): string | null {
+  const getFuzzyScore = (modelName: string): number => {
+    const name = modelName.toLowerCase();
+    if (name === requested) return 1000;
+    if (name.startsWith(requested)) return 900;
+    let score = 0;
+    let lastIndex = -1;
+    for (const char of requested) {
+      const index = name.indexOf(char, lastIndex + 1);
+      if (index === -1) return 0;
+      score += 100 - (index - lastIndex);
+      lastIndex = index;
+    }
+    score += Math.max(0, 50 - name.length);
+    return score;
+  };
+  let bestMatch: string | null = null;
+  let bestScore = 0;
+  for (const model of models) {
+    const score = Math.max(getFuzzyScore(model.name ?? ""), getFuzzyScore(model.llmName));
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = model.llmName;
+    }
+  }
+  return bestScore >= 100 ? bestMatch : null;
+}
+
+async function selectModel(apiClient: AbacusClient, requestedModel?: string): Promise<string> {
+  const modelsResponse = await apiClient.listLLMModels();
+  const models = modelsResponse?.result ?? [];
+
+  if (!models.length) {
+    console.error("Error: No models available. Check your API key and connection.");
+    process.exit(1);
+  }
+
+  if (!requestedModel) return models[0].llmName;
+
+  const match = findBestMatchingModel(models, requestedModel.toLowerCase());
+  if (!match) {
+    console.error(
+      `Warning: Model "${requestedModel}" not found. Using default: ${models[0].llmName}`,
+    );
+    return models[0].llmName;
+  }
+  return match;
+}
+
+/**
+ * Resolve the startup conversation ID from --resume / --continue flags.
+ */
+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("CODE_LLM_AGENT");
+      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 a new conversation
+    }
+  }
+  return agentArgs?.conversationId;
+}
+
+/**
+ * Print mode: run headlessly, stream events per output format, always Yolo.
+ */
+export async function runPrintMode({ agentArgs }: { agentArgs?: AgentArgs }): Promise<void> {
+  const { apiClient, authManager } = await createApiClient();
+
+  await handleAuth(authManager, apiClient);
+
+  // Configure custom base URL if provided
+  const baseUrl = process.env[`${product.envPrefix}BASE_URL`];
+  if (baseUrl) {
+    try {
+      new URL(baseUrl);
+    } catch {
+      console.error(`Invalid ${product.envPrefix}BASE_URL: ${baseUrl}`);
+      process.exit(1);
+    }
+    apiClient.setUrl(baseUrl);
+    apiClient.resetEndpoints();
+    await apiClient.getApiEndpoint();
+  }
+
+  const cwd = process.cwd();
+  const outputFormat = agentArgs?.["output-format"] ?? "text";
+  const model = await selectModel(apiClient, agentArgs?.model);
+
+  const session = new AgentSession({
+    allowedDirectories: [cwd],
+    primaryWorkspace: cwd,
+    apiClient,
+    mode: AgentMode.Yolo,
+    model,
+    permissionProvider: new AutoAcceptProvider(),
+    isPrintMode: true,
+    enablePromptRewrite: false,
+    supportsThoughtStreaming: true,
+  });
+
+  // Register graceful Ctrl+C handler
+  onExit(
+    async () => {
+      session.stop();
+      await new Promise((r) => setTimeout(r, 200));
+    },
+    { wait: 1000 },
+  );
+
+  // Resolve startup conversation from --resume / --continue flags
+  const startupConversationId = await resolveConversationId(agentArgs, apiClient);
+  if (startupConversationId) {
+    await session.loadConversation(startupConversationId);
+  }
+
+  let userMessage = agentArgs?.prompt ?? "";
+  if (process.env.DEEPAGENT_HIGH_QUALITY === "true") {
+    userMessage = `${HIGH_QUALITY_INSTRUCTIONS}\nThis is the task description: <task_description>${userMessage}</task_description>`;
+  }
+
+  // Print startup header to stderr (not stdout, to keep stdout clean for piping)
+  const convLabel = startupConversationId
+    ? `conversation: ${startupConversationId}`
+    : "conversation: new";
+  process.stderr.write(`model: ${model} | cwd: ${cwd} | ${convLabel}\n`);
+
+  // Record in prompt history
+  const promptHistory = new PromptHistory("cli-print");
+  await promptHistory.load();
+  promptHistory.append(userMessage);
+
+  // Accumulate text and thinking for grouped output
+  let accumulatedText = "";
+  let accumulatedThinking = "";
+
+  // Stream agent events
+  for await (const event of session.send(userMessage)) {
+    switch (event.type) {
+      case "text_delta":
+        accumulatedText += event.content;
+        break;
+
+      case "thinking_delta":
+        accumulatedThinking += event.content;
+        break;
+
+      case "tool_requested": {
+        const toolName = event.tool.name;
+        const toolId = event.tool.id;
+        if (outputFormat === "stream-json") {
+          emitJson({ type: "tool_call", name: toolName, id: toolId, input: event.tool.input });
+        } else {
+          const inputSummary = Object.entries(event.tool.input ?? {})
+            .slice(0, 2)
+            .map(([k, v]) => `${k}=${JSON.stringify(v).slice(0, 60)}`)
+            .join(", ");
+          process.stderr.write(`  ⏺ ${toolName}(${inputSummary})\n`);
+        }
+        break;
+      }
+
+      case "tool_execution_complete": {
+        if (outputFormat === "stream-json") {
+          const resultText =
+            typeof event.result?.content === "string" ? event.result.content.slice(0, 200) : "";
+          emitJson({ type: "tool_result", id: event.tool.id, result: resultText });
+        }
+        break;
+      }
+
+      case "notification":
+        if (outputFormat === "stream-json") {
+          emitJson({
+            type: "notification",
+            severity: event.severity,
+            message: event.message,
+            ...(event.actions ? { actions: event.actions } : {}),
+          });
+        } else if (event.severity === "error" || event.severity === "warning") {
+          process.stderr.write(`[${event.severity}] ${event.message}\n`);
+        }
+        break;
+
+      case "error":
+        if (outputFormat === "stream-json") {
+          emitJson({ type: "error", message: event.error.message });
+        } else {
+          process.stderr.write(`Error: ${event.error.message}\n`);
+        }
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  // Output final result based on format
+  if (outputFormat === "stream-json") {
+    if (accumulatedThinking) {
+      emitJson({ type: "thinking", content: accumulatedThinking });
+    }
+    if (accumulatedText) {
+      emitJson({ type: "text", content: accumulatedText });
+    }
+    emitJson({ type: "result", success: true });
+  } else {
+    if (accumulatedText) {
+      process.stdout.write(accumulatedText);
+      process.stdout.write("\n");
+    }
+  }
+
+  process.exit(0);
+}