ai-cli-mcp 2.12.0 → 2.14.0

package/src/cli-parse.ts

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
 
-const AGENTS = ['claude', 'codex', 'gemini'] as const;
+const AGENTS = ['claude', 'codex', 'gemini', 'forge'] as const;
 type Agent = typeof AGENTS[number];
 
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini>
+const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge>
 
 Reads raw CLI output from stdin and outputs parsed JSON to stdout.
 
 Options:
-  --agent   Agent type: claude, codex, or gemini (required)
+  --agent   Agent type: claude, codex, gemini, or forge (required)
   --help    Show this help message
 
 Examples:
@@ -62,7 +62,7 @@ async function main(): Promise<void> {
 
   const agent = args.agent as Agent;
   if (!agent || !AGENTS.includes(agent)) {
-    process.stderr.write(`Error: --agent is required (claude, codex, or gemini)\n\n`);
+    process.stderr.write(`Error: --agent is required (claude, codex, gemini, or forge)\n\n`);
     process.stderr.write(USAGE);
     process.exit(1);
   }
@@ -85,6 +85,9 @@ async function main(): Promise<void> {
     case 'gemini':
       parsed = parseGeminiOutput(input);
       break;
+    case 'forge':
+      parsed = parseForgeOutput(input);
+      break;
   }
 
   process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');

package/src/cli-process-service.ts

@@ -15,8 +15,9 @@ import {
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
-import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { buildProcessResult } from './process-result.js';
 import type { AgentType, ProcessListItem } from './process-service.js';
 
 interface StoredProcess {
@@ -78,6 +79,7 @@ export class CliProcessService {
       claude: findClaudeCli(),
       codex: findCodexCli(),
       gemini: findGeminiCli(),
+      forge: findForgeCli(),
     };
     mkdirSync(this.stateDir, { recursive: true });
   }
@@ -177,10 +179,12 @@ export class CliProcessService {
         agentOutput = parseClaudeOutput(stdout);
       } else if (refreshed.toolType === 'gemini') {
         agentOutput = parseGeminiOutput(stdout);
+      } else if (refreshed.toolType === 'forge') {
+        agentOutput = parseForgeOutput(stdout);
       }
     }
 
-    const response: any = {
+    return buildProcessResult({
       pid,
       agent: refreshed.toolType,
       status: refreshed.status,
@@ -189,27 +193,12 @@ export class CliProcessService {
       workFolder: refreshed.workFolder,
       prompt: refreshed.prompt,
       model: refreshed.model,
-    };
-
-    if (agentOutput) {
-      if (!verbose && agentOutput.tools) {
-        const { tools, ...rest } = agentOutput;
-        response.agentOutput = rest;
-      } else {
-        response.agentOutput = agentOutput;
-      }
-      if (agentOutput.session_id) {
-        response.session_id = agentOutput.session_id;
-      }
-    } else {
-      response.stdout = stdout;
-      response.stderr = stderr;
-    }
-
-    return response;
+      stdout,
+      stderr,
+    }, agentOutput, verbose);
   }
 
-  async waitForProcesses(pids: number[], timeoutSeconds = 180): Promise<any[]> {
+  async waitForProcesses(pids: number[], timeoutSeconds = 180, verbose = false): Promise<any[]> {
     const start = Date.now();
     for (const pid of pids) {
       this.readProcess(pid);
@@ -218,7 +207,7 @@ export class CliProcessService {
     while (true) {
       const statuses = pids.map((pid) => this.refreshStatus(this.readProcess(pid)).status);
       if (statuses.every((status) => status !== 'running')) {
-        return Promise.all(pids.map((pid) => this.getProcessResult(pid, false)));
+        return Promise.all(pids.map((pid) => this.getProcessResult(pid, verbose)));
       }
 
       if (Date.now() - start >= timeoutSeconds * 1000) {

package/src/cli-utils.ts

@@ -148,7 +148,7 @@ function isExecutableFile(filePath: string): boolean {
   }
 }
 
-type CliBinaryName = 'claude' | 'codex' | 'gemini';
+type CliBinaryName = 'claude' | 'codex' | 'gemini' | 'forge';
 
 function getCliBinaryConfig(name: CliBinaryName): {
   envVarName: string;
@@ -174,6 +174,15 @@ function getCliBinaryConfig(name: CliBinaryName): {
     };
   }
 
+  if (name === 'forge') {
+    return {
+      envVarName: 'FORGE_CLI_NAME',
+      customCliName: process.env.FORGE_CLI_NAME,
+      defaultCliName: 'forge',
+      localInstallPath: join(homedir(), '.forge', 'local', 'forge'),
+    };
+  }
+
   return {
     envVarName: 'GEMINI_CLI_NAME',
     customCliName: process.env.GEMINI_CLI_NAME,
@@ -190,11 +199,13 @@ export function getCliDoctorStatus(): {
   claude: CliBinaryStatus;
   codex: CliBinaryStatus;
   gemini: CliBinaryStatus;
+  forge: CliBinaryStatus;
 } {
   return {
     claude: getCliBinaryStatus('claude'),
     codex: getCliBinaryStatus('codex'),
     gemini: getCliBinaryStatus('gemini'),
+    forge: getCliBinaryStatus('forge'),
   };
 }
 
@@ -218,6 +229,15 @@ export function findCodexCli(): string {
   return getCliCommandOrThrow(status);
 }
 
+/**
+ * Determine the Forge CLI command/path.
+ */
+export function findForgeCli(): string {
+  debugLog('[Debug] Attempting to find Forge CLI...');
+  const status = getCliBinaryStatus('forge');
+  return getCliCommandOrThrow(status);
+}
+
 /**
  * Determine the Claude CLI command/path.
  * 1. Checks for CLAUDE_CLI_NAME environment variable:

package/src/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 
 /**
  * Minimal argv parser. No external dependencies.
@@ -35,12 +35,12 @@ function parseArgs(argv: string[]): Record<string, string> {
 const USAGE = `Usage: npm run -s cli.run -- --model <model> --workFolder <path> --prompt "..." [options]
 
 Options:
-  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro)
+  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro, forge)
   --workFolder         Working directory (absolute path)
   --prompt             Prompt string (mutually exclusive with --prompt_file)
   --prompt_file        Path to a file containing the prompt
   --session_id         Session ID to resume
-  --reasoning_effort   Claude/Codex: Claude=low|medium|high, Codex=low|medium|high|xhigh
+  --reasoning_effort   Claude/Codex only: Claude=low|medium|high, Codex=low|medium|high|xhigh
   --help               Show this help message
 
 Raw CLI output goes to stdout. Use cli.run.parse to parse the output:
@@ -73,6 +73,7 @@ async function main(): Promise<void> {
     claude: findClaudeCli(),
     codex: findCodexCli(),
     gemini: findGeminiCli(),
+    forge: findForgeCli(),
   };
 
   // Build command

package/src/model-catalog.ts

@@ -19,6 +19,7 @@ export const GEMINI_MODELS = [
   'gemini-3-pro-preview',
   'gemini-3-flash-preview',
 ] as const;
+export const FORGE_MODELS = ['forge'] as const;
 
 export const MODEL_ALIASES: Record<string, string> = {
   'claude-ultra': 'opus',
@@ -38,11 +39,12 @@ export function getSupportedModelsDescription(): string {
     ...CLAUDE_MODELS.map((model) => `"${model}"`),
     ...CODEX_MODELS.map((model) => `"${model}"`),
     ...GEMINI_MODELS.map((model) => `"${model}"`),
+    ...FORGE_MODELS.map((model) => `"${model}"`),
   ].join(', ');
 }
 
 export function getModelParameterDescription(): string {
-  return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS].map((model) => `"${model}"`).join(', ')}.`;
+  return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS].map((model) => `"${model}"`).join(', ')}. "forge" is a provider key, not a Forge model family selector.`;
 }
 
 export function getModelsPayload(): {
@@ -50,11 +52,13 @@ export function getModelsPayload(): {
   claude: ReadonlyArray<string>;
   codex: ReadonlyArray<string>;
   gemini: ReadonlyArray<string>;
+  forge: ReadonlyArray<string>;
 } {
   return {
     aliases: MODEL_ALIAS_DETAILS,
     claude: CLAUDE_MODELS,
     codex: CODEX_MODELS,
     gemini: GEMINI_MODELS,
+    forge: FORGE_MODELS,
   };
 }

package/src/parsers.ts

@@ -167,3 +167,64 @@ export function parseGeminiOutput(stdout: string): any {
     return null;
   }
 }
+
+/**
+ * Parse Forge output framed by Initialize/Continue/Finished markers.
+ */
+export function parseForgeOutput(stdout: string): any {
+  if (!stdout) return null;
+
+  const lines = stdout.split('\n');
+  const markerPattern = /^● \[[^\]]+\] (Initialize|Continue|Finished) (\S+)\s*$/;
+  let collecting = false;
+  let currentConversationId: string | null = null;
+  let currentBody: string[] = [];
+  let lastConversationId: string | null = null;
+  let lastMessage: string | null = null;
+
+  for (const line of lines) {
+    const match = line.match(markerPattern);
+    if (match) {
+      const [, action, conversationId] = match;
+      lastConversationId = conversationId;
+
+      if (action === 'Initialize' || action === 'Continue') {
+        collecting = true;
+        currentConversationId = conversationId;
+        currentBody = [];
+      } else if (collecting && currentConversationId === conversationId) {
+        const message = currentBody.join('\n').trim();
+        if (message) {
+          lastMessage = message;
+        }
+        collecting = false;
+        currentConversationId = null;
+        currentBody = [];
+      }
+      continue;
+    }
+
+    if (collecting) {
+      currentBody.push(line);
+    }
+  }
+
+  if (collecting) {
+    const message = currentBody.join('\n').trim();
+    if (message) {
+      lastMessage = message;
+    }
+    if (currentConversationId) {
+      lastConversationId = currentConversationId;
+    }
+  }
+
+  if (!lastMessage && !lastConversationId) {
+    return null;
+  }
+
+  return {
+    message: lastMessage,
+    session_id: lastConversationId,
+  };
+}

package/src/process-result.ts

@@ -0,0 +1,79 @@
+import type { AgentType, ProcessStatus } from './process-service.js';
+
+interface ProcessResultContext {
+  pid: number;
+  agent: AgentType;
+  status: ProcessStatus;
+  exitCode?: number;
+  startTime: string;
+  workFolder: string;
+  prompt: string;
+  model?: string;
+  stdout: string;
+  stderr: string;
+}
+
+function compactAgentOutput(agentOutput: any): any | null {
+  if (!agentOutput || typeof agentOutput !== 'object') {
+    return null;
+  }
+
+  const { tools: _tools, ...rest } = agentOutput;
+  const compact = Object.fromEntries(Object.entries(rest).filter(([, value]) => value !== undefined && value !== null));
+  return Object.keys(compact).length > 0 ? compact : null;
+}
+
+function hasMeaningfulParsedOutput(agentOutput: any): boolean {
+  if (!agentOutput || typeof agentOutput !== 'object') {
+    return false;
+  }
+
+  return Object.entries(agentOutput).some(([key, value]) => {
+    if (value === undefined || value === null) {
+      return false;
+    }
+
+    if (key === 'session_id') {
+      return false;
+    }
+
+    if (key === 'tools') {
+      return Array.isArray(value) ? value.length > 0 : true;
+    }
+
+    return true;
+  });
+}
+
+export function buildProcessResult(context: ProcessResultContext, agentOutput: any, verbose = false): any {
+  const response: any = {
+    pid: context.pid,
+    agent: context.agent,
+    status: context.status,
+    exitCode: context.exitCode ?? null,
+    model: context.model ?? null,
+  };
+
+  if (verbose) {
+    response.startTime = context.startTime;
+    response.workFolder = context.workFolder;
+    response.prompt = context.prompt;
+  }
+
+  if (agentOutput?.session_id) {
+    response.session_id = agentOutput.session_id;
+  }
+
+  const shapedAgentOutput = verbose ? agentOutput : compactAgentOutput(agentOutput);
+
+  if (hasMeaningfulParsedOutput(shapedAgentOutput)) {
+    response.agentOutput = shapedAgentOutput;
+  }
+
+  if (!response.agentOutput) {
+    response.stdout = context.stdout;
+    response.stderr = context.stderr;
+  }
+
+  return response;
+}

package/src/process-service.ts

@@ -1,8 +1,9 @@
 import { spawn, type ChildProcess } from 'node:child_process';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { buildProcessResult } from './process-result.js';
 
-export type AgentType = 'claude' | 'codex' | 'gemini';
+export type AgentType = 'claude' | 'codex' | 'gemini' | 'forge';
 export type ProcessStatus = 'running' | 'completed' | 'failed';
 
 interface TrackedProcess {
@@ -144,10 +145,12 @@ export class ProcessService {
         agentOutput = parseClaudeOutput(process.stdout);
       } else if (process.toolType === 'gemini') {
         agentOutput = parseGeminiOutput(process.stdout);
+      } else if (process.toolType === 'forge') {
+        agentOutput = parseForgeOutput(process.stdout);
       }
     }
 
-    const response: any = {
+    return buildProcessResult({
       pid,
       agent: process.toolType,
       status: process.status,
@@ -156,28 +159,12 @@ export class ProcessService {
       workFolder: process.workFolder,
       prompt: process.prompt,
       model: process.model,
-    };
-
-    if (agentOutput) {
-      if (!verbose && agentOutput.tools) {
-        const { tools, ...rest } = agentOutput;
-        response.agentOutput = rest;
-      } else {
-        response.agentOutput = agentOutput;
-      }
-
-      if (agentOutput.session_id) {
-        response.session_id = agentOutput.session_id;
-      }
-    } else {
-      response.stdout = process.stdout;
-      response.stderr = process.stderr;
-    }
-
-    return response;
+      stdout: process.stdout,
+      stderr: process.stderr,
+    }, agentOutput, verbose);
   }
 
-  async waitForProcesses(pids: number[], timeoutSeconds = 180): Promise<any[]> {
+  async waitForProcesses(pids: number[], timeoutSeconds = 180, verbose = false): Promise<any[]> {
     for (const pid of pids) {
       if (!this.processManager.has(pid)) {
         throw new Error(`Process with PID ${pid} not found`);
@@ -209,7 +196,7 @@ export class ProcessService {
 
     try {
       await Promise.race([Promise.all(waitPromises), timeoutPromise]);
-      return pids.map((pid) => this.getProcessResult(pid, false));
+      return pids.map((pid) => this.getProcessResult(pid, verbose));
     } finally {
       if (timeoutHandle) {
         clearTimeout(timeoutHandle);

package/src/server.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-export { debugLog, findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
+export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 export { resolveModelAlias } from './cli-builder.js';
 export { ClaudeCodeServer, runMcpServer, spawnAsync } from './app/mcp.js';