@probelabs/probe 0.6.0-rc259 → 0.6.0-rc261

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc259",
+  "version": "0.6.0-rc261",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/bashCommandUtils.js

@@ -127,6 +127,8 @@ export function parseSimpleCommand(command) {
     /&&/,           // Logical AND
     /\|\|/,         // Logical OR
     /(?<!\\);/,     // Command separator (but not escaped \;)
+    /\n/,           // Newline command separator (multi-line commands)
+    /\r/,           // Carriage return (CRLF line endings)
     /&$/,           // Background execution
     /\$\(/,         // Command substitution $()
     /`/,            // Command substitution ``
@@ -260,6 +262,7 @@ export function isComplexPattern(pattern) {
     /&&/,           // Logical AND
     /\|\|/,         // Logical OR
     /;/,            // Command separator
+    /\n/,           // Newline command separator
     /&$/,           // Background execution
     /\$\(/,         // Command substitution $()
     /`/,            // Command substitution ``

package/src/agent/bashPermissions.js

@@ -402,6 +402,29 @@ export class BashPermissionChecker {
           i++;
           continue;
         }
+        // Check for newline (command separator in multi-line scripts)
+        // Also handle \r\n (CRLF) line endings
+        if (char === '\n' || (char === '\r' && nextChar === '\n')) {
+          if (current.trim()) {
+            components.push(current.trim());
+          }
+          current = '';
+          if (char === '\r') {
+            i += 2; // Skip \r\n
+          } else {
+            i++;
+          }
+          continue;
+        }
+        if (char === '\r') {
+          // Bare \r without \n
+          if (current.trim()) {
+            components.push(current.trim());
+          }
+          current = '';
+          i++;
+          continue;
+        }
       }
 
       current += char;

package/src/agent/schemaUtils.js

@@ -266,6 +266,36 @@ function normalizeJsonQuotes(str) {
   return result;
 }
 
+/**
+ * Check if a code block is embedded within a structured markdown document.
+ * Used to avoid extracting embedded JSON examples from markdown text.
+ * Issue #456: attempt_completion results containing markdown with JSON code block
+ * documentation examples were having the examples extracted as structured output.
+ *
+ * Normal AI behavior: AI wraps JSON answer in a code block with brief explanation text.
+ * Issue #456: AI returns a markdown document that contains JSON code blocks as examples.
+ *
+ * We distinguish these by checking if the surrounding text contains markdown structural
+ * elements (headings) which indicate a document rather than a brief explanation.
+ *
+ * @param {string} text - The full trimmed text
+ * @param {RegExpMatchArray} match - The regex match for the code block
+ * @returns {boolean} - true if the code block is embedded in a markdown document
+ */
+function isCodeBlockEmbeddedInDocument(text, match) {
+  const beforeBlock = text.substring(0, match.index).trim();
+  const afterBlock = text.substring(match.index + match[0].length).trim();
+
+  // Check if surrounding text contains markdown headings (lines starting with #)
+  // This is a strong signal that the content is a structured document, not just explanation text
+  const hasMarkdownHeadings = /^#{1,6}\s/m.test(beforeBlock) || /^#{1,6}\s/m.test(afterBlock);
+  if (hasMarkdownHeadings) {
+    return true;
+  }
+
+  return false;
+}
+
 /**
  * Clean AI response by extracting JSON content when response contains JSON
  * Only processes responses that contain JSON structures { or [
@@ -311,15 +341,20 @@ export function cleanSchemaResponse(response) {
   }
 
   // First, look for JSON after code block markers - similar to mermaid extraction
+  // Only extract from code blocks when they are the primary content (not embedded examples in markdown).
+  // Issue #456: When attempt_completion result contains markdown with embedded JSON code blocks
+  // as documentation examples, extracting those blocks produces wrong structured output.
+  // We check that there's no significant text content outside the code block.
+
   // Try with json language specifier
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
-  if (jsonBlockMatch) {
+  if (jsonBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, jsonBlockMatch)) {
     return normalizeJsonQuotes(jsonBlockMatch[1].trim());
   }
 
   // Try any code block with JSON content
   const anyBlockMatch = trimmed.match(/```\s*\n([{\[][\s\S]*?[}\]])\s*```/);
-  if (anyBlockMatch) {
+  if (anyBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, anyBlockMatch)) {
     return normalizeJsonQuotes(anyBlockMatch[1].trim());
   }
 
@@ -331,7 +366,7 @@ export function cleanSchemaResponse(response) {
 
   for (const pattern of codeBlockPatterns) {
     const match = trimmed.match(pattern);
-    if (match) {
+    if (match && !isCodeBlockEmbeddedInDocument(trimmed, match)) {
       return normalizeJsonQuotes(match[1].trim());
     }
   }
@@ -345,10 +380,11 @@ export function cleanSchemaResponse(response) {
   }
 
   // Look for code block start followed immediately by JSON
+  // Only extract if the code block is not embedded in a structured markdown document
   const codeBlockStartPattern = /```(?:json)?\s*\n?\s*([{\[])/;
   const codeBlockMatch = trimmed.match(codeBlockStartPattern);
 
-  if (codeBlockMatch) {
+  if (codeBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, codeBlockMatch)) {
     const startIndex = codeBlockMatch.index + codeBlockMatch[0].length - 1; // Position of the bracket
 
     // Find the matching closing bracket

package/src/agent/xmlParsingUtils.js

@@ -11,7 +11,7 @@ import { DEFAULT_VALID_TOOLS, buildToolTagPattern } from '../tools/common.js';
  * @param {string} xmlString - The XML string to clean
  * @returns {string} - Cleaned XML string without thinking tags
  */
-export function removeThinkingTags(xmlString) {
+export function removeThinkingTags(xmlString, validTools = DEFAULT_VALID_TOOLS) {
   let result = xmlString;
 
   // Remove all properly closed thinking tags first
@@ -26,8 +26,8 @@ export function removeThinkingTags(xmlString) {
     const afterThinking = result.substring(thinkingIndex + '<thinking>'.length);
 
     // Look for any tool tags in the remaining content
-    // Use the shared tool list to build the pattern dynamically
-    const toolPattern = buildToolTagPattern(DEFAULT_VALID_TOOLS);
+    // Use the provided valid tools list to build the pattern dynamically
+    const toolPattern = buildToolTagPattern(validTools);
     const toolMatch = afterThinking.match(toolPattern);
 
     if (toolMatch) {
@@ -201,7 +201,9 @@ export function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
   const thinkingContent = extractThinkingContent(xmlString);
 
   // Remove thinking tags and their content from the XML string
-  const cleanedXmlString = removeThinkingTags(xmlString);
+  // Forward validTools so that tool tags (e.g. edit, create) inside unclosed
+  // thinking blocks are preserved when they are in the valid tools list
+  const cleanedXmlString = removeThinkingTags(xmlString, validTools.length > 0 ? validTools : undefined);
 
   // Check for attempt_complete recovery patterns
   const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);