@kynetic-ai/spec 0.1.2 → 0.4.0

package/dist/ralph/events.js

@@ -15,49 +15,49 @@
 function getToolSummary(tool, input) {
     const inp = input;
     switch (tool) {
-        case 'Bash': {
+        case "Bash": {
             const cmd = inp.command;
             if (cmd) {
-                return cmd.length > 50 ? cmd.slice(0, 47) + '...' : cmd;
+                return cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd;
             }
-            return '';
+            return "";
         }
-        case 'Read':
-        case 'Write':
-        case 'Edit': {
+        case "Read":
+        case "Write":
+        case "Edit": {
             const filePath = inp.file_path;
             if (filePath) {
                 // Extract filename from path
-                const parts = filePath.split('/');
+                const parts = filePath.split("/");
                 return parts[parts.length - 1] || filePath;
             }
-            return '';
+            return "";
         }
-        case 'Grep': {
+        case "Grep": {
             const pattern = inp.pattern;
-            return pattern ? `/${pattern}/` : '';
+            return pattern ? `/${pattern}/` : "";
         }
-        case 'Glob': {
+        case "Glob": {
             const pattern = inp.pattern;
-            return pattern || '';
+            return pattern || "";
         }
-        case 'WebSearch': {
+        case "WebSearch": {
             const query = inp.query;
-            return query || '';
+            return query || "";
         }
-        case 'Task': {
+        case "Task": {
             const desc = inp.description;
-            return desc || '';
+            return desc || "";
         }
-        case 'TodoWrite': {
+        case "TodoWrite": {
             const todos = inp.todos;
             if (todos && todos.length > 0) {
                 return `${todos.length} item(s)`;
             }
-            return '';
+            return "";
         }
         default:
-            return '';
+            return "";
     }
 }
 /**
@@ -84,7 +84,7 @@ function extractToolName(update) {
     if (update.title) {
         return normalizeTool(update.title);
     }
-    return 'unknown';
+    return "unknown";
 }
 /**
  * Normalize tool name by stripping MCP prefixes.
@@ -103,7 +103,7 @@ function normalizeTool(name) {
 function extractToolOutput(update) {
     // Try rawOutput first
     if (update.rawOutput !== undefined) {
-        return truncateOutput(String(update.rawOutput));
+        return truncateOutput(stringify(update.rawOutput));
     }
     // Try _meta.claudeCode.toolResponse (Claude Code pattern)
     // toolResponse is an object with stdout/stderr, not a string
@@ -113,16 +113,17 @@ function extractToolOutput(update) {
         if (claudeCode?.toolResponse !== undefined) {
             const toolResponse = claudeCode.toolResponse;
             // Extract stdout, falling back to stringifying the whole response
-            if (typeof toolResponse.stdout === 'string') {
-                const combined = toolResponse.stdout + (toolResponse.stderr ? `\n${toolResponse.stderr}` : '');
+            if (typeof toolResponse.stdout === "string") {
+                const combined = toolResponse.stdout +
+                    (toolResponse.stderr ? `\n${toolResponse.stderr}` : "");
                 return truncateOutput(combined.trim());
             }
-            return truncateOutput(String(toolResponse));
+            return truncateOutput(stringify(toolResponse));
         }
     }
     // Try output field
     if (update.output !== undefined) {
-        return truncateOutput(String(update.output));
+        return truncateOutput(stringify(update.output));
     }
     return undefined;
 }
@@ -131,32 +132,56 @@ function extractToolOutput(update) {
  */
 function extractOriginalOutput(update) {
     if (update.rawOutput !== undefined) {
-        return String(update.rawOutput);
+        return stringify(update.rawOutput);
     }
     const meta = update._meta;
     if (meta) {
         const claudeCode = meta.claudeCode;
         if (claudeCode?.toolResponse !== undefined) {
             const toolResponse = claudeCode.toolResponse;
-            if (typeof toolResponse.stdout === 'string') {
-                return (toolResponse.stdout + (toolResponse.stderr ? `\n${toolResponse.stderr}` : '')).trim();
+            if (typeof toolResponse.stdout === "string") {
+                return (toolResponse.stdout +
+                    (toolResponse.stderr ? `\n${toolResponse.stderr}` : "")).trim();
             }
         }
     }
     if (update.output !== undefined) {
-        return String(update.output);
+        return stringify(update.output);
     }
     return undefined;
 }
+/**
+ * Safely stringify a value that may be a string, array of content blocks, or object.
+ * Handles ACP tool results delivered as arrays like [{type:'text',text:'...'},...]
+ */
+function stringify(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        // Array of content blocks: extract .text fields
+        const texts = value
+            .map((item) => typeof item === "string"
+            ? item
+            : typeof item === "object" && item !== null && "text" in item
+                ? String(item.text)
+                : JSON.stringify(item))
+            .filter(Boolean);
+        return texts.join("\n");
+    }
+    if (typeof value === "object" && value !== null) {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
 /**
  * Truncate output to reasonable size.
  */
 function truncateOutput(output) {
     const MAX_LINES = 20;
     const MAX_CHARS = 1000;
-    const lines = output.split('\n');
+    const lines = output.split("\n");
     if (lines.length > MAX_LINES) {
-        return lines.slice(0, MAX_LINES).join('\n');
+        return lines.slice(0, MAX_LINES).join("\n");
     }
     if (output.length > MAX_CHARS) {
         return output.slice(0, MAX_CHARS);
@@ -174,119 +199,256 @@ function wasOutputTruncated(original, truncated) {
 // ============================================================================
 // Noise Suppression
 // ============================================================================
-const SUPPRESSED_PATTERNS = [
-    /No onPostToolUseHook found/i,
-    /No onPreToolUseHook found/i,
+/**
+ * Noise patterns to strip from streaming content.
+ * These match Claude Code hook warning messages that leak into agent output.
+ * Pattern structure handles various noise forms:
+ * - "No on[Pre|Post]ToolUseHook found"
+ * - "No on[Pre|Post]ToolUseHook found for tool use"
+ * - "No on[Pre|Post]ToolUseHook found for tool use ID: toolu_<24 chars>"
+ * Tool IDs are exactly 24 base62 characters after "toolu_".
+ */
+const NOISE_PATTERNS = [
+    /No onPostToolUseHook found(?:\s+for\s+tool\s+use(?:\s+ID:\s*toolu_[A-Za-z0-9]{24})?)?/gi,
+    /No onPreToolUseHook found(?:\s+for\s+tool\s+use(?:\s+ID:\s*toolu_[A-Za-z0-9]{24})?)?/gi,
 ];
 /**
- * Check if a message should be suppressed from display.
+ * Full noise pattern strings (without tool ID suffix).
+ * Used to check if a suffix could be a prefix of a noise pattern.
  */
-function shouldSuppress(content) {
-    return SUPPRESSED_PATTERNS.some((pattern) => pattern.test(content));
+const NOISE_PATTERN_STRINGS = [
+    "No onPostToolUseHook found for tool use ID: toolu_",
+    "No onPreToolUseHook found for tool use ID: toolu_",
+    "No onPostToolUseHook found for tool use",
+    "No onPreToolUseHook found for tool use",
+    "No onPostToolUseHook found",
+    "No onPreToolUseHook found",
+];
+// Maximum length to check for potential partial match
+const MAX_NOISE_PATTERN_LEN = Math.max(...NOISE_PATTERN_STRINGS.map((p) => p.length)) + 24; // +24 for tool ID
+/**
+ * Check if the content ends with a potential partial noise pattern.
+ * Returns the partial match length if found, 0 otherwise.
+ *
+ * A partial match occurs when:
+ * 1. The content ends with something that is a PREFIX of a noise pattern
+ *    (e.g., "No on" or "No onPostToolUseHook found"), OR
+ * 2. The content ends with a complete noise pattern prefix followed by
+ *    a partial tool ID (< 24 chars)
+ */
+function getPartialNoiseLength(content) {
+    // Check suffixes of decreasing length (longer matches first)
+    const maxCheck = Math.min(content.length, MAX_NOISE_PATTERN_LEN);
+    for (let len = maxCheck; len > 0; len--) {
+        const suffix = content.slice(-len);
+        for (const pattern of NOISE_PATTERN_STRINGS) {
+            // Case 1: suffix is a prefix of a pattern (suffix is shorter than pattern)
+            // e.g., suffix="No onPost" is a prefix of pattern="No onPostToolUseHook found..."
+            if (suffix.length <= pattern.length && pattern.startsWith(suffix)) {
+                return len;
+            }
+            // Case 2: suffix starts with a complete toolu_ pattern and has partial tool ID
+            // e.g., suffix="No onPostToolUseHook found for tool use ID: toolu_ABC123"
+            // where the tool ID is < 24 chars
+            if (pattern.endsWith("toolu_") && suffix.startsWith(pattern)) {
+                const afterToolu = suffix.slice(pattern.length);
+                // If tool ID is incomplete (< 24 chars) and valid chars, it's a partial match
+                if (afterToolu.length < 24 && /^[A-Za-z0-9]*$/.test(afterToolu)) {
+                    return len;
+                }
+            }
+        }
+    }
+    return 0;
+}
+/**
+ * Strip noise patterns from content.
+ * Returns the cleaned content, or null if nothing remains after stripping.
+ * Preserves whitespace-only chunks that aren't noise to maintain streaming formatting.
+ */
+function stripNoise(content) {
+    let cleaned = content;
+    for (const pattern of NOISE_PATTERNS) {
+        cleaned = cleaned.replace(pattern, "");
+    }
+    // If nothing was stripped, return original (preserves pure whitespace chunks)
+    if (cleaned === content) {
+        return content;
+    }
+    // Something was stripped - return cleaned if non-empty, null otherwise
+    return cleaned.length > 0 ? cleaned : null;
 }
 export function createTranslator() {
     const state = {
         sessionStart: Date.now(),
         activeMessage: null,
         pendingTools: new Map(),
+        noiseBuffer: "",
     };
     function getTimestamp() {
         return Date.now() - state.sessionStart;
     }
+    /**
+     * Process a text chunk with boundary-aware noise stripping.
+     * Returns the safe content to emit, and updates the noise buffer.
+     * Returns null if the entire chunk should be suppressed.
+     *
+     * The key insight is that we need to check for partial noise patterns
+     * BEFORE stripping, because partial patterns won't match the full regex
+     * and could leave fragments behind.
+     */
+    function processChunkWithBuffer(text) {
+        // Combine buffer with new text
+        const combined = state.noiseBuffer + text;
+        state.noiseBuffer = "";
+        // First, check if the combined content ends with a partial noise pattern
+        // This must happen BEFORE stripping, because partial patterns at the end
+        // won't match the regex and could leave fragments
+        const partialLen = getPartialNoiseLength(combined);
+        if (partialLen > 0) {
+            // Buffer the potential partial match
+            state.noiseBuffer = combined.slice(-partialLen);
+            const safeContent = combined.slice(0, -partialLen);
+            // Strip complete noise patterns from the safe content
+            const cleaned = stripNoise(safeContent);
+            if (cleaned === null || cleaned.length === 0) {
+                return null;
+            }
+            return cleaned;
+        }
+        // No partial match at the end - strip complete patterns
+        const cleaned = stripNoise(combined);
+        if (cleaned === null) {
+            return null;
+        }
+        return cleaned;
+    }
+    /**
+     * Flush any remaining buffer content at finalization.
+     * Strips any complete noise patterns from the buffer.
+     */
+    function flushBuffer() {
+        const buffered = state.noiseBuffer;
+        state.noiseBuffer = "";
+        // Strip any complete noise from the buffer
+        const cleaned = stripNoise(buffered);
+        return cleaned ?? "";
+    }
     function translate(update) {
         const updateType = update.sessionUpdate;
         const timestamp = getTimestamp();
         switch (updateType) {
             // ─── Content Chunks ─────────────────────────────────────────────────────
-            case 'agent_message_chunk': {
+            case "agent_message_chunk": {
                 const content = update.content;
-                if (content?.type === 'text' && typeof content.text === 'string') {
-                    // Check for noise
-                    if (shouldSuppress(content.text)) {
-                        return null;
-                    }
+                if (content?.type === "text" && typeof content.text === "string") {
                     // Empty string signals finalization
-                    if (content.text === '') {
-                        if (state.activeMessage?.type === 'agent_message') {
-                            const final = {
-                                type: 'agent_message',
+                    if (content.text === "") {
+                        if (state.activeMessage?.type === "agent_message") {
+                            // Flush buffer and strip noise from accumulated content
+                            const buffered = flushBuffer();
+                            const combined = state.activeMessage.content + buffered;
+                            const finalContent = stripNoise(combined);
+                            state.activeMessage = null;
+                            if (finalContent === null || finalContent.trim() === "") {
+                                return null;
+                            }
+                            return {
+                                type: "agent_message",
                                 timestamp,
                                 data: {
-                                    kind: 'agent_message',
-                                    content: state.activeMessage.content,
+                                    kind: "agent_message",
+                                    content: finalContent,
                                     isStreaming: false,
                                 },
                             };
-                            state.activeMessage = null;
-                            return final;
                         }
                         return null;
                     }
+                    // Process chunk with boundary-aware noise stripping
+                    const cleanedText = processChunkWithBuffer(content.text);
+                    if (cleanedText === null) {
+                        return null;
+                    }
                     // Accumulate content
-                    if (state.activeMessage?.type === 'agent_message') {
-                        state.activeMessage.content += content.text;
+                    if (state.activeMessage?.type === "agent_message") {
+                        state.activeMessage.content += cleanedText;
                     }
                     else {
-                        state.activeMessage = { type: 'agent_message', content: content.text };
+                        state.activeMessage = {
+                            type: "agent_message",
+                            content: cleanedText,
+                        };
                     }
                     return {
-                        type: 'agent_message',
+                        type: "agent_message",
                         timestamp,
                         data: {
-                            kind: 'agent_message',
-                            content: content.text,
+                            kind: "agent_message",
+                            content: cleanedText,
                             isStreaming: true,
                         },
                     };
                 }
                 return null;
             }
-            case 'agent_thought_chunk': {
+            case "agent_thought_chunk": {
                 const content = update.content;
-                if (content?.type === 'text' && typeof content.text === 'string') {
-                    if (shouldSuppress(content.text)) {
-                        return null;
-                    }
-                    if (content.text === '') {
-                        if (state.activeMessage?.type === 'agent_thought') {
-                            const final = {
-                                type: 'agent_thought',
+                if (content?.type === "text" && typeof content.text === "string") {
+                    if (content.text === "") {
+                        if (state.activeMessage?.type === "agent_thought") {
+                            // Flush buffer and strip noise from accumulated content
+                            const buffered = flushBuffer();
+                            const combined = state.activeMessage.content + buffered;
+                            const finalContent = stripNoise(combined);
+                            state.activeMessage = null;
+                            if (finalContent === null || finalContent.trim() === "") {
+                                return null;
+                            }
+                            return {
+                                type: "agent_thought",
                                 timestamp,
                                 data: {
-                                    kind: 'agent_thought',
-                                    content: state.activeMessage.content,
+                                    kind: "agent_thought",
+                                    content: finalContent,
                                     isStreaming: false,
                                 },
                             };
-                            state.activeMessage = null;
-                            return final;
                         }
                         return null;
                     }
-                    if (state.activeMessage?.type === 'agent_thought') {
-                        state.activeMessage.content += content.text;
+                    // Process chunk with boundary-aware noise stripping
+                    const cleanedText = processChunkWithBuffer(content.text);
+                    if (cleanedText === null) {
+                        return null;
+                    }
+                    if (state.activeMessage?.type === "agent_thought") {
+                        state.activeMessage.content += cleanedText;
                     }
                     else {
-                        state.activeMessage = { type: 'agent_thought', content: content.text };
+                        state.activeMessage = {
+                            type: "agent_thought",
+                            content: cleanedText,
+                        };
                     }
                     return {
-                        type: 'agent_thought',
+                        type: "agent_thought",
                         timestamp,
                         data: {
-                            kind: 'agent_thought',
-                            content: content.text,
+                            kind: "agent_thought",
+                            content: cleanedText,
                             isStreaming: true,
                         },
                     };
                 }
                 return null;
             }
-            case 'user_message_chunk': {
+            case "user_message_chunk": {
                 // User messages are typically the prompt we sent, skip display
                 return null;
             }
             // ─── Tool Events ────────────────────────────────────────────────────────
-            case 'tool_call': {
+            case "tool_call": {
                 const u = update;
                 const toolCallId = (u.tool_call_id || u.toolCallId || u.id);
                 const tool = extractToolName(u);
@@ -302,13 +464,13 @@ export function createTranslator() {
                     // Only emit update if we now have a summary we didn't have before
                     if (summary && !hadSummary) {
                         return {
-                            type: 'tool_update',
+                            type: "tool_update",
                             timestamp,
                             data: {
-                                kind: 'tool_update',
+                                kind: "tool_update",
                                 toolCallId,
                                 tool,
-                                status: 'pending',
+                                status: "pending",
                                 summary,
                             },
                         };
@@ -317,12 +479,16 @@ export function createTranslator() {
                     return null;
                 }
                 // First time seeing this tool_call_id - create entry and emit tool_start
-                state.pendingTools.set(toolCallId, { tool, input, startTime: timestamp });
+                state.pendingTools.set(toolCallId, {
+                    tool,
+                    input,
+                    startTime: timestamp,
+                });
                 return {
-                    type: 'tool_start',
+                    type: "tool_start",
                     timestamp,
                     data: {
-                        kind: 'tool_start',
+                        kind: "tool_start",
                         toolCallId,
                         tool,
                         summary,
@@ -330,35 +496,65 @@ export function createTranslator() {
                     },
                 };
             }
-            case 'tool_call_update': {
+            case "tool_call_update": {
                 const u = update;
                 const toolCallId = (u.tool_call_id || u.toolCallId || u.id);
                 const status = u.status;
                 const pending = state.pendingTools.get(toolCallId);
                 const tool = pending?.tool || extractToolName(u);
+                // Check if rawInput arrived with this update (phased event pattern)
+                const newInput = u.rawInput || u.input || u.params;
+                if (newInput && pending) {
+                    const oldSummary = getToolSummary(pending.tool, pending.input);
+                    const newSummary = getToolSummary(tool, newInput);
+                    if (newSummary && !oldSummary) {
+                        // Input became available - update pending entry and emit summary
+                        pending.input = newInput;
+                        pending.tool = tool;
+                        return {
+                            type: "tool_update",
+                            timestamp,
+                            data: {
+                                kind: "tool_update",
+                                toolCallId,
+                                tool,
+                                status: "pending",
+                                summary: newSummary,
+                            },
+                        };
+                    }
+                    // Update the pending entry even if summary didn't change
+                    pending.input = newInput;
+                }
                 // Non-terminal status update
-                if (status === 'pending' || status === 'in_progress' || status === 'running') {
+                if (status === "pending" ||
+                    status === "in_progress" ||
+                    status === "running") {
                     return {
-                        type: 'tool_update',
+                        type: "tool_update",
                         timestamp,
                         data: {
-                            kind: 'tool_update',
+                            kind: "tool_update",
                             toolCallId,
                             tool,
-                            status: status === 'in_progress' ? 'running' : status,
+                            status: status === "in_progress"
+                                ? "running"
+                                : status,
                         },
                     };
                 }
                 // Terminal status - treat as result
-                if (status === 'completed' || status === 'failed' || status === 'cancelled') {
+                if (status === "completed" ||
+                    status === "failed" ||
+                    status === "cancelled") {
                     const rawOutput = extractToolOutput(u);
                     const originalOutput = extractOriginalOutput(u);
                     state.pendingTools.delete(toolCallId);
                     return {
-                        type: 'tool_result',
+                        type: "tool_result",
                         timestamp,
                         data: {
-                            kind: 'tool_result',
+                            kind: "tool_result",
                             toolCallId,
                             tool,
                             status,
@@ -378,17 +574,24 @@ export function createTranslator() {
     }
     function finalize() {
         if (state.activeMessage) {
-            const final = {
-                type: state.activeMessage.type,
+            // Flush buffer and strip noise from accumulated content
+            const buffered = flushBuffer();
+            const combined = state.activeMessage.content + buffered;
+            const finalContent = stripNoise(combined);
+            const type = state.activeMessage.type;
+            state.activeMessage = null;
+            if (finalContent === null || finalContent.trim() === "") {
+                return null;
+            }
+            return {
+                type,
                 timestamp: getTimestamp(),
                 data: {
-                    kind: state.activeMessage.type,
-                    content: state.activeMessage.content,
+                    kind: type,
+                    content: finalContent,
                     isStreaming: false,
                 },
             };
-            state.activeMessage = null;
-            return final;
         }
         return null;
     }