@probelabs/probe 0.6.0-rc138 → 0.6.0-rc140

package/build/agent/index.js

@@ -2689,21 +2689,26 @@ var init_query = __esm({
 });
 
 // src/extract.js
-import { exec as exec4 } from "child_process";
+import { exec as exec4, spawn } from "child_process";
 import { promisify as promisify4 } from "util";
 async function extract(options) {
   if (!options) {
     throw new Error("Options object is required");
   }
-  if ((!options.files || !Array.isArray(options.files) || options.files.length === 0) && !options.inputFile) {
-    throw new Error("Either files array or inputFile must be provided");
+  const hasFiles = options.files && Array.isArray(options.files) && options.files.length > 0;
+  const hasInputFile = !!options.inputFile;
+  const hasContent = options.content !== void 0 && options.content !== null;
+  if (!hasFiles && !hasInputFile && !hasContent) {
+    throw new Error("Either files array, inputFile, or content must be provided");
   }
   const binaryPath = await getBinaryPath(options.binaryOptions || {});
-  const cliArgs = buildCliArgs(options, EXTRACT_FLAG_MAP);
+  const filteredOptions = { ...options };
+  delete filteredOptions.content;
+  const cliArgs = buildCliArgs(filteredOptions, EXTRACT_FLAG_MAP);
   if (options.json && !options.format) {
     cliArgs.push("--format", "json");
   }
-  if (options.files && Array.isArray(options.files) && options.files.length > 0) {
+  if (hasFiles) {
     for (const file of options.files) {
       cliArgs.push(escapeString(file));
     }
@@ -2715,66 +2720,115 @@ Extract:`;
       logMessage += ` files="${options.files.join(", ")}"`;
     }
     if (options.inputFile) logMessage += ` inputFile="${options.inputFile}"`;
+    if (options.content) logMessage += ` content=(${typeof options.content === "string" ? options.content.length : options.content.byteLength} bytes)`;
     if (options.allowTests) logMessage += " allowTests=true";
     if (options.contextLines) logMessage += ` contextLines=${options.contextLines}`;
     if (options.format) logMessage += ` format=${options.format}`;
     if (options.json) logMessage += " json=true";
     console.error(logMessage);
   }
+  if (hasContent) {
+    return extractWithStdin(binaryPath, cliArgs, options.content, options);
+  }
   const command = `${binaryPath} extract ${cliArgs.join(" ")}`;
   try {
     const { stdout, stderr } = await execAsync3(command);
     if (stderr) {
       console.error(`stderr: ${stderr}`);
     }
-    let tokenUsage = {
-      requestTokens: 0,
-      responseTokens: 0,
-      totalTokens: 0
-    };
-    if (options.files && Array.isArray(options.files)) {
-      tokenUsage.requestTokens = options.files.join(" ").length / 4;
-    } else if (options.inputFile) {
-      tokenUsage.requestTokens = options.inputFile.length / 4;
-    }
-    if (stdout.includes("Total tokens returned:")) {
-      const tokenMatch = stdout.match(/Total tokens returned: (\d+)/);
-      if (tokenMatch && tokenMatch[1]) {
-        tokenUsage.responseTokens = parseInt(tokenMatch[1], 10);
-        tokenUsage.totalTokens = tokenUsage.requestTokens + tokenUsage.responseTokens;
+    return processExtractOutput(stdout, options);
+  } catch (error) {
+    const errorMessage = `Error executing extract command: ${error.message}
+Command: ${command}`;
+    throw new Error(errorMessage);
+  }
+}
+function extractWithStdin(binaryPath, cliArgs, content, options) {
+  return new Promise((resolve5, reject2) => {
+    const childProcess = spawn(binaryPath, ["extract", ...cliArgs], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    childProcess.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    childProcess.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    childProcess.on("close", (code) => {
+      if (stderr && process.env.DEBUG === "1") {
+        console.error(`stderr: ${stderr}`);
+      }
+      if (code !== 0) {
+        reject2(new Error(`Extract command failed with exit code ${code}: ${stderr}`));
+        return;
       }
+      try {
+        const result = processExtractOutput(stdout, options);
+        resolve5(result);
+      } catch (error) {
+        reject2(error);
+      }
+    });
+    childProcess.on("error", (error) => {
+      reject2(new Error(`Failed to spawn extract process: ${error.message}`));
+    });
+    if (typeof content === "string") {
+      childProcess.stdin.write(content);
+    } else {
+      childProcess.stdin.write(content);
     }
-    let output = stdout;
-    if (!output.includes("Token Usage:")) {
-      output += `
+    childProcess.stdin.end();
+  });
+}
+function processExtractOutput(stdout, options) {
+  let tokenUsage = {
+    requestTokens: 0,
+    responseTokens: 0,
+    totalTokens: 0
+  };
+  if (options.files && Array.isArray(options.files)) {
+    tokenUsage.requestTokens = options.files.join(" ").length / 4;
+  } else if (options.inputFile) {
+    tokenUsage.requestTokens = options.inputFile.length / 4;
+  } else if (options.content) {
+    const contentLength = typeof options.content === "string" ? options.content.length : options.content.byteLength;
+    tokenUsage.requestTokens = contentLength / 4;
+  }
+  if (stdout.includes("Total tokens returned:")) {
+    const tokenMatch = stdout.match(/Total tokens returned: (\d+)/);
+    if (tokenMatch && tokenMatch[1]) {
+      tokenUsage.responseTokens = parseInt(tokenMatch[1], 10);
+      tokenUsage.totalTokens = tokenUsage.requestTokens + tokenUsage.responseTokens;
+    }
+  }
+  let output = stdout;
+  if (!output.includes("Token Usage:")) {
+    output += `
 Token Usage:
   Request tokens: ${tokenUsage.requestTokens}
   Response tokens: ${tokenUsage.responseTokens}
   Total tokens: ${tokenUsage.totalTokens}
 `;
-    }
-    if (options.json || options.format === "json") {
-      try {
-        const jsonOutput = JSON.parse(stdout);
-        if (!jsonOutput.token_usage) {
-          jsonOutput.token_usage = {
-            request_tokens: tokenUsage.requestTokens,
-            response_tokens: tokenUsage.responseTokens,
-            total_tokens: tokenUsage.totalTokens
-          };
-        }
-        return jsonOutput;
-      } catch (error) {
-        console.error("Error parsing JSON output:", error);
-        return output;
+  }
+  if (options.json || options.format === "json") {
+    try {
+      const jsonOutput = JSON.parse(stdout);
+      if (!jsonOutput.token_usage) {
+        jsonOutput.token_usage = {
+          request_tokens: tokenUsage.requestTokens,
+          response_tokens: tokenUsage.responseTokens,
+          total_tokens: tokenUsage.totalTokens
+        };
       }
+      return jsonOutput;
+    } catch (error) {
+      console.error("Error parsing JSON output:", error);
+      return output;
     }
-    return output;
-  } catch (error) {
-    const errorMessage = `Error executing extract command: ${error.message}
-Command: ${command}`;
-    throw new Error(errorMessage);
   }
+  return output;
 }
 var execAsync3, EXTRACT_FLAG_MAP;
 var init_extract = __esm({
@@ -7275,7 +7329,7 @@ I have refactored the search module according to the requirements and verified t
 });
 
 // src/delegate.js
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { randomUUID } from "crypto";
 async function delegate({ task, timeout = 300, debug = false, currentIteration = 0, maxIterations = 30, tracer = null }) {
   if (!task || typeof task !== "string") {
@@ -7318,7 +7372,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
     }
     return new Promise((resolve5, reject2) => {
       const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
-      const process2 = spawn(binaryPath, args, {
+      const process2 = spawn2(binaryPath, args, {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: timeout * 1e3
       });
@@ -8476,7 +8530,7 @@ var init_bashPermissions = __esm({
 });
 
 // src/agent/bashExecutor.js
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { resolve, join } from "path";
 import { existsSync } from "fs";
 async function executeBashCommand(command, options = {}) {
@@ -8533,7 +8587,7 @@ async function executeBashCommand(command, options = {}) {
       return;
     }
     const [cmd, ...cmdArgs] = args;
-    const child = spawn2(cmd, cmdArgs, {
+    const child = spawn3(cmd, cmdArgs, {
       cwd,
       env: processEnv,
       stdio: ["ignore", "pipe", "pipe"],

package/build/extract.js

@@ -3,7 +3,7 @@
  * @module extract
  */
 
-import { exec } from 'child_process';
+import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import { getBinaryPath, buildCliArgs, escapeString } from './utils.js';
 
@@ -22,13 +22,14 @@ const EXTRACT_FLAG_MAP = {
 
 /**
  * Extract code blocks from files
- * 
+ *
  * @param {Object} options - Extract options
  * @param {string[]} [options.files] - Files to extract from (can include line numbers with colon, e.g., "/path/to/file.rs:10")
  * @param {string} [options.inputFile] - Path to a file containing unstructured text to extract file paths from
+ * @param {string|Buffer} [options.content] - Content to pipe to stdin (e.g., git diff output). Alternative to inputFile.
  * @param {boolean} [options.allowTests] - Include test files
  * @param {number} [options.contextLines] - Number of context lines to include
- * @param {string} [options.format] - Output format ('markdown', 'plain', 'json')
+ * @param {string} [options.format] - Output format ('markdown', 'plain', 'json', 'xml', 'color', 'outline-xml', 'outline-diff')
  * @param {Object} [options.binaryOptions] - Options for getting the binary
  * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
  * @param {string} [options.binaryOptions.version] - Specific version to download
@@ -41,16 +42,22 @@ export async function extract(options) {
 		throw new Error('Options object is required');
 	}
 
-	// Either files or inputFile must be provided
-	if ((!options.files || !Array.isArray(options.files) || options.files.length === 0) && !options.inputFile) {
-		throw new Error('Either files array or inputFile must be provided');
+	// Either files, inputFile, or content must be provided
+	const hasFiles = options.files && Array.isArray(options.files) && options.files.length > 0;
+	const hasInputFile = !!options.inputFile;
+	const hasContent = options.content !== undefined && options.content !== null;
+
+	if (!hasFiles && !hasInputFile && !hasContent) {
+		throw new Error('Either files array, inputFile, or content must be provided');
 	}
 
 	// Get the binary path
 	const binaryPath = await getBinaryPath(options.binaryOptions || {});
 
-	// Build CLI arguments from options
-	const cliArgs = buildCliArgs(options, EXTRACT_FLAG_MAP);
+	// Build CLI arguments from options (excluding content which goes via stdin)
+	const filteredOptions = { ...options };
+	delete filteredOptions.content;
+	const cliArgs = buildCliArgs(filteredOptions, EXTRACT_FLAG_MAP);
 
 	// If json option is true, override format to json
 	if (options.json && !options.format) {
@@ -58,7 +65,7 @@ export async function extract(options) {
 	}
 
 	// Add files as positional arguments if provided
-	if (options.files && Array.isArray(options.files) && options.files.length > 0) {
+	if (hasFiles) {
 		for (const file of options.files) {
 			cliArgs.push(escapeString(file));
 		}
@@ -71,6 +78,7 @@ export async function extract(options) {
 			logMessage += ` files="${options.files.join(', ')}"`;
 		}
 		if (options.inputFile) logMessage += ` inputFile="${options.inputFile}"`;
+		if (options.content) logMessage += ` content=(${typeof options.content === 'string' ? options.content.length : options.content.byteLength} bytes)`;
 		if (options.allowTests) logMessage += " allowTests=true";
 		if (options.contextLines) logMessage += ` contextLines=${options.contextLines}`;
 		if (options.format) logMessage += ` format=${options.format}`;
@@ -78,7 +86,12 @@ export async function extract(options) {
 		console.error(logMessage);
 	}
 
-	// Execute command
+	// If content is provided, use spawn with stdin piping
+	if (hasContent) {
+		return extractWithStdin(binaryPath, cliArgs, options.content, options);
+	}
+
+	// Otherwise use exec for simple command execution
 	const command = `${binaryPath} extract ${cliArgs.join(' ')}`;
 
 	try {
@@ -88,62 +101,132 @@ export async function extract(options) {
 			console.error(`stderr: ${stderr}`);
 		}
 
-		// Parse the output to extract token usage information
-		let tokenUsage = {
-			requestTokens: 0,
-			responseTokens: 0,
-			totalTokens: 0
-		};
-
-		// Calculate approximate request tokens
-		if (options.files && Array.isArray(options.files)) {
-			tokenUsage.requestTokens = options.files.join(' ').length / 4;
-		} else if (options.inputFile) {
-			tokenUsage.requestTokens = options.inputFile.length / 4;
-		}
+		return processExtractOutput(stdout, options);
+	} catch (error) {
+		// Enhance error message with command details
+		const errorMessage = `Error executing extract command: ${error.message}\nCommand: ${command}`;
+		throw new Error(errorMessage);
+	}
+}
 
-		// Try to extract token information from the output
-		if (stdout.includes('Total tokens returned:')) {
-			const tokenMatch = stdout.match(/Total tokens returned: (\d+)/);
-			if (tokenMatch && tokenMatch[1]) {
-				tokenUsage.responseTokens = parseInt(tokenMatch[1], 10);
-				tokenUsage.totalTokens = tokenUsage.requestTokens + tokenUsage.responseTokens;
+/**
+ * Extract with content piped to stdin
+ * @private
+ */
+function extractWithStdin(binaryPath, cliArgs, content, options) {
+	return new Promise((resolve, reject) => {
+		const childProcess = spawn(binaryPath, ['extract', ...cliArgs], {
+			stdio: ['pipe', 'pipe', 'pipe']
+		});
+
+		let stdout = '';
+		let stderr = '';
+
+		// Collect stdout
+		childProcess.stdout.on('data', (data) => {
+			stdout += data.toString();
+		});
+
+		// Collect stderr
+		childProcess.stderr.on('data', (data) => {
+			stderr += data.toString();
+		});
+
+		// Handle process exit
+		childProcess.on('close', (code) => {
+			if (stderr && process.env.DEBUG === '1') {
+				console.error(`stderr: ${stderr}`);
 			}
-		}
-
-		// Add token usage information to the output
-		let output = stdout;
 
-		// Add token usage information at the end if not already present
-		if (!output.includes('Token Usage:')) {
-			output += `\nToken Usage:\n  Request tokens: ${tokenUsage.requestTokens}\n  Response tokens: ${tokenUsage.responseTokens}\n  Total tokens: ${tokenUsage.totalTokens}\n`;
-		}
+			if (code !== 0) {
+				reject(new Error(`Extract command failed with exit code ${code}: ${stderr}`));
+				return;
+			}
 
-		// Parse JSON if requested or if format is json
-		if (options.json || options.format === 'json') {
 			try {
-				const jsonOutput = JSON.parse(stdout);
-
-				// Add token usage to JSON output
-				if (!jsonOutput.token_usage) {
-					jsonOutput.token_usage = {
-						request_tokens: tokenUsage.requestTokens,
-						response_tokens: tokenUsage.responseTokens,
-						total_tokens: tokenUsage.totalTokens
-					};
-				}
-
-				return jsonOutput;
+				const result = processExtractOutput(stdout, options);
+				resolve(result);
 			} catch (error) {
-				console.error('Error parsing JSON output:', error);
-				return output; // Fall back to string output with token usage
+				reject(error);
 			}
+		});
+
+		// Handle errors
+		childProcess.on('error', (error) => {
+			reject(new Error(`Failed to spawn extract process: ${error.message}`));
+		});
+
+		// Write content to stdin and close
+		if (typeof content === 'string') {
+			childProcess.stdin.write(content);
+		} else {
+			childProcess.stdin.write(content);
 		}
+		childProcess.stdin.end();
+	});
+}
 
-		return output;
-	} catch (error) {
-		// Enhance error message with command details
-		const errorMessage = `Error executing extract command: ${error.message}\nCommand: ${command}`;
-		throw new Error(errorMessage);
+/**
+ * Process extract output and add token usage information
+ * @private
+ */
+function processExtractOutput(stdout, options) {
+	// Parse the output to extract token usage information
+	let tokenUsage = {
+		requestTokens: 0,
+		responseTokens: 0,
+		totalTokens: 0
+	};
+
+	// Calculate approximate request tokens
+	if (options.files && Array.isArray(options.files)) {
+		tokenUsage.requestTokens = options.files.join(' ').length / 4;
+	} else if (options.inputFile) {
+		tokenUsage.requestTokens = options.inputFile.length / 4;
+	} else if (options.content) {
+		const contentLength = typeof options.content === 'string'
+			? options.content.length
+			: options.content.byteLength;
+		tokenUsage.requestTokens = contentLength / 4;
+	}
+
+	// Try to extract token information from the output
+	if (stdout.includes('Total tokens returned:')) {
+		const tokenMatch = stdout.match(/Total tokens returned: (\d+)/);
+		if (tokenMatch && tokenMatch[1]) {
+			tokenUsage.responseTokens = parseInt(tokenMatch[1], 10);
+			tokenUsage.totalTokens = tokenUsage.requestTokens + tokenUsage.responseTokens;
+		}
+	}
+
+	// Add token usage information to the output
+	let output = stdout;
+
+	// Add token usage information at the end if not already present
+	if (!output.includes('Token Usage:')) {
+		output += `\nToken Usage:\n  Request tokens: ${tokenUsage.requestTokens}\n  Response tokens: ${tokenUsage.responseTokens}\n  Total tokens: ${tokenUsage.totalTokens}\n`;
+	}
+
+	// Parse JSON if requested or if format is json
+	if (options.json || options.format === 'json') {
+		try {
+			const jsonOutput = JSON.parse(stdout);
+
+			// Add token usage to JSON output
+			if (!jsonOutput.token_usage) {
+				jsonOutput.token_usage = {
+					request_tokens: tokenUsage.requestTokens,
+					response_tokens: tokenUsage.responseTokens,
+					total_tokens: tokenUsage.totalTokens
+				};
+			}
+
+			return jsonOutput;
+		} catch (error) {
+			console.error('Error parsing JSON output:', error);
+			return output; // Fall back to string output with token usage
+		}
 	}
-}
+
+	return output;
+}