ai-cli-mcp 2.17.0 → 2.19.0

package/dist/parsers.js

@@ -1,4 +1,7 @@
 import { debugLog } from './cli-utils.js';
+const PEEK_TOOL_SUMMARY_MAX_LENGTH = 200;
+const FORGE_EXECUTE_PATTERN = /^● \[[^\]]+\] Execute \[([^\]]*)\]\s+(.+)$/;
+const FORGE_FINISHED_PATTERN = /^● \[[^\]]+\] Finished(?:\s+\S+)?\s*$/;
 function isGeminiAssistantMessageEvent(parsed) {
     return parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string';
 }
@@ -14,34 +17,257 @@ const GEMINI_STREAM_EVENT_TYPES = new Set([
 function isGeminiStreamJsonEvent(parsed) {
     return parsed && typeof parsed === 'object' && !Array.isArray(parsed) && GEMINI_STREAM_EVENT_TYPES.has(parsed.type);
 }
-function extractPeekMessagesFromParsedEvent(agent, parsed, observedAt) {
+function oneLine(value) {
+    return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+function boundedSummary(value) {
+    const summary = oneLine(value);
+    if (summary.length <= PEEK_TOOL_SUMMARY_MAX_LENGTH) {
+        return { summary };
+    }
+    return {
+        summary: `${summary.slice(0, PEEK_TOOL_SUMMARY_MAX_LENGTH - 3)}...`,
+        summary_truncated: true,
+    };
+}
+function normalizeMcpToolName(tool, explicitServer) {
+    if (explicitServer) {
+        return {
+            server: explicitServer,
+            ...boundedSummary(`${explicitServer}.${tool}`),
+        };
+    }
+    const mcpDouble = tool.match(/^mcp__([^_]+)__(.+)$/);
+    if (mcpDouble) {
+        return {
+            server: mcpDouble[1],
+            ...boundedSummary(`${mcpDouble[1]}.${mcpDouble[2]}`),
+        };
+    }
+    const mcpSingle = tool.match(/^mcp_([^_]+)_(.+)$/);
+    if (mcpSingle) {
+        return {
+            server: mcpSingle[1],
+            ...boundedSummary(`${mcpSingle[1]}.${mcpSingle[2]}`),
+        };
+    }
+    const acmShort = tool.match(/^acm_(.+)$/);
+    if (acmShort) {
+        return {
+            server: 'acm',
+            ...boundedSummary(`acm.${acmShort[1]}`),
+        };
+    }
+    return null;
+}
+function buildToolSummary(tool, options = {}) {
+    if (typeof options.command === 'string' && options.command.trim()) {
+        return boundedSummary(options.command);
+    }
+    const mcpSummary = normalizeMcpToolName(tool, options.server);
+    if (mcpSummary) {
+        return mcpSummary;
+    }
+    return boundedSummary(tool || 'tool_call');
+}
+function normalizeToolStatus(rawStatus, exitCode, defaultStatus = 'unknown') {
+    if (typeof exitCode === 'number') {
+        return exitCode === 0 ? 'success' : 'failed';
+    }
+    const status = typeof rawStatus === 'string' ? rawStatus.toLowerCase() : '';
+    if (['success', 'succeeded', 'ok', 'completed'].includes(status)) {
+        return 'success';
+    }
+    if (['failed', 'failure', 'error', 'errored'].includes(status)) {
+        return 'failed';
+    }
+    if (['cancelled', 'canceled'].includes(status)) {
+        return 'cancelled';
+    }
+    return defaultStatus;
+}
+function createToolCallEvent(params) {
+    const tool = params.tool || 'tool_call';
+    const summary = buildToolSummary(tool, { server: params.server, command: params.command });
+    const event = {
+        kind: 'tool_call',
+        ts: params.ts,
+        phase: params.phase,
+        tool,
+        summary: summary.summary,
+    };
+    if (params.id) {
+        event.id = params.id;
+    }
+    if (summary.server) {
+        event.server = summary.server;
+    }
+    else if (params.server) {
+        event.server = params.server;
+    }
+    if (summary.summary_truncated) {
+        event.summary_truncated = true;
+    }
+    if (params.phase === 'completed') {
+        event.status = normalizeToolStatus(params.status, params.exit_code, params.defaultStatus);
+        if (typeof params.exit_code === 'number') {
+            event.exit_code = params.exit_code;
+        }
+        if (typeof params.duration_ms === 'number' && Number.isFinite(params.duration_ms)) {
+            event.duration_ms = params.duration_ms;
+        }
+    }
+    return event;
+}
+function rememberToolCall(event, memory) {
+    if (event.kind !== 'tool_call' || !event.id) {
+        return;
+    }
+    memory.set(event.id, {
+        tool: event.tool,
+        server: event.server,
+        summary: event.summary,
+        summary_truncated: event.summary_truncated,
+    });
+}
+function createRememberedCompletion(params) {
+    const remembered = params.id ? params.memory.get(params.id) : undefined;
+    const event = createToolCallEvent({
+        ts: params.ts,
+        phase: 'completed',
+        id: params.id,
+        tool: remembered?.tool || params.fallbackTool,
+        server: remembered?.server,
+        status: params.status,
+        defaultStatus: params.defaultStatus,
+    });
+    if (remembered) {
+        event.summary = remembered.summary;
+        if (remembered.summary_truncated) {
+            event.summary_truncated = true;
+        }
+    }
+    return event;
+}
+function extractPeekEventsFromParsedEvent(agent, parsed, observedAt, includeToolCalls, memory) {
     if (agent === 'codex') {
         if (parsed.item?.type === 'agent_message' && typeof parsed.item.text === 'string' && parsed.item.text.trim()) {
-            return [{ ts: observedAt, text: parsed.item.text }];
+            return [{ kind: 'message', ts: observedAt, text: parsed.item.text }];
         }
         if (parsed.msg?.type === 'agent_message' && typeof parsed.msg.message === 'string' && parsed.msg.message.trim()) {
-            return [{ ts: observedAt, text: parsed.msg.message }];
+            return [{ kind: 'message', ts: observedAt, text: parsed.msg.message }];
+        }
+        if (includeToolCalls && (parsed.type === 'item.started' || parsed.type === 'item.completed')) {
+            const item = parsed.item;
+            if (item?.type === 'command_execution') {
+                const event = createToolCallEvent({
+                    ts: observedAt,
+                    phase: parsed.type === 'item.started' ? 'started' : 'completed',
+                    id: item.id,
+                    tool: 'command_execution',
+                    command: item.command,
+                    status: item.status || item.error,
+                    exit_code: typeof item.exit_code === 'number' ? item.exit_code : undefined,
+                    defaultStatus: parsed.type === 'item.completed' ? 'success' : 'unknown',
+                });
+                rememberToolCall(event, memory);
+                return [event];
+            }
+            if (item?.type === 'mcp_tool_call') {
+                const event = createToolCallEvent({
+                    ts: observedAt,
+                    phase: parsed.type === 'item.started' ? 'started' : 'completed',
+                    id: item.id,
+                    tool: item.tool || 'mcp_tool_call',
+                    server: item.server,
+                    status: item.status || item.error,
+                    defaultStatus: parsed.type === 'item.completed' ? 'success' : 'unknown',
+                });
+                rememberToolCall(event, memory);
+                return [event];
+            }
         }
         return [];
     }
-    if (agent === 'claude' && parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
-        return parsed.message.content
-            .filter((content) => content?.type === 'text' && typeof content.text === 'string' && content.text.trim())
-            .map((content) => ({ ts: observedAt, text: content.text }));
+    if (agent === 'claude') {
+        if (parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
+            const events = [];
+            for (const content of parsed.message.content) {
+                if (content?.type === 'text' && typeof content.text === 'string' && content.text.trim()) {
+                    events.push({ kind: 'message', ts: observedAt, text: content.text });
+                }
+                else if (includeToolCalls && content?.type === 'tool_use') {
+                    const event = createToolCallEvent({
+                        ts: observedAt,
+                        phase: 'started',
+                        id: content.id,
+                        tool: content.name || 'tool_use',
+                        command: content.input?.command,
+                    });
+                    rememberToolCall(event, memory);
+                    events.push(event);
+                }
+            }
+            return events;
+        }
+        if (includeToolCalls && parsed.type === 'user' && Array.isArray(parsed.message?.content)) {
+            const events = [];
+            for (const content of parsed.message.content) {
+                if (content?.type === 'tool_result') {
+                    events.push(createRememberedCompletion({
+                        ts: observedAt,
+                        id: content.tool_use_id,
+                        memory,
+                        fallbackTool: 'tool_result',
+                        status: content.is_error === true ? 'failed' : undefined,
+                        defaultStatus: content.is_error === true ? 'failed' : 'success',
+                    }));
+                }
+            }
+            return events;
+        }
+        return [];
     }
     if (agent === 'opencode' && parsed.type === 'text' && parsed.part?.type === 'text' && typeof parsed.part.text === 'string' && parsed.part.text.trim()) {
-        return [{ ts: observedAt, text: parsed.part.text }];
+        return [{ kind: 'message', ts: observedAt, text: parsed.part.text }];
+    }
+    if (agent === 'opencode' && includeToolCalls && parsed.type === 'tool_use' && parsed.part?.type === 'tool') {
+        const state = parsed.part.state || {};
+        const start = state.time?.start;
+        const end = state.time?.end;
+        const event = createToolCallEvent({
+            ts: observedAt,
+            phase: state.status === 'running' || state.status === 'pending' ? 'started' : 'completed',
+            id: parsed.part.callID,
+            tool: parsed.part.tool || 'tool_use',
+            command: state.input?.command,
+            status: state.status,
+            defaultStatus: state.status === 'completed' ? 'success' : 'unknown',
+            duration_ms: typeof start === 'number' && typeof end === 'number' ? end - start : undefined,
+        });
+        rememberToolCall(event, memory);
+        return [event];
     }
     return [];
 }
-export class PeekMessageExtractor {
+export class PeekEventExtractor {
     agent;
     pending = '';
     geminiAssistantBuffer = '';
-    constructor(agent) {
+    includeToolCalls;
+    source;
+    toolMemory = new Map();
+    forgePendingTool = null;
+    forgeToolSequence = 0;
+    constructor(agent, options = {}) {
         this.agent = agent;
+        this.includeToolCalls = options.includeToolCalls === true;
+        this.source = options.source || 'stdout';
     }
     push(chunk, observedAt = new Date().toISOString()) {
+        if (this.agent === 'forge' && this.source === 'stderr') {
+            return [];
+        }
         if (!chunk) {
             return [];
         }
@@ -49,41 +275,129 @@ export class PeekMessageExtractor {
         this.pending = lines.pop() || '';
         return this.extractLines(lines, observedAt);
     }
-    flush(observedAt = new Date().toISOString()) {
-        const messages = [];
-        if (this.pending) {
-            const line = this.pending;
+    flush(observedAt = new Date().toISOString(), options = {}) {
+        if (this.agent === 'forge' && this.source === 'stderr') {
             this.pending = '';
-            messages.push(...this.extractLines([line], observedAt));
+            return [];
         }
-        messages.push(...this.flushGeminiAssistantBuffer(observedAt));
-        return messages;
+        const events = [];
+        if (this.pending) {
+            if (this.agent !== 'forge' || options.terminal === true) {
+                const line = this.pending;
+                this.pending = '';
+                events.push(...this.extractLines([line], observedAt));
+            }
+        }
+        events.push(...this.flushGeminiAssistantBuffer(observedAt));
+        events.push(...this.flushForgePendingTool(observedAt, options.terminal === true));
+        return events;
     }
     extractLines(lines, observedAt) {
-        const messages = [];
+        if (this.agent === 'forge') {
+            return this.extractForgeLines(lines, observedAt);
+        }
+        const events = [];
         for (const line of lines) {
             if (!line.trim()) {
                 continue;
             }
             try {
-                messages.push(...this.extractParsedEvent(JSON.parse(line), observedAt));
+                events.push(...this.extractParsedEvent(JSON.parse(line), observedAt));
             }
             catch {
                 debugLog(`[Debug] Skipping invalid peek JSON line: ${line}`);
-                messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+                events.push(...this.flushGeminiAssistantBuffer(observedAt));
             }
         }
-        return messages;
+        return events;
+    }
+    extractForgeLines(lines, observedAt) {
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            const summary = this.extractForgeMessage(line, 'Summary:');
+            if (summary !== null) {
+                events.push({ kind: 'message', ts: observedAt, text: summary });
+                continue;
+            }
+            const completed = this.extractForgeMessage(line, 'Completed successfully:');
+            if (completed !== null) {
+                events.push({ kind: 'message', ts: observedAt, text: completed });
+                continue;
+            }
+            if (this.includeToolCalls) {
+                const executeMatch = line.match(FORGE_EXECUTE_PATTERN);
+                if (executeMatch) {
+                    events.push(...this.completeForgePendingTool(observedAt));
+                    const [, rawTool, rawSummary] = executeMatch;
+                    const tool = rawTool.trim() && !/\s/.test(rawTool.trim()) ? rawTool.trim() : 'shell';
+                    const event = createToolCallEvent({
+                        ts: observedAt,
+                        phase: 'started',
+                        id: `forge_${this.forgeToolSequence++}`,
+                        tool,
+                        command: rawSummary,
+                    });
+                    this.forgePendingTool = {
+                        id: event.id,
+                        tool: event.tool,
+                        summary: event.summary,
+                        summary_truncated: event.summary_truncated,
+                    };
+                    events.push(event);
+                    continue;
+                }
+                if (FORGE_FINISHED_PATTERN.test(line)) {
+                    events.push(...this.completeForgePendingTool(observedAt));
+                }
+            }
+        }
+        return events;
+    }
+    extractForgeMessage(line, prefix) {
+        if (!line.startsWith(prefix)) {
+            return null;
+        }
+        const text = line.slice(prefix.length).trim();
+        return text || null;
     }
     extractParsedEvent(parsed, observedAt) {
-        if (this.agent !== 'gemini') {
-            return extractPeekMessagesFromParsedEvent(this.agent, parsed, observedAt);
+        if (this.agent === 'gemini') {
+            const events = this.extractGeminiParsedEvent(parsed, observedAt);
+            return events;
         }
+        return extractPeekEventsFromParsedEvent(this.agent, parsed, observedAt, this.includeToolCalls, this.toolMemory);
+    }
+    extractGeminiParsedEvent(parsed, observedAt) {
         if (isGeminiAssistantMessageEvent(parsed)) {
             this.geminiAssistantBuffer += parsed.content;
             return [];
         }
-        return this.flushGeminiAssistantBuffer(observedAt);
+        const events = this.flushGeminiAssistantBuffer(observedAt);
+        if (this.includeToolCalls && parsed.type === 'tool_use') {
+            const event = createToolCallEvent({
+                ts: observedAt,
+                phase: 'started',
+                id: parsed.tool_id,
+                tool: parsed.tool_name || parsed.name || 'tool_use',
+                command: parsed.parameters?.command,
+            });
+            rememberToolCall(event, this.toolMemory);
+            events.push(event);
+        }
+        else if (this.includeToolCalls && parsed.type === 'tool_result') {
+            events.push(createRememberedCompletion({
+                ts: observedAt,
+                id: parsed.tool_id,
+                memory: this.toolMemory,
+                fallbackTool: parsed.tool_name || parsed.name || 'tool_result',
+                status: parsed.status,
+                defaultStatus: 'unknown',
+            }));
+        }
+        return events;
     }
     flushGeminiAssistantBuffer(observedAt) {
         if (this.agent !== 'gemini' || !this.geminiAssistantBuffer) {
@@ -94,7 +408,50 @@ export class PeekMessageExtractor {
         if (!text.trim()) {
             return [];
         }
-        return [{ ts: observedAt, text }];
+        return [{ kind: 'message', ts: observedAt, text }];
+    }
+    completeForgePendingTool(observedAt) {
+        if (!this.forgePendingTool) {
+            return [];
+        }
+        const pending = this.forgePendingTool;
+        this.forgePendingTool = null;
+        const event = createToolCallEvent({
+            ts: observedAt,
+            phase: 'completed',
+            id: pending.id,
+            tool: pending.tool,
+            status: 'unknown',
+            defaultStatus: 'unknown',
+        });
+        event.summary = pending.summary;
+        if (pending.summary_truncated) {
+            event.summary_truncated = true;
+        }
+        return [event];
+    }
+    flushForgePendingTool(observedAt, terminal) {
+        if (this.agent !== 'forge' || !terminal) {
+            return [];
+        }
+        return this.completeForgePendingTool(observedAt);
+    }
+}
+export class PeekMessageExtractor {
+    extractor;
+    constructor(agent) {
+        this.extractor = new PeekEventExtractor(agent, { includeToolCalls: false });
+    }
+    push(chunk, observedAt = new Date().toISOString()) {
+        return this.toMessages(this.extractor.push(chunk, observedAt));
+    }
+    flush(observedAt = new Date().toISOString(), options = {}) {
+        return this.toMessages(this.extractor.flush(observedAt, options));
+    }
+    toMessages(events) {
+        return events
+            .filter((event) => event.kind === 'message')
+            .map((event) => ({ ts: event.ts, text: event.text }));
     }
 }
 export function parseCodexOutput(stdout) {

package/dist/peek.js

@@ -36,21 +36,24 @@ export function buildNotFoundPeekProcess(pid) {
         pid,
         agent: null,
         status: 'not_found',
-        messages: [],
+        events: [],
         truncated: false,
         error: 'process not found',
     };
 }
-export function appendPeekMessages(target, messages) {
-    for (const message of messages) {
-        if (target.messages.length < PEEK_MESSAGE_CAP) {
-            target.messages.push(message);
+export function appendPeekEvents(target, events) {
+    for (const event of events) {
+        if (target.events.length < PEEK_MESSAGE_CAP) {
+            target.events.push(event);
         }
         else {
             target.truncated = true;
         }
     }
 }
+export function appendPeekMessages(target, messages) {
+    appendPeekEvents(target, messages.map((message) => ({ kind: 'message', ...message })));
+}
 export function observedDurationSec(startedAtMs, endedAtMs = Date.now()) {
     return Number(((endedAtMs - startedAtMs) / 1000).toFixed(2));
 }

package/dist/process-service.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from './parsers.js';
-import { appendPeekMessages, buildNotFoundPeekProcess, observedDurationSec, validatePeekPids, validatePeekTimeSec, } from './peek.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekEventExtractor } from './parsers.js';
+import { appendPeekEvents, buildNotFoundPeekProcess, observedDurationSec, validatePeekPids, validatePeekTimeSec, } from './peek.js';
 import { buildProcessResult } from './process-result.js';
 function parseAgentOutput(agent, stdout, stderr) {
     if (agent === 'codex') {
@@ -156,7 +156,7 @@ export class ProcessService {
             }
         }
     }
-    async peekProcesses(pids, peekTimeSec = 10) {
+    async peekProcesses(pids, peekTimeSec = 10, includeToolCalls = false) {
         const targetPids = validatePeekPids(pids);
         const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
         const processes = [];
@@ -171,18 +171,18 @@ export class ProcessService {
                 pid,
                 agent: entry.toolType,
                 status: entry.status,
-                messages: [],
+                events: [],
                 truncated: false,
                 error: null,
             };
             processes.push(result);
-            const stdoutExtractor = new PeekMessageExtractor(entry.toolType);
-            const stderrExtractor = new PeekMessageExtractor(entry.toolType);
+            const stdoutExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stdout' });
+            const stderrExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stderr' });
             const onStdout = (data) => {
-                appendPeekMessages(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
+                appendPeekEvents(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
             };
             const onStderr = (data) => {
-                appendPeekMessages(result, stderrExtractor.push(data.toString(), new Date().toISOString()));
+                appendPeekEvents(result, stderrExtractor.push(data.toString(), new Date().toISOString()));
             };
             if (entry.status === 'running') {
                 entry.process.stdout?.on('data', onStdout);
@@ -210,8 +210,9 @@ export class ProcessService {
             for (const observer of observers) {
                 observer.entry.process.stdout?.off('data', observer.onStdout);
                 observer.entry.process.stderr?.off('data', observer.onStderr);
-                appendPeekMessages(observer.result, observer.stdoutExtractor.flush(flushTs));
-                appendPeekMessages(observer.result, observer.stderrExtractor.flush(flushTs));
+                const terminal = observer.entry.status !== 'running';
+                appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+                appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
                 observer.result.status = observer.entry.status;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.17.0",
+  "version": "2.19.0",
   "mcpName": "io.github.mkXultra/ai-cli-mcp",
   "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, Forge, and OpenCode) with background process management",
   "author": "mkXultra",

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

@@ -210,7 +210,7 @@ describe('ai-cli app', () => {
     });
 
     const exitCode = await runCli(
-      ['peek', '123', '456', '123', '--time', '5'],
+      ['peek', '123', '456', '123', '--time', '5', '--include-tool-calls'],
       {
         stdout,
         stderr,
@@ -219,7 +219,7 @@ describe('ai-cli app', () => {
     );
 
     expect(exitCode).toBe(0);
-    expect(peekProcesses).toHaveBeenCalledWith([123, 456], 5);
+    expect(peekProcesses).toHaveBeenCalledWith([123, 456], 5, true);
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"peek_started_at"'));
     expect(stderr).not.toHaveBeenCalled();
   });
@@ -235,7 +235,7 @@ describe('ai-cli app', () => {
 
     const defaultExitCode = await runCli(['peek', '123'], { stdout, stderr, peekProcesses });
     expect(defaultExitCode).toBe(0);
-    expect(peekProcesses).toHaveBeenCalledWith([123], 10);
+    expect(peekProcesses).toHaveBeenCalledWith([123], 10, false);
 
     const followExitCode = await runCli(['peek', '123', '--follow'], { stdout, stderr, peekProcesses });
     expect(followExitCode).toBe(1);

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

@@ -171,8 +171,9 @@ printf '%s\n' '{"type":"user","message":{"content":[{"type":"tool_result","tool_
       pid: runResult.pid,
       agent: 'claude',
       status: 'completed',
-      messages: [
+      events: [
         {
+          kind: 'message',
           ts: expect.any(String),
           text: 'new cli message',
         },
@@ -184,7 +185,7 @@ printf '%s\n' '{"type":"user","message":{"content":[{"type":"tool_result","tool_
       pid: 999999,
       agent: null,
       status: 'not_found',
-      messages: [],
+      events: [],
       truncated: false,
       error: 'process not found',
     });

package/src/__tests__/mcp-contract.test.ts

@@ -137,6 +137,7 @@ describe('MCP Contract Tests', () => {
     const peekTool = tools.find((tool: any) => tool.name === 'peek');
     expect(peekTool.inputSchema.required).toEqual(['pids']);
     expect(Object.keys(peekTool.inputSchema.properties).sort()).toEqual([
+      'include_tool_calls',
       'peek_time_sec',
       'pids',
     ]);