@probelabs/probe 0.6.0-rc105 → 0.6.0-rc107

package/src/agent/schemaUtils.js

@@ -14,6 +14,7 @@ const HTML_ENTITY_MAP = {
   '&': '&',
   '"': '"',
   ''': "'",
+  ''': "'",  // Also handle XML/HTML5 apostrophe entity
   ' ': ' '
 };
 
@@ -1183,16 +1184,35 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
         // Enhanced auto-fixing for square bracket nodes [...]
         if (trimmedLine.match(/\[[^\]]*\]/)) {
           modifiedLine = modifiedLine.replace(/\[([^\]]*)\]/g, (match, content) => {
-            // Skip if already properly quoted
+            // Check if already properly quoted with outer quotes
             if (content.trim().startsWith('"') && content.trim().endsWith('"')) {
+              // Extract the inner content (between the outer quotes)
+              const innerContent = content.trim().slice(1, -1);
+              // Check if inner content has unescaped quotes that need escaping
+              if (innerContent.includes('"') || innerContent.includes("'")) {
+                wasFixed = true;
+                // Decode any existing HTML entities first, then re-encode ALL quotes
+                const decodedContent = decodeHtmlEntities(innerContent);
+                const safeContent = decodedContent
+                  .replace(/"/g, '"')  // Replace ALL double quotes with HTML entity
+                  .replace(/'/g, ''');  // Replace ALL single quotes with HTML entity
+                return `["${safeContent}"]`;
+              }
               return match;
             }
             
             // Check if content needs quoting (contains problematic patterns)
             if (needsQuoting(content)) {
               wasFixed = true;
-              // Replace internal double quotes with single quotes to avoid nesting
-              const safeContent = content.replace(/"/g, "'");
+              // Use HTML entities for quotes as per Mermaid best practices:
+              // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+              // - HTML entities are the official way to escape quotes in Mermaid
+              // - Always use double quotes with square brackets ["..."] for node labels
+              // IMPORTANT: Decode any existing HTML entities first to avoid double-encoding
+              const decodedContent = decodeHtmlEntities(content);
+              const safeContent = decodedContent
+                .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                .replace(/'/g, ''');  // Replace single quotes with HTML entity
               return `["${safeContent}"]`;
             }
             
@@ -1203,16 +1223,35 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
         // Enhanced auto-fixing for diamond nodes {...}
         if (trimmedLine.match(/\{[^{}]*\}/)) {
           modifiedLine = modifiedLine.replace(/\{([^{}]*)\}/g, (match, content) => {
-            // Skip if already properly quoted
+            // Check if already properly quoted with outer quotes
             if (content.trim().startsWith('"') && content.trim().endsWith('"')) {
+              // Extract the inner content (between the outer quotes)
+              const innerContent = content.trim().slice(1, -1);
+              // Check if inner content has unescaped quotes that need escaping
+              if (innerContent.includes('"') || innerContent.includes("'")) {
+                wasFixed = true;
+                // Decode any existing HTML entities first, then re-encode ALL quotes
+                const decodedContent = decodeHtmlEntities(innerContent);
+                const safeContent = decodedContent
+                  .replace(/"/g, '"')  // Replace ALL double quotes with HTML entity
+                  .replace(/'/g, ''');  // Replace ALL single quotes with HTML entity
+                return `{"${safeContent}"}`;
+              }
               return match;
             }
             
             // Check if content needs quoting (contains problematic patterns)
             if (needsQuoting(content)) {
               wasFixed = true;
-              // Replace internal double quotes with single quotes to avoid nesting
-              const safeContent = content.replace(/"/g, "'");
+              // Use HTML entities for quotes as per Mermaid best practices:
+              // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+              // - HTML entities are the official way to escape quotes in Mermaid
+              // - Always use double quotes with curly brackets {"..."} for diamond nodes
+              // IMPORTANT: Decode any existing HTML entities first to avoid double-encoding
+              const decodedContent = decodeHtmlEntities(content);
+              const safeContent = decodedContent
+                .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                .replace(/'/g, ''');  // Replace single quotes with HTML entity
               return `{"${safeContent}"}`;
             }
             
@@ -1438,16 +1477,35 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
           // Look for any node labels that contain special characters and aren't already quoted
           if (trimmedLine.match(/\[[^\]]*\]/)) {
             modifiedLine = modifiedLine.replace(/\[([^\]]*)\]/g, (match, content) => {
-              // Skip if already properly quoted
+              // Check if already properly quoted with outer quotes
               if (content.trim().startsWith('"') && content.trim().endsWith('"')) {
+                // Extract the inner content (between the outer quotes)
+                const innerContent = content.trim().slice(1, -1);
+                // Check if inner content has unescaped quotes that need escaping
+                if (innerContent.includes('"') || innerContent.includes("'")) {
+                  wasFixed = true;
+                  // Decode any existing HTML entities first, then re-encode ALL quotes
+                  const decodedContent = decodeHtmlEntities(innerContent);
+                  const safeContent = decodedContent
+                    .replace(/"/g, '"')  // Replace ALL double quotes with HTML entity
+                    .replace(/'/g, ''');  // Replace ALL single quotes with HTML entity
+                  return `["${safeContent}"]`;
+                }
                 return match;
               }
               
               // Check if content needs quoting (contains problematic patterns)
               if (needsQuoting(content)) {
                 wasFixed = true;
-                // Replace internal double quotes with single quotes to avoid nesting
-                const safeContent = content.replace(/"/g, "'");
+                // Use HTML entities for quotes as per Mermaid best practices:
+                // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+                // - HTML entities are the official way to escape quotes in Mermaid
+                // - Always use double quotes with square brackets ["..."] for node labels
+                // IMPORTANT: Decode any existing HTML entities first to avoid double-encoding
+                const decodedContent = decodeHtmlEntities(content);
+                const safeContent = decodedContent
+                  .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                  .replace(/'/g, ''');  // Replace single quotes with HTML entity
                 return `["${safeContent}"]`;
               }
               
@@ -1458,16 +1516,35 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
           // Enhanced auto-fixing for diamond nodes {...}
           if (trimmedLine.match(/\{[^{}]*\}/)) {
             modifiedLine = modifiedLine.replace(/\{([^{}]*)\}/g, (match, content) => {
-              // Skip if already properly quoted
+              // Check if already properly quoted with outer quotes
               if (content.trim().startsWith('"') && content.trim().endsWith('"')) {
+                // Extract the inner content (between the outer quotes)
+                const innerContent = content.trim().slice(1, -1);
+                // Check if inner content has unescaped quotes that need escaping
+                if (innerContent.includes('"') || innerContent.includes("'")) {
+                  wasFixed = true;
+                  // Decode any existing HTML entities first, then re-encode ALL quotes
+                  const decodedContent = decodeHtmlEntities(innerContent);
+                  const safeContent = decodedContent
+                    .replace(/"/g, '"')  // Replace ALL double quotes with HTML entity
+                    .replace(/'/g, ''');  // Replace ALL single quotes with HTML entity
+                  return `{"${safeContent}"}`;
+                }
                 return match;
               }
               
               // Check if content needs quoting (contains problematic patterns)
               if (needsQuoting(content)) {
                 wasFixed = true;
-                // Replace internal double quotes with single quotes to avoid nesting
-                const safeContent = content.replace(/"/g, "'");
+                // Use HTML entities for quotes as per Mermaid best practices:
+                // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+                // - HTML entities are the official way to escape quotes in Mermaid
+                // - Always use double quotes with curly brackets {"..."} for diamond nodes
+                // IMPORTANT: Decode any existing HTML entities first to avoid double-encoding
+                const decodedContent = decodeHtmlEntities(content);
+                const safeContent = decodedContent
+                  .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                  .replace(/'/g, ''');  // Replace single quotes with HTML entity
                 return `{"${safeContent}"}`;
               }
               

package/src/agent/tools.js

@@ -4,6 +4,7 @@ import {
   queryTool,
   extractTool,
   delegateTool,
+  bashTool,
   DEFAULT_SYSTEM_MESSAGE,
   attemptCompletionSchema,
   attemptCompletionToolDefinition,
@@ -11,10 +12,12 @@ import {
   querySchema,
   extractSchema,
   delegateSchema,
+  bashSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
   delegateToolDefinition,
+  bashToolDefinition,
   parseXmlToolCall
 } from '../index.js';
 import { randomUUID } from 'crypto';
@@ -22,12 +25,19 @@ import { processXmlWithThinkingAndRecovery } from './xmlParsingUtils.js';
 
 // Create configured tool instances
 export function createTools(configOptions) {
-  return {
+  const tools = {
     searchTool: searchTool(configOptions),
     queryTool: queryTool(configOptions),
     extractTool: extractTool(configOptions),
     delegateTool: delegateTool(configOptions)
   };
+
+  // Add bash tool if enabled
+  if (configOptions.enableBash) {
+    tools.bashTool = bashTool(configOptions);
+  }
+
+  return tools;
 }
 
 // Export tool definitions and schemas
@@ -37,11 +47,13 @@ export {
   querySchema,
   extractSchema,
   delegateSchema,
+  bashSchema,
   attemptCompletionSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
   delegateToolDefinition,
+  bashToolDefinition,
   attemptCompletionToolDefinition,
   parseXmlToolCall
 };

package/src/index.js

@@ -21,14 +21,17 @@ import {
 	extractSchema,
 	delegateSchema,
 	attemptCompletionSchema,
+	bashSchema,
 	searchToolDefinition,
 	queryToolDefinition,
 	extractToolDefinition,
 	delegateToolDefinition,
 	attemptCompletionToolDefinition,
+	bashToolDefinition,
 	parseXmlToolCall
 } from './tools/common.js';
 import { searchTool, queryTool, extractTool, delegateTool } from './tools/vercel.js';
+import { bashTool } from './tools/bash.js';
 import { ProbeAgent } from './agent/ProbeAgent.js';
 import { SimpleTelemetry, SimpleAppTracer, initializeSimpleTelemetryFromOptions } from './agent/simpleTelemetry.js';
 
@@ -53,18 +56,21 @@ export {
 	queryTool,
 	extractTool,
 	delegateTool,
+	bashTool,
 	// Export schemas
 	searchSchema,
 	querySchema,
 	extractSchema,
 	delegateSchema,
 	attemptCompletionSchema,
+	bashSchema,
 	// Export tool definitions
 	searchToolDefinition,
 	queryToolDefinition,
 	extractToolDefinition,
 	delegateToolDefinition,
 	attemptCompletionToolDefinition,
+	bashToolDefinition,
 	// Export parser function
 	parseXmlToolCall
 };

package/src/tools/bash.js

@@ -0,0 +1,216 @@
+/**
+ * Bash command execution tool for Vercel AI SDK
+ * @module tools/bash
+ */
+
+import { tool } from 'ai';
+import { resolve } from 'path';
+import { BashPermissionChecker } from '../agent/bashPermissions.js';
+import { executeBashCommand, formatExecutionResult, validateExecutionOptions } from '../agent/bashExecutor.js';
+
+/**
+ * Bash tool generator
+ * 
+ * @param {Object} [options] - Configuration options
+ * @param {Object} [options.bashConfig] - Bash-specific configuration
+ * @param {string[]} [options.bashConfig.allow] - Additional allow patterns
+ * @param {string[]} [options.bashConfig.deny] - Additional deny patterns
+ * @param {boolean} [options.bashConfig.disableDefaultAllow] - Disable default allow list
+ * @param {boolean} [options.bashConfig.disableDefaultDeny] - Disable default deny list
+ * @param {number} [options.bashConfig.timeout=120000] - Command timeout in milliseconds
+ * @param {string} [options.bashConfig.workingDirectory] - Default working directory
+ * @param {Object} [options.bashConfig.env={}] - Default environment variables
+ * @param {number} [options.bashConfig.maxBuffer] - Maximum output buffer size
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @param {string} [options.defaultPath] - Default working directory from probe config
+ * @param {string[]} [options.allowedFolders] - Allowed directories for execution
+ * @returns {Object} Configured bash tool
+ */
+export const bashTool = (options = {}) => {
+  const { 
+    bashConfig = {},
+    debug = false,
+    defaultPath,
+    allowedFolders = []
+  } = options;
+
+  // Create permission checker
+  const permissionChecker = new BashPermissionChecker({
+    allow: bashConfig.allow,
+    deny: bashConfig.deny,
+    disableDefaultAllow: bashConfig.disableDefaultAllow,
+    disableDefaultDeny: bashConfig.disableDefaultDeny,
+    debug
+  });
+
+  // Determine default working directory
+  const getDefaultWorkingDirectory = () => {
+    if (bashConfig.workingDirectory) {
+      return bashConfig.workingDirectory;
+    }
+    if (defaultPath) {
+      return defaultPath;
+    }
+    if (allowedFolders && allowedFolders.length > 0) {
+      return allowedFolders[0];
+    }
+    return process.cwd();
+  };
+
+  return tool({
+    name: 'bash',
+    description: `Execute bash commands for system exploration and development tasks.
+
+Security: This tool has built-in security with allow/deny lists. By default, only safe read-only commands are allowed for code exploration.
+
+Parameters:
+- command: (required) The bash command to execute
+- workingDirectory: (optional) Directory to execute command in
+- timeout: (optional) Command timeout in milliseconds
+- env: (optional) Additional environment variables
+
+Examples of allowed commands by default:
+- File exploration: ls, cat, head, tail, find, grep
+- Git operations: git status, git log, git diff, git show
+- Package info: npm list, pip list, cargo --version
+- System info: whoami, pwd, uname, date
+
+Dangerous commands are blocked by default (rm -rf, sudo, npm install, etc.)`,
+
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: {
+          type: 'string',
+          description: 'The bash command to execute'
+        },
+        workingDirectory: {
+          type: 'string',
+          description: 'Directory to execute the command in (optional)'
+        },
+        timeout: {
+          type: 'number',
+          description: 'Command timeout in milliseconds (optional)',
+          minimum: 1000,
+          maximum: 600000
+        },
+        env: {
+          type: 'object',
+          description: 'Additional environment variables (optional)',
+          additionalProperties: {
+            type: 'string'
+          }
+        }
+      },
+      required: ['command'],
+      additionalProperties: false
+    },
+
+    execute: async ({ command, workingDirectory, timeout, env }) => {
+      try {
+        // Validate command
+        if (command === null || command === undefined || typeof command !== 'string') {
+          return 'Error: Command is required and must be a string';
+        }
+
+        if (command.trim().length === 0) {
+          return 'Error: Command cannot be empty';
+        }
+
+        // Check permissions
+        const permissionResult = permissionChecker.check(command.trim());
+        if (!permissionResult.allowed) {
+          if (debug) {
+            console.log(`[BashTool] Permission denied for command: "${command}"`);
+            console.log(`[BashTool] Reason: ${permissionResult.reason}`);
+          }
+          return `Permission denied: ${permissionResult.reason}
+
+This command is not allowed by the current security policy. 
+
+Common reasons:
+1. The command is in the deny list (potentially dangerous)
+2. The command is not in the allow list (not a recognized safe command)
+
+If you believe this command should be allowed, you can:
+- Use the --bash-allow option to add specific patterns
+- Use the --no-default-bash-deny flag to remove default restrictions (not recommended)
+
+For code exploration, try these safe alternatives:
+- ls, cat, head, tail for file operations
+- find, grep, rg for searching
+- git status, git log, git show for git operations
+- npm list, pip list for package information`;
+        }
+
+        // Determine working directory
+        const workingDir = workingDirectory || getDefaultWorkingDirectory();
+
+        // Validate working directory is within allowed folders if specified
+        if (allowedFolders && allowedFolders.length > 0) {
+          const resolvedWorkingDir = resolve(workingDir);
+          const isAllowed = allowedFolders.some(folder => {
+            const resolvedFolder = resolve(folder);
+            return resolvedWorkingDir.startsWith(resolvedFolder);
+          });
+
+          if (!isAllowed) {
+            return `Error: Working directory "${workingDir}" is not within allowed folders: ${allowedFolders.join(', ')}`;
+          }
+        }
+
+        // Prepare execution options
+        const executionOptions = {
+          workingDirectory: workingDir,
+          timeout: timeout || bashConfig.timeout || 120000,
+          env: { ...bashConfig.env, ...env },
+          maxBuffer: bashConfig.maxBuffer,
+          debug
+        };
+
+        // Validate execution options
+        const validation = validateExecutionOptions(executionOptions);
+        if (!validation.valid) {
+          return `Error: Invalid execution options: ${validation.errors.join(', ')}`;
+        }
+
+        if (validation.warnings.length > 0 && debug) {
+          console.log('[BashTool] Warnings:', validation.warnings);
+        }
+
+        if (debug) {
+          console.log(`[BashTool] Executing command: "${command}"`);
+          console.log(`[BashTool] Working directory: "${workingDir}"`);
+          console.log(`[BashTool] Timeout: ${executionOptions.timeout}ms`);
+        }
+
+        // Execute command
+        const result = await executeBashCommand(command.trim(), executionOptions);
+
+        if (debug) {
+          console.log(`[BashTool] Command completed - Success: ${result.success}, Duration: ${result.duration}ms`);
+        }
+
+        // Format and return result
+        const formattedResult = formatExecutionResult(result, debug);
+        
+        // Add metadata for failed commands
+        if (!result.success) {
+          let errorInfo = `\n\nCommand failed with exit code ${result.exitCode}`;
+          if (result.killed) {
+            errorInfo += ` (${result.error})`;
+          }
+          return formattedResult + errorInfo;
+        }
+
+        return formattedResult;
+
+      } catch (error) {
+        if (debug) {
+          console.error('[BashTool] Execution error:', error);
+        }
+        return `Error executing bash command: ${error.message}`;
+      }
+    }
+  });
+};

package/src/tools/common.js

@@ -37,6 +37,13 @@ export const delegateSchema = z.object({
 	task: z.string().describe('The task to delegate to a subagent. Be specific about what needs to be accomplished.')
 });
 
+export const bashSchema = z.object({
+	command: z.string().describe('The bash command to execute'),
+	workingDirectory: z.string().optional().describe('Directory to execute the command in (optional)'),
+	timeout: z.number().optional().describe('Command timeout in milliseconds (optional)'),
+	env: z.record(z.string()).optional().describe('Additional environment variables (optional)')
+});
+
 // Schema for the attempt_completion tool - flexible validation for direct XML response
 export const attemptCompletionSchema = {
 	// Custom validation that requires result parameter but allows direct XML response
@@ -277,10 +284,67 @@ I have refactored the search module according to the requirements and verified t
 </attempt_completion>
 `;
 
+export const bashToolDefinition = `
+## bash
+Description: Execute bash commands for system exploration and development tasks. This tool has built-in security with allow/deny lists. By default, only safe read-only commands are allowed for code exploration.
+
+Parameters:
+- command: (required) The bash command to execute
+- workingDirectory: (optional) Directory to execute the command in
+- timeout: (optional) Command timeout in milliseconds
+- env: (optional) Additional environment variables as an object
+
+Security: Commands are filtered through allow/deny lists for safety:
+- Allowed by default: ls, cat, git status, npm list, find, grep, etc.
+- Denied by default: rm -rf, sudo, npm install, dangerous system commands
+
+Usage Examples:
+
+<examples>
+
+User: What files are in the src directory?
+<bash>
+<command>ls -la src/</command>
+</bash>
+
+User: Show me the git status
+<bash>
+<command>git status</command>
+</bash>
+
+User: Find all TypeScript files
+<bash>
+<command>find . -name "*.ts" -type f</command>
+</bash>
+
+User: Check installed npm packages
+<bash>
+<command>npm list --depth=0</command>
+</bash>
+
+User: Search for TODO comments in code
+<bash>
+<command>grep -r "TODO" src/</command>
+</bash>
+
+User: Show recent git commits
+<bash>
+<command>git log --oneline -10</command>
+</bash>
+
+User: Check system info
+<bash>
+<command>uname -a</command>
+</bash>
+
+</examples>
+`;
+
 export const searchDescription = 'Search code in the repository using Elasticsearch-like query syntax. Use this tool first for any code-related questions.';
 export const queryDescription = 'Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.';
 export const extractDescription = 'Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files.';
 export const delegateDescription = 'Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Used by AI agents to break down complex requests into focused, parallel tasks.';
+export const bashDescription = 'Execute bash commands for system exploration and development tasks. Secure by default with built-in allow/deny lists.';
 
 // Valid tool names that should be parsed as tool calls
 const DEFAULT_VALID_TOOLS = [

package/src/tools/index.js

@@ -5,6 +5,7 @@
 
 // Export Vercel AI SDK tool generators
 export { searchTool, queryTool, extractTool, delegateTool } from './vercel.js';
+export { bashTool } from './bash.js';
 
 // Export LangChain tools
 export { createSearchTool, createQueryTool, createExtractTool } from './langchain.js';
@@ -15,8 +16,11 @@ export {
 	querySchema,
 	extractSchema,
 	delegateSchema,
+	bashSchema,
 	delegateDescription,
 	delegateToolDefinition,
+	bashDescription,
+	bashToolDefinition,
 	attemptCompletionSchema,
 	attemptCompletionToolDefinition
 } from './common.js';
@@ -26,6 +30,7 @@ export { DEFAULT_SYSTEM_MESSAGE } from './system-message.js';
 
 // For backward compatibility, create and export pre-configured tools
 import { searchTool as searchToolGenerator, queryTool as queryToolGenerator, extractTool as extractToolGenerator, delegateTool as delegateToolGenerator } from './vercel.js';
+import { bashTool as bashToolGenerator } from './bash.js';
 import { DEFAULT_SYSTEM_MESSAGE } from './system-message.js';
 
 // Create default tool instances (for backward compatibility)
@@ -34,6 +39,7 @@ const tools = {
 	queryTool: queryToolGenerator(),
 	extractTool: extractToolGenerator(),
 	delegateTool: delegateToolGenerator(),
+	bashTool: bashToolGenerator(),
 	DEFAULT_SYSTEM_MESSAGE
 };