@promptbook/cli 0.114.0-2 → 0.114.0-20

package/src/utils/agent-message-runtime/resolveAgentMessageRuntimeActivity.ts

@@ -1,3 +1,6 @@
+import type { AgentMessageRuntimeLogEvent } from './parseAgentMessageRuntimeLogEvents';
+import { parseAgentMessageRuntimeLogEvents } from './parseAgentMessageRuntimeLogEvents';
+
 /**
  * Maximum length of one user-facing progress activity snippet.
  *
@@ -6,28 +9,69 @@
 const MAX_RUNTIME_ACTIVITY_LENGTH = 160;
 
 /**
- * Minimal shape of one coding-harness `stream-json` event relevant to progress extraction.
- *
- * Only the natural-language assistant narration is read; every other field is ignored so raw
- * tool payloads and technical envelopes never reach the user-facing progress card.
+ * One safe, concrete category of a command emitted by the Codex runtime.
  *
  * @private internal type of agent-message runtime activity
  */
-type RuntimeLogEvent = {
-    readonly type?: string;
-    readonly message?: {
-        readonly content?: ReadonlyArray<{
-            readonly type?: string;
-            readonly text?: string;
-        }>;
-    };
-    readonly item?: {
-        readonly type?: string;
-        readonly command?: string;
-        readonly exit_code?: number | null;
-    };
+type CodexCommandActivity = {
+    readonly pattern: RegExp;
+    readonly running: string;
+    readonly completed: string;
 };
 
+/**
+ * Ordered command categories that can be described truthfully without showing raw commands,
+ * arguments, file names, or other private runtime details.
+ *
+ * The local runner can execute on either Unix or Windows. Keeping the variants together here
+ * ensures that equivalent shell commands yield the same concise status in the chat.
+ *
+ * @private internal constant of agent-message runtime activity
+ */
+const CODEX_COMMAND_ACTIVITIES: ReadonlyArray<CodexCommandActivity> = [
+    {
+        pattern: /(^|\s)(npm\s+(?:run\s+)?test|pnpm\s+(?:run\s+)?test|yarn\s+test|jest|vitest|pytest)\b/u,
+        running: 'Running tests.',
+        completed: 'Finished running tests.',
+    },
+    {
+        pattern: /(^|\s)(npm\s+run\s+build|pnpm\s+(?:run\s+)?build|yarn\s+build|next\s+build)\b/u,
+        running: 'Building the project.',
+        completed: 'Finished building the project.',
+    },
+    {
+        pattern: /(^|\s)(npm|pnpm|yarn)\s+(?:install|add)\b/u,
+        running: 'Installing dependencies.',
+        completed: 'Finished installing dependencies.',
+    },
+    {
+        pattern: /(^|\s)(npm\s+(?:run\s+)?lint|pnpm\s+(?:run\s+)?lint|yarn\s+lint|eslint|prettier)\b/u,
+        running: 'Checking the implementation.',
+        completed: 'Finished checking the implementation.',
+    },
+    {
+        pattern: /(^|\s)git\s+(?:status|diff|log|show)\b/u,
+        running: 'Reviewing changes.',
+        completed: 'Finished reviewing changes.',
+    },
+    {
+        pattern: /(^|\s)(apply_patch|set-content|add-content|out-file|new-item|copy-item|move-item|set-item)\b/u,
+        running: 'Updating relevant files.',
+        completed: 'Finished updating relevant files.',
+    },
+    {
+        pattern:
+            /(^|\s)(ls|find|rg|grep|sed|cat|head|tail|get-content|get-childitem|get-item|select-string|findstr|type)\b/u,
+        running: 'Inspecting relevant files.',
+        completed: 'Finished inspecting relevant files.',
+    },
+    {
+        pattern: /(^|\s)(curl|wget|invoke-webrequest)\b/u,
+        running: 'Looking up information.',
+        completed: 'Finished looking up information.',
+    },
+];
+
 /**
  * Resolves the latest user-friendly activity snippet from a coding-harness runtime log.
  *
@@ -35,9 +79,9 @@ type RuntimeLogEvent = {
  * Claude Code `--output-format stream-json`) into a live runtime log file next to the queued
  * message. This helper extracts the most recent natural-language assistant narration so the
  * durable chat can show what the agent is doing right now instead of a generic thinking
- * placeholder. Only plain assistant text is surfaced; raw tool payloads, JSON envelopes and
- * other technical details are intentionally ignored, and harnesses that do not stream
- * structured text simply resolve to `null` so the caller keeps its existing behavior.
+ * placeholder. Only concrete, safe activity is surfaced; raw tool payloads, JSON envelopes,
+ * and private reasoning are intentionally ignored. When no concrete activity is known, this
+ * resolves to `null` so the caller keeps the browser's rotating generic thinking state.
  *
  * @param logText - Raw runtime log content.
  * @returns Latest human-readable activity snippet, or `null` when none can be resolved.
@@ -50,12 +94,7 @@ export function resolveAgentMessageRuntimeActivity(logText: string | null | unde
 
     let latestActivity: string | null = null;
 
-    for (const line of logText.split(/\r?\n/u)) {
-        const event = parseRuntimeLogEvent(line);
-        if (!event) {
-            continue;
-        }
-
+    for (const event of parseAgentMessageRuntimeLogEvents(logText)) {
         const activity = resolveRuntimeLogEventActivity(event);
         if (activity) {
             latestActivity = activity;
@@ -65,35 +104,12 @@ export function resolveAgentMessageRuntimeActivity(logText: string | null | unde
     return latestActivity === null ? null : truncateRuntimeActivity(latestActivity);
 }
 
-/**
- * Parses one runtime log line into a structured event when it embeds JSON.
- *
- * @private internal helper of `resolveAgentMessageRuntimeActivity`
- */
-function parseRuntimeLogEvent(line: string): RuntimeLogEvent | null {
-    const jsonStartIndex = line.indexOf('{');
-    if (jsonStartIndex === -1) {
-        return null;
-    }
-
-    try {
-        const parsed = JSON.parse(line.slice(jsonStartIndex).trim()) as unknown;
-        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-            return null;
-        }
-
-        return parsed as RuntimeLogEvent;
-    } catch {
-        return null;
-    }
-}
-
 /**
  * Resolves the natural-language assistant narration from one complete assistant event.
  *
  * @private internal helper of `resolveAgentMessageRuntimeActivity`
  */
-function resolveRuntimeLogEventActivity(event: RuntimeLogEvent): string | null {
+function resolveRuntimeLogEventActivity(event: AgentMessageRuntimeLogEvent): string | null {
     const codexActivity = resolveCodexRuntimeLogEventActivity(event);
     if (codexActivity) {
         return codexActivity;
@@ -118,10 +134,13 @@ function resolveRuntimeLogEventActivity(event: RuntimeLogEvent): string | null {
  *
  * Codex reasoning and raw command text deliberately remain private. The event type tells us
  * enough to report a useful action without exposing the internal trace or a command payload.
+ * Reasoning events are intentionally not a progress update: while they are the only signal,
+ * the chat retains its configured generic thinking rotation. Once a concrete action arrives,
+ * it becomes the latest user-facing status instead.
  *
  * @private internal helper of `resolveAgentMessageRuntimeActivity`
  */
-function resolveCodexRuntimeLogEventActivity(event: RuntimeLogEvent): string | null {
+function resolveCodexRuntimeLogEventActivity(event: AgentMessageRuntimeLogEvent): string | null {
     if (!event.item || !isCodexItemEvent(event.type)) {
         return null;
     }
@@ -130,7 +149,7 @@ function resolveCodexRuntimeLogEventActivity(event: RuntimeLogEvent): string | n
 
     switch (event.item.type) {
         case 'reasoning':
-            return isCompleted ? 'Considered the request.' : 'Considering the request.';
+            return null;
         case 'command_execution':
             return resolveCodexCommandActivity(event.item.command, isCompleted, event.item.exit_code);
         case 'file_change':
@@ -164,12 +183,16 @@ function resolveCodexCommandActivity(
     command: string | undefined,
     isCompleted: boolean,
     exitCode: number | null | undefined,
-): string {
+): string | null {
     if (isCompleted && exitCode !== undefined && exitCode !== null && exitCode !== 0) {
         return 'A command needs attention.';
     }
 
     const activity = resolveCodexCommandActivityLabel(command);
+    if (!activity) {
+        return null;
+    }
+
     return isCompleted ? activity.completed : activity.running;
 }
 
@@ -178,30 +201,10 @@ function resolveCodexCommandActivity(
  *
  * @private internal helper of `resolveAgentMessageRuntimeActivity`
  */
-function resolveCodexCommandActivityLabel(command: string | undefined): { running: string; completed: string } {
+function resolveCodexCommandActivityLabel(command: string | undefined): CodexCommandActivity | null {
     const normalizedCommand = command?.toLowerCase() || '';
 
-    if (/(^|\s)(npm\s+(?:run\s+)?test|pnpm\s+(?:run\s+)?test|yarn\s+test|jest|vitest|pytest)\b/u.test(normalizedCommand)) {
-        return { running: 'Running tests.', completed: 'Finished running tests.' };
-    }
-
-    if (/(^|\s)(npm\s+run\s+build|pnpm\s+(?:run\s+)?build|yarn\s+build|next\s+build)\b/u.test(normalizedCommand)) {
-        return { running: 'Building the project.', completed: 'Finished building the project.' };
-    }
-
-    if (/(^|\s)(npm|pnpm|yarn)\s+(?:install|add)\b/u.test(normalizedCommand)) {
-        return { running: 'Installing dependencies.', completed: 'Finished installing dependencies.' };
-    }
-
-    if (/(^|\s)git\s+(?:status|diff|log|show)\b/u.test(normalizedCommand)) {
-        return { running: 'Reviewing changes.', completed: 'Finished reviewing changes.' };
-    }
-
-    if (/(^|\s)(ls|find|rg|grep|sed|cat|head|tail)\b/u.test(normalizedCommand)) {
-        return { running: 'Inspecting relevant files.', completed: 'Finished inspecting relevant files.' };
-    }
-
-    return { running: 'Running a task.', completed: 'Finished a task.' };
+    return CODEX_COMMAND_ACTIVITIES.find((activity) => activity.pattern.test(normalizedCommand)) ?? null;
 }
 
 /**

package/src/utils/agent-message-runtime/resolveAgentMessageTouchedExternalSources.ts

@@ -0,0 +1,341 @@
+import { capitalize } from '../normalization/capitalize';
+import type { AgentMessageTouchedExternalSource } from './AgentMessageTouchedExternalSource';
+import type {
+    AgentMessageRuntimeLogContentBlock,
+    AgentMessageRuntimeLogEvent,
+} from './parseAgentMessageRuntimeLogEvents';
+import { parseAgentMessageRuntimeLogEvents } from './parseAgentMessageRuntimeLogEvents';
+
+/**
+ * Maximum count of external sources reported for one answered message.
+ *
+ * A single answer can reach the same kind of source many times, so the chip row below it stays
+ * readable by keeping only the sources touched first.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const MAX_TOUCHED_EXTERNAL_SOURCES = 12;
+
+/**
+ * Maximum length of one search query shown as the name of a touched search source.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const MAX_SEARCH_QUERY_LENGTH = 48;
+
+/**
+ * Separator between the segments of one integration tool name, as in `mcp__gmail__create_draft`.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const INTEGRATION_TOOL_NAME_SEPARATOR = '__';
+
+/**
+ * First segment marking one tool name as belonging to an integration.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const INTEGRATION_TOOL_NAME_PREFIX = 'mcp';
+
+/**
+ * Names of the harness tools which look something up on the web, indexed for case-insensitive matching.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const WEB_SEARCH_TOOL_NAMES: ReadonlySet<string> = new Set(
+    ['WebSearch', 'web_search'].map((webSearchToolName) => webSearchToolName.toLowerCase()),
+);
+
+/**
+ * Matches one shell command invoking a network client, whose arguments therefore address the outside world.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const NETWORK_CLIENT_COMMAND_REGEX = /(^|[\s|;&(])(curl|wget|invoke-webrequest|iwr)\b/iu;
+
+/**
+ * Matches one web address inside a shell command.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const COMMAND_URL_REGEX = /https?:\/\/[^\s"'`<>)\]]+/giu;
+
+/**
+ * Separators used between the words of one integration name.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const INTEGRATION_NAME_WORD_SEPARATOR_REGEX = /[-_.\s]+/gu;
+
+/**
+ * Hostnames which address the machine the agent runs on and are therefore not external.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const LOCAL_HOSTNAMES: ReadonlySet<string> = new Set(['localhost', '127.0.0.1', '0.0.0.0', '::1', '[::1]']);
+
+/**
+ * Resolves which sources outside the agent one coding harness touched while answering a single message.
+ *
+ * The runtime log streams what the harness really did, so a source counts as touched when the
+ * harness reached it in a tool invocation — calling an integration, fetching a web address,
+ * searching the web, or running a network client in the shell. Only tool payloads are inspected:
+ * tool results and assistant narration are ignored so a service merely mentioned in the
+ * conversation is never reported, and addresses of the machine the agent runs on are dropped
+ * because they are internal.
+ *
+ * @param options - Raw runtime log content of one answered message.
+ * @returns Touched external sources without duplicates, ordered by first appearance.
+ * @private internal utility of the agent-message runtime
+ */
+export function resolveAgentMessageTouchedExternalSources(options: {
+    readonly logText: string | null | undefined;
+}): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    const touchedExternalSources = new Map<string, AgentMessageTouchedExternalSource>();
+
+    for (const event of parseAgentMessageRuntimeLogEvents(options.logText)) {
+        for (const externalSource of resolveRuntimeLogEventExternalSources(event)) {
+            const externalSourceKey = createExternalSourceKey(externalSource);
+
+            if (!touchedExternalSources.has(externalSourceKey)) {
+                touchedExternalSources.set(externalSourceKey, externalSource);
+            }
+
+            if (touchedExternalSources.size === MAX_TOUCHED_EXTERNAL_SOURCES) {
+                return Array.from(touchedExternalSources.values());
+            }
+        }
+    }
+
+    return Array.from(touchedExternalSources.values());
+}
+
+/**
+ * Collects every external source described by one runtime log event.
+ *
+ * Claude Code reports tool invocations as `tool_use` content blocks, while Codex reports executed
+ * commands, web searches, and integration calls as items.
+ *
+ * @param event - One structured runtime log event.
+ * @returns External sources the event reached, possibly with duplicates.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveRuntimeLogEventExternalSources(
+    event: AgentMessageRuntimeLogEvent,
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    const externalSources: Array<AgentMessageTouchedExternalSource> = [];
+
+    for (const contentBlock of event.message?.content || []) {
+        if (contentBlock.type === 'tool_use') {
+            externalSources.push(...resolveToolUseExternalSources(contentBlock));
+        }
+    }
+
+    externalSources.push(...resolveCodexItemExternalSources(event.item));
+
+    return externalSources;
+}
+
+/**
+ * Collects the external sources reached by one Claude Code tool invocation.
+ *
+ * @param contentBlock - One `tool_use` content block.
+ * @returns External sources the invocation reached.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveToolUseExternalSources(
+    contentBlock: AgentMessageRuntimeLogContentBlock,
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    const toolName = contentBlock.name || '';
+    const toolInput = contentBlock.input || {};
+
+    return collectDefinedExternalSources([
+        createIntegrationExternalSource(resolveIntegrationName(toolName)),
+        typeof toolInput.url === 'string' ? createWebsiteExternalSource(toolInput.url) : null,
+        WEB_SEARCH_TOOL_NAMES.has(toolName.toLowerCase()) && typeof toolInput.query === 'string'
+            ? createSearchExternalSource(toolInput.query)
+            : null,
+        ...(typeof toolInput.command === 'string' ? resolveNetworkCommandExternalSources(toolInput.command) : []),
+    ]);
+}
+
+/**
+ * Collects the external sources reached by one Codex runtime item.
+ *
+ * @param item - One Codex item of a runtime log event.
+ * @returns External sources the item reached.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveCodexItemExternalSources(
+    item: AgentMessageRuntimeLogEvent['item'],
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    if (!item) {
+        return [];
+    }
+
+    return collectDefinedExternalSources([
+        item.type === 'mcp_tool_call'
+            ? createIntegrationExternalSource(item.server || resolveIntegrationName(item.tool || ''))
+            : null,
+        item.type === 'web_search' && typeof item.query === 'string' ? createSearchExternalSource(item.query) : null,
+        ...(typeof item.command === 'string' ? resolveNetworkCommandExternalSources(item.command) : []),
+    ]);
+}
+
+/**
+ * Drops the candidates which turned out not to describe an external source.
+ *
+ * @param candidates - Resolved sources mixed with the candidates that resolved to nothing.
+ * @returns Only the sources which were resolved.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function collectDefinedExternalSources(
+    candidates: ReadonlyArray<AgentMessageTouchedExternalSource | null>,
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    return candidates.filter((candidate): candidate is AgentMessageTouchedExternalSource => candidate !== null);
+}
+
+/**
+ * Resolves the integration a tool name belongs to, following the `mcp__<integration>__<tool>` convention.
+ *
+ * @param toolName - Raw harness tool name.
+ * @returns Raw integration name, or `null` when the tool belongs to no integration.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveIntegrationName(toolName: string): string | null {
+    const toolNameSegments = toolName.split(INTEGRATION_TOOL_NAME_SEPARATOR);
+
+    if (toolNameSegments.length < 3 || toolNameSegments[0]!.toLowerCase() !== INTEGRATION_TOOL_NAME_PREFIX) {
+        return null;
+    }
+
+    return toolNameSegments[1] || null;
+}
+
+/**
+ * Creates one touched integration source.
+ *
+ * @param integrationName - Raw integration name, or `null` when there is none.
+ * @returns Touched source, or `null` when the integration cannot be named.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createIntegrationExternalSource(integrationName: string | null): AgentMessageTouchedExternalSource | null {
+    const humanizedIntegrationName = humanizeIntegrationName(integrationName || '');
+
+    if (humanizedIntegrationName === '') {
+        return null;
+    }
+
+    return { kind: 'integration', name: humanizedIntegrationName };
+}
+
+/**
+ * Creates one touched website source.
+ *
+ * @param rawUrl - Raw web address the harness reached.
+ * @returns Touched source, or `null` when the address is unusable or addresses the local machine.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createWebsiteExternalSource(rawUrl: string): AgentMessageTouchedExternalSource | null {
+    let url: URL;
+    try {
+        url = new URL(rawUrl.trim());
+    } catch {
+        return null;
+    }
+
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return null;
+    }
+
+    const hostname = url.hostname.toLowerCase();
+    if (hostname === '' || LOCAL_HOSTNAMES.has(hostname) || hostname.endsWith('.localhost')) {
+        return null;
+    }
+
+    return { kind: 'website', name: hostname, url: url.href };
+}
+
+/**
+ * Creates one touched web search source.
+ *
+ * @param query - Raw query the harness looked up.
+ * @returns Touched source, or `null` when the query is empty.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createSearchExternalSource(query: string): AgentMessageTouchedExternalSource | null {
+    const normalizedQuery = query.replace(/\s+/gu, ' ').trim();
+
+    if (normalizedQuery === '') {
+        return null;
+    }
+
+    return {
+        kind: 'search',
+        name:
+            normalizedQuery.length <= MAX_SEARCH_QUERY_LENGTH
+                ? normalizedQuery
+                : `${normalizedQuery.slice(0, MAX_SEARCH_QUERY_LENGTH).trimEnd()}…`,
+    };
+}
+
+/**
+ * Collects the websites addressed by one shell command running a network client.
+ *
+ * Commands which do not invoke a network client are ignored, so a web address that merely appears
+ * in the text the agent writes into a file is never reported as touched.
+ *
+ * @param command - One executed shell command.
+ * @returns Touched website sources of the command.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveNetworkCommandExternalSources(command: string): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    if (!NETWORK_CLIENT_COMMAND_REGEX.test(command)) {
+        return [];
+    }
+
+    const commandUrlRegex = new RegExp(COMMAND_URL_REGEX.source, COMMAND_URL_REGEX.flags);
+    const externalSources: Array<AgentMessageTouchedExternalSource> = [];
+    let commandUrlMatch = commandUrlRegex.exec(command);
+
+    while (commandUrlMatch !== null) {
+        const externalSource = createWebsiteExternalSource(commandUrlMatch[0]);
+
+        if (externalSource) {
+            externalSources.push(externalSource);
+        }
+
+        commandUrlMatch = commandUrlRegex.exec(command);
+    }
+
+    return externalSources;
+}
+
+/**
+ * Converts one raw integration name into its user-facing form.
+ *
+ * For example `google-calendar` becomes `Google Calendar`.
+ *
+ * @param integrationName - Raw integration name.
+ * @returns Human-readable integration name, or an empty string when there is nothing to show.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function humanizeIntegrationName(integrationName: string): string {
+    return integrationName
+        .trim()
+        .split(INTEGRATION_NAME_WORD_SEPARATOR_REGEX)
+        .filter((integrationNameWord) => integrationNameWord !== '')
+        .map((integrationNameWord) => capitalize(integrationNameWord))
+        .join(' ');
+}
+
+/**
+ * Builds the key identifying one external source across the whole run.
+ *
+ * @param externalSource - One touched external source.
+ * @returns Key under which repeated touches of the same source collapse into one.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createExternalSourceKey(externalSource: AgentMessageTouchedExternalSource): string {
+    return `${externalSource.kind}:${externalSource.name.toLowerCase()}`;
+}