ai-cli-mcp 2.12.0 → 2.14.0

package/src/__tests__/app-cli.test.ts

@@ -3,6 +3,7 @@ import {
   CLI_HELP_TEXT,
   DOCTOR_HELP_TEXT,
   MODELS_HELP_TEXT,
+  RESULT_HELP_TEXT,
   RUN_HELP_TEXT,
   WAIT_HELP_TEXT,
   runCli,
@@ -142,10 +143,28 @@ describe('ai-cli app', () => {
     );
 
     expect(exitCode).toBe(0);
-    expect(waitForProcesses).toHaveBeenCalledWith([123, 456], 5);
+    expect(waitForProcesses).toHaveBeenCalledWith([123, 456], 5, false);
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"status": "completed"'));
   });
 
+  it('passes verbose through to wait', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+    const waitForProcesses = vi.fn().mockResolvedValue([{ pid: 123, status: 'completed' }]);
+
+    const exitCode = await runCli(
+      ['wait', '123', '--verbose'],
+      {
+        stdout,
+        stderr,
+        waitForProcesses,
+      }
+    );
+
+    expect(exitCode).toBe(0);
+    expect(waitForProcesses).toHaveBeenCalledWith([123], undefined, true);
+  });
+
   it('rejects invalid wait timeout values', async () => {
     const stdout = vi.fn();
     const stderr = vi.fn();
@@ -222,6 +241,7 @@ describe('ai-cli app', () => {
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"aliases"'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"claude-ultra"'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"gpt-5.4"'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"forge"'));
     expect(stderr).not.toHaveBeenCalled();
   });
 
@@ -247,6 +267,12 @@ describe('ai-cli app', () => {
         available: true,
         lookup: 'path',
       },
+      forge: {
+        configuredCommand: 'forge',
+        resolvedPath: '/tmp/bin/forge',
+        available: true,
+        lookup: 'path',
+      },
     });
 
     const exitCode = await runCli(['doctor'], { stdout, stderr, getDoctorStatus });
@@ -280,6 +306,20 @@ describe('ai-cli app', () => {
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('claude-ultra'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gpt-5.2-codex'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gemini-2.5-pro'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('forge'));
+    expect(stderr).not.toHaveBeenCalled();
+  });
+
+  it('prints detailed help for result --help', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+
+    const exitCode = await runCli(['result', '--help'], { stdout, stderr });
+
+    expect(exitCode).toBe(0);
+    expect(stdout).toHaveBeenCalledWith(RESULT_HELP_TEXT);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('compact result shape'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('--verbose'));
     expect(stderr).not.toHaveBeenCalled();
   });
 
@@ -291,6 +331,8 @@ describe('ai-cli app', () => {
 
     expect(exitCode).toBe(0);
     expect(stdout).toHaveBeenCalledWith(WAIT_HELP_TEXT);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('compact shape'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('--verbose'));
     expect(stderr).not.toHaveBeenCalled();
   });
 

package/src/__tests__/cli-bin-smoke.test.ts

@@ -30,6 +30,7 @@ describe('ai-cli entrypoint smoke', () => {
     writeExecutable(fakeBinDir, 'claude');
     writeExecutable(fakeBinDir, 'codex');
     writeExecutable(fakeBinDir, 'gemini');
+    writeExecutable(fakeBinDir, 'forge');
 
     const output = execFileSync(
       'node',
@@ -43,6 +44,7 @@ describe('ai-cli entrypoint smoke', () => {
           CLAUDE_CLI_NAME: 'claude',
           CODEX_CLI_NAME: 'codex',
           GEMINI_CLI_NAME: 'gemini',
+          FORGE_CLI_NAME: 'forge',
         },
       }
     );
@@ -50,6 +52,7 @@ describe('ai-cli entrypoint smoke', () => {
     expect(output).toContain('"claude"');
     expect(output).toContain('"codex"');
     expect(output).toContain('"gemini"');
+    expect(output).toContain('"forge"');
     expect(output).toContain('"available": true');
   });
 
@@ -67,5 +70,6 @@ describe('ai-cli entrypoint smoke', () => {
     expect(output).toContain('Usage: ai-cli run --cwd <path> [options]');
     expect(output).toContain('--model <model>');
     expect(output).toContain('claude-ultra');
+    expect(output).toContain('forge');
   });
 });

package/src/__tests__/cli-builder.test.ts

@@ -22,6 +22,7 @@ const DEFAULT_CLI_PATHS = {
   claude: '/usr/bin/claude',
   codex: '/usr/bin/codex',
   gemini: '/usr/bin/gemini',
+  forge: '/usr/bin/forge',
 };
 
 describe('cli-builder', () => {
@@ -97,6 +98,12 @@ describe('cli-builder', () => {
         'reasoning_effort is only supported for Claude and Codex models.'
       );
     });
+
+    it('should reject reasoning_effort for forge explicitly', () => {
+      expect(() => getReasoningEffort('forge', 'high')).toThrow(
+        'reasoning_effort is not supported for forge.'
+      );
+    });
   });
 
   describe('buildCliCommand', () => {
@@ -401,5 +408,45 @@ describe('cli-builder', () => {
         expect(cmd.resolvedModel).toBe('gemini-3.1-pro-preview');
       });
     });
+
+    describe('forge agent', () => {
+      it('should build forge command without model flags', () => {
+        const cmd = buildCliCommand({
+          prompt: 'test',
+          workFolder: '/tmp',
+          model: 'forge',
+          cliPaths: DEFAULT_CLI_PATHS,
+        });
+
+        expect(cmd.agent).toBe('forge');
+        expect(cmd.cliPath).toBe('/usr/bin/forge');
+        expect(cmd.resolvedModel).toBe('forge');
+        expect(cmd.args).toEqual(['-C', '/tmp', '-p', 'test']);
+      });
+
+      it('should map session_id to --conversation-id for forge', () => {
+        const cmd = buildCliCommand({
+          prompt: 'test',
+          workFolder: '/tmp',
+          model: 'forge',
+          session_id: 'forge-conv-123',
+          cliPaths: DEFAULT_CLI_PATHS,
+        });
+
+        expect(cmd.args).toEqual(['-C', '/tmp', '--conversation-id', 'forge-conv-123', '-p', 'test']);
+      });
+
+      it('should reject reasoning_effort for forge in command building', () => {
+        expect(() =>
+          buildCliCommand({
+            prompt: 'test',
+            workFolder: '/tmp',
+            model: 'forge',
+            reasoning_effort: 'high',
+            cliPaths: DEFAULT_CLI_PATHS,
+          })
+        ).toThrow('reasoning_effort is not supported for forge.');
+      });
+    });
   });
 });

package/src/__tests__/cli-process-service.test.ts

@@ -65,6 +65,7 @@ describe('CliProcessService', () => {
         claude: scriptPath,
         codex: scriptPath,
         gemini: scriptPath,
+        forge: scriptPath,
       },
     });
 
@@ -83,8 +84,18 @@ describe('CliProcessService', () => {
 
     const waitResult = await service.waitForProcesses([runResult.pid], 5);
     expect(waitResult).toHaveLength(1);
-    expect(waitResult[0].pid).toBe(runResult.pid);
-    expect(waitResult[0].status).toBe('completed');
+    expect(waitResult[0]).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: 'sonnet',
+      stdout: expect.any(String),
+      stderr: expect.any(String),
+    });
+    expect(waitResult[0]).not.toHaveProperty('startTime');
+    expect(waitResult[0]).not.toHaveProperty('workFolder');
+    expect(waitResult[0]).not.toHaveProperty('prompt');
 
     const listed = await service.listProcesses();
     expect(listed).toContainEqual({
@@ -94,12 +105,141 @@ describe('CliProcessService', () => {
     });
 
     const result = await service.getProcessResult(runResult.pid, false);
-    expect(result.pid).toBe(runResult.pid);
-    expect(result.status).toBe('completed');
-    expect(result.stdout).toContain('Command executed successfully');
+    expect(result).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: 'sonnet',
+      stdout: expect.stringContaining('Command executed successfully'),
+      stderr: expect.any(String),
+    });
+    expect(result).not.toHaveProperty('startTime');
+    expect(result).not.toHaveProperty('workFolder');
+    expect(result).not.toHaveProperty('prompt');
     expect(readFileSync(join(processDir, 'meta.json'), 'utf-8')).toContain('"status": "completed"');
   });
 
+  it('returns compact results by default and full results when verbose is true', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const scriptPath = join(root, 'mock-claude-json');
+    writeFileSync(
+      scriptPath,
+      `#!/bin/bash
+printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/demo.txt"}}]}}'
+printf '%s\n' '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":[{"type":"text","text":"demo output"}]}]}}'
+printf '%s\n' '{"type":"result","result":"Completed cli-process-service test"}'
+printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
+`
+    );
+    chmodSync(scriptPath, 0o755);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'work');
+    mkdirSync(workFolder, { recursive: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: scriptPath,
+        codex: scriptPath,
+        gemini: scriptPath,
+        forge: scriptPath,
+      },
+    });
+
+    const runResult = await service.startProcess({
+      prompt: 'hello structured output',
+      cwd: workFolder,
+    });
+
+    const compactWait = await service.waitForProcesses([runResult.pid], 5);
+    expect(compactWait).toHaveLength(1);
+    expect(compactWait[0]).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+      },
+    });
+    expect(compactWait[0]).not.toHaveProperty('startTime');
+    expect(compactWait[0]).not.toHaveProperty('workFolder');
+    expect(compactWait[0]).not.toHaveProperty('prompt');
+    expect(compactWait[0].agentOutput).not.toHaveProperty('tools');
+
+    const compactResult = await service.getProcessResult(runResult.pid, false);
+    expect(compactResult).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+      },
+    });
+    expect(compactResult).not.toHaveProperty('startTime');
+    expect(compactResult).not.toHaveProperty('workFolder');
+    expect(compactResult).not.toHaveProperty('prompt');
+    expect(compactResult.agentOutput).not.toHaveProperty('tools');
+
+    const verboseWait = await service.waitForProcesses([runResult.pid], 5, true);
+    expect(verboseWait).toHaveLength(1);
+    expect(verboseWait[0]).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      startTime: expect.any(String),
+      workFolder,
+      prompt: 'hello structured output',
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+        tools: [
+          {
+            tool: 'Read',
+            input: { file_path: '/tmp/demo.txt' },
+            output: 'demo output',
+          },
+        ],
+      },
+    });
+
+    const verboseResult = await service.getProcessResult(runResult.pid, true);
+    expect(verboseResult).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      startTime: expect.any(String),
+      workFolder,
+      prompt: 'hello structured output',
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+        tools: [
+          {
+            tool: 'Read',
+            input: { file_path: '/tmp/demo.txt' },
+            output: 'demo output',
+          },
+        ],
+      },
+    });
+  });
+
   it('can terminate a tracked process', async () => {
     const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
     tempDirs.push(root);
@@ -114,6 +254,7 @@ describe('CliProcessService', () => {
         claude: scriptPath,
         codex: scriptPath,
         gemini: scriptPath,
+        forge: scriptPath,
       },
     });
 
@@ -152,6 +293,7 @@ describe('CliProcessService', () => {
         claude: '/bin/sh',
         codex: '/bin/sh',
         gemini: '/bin/sh',
+        forge: '/bin/sh',
       },
     });
 
@@ -254,6 +396,7 @@ describe('CliProcessService', () => {
         claude: '/bin/sh',
         codex: '/bin/sh',
         gemini: '/bin/sh',
+        forge: '/bin/sh',
       },
     });
 
@@ -275,4 +418,56 @@ describe('CliProcessService', () => {
     expect(existsSync(failedDir)).toBe(false);
     killSpy.mockRestore();
   });
+
+  it('parses forge output from detached process logs', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'forge-project');
+    mkdirSync(workFolder, { recursive: true });
+    const pid = 54321;
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    writeFileSync(
+      join(processDir, 'stdout.log'),
+      `● [21:09:01] Initialize forge-conv-1
+Forge assistant reply
+● [21:09:08] Finished forge-conv-1
+`
+    );
+    writeFileSync(join(processDir, 'stderr.log'), '');
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'hello forge',
+        workFolder,
+        model: 'forge',
+        toolType: 'forge',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'completed',
+      })
+    );
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+      },
+    });
+
+    const result = await service.getProcessResult(pid, false);
+    expect(result.agent).toBe('forge');
+    expect(result.session_id).toBe('forge-conv-1');
+    expect(result.agentOutput).toEqual({
+      message: 'Forge assistant reply',
+      session_id: 'forge-conv-1',
+    });
+  });
 });

package/src/__tests__/cli-utils.test.ts

@@ -19,6 +19,7 @@ describe('cli-utils doctor status', () => {
     delete process.env.CLAUDE_CLI_NAME;
     delete process.env.CODEX_CLI_NAME;
     delete process.env.GEMINI_CLI_NAME;
+    delete process.env.FORGE_CLI_NAME;
     process.env.PATH = '/mock/bin:/usr/bin';
   });
 
@@ -44,6 +45,12 @@ describe('cli-utils doctor status', () => {
       available: true,
       lookup: 'path',
     });
+    expect(status.forge).toEqual({
+      configuredCommand: 'forge',
+      resolvedPath: null,
+      available: false,
+      lookup: 'path',
+    });
   });
 
   it('does not mark non-executable PATH entries as available', async () => {
@@ -60,6 +67,12 @@ describe('cli-utils doctor status', () => {
       available: false,
       lookup: 'path',
     });
+    expect(status.forge).toEqual({
+      configuredCommand: 'forge',
+      resolvedPath: null,
+      available: false,
+      lookup: 'path',
+    });
   });
 
   it('reports invalid relative env paths as doctor errors', async () => {
@@ -129,4 +142,25 @@ describe('cli-utils doctor status', () => {
       lookup: 'env',
     });
   });
+
+  it('supports forge lookup via FORGE_CLI_NAME', async () => {
+    process.env.FORGE_CLI_NAME = 'forge-custom';
+    mockAccessSync.mockImplementation((filePath) => {
+      if (filePath === '/mock/bin/forge-custom') {
+        return undefined;
+      }
+      throw new Error('not executable');
+    });
+
+    const { getCliDoctorStatus, findForgeCli } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.forge).toEqual({
+      configuredCommand: 'forge-custom',
+      resolvedPath: '/mock/bin/forge-custom',
+      available: true,
+      lookup: 'env',
+    });
+    expect(findForgeCli()).toBe('forge-custom');
+  });
 });