@promptbook/cli 0.114.0-11 → 0.114.0-13

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

@@ -0,0 +1,105 @@
+/**
+ * One string-keyed payload of a coding-harness tool invocation.
+ *
+ * @private internal type of agent-message runtime logs
+ */
+type RuntimeLogToolInput = Record<string, unknown>;
+
+/**
+ * One content block of a Claude Code `stream-json` assistant event.
+ *
+ * @private internal type of agent-message runtime logs
+ */
+export type AgentMessageRuntimeLogContentBlock = {
+    readonly type?: string;
+    readonly text?: string;
+    readonly name?: string;
+    readonly input?: RuntimeLogToolInput;
+};
+
+/**
+ * One file path touched by a Codex `file_change` item.
+ *
+ * @private internal type of agent-message runtime logs
+ */
+export type AgentMessageRuntimeLogFileChange = {
+    readonly path?: string;
+};
+
+/**
+ * Minimal shape of one coding-harness runtime log event.
+ *
+ * The runtime log mixes two harness formats — Claude Code `stream-json` (`type`/`message`) and
+ * Codex JSONL (`type`/`item`) — so both are described by one permissive structure and every
+ * consumer reads only the fields it understands.
+ *
+ * @private internal type of agent-message runtime logs
+ */
+export type AgentMessageRuntimeLogEvent = {
+    readonly type?: string;
+    readonly message?: {
+        readonly content?: ReadonlyArray<AgentMessageRuntimeLogContentBlock>;
+    };
+    readonly item?: {
+        readonly type?: string;
+        readonly command?: string;
+        readonly exit_code?: number | null;
+        readonly changes?: ReadonlyArray<AgentMessageRuntimeLogFileChange>;
+    };
+};
+
+/**
+ * Parses every structured event out of one coding-harness runtime log.
+ *
+ * The local agent runner streams the answering harness output into a live runtime log file, one
+ * JSON event per line, optionally prefixed by shell noise. Lines without a usable JSON object are
+ * skipped so a partially written or interleaved log never breaks its consumers.
+ *
+ * @param logText - Raw runtime log content.
+ * @returns Structured events in the order they were streamed.
+ * @private internal utility of the agent-message runtime
+ */
+export function parseAgentMessageRuntimeLogEvents(
+    logText: string | null | undefined,
+): ReadonlyArray<AgentMessageRuntimeLogEvent> {
+    if (!logText) {
+        return [];
+    }
+
+    const events: Array<AgentMessageRuntimeLogEvent> = [];
+
+    for (const line of logText.split(/\r?\n/u)) {
+        const event = parseAgentMessageRuntimeLogEvent(line);
+
+        if (event) {
+            events.push(event);
+        }
+    }
+
+    return events;
+}
+
+/**
+ * Parses one runtime log line into a structured event when it embeds JSON.
+ *
+ * @param line - One raw runtime log line.
+ * @returns Structured event, or `null` when the line carries no JSON object.
+ * @private internal helper of `parseAgentMessageRuntimeLogEvents`
+ */
+function parseAgentMessageRuntimeLogEvent(line: string): AgentMessageRuntimeLogEvent | null {
+    const jsonStartIndex = line.indexOf('{');
+    if (jsonStartIndex === -1) {
+        return null;
+    }
+
+    try {
+        const parsedEvent = JSON.parse(line.slice(jsonStartIndex).trim()) as unknown;
+        if (typeof parsedEvent !== 'object' || parsedEvent === null || Array.isArray(parsedEvent)) {
+            return null;
+        }
+
+        return parsedEvent as AgentMessageRuntimeLogEvent;
+    } catch {
+        return null;
+    }
+}

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.
  *
@@ -71,29 +74,6 @@ const CODEX_COMMAND_ACTIVITIES: ReadonlyArray<CodexCommandActivity> = [
     },
 ];
 
-/**
- * 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.
- *
- * @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;
-    };
-};
-
 /**
  * Resolves the latest user-friendly activity snippet from a coding-harness runtime log.
  *
@@ -116,12 +96,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;
@@ -131,35 +106,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;
@@ -190,7 +142,7 @@ function resolveRuntimeLogEventActivity(event: RuntimeLogEvent): string | null {
  *
  * @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;
     }

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

@@ -0,0 +1,147 @@
+import { AGENT_PROJECTS_DIRECTORY_PATH } from '../../book-3.0/agentFolderPaths';
+import type { AgentMessageRuntimeLogEvent } from './parseAgentMessageRuntimeLogEvents';
+import { parseAgentMessageRuntimeLogEvents } from './parseAgentMessageRuntimeLogEvents';
+
+/**
+ * Matches one project directory name following the agent `projects/` folder in a file path or command.
+ *
+ * Both path separators are accepted because the local runner answers messages on Unix and Windows,
+ * and JSON-encoded payloads escape backslashes.
+ *
+ * @private internal constant of agent-message touched projects
+ */
+const TOUCHED_PROJECT_PATH_REGEX = new RegExp(`${AGENT_PROJECTS_DIRECTORY_PATH}[\\\\/]+([^\\\\/"'\\s,;:]+)`, 'giu');
+
+/**
+ * Resolves which projects one coding harness touched while answering a single message.
+ *
+ * The runtime log streams what the harness really did, so a project counts as touched when the
+ * harness named it in a tool invocation — reading, searching, running, or editing files inside
+ * `projects/<project-name>/`. Only tool payloads are inspected: tool results and assistant
+ * narration are ignored so a project merely mentioned in the conversation is never reported.
+ *
+ * Every candidate is matched against the projects that really exist, which both filters prompt
+ * placeholders such as `projects/<project-name>/` and keeps the reported names canonical.
+ *
+ * @param options - Raw runtime log content and the project directory names of the agent.
+ * @returns Touched project names in the canonical spelling, ordered by first appearance.
+ * @private internal utility of the agent-message runtime
+ */
+export function resolveAgentMessageTouchedProjectNames(options: {
+    readonly logText: string | null | undefined;
+    readonly knownProjectNames: ReadonlyArray<string>;
+}): ReadonlyArray<string> {
+    const canonicalProjectNames = createCanonicalProjectNameLookup(options.knownProjectNames);
+    if (canonicalProjectNames.size === 0) {
+        return [];
+    }
+
+    const touchedProjectNames = new Set<string>();
+
+    for (const event of parseAgentMessageRuntimeLogEvents(options.logText)) {
+        for (const toolInvocationText of resolveRuntimeLogEventToolInvocationTexts(event)) {
+            for (const candidateProjectName of resolveCandidateProjectNames(toolInvocationText)) {
+                const canonicalProjectName = canonicalProjectNames.get(candidateProjectName.toLowerCase());
+
+                if (canonicalProjectName !== undefined) {
+                    touchedProjectNames.add(canonicalProjectName);
+                }
+            }
+        }
+    }
+
+    return Array.from(touchedProjectNames);
+}
+
+/**
+ * Indexes the existing project directory names by their lower-cased form.
+ *
+ * @param knownProjectNames - Project directory names of the agent.
+ * @returns Lookup from the lower-cased name to its canonical spelling.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function createCanonicalProjectNameLookup(knownProjectNames: ReadonlyArray<string>): Map<string, string> {
+    const canonicalProjectNames = new Map<string, string>();
+
+    for (const knownProjectName of knownProjectNames) {
+        const normalizedProjectName = knownProjectName.trim();
+
+        if (normalizedProjectName.length > 0) {
+            canonicalProjectNames.set(normalizedProjectName.toLowerCase(), normalizedProjectName);
+        }
+    }
+
+    return canonicalProjectNames;
+}
+
+/**
+ * Collects the texts of every tool invocation described by one runtime log event.
+ *
+ * Claude Code reports tool invocations as `tool_use` content blocks, while Codex reports executed
+ * commands and file changes as items — both carry the paths the harness worked with.
+ *
+ * @param event - One structured runtime log event.
+ * @returns Texts that may contain project paths.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function resolveRuntimeLogEventToolInvocationTexts(event: AgentMessageRuntimeLogEvent): ReadonlyArray<string> {
+    const toolInvocationTexts: Array<string> = [];
+
+    for (const contentBlock of event.message?.content || []) {
+        if (contentBlock.type === 'tool_use' && contentBlock.input) {
+            toolInvocationTexts.push(serializeToolInput(contentBlock.input));
+        }
+    }
+
+    if (typeof event.item?.command === 'string') {
+        toolInvocationTexts.push(event.item.command);
+    }
+
+    for (const fileChange of event.item?.changes || []) {
+        if (typeof fileChange.path === 'string') {
+            toolInvocationTexts.push(fileChange.path);
+        }
+    }
+
+    return toolInvocationTexts;
+}
+
+/**
+ * Serializes one tool input payload into scannable text.
+ *
+ * @param toolInput - Tool arguments of one harness tool invocation.
+ * @returns Serialized payload, or an empty string when it cannot be serialized.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function serializeToolInput(toolInput: Record<string, unknown>): string {
+    try {
+        return JSON.stringify(toolInput);
+    } catch {
+        return '';
+    }
+}
+
+/**
+ * Extracts every project directory name mentioned right after the agent `projects/` folder.
+ *
+ * @param toolInvocationText - One tool payload, command, or changed path.
+ * @returns Candidate project directory names.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function resolveCandidateProjectNames(toolInvocationText: string): ReadonlyArray<string> {
+    const candidateProjectNames: Array<string> = [];
+    const projectPathRegex = new RegExp(TOUCHED_PROJECT_PATH_REGEX.source, TOUCHED_PROJECT_PATH_REGEX.flags);
+    let projectPathMatch = projectPathRegex.exec(toolInvocationText);
+
+    while (projectPathMatch !== null) {
+        const candidateProjectName = projectPathMatch[1];
+
+        if (candidateProjectName) {
+            candidateProjectNames.push(candidateProjectName);
+        }
+
+        projectPathMatch = projectPathRegex.exec(toolInvocationText);
+    }
+
+    return candidateProjectNames;
+}

package/src/version.ts

@@ -16,11 +16,11 @@ export const BOOK_LANGUAGE_VERSION: string_semantic_version = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-11';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-13';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.114.0-10`).
+ * It follows semantic versioning (e.g., `0.114.0-12`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1187,4 +1187,5 @@
 0.114.0-8
 0.114.0-9
 0.114.0-10
-0.114.0-11
+0.114.0-12
+0.114.0-13