@probelabs/probe 0.6.0-rc263 → 0.6.0-rc265

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc263",
+  "version": "0.6.0-rc265",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -80,7 +80,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.1.46",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@nyariv/sandboxjs": "github:probelabs/SandboxJS",
-    "@probelabs/maid": "^0.0.25",
+    "@probelabs/maid": "^0.0.26",
     "acorn": "^8.15.0",
     "acorn-walk": "^8.3.4",
     "adm-zip": "^0.5.16",

package/src/agent/ProbeAgent.js

@@ -2771,6 +2771,7 @@ Follow these instructions carefully:
       * For rewriting entire functions/classes/methods, use the symbol parameter instead (no exact text matching needed).
       * For editing specific lines from search/extract output, use start_line (and optionally end_line) with the line numbers shown in the output.${this.hashLines ? ' Line references include content hashes (e.g. "42:ab") for integrity verification.' : ''}
       * For editing inside large functions: first use extract with the symbol target (e.g. "file.js#myFunction") to see the function with line numbers${this.hashLines ? ' and hashes' : ''}, then use start_line/end_line to surgically edit specific lines within it.
+      * IMPORTANT: Keep old_string as small as possible — include only the lines you need to change plus minimal context for uniqueness. For replacing large blocks (10+ lines), prefer line-targeted editing with start_line/end_line to constrain scope.
     - Use 'create' for new files or complete file rewrites.
     - If an edit fails, read the error message — it tells you exactly how to fix the call and retry.
     - The system tracks which files you've seen via search/extract. If you try to edit a file you haven't read, or one that changed since you last read it, the edit will fail with instructions to re-read first. Always use extract before editing to ensure you have current file content.` : ''}

package/src/agent/bashExecutor.js

@@ -8,6 +8,191 @@ import { resolve, join } from 'path';
 import { existsSync } from 'fs';
 import { parseCommandForExecution, isComplexCommand } from './bashCommandUtils.js';
 
+// ─── Interactive Command Detection ─────────────────────────────────────────
+
+/**
+ * Split a command string by shell operators (&&, ||, |, ;) while respecting quotes.
+ * Used for interactive command detection in complex pipelines.
+ * @param {string} command - Command string to split
+ * @returns {string[]} Array of individual command strings
+ */
+function splitCommandComponents(command) {
+  const parts = [];
+  let current = '';
+  let inQuote = false;
+  let quoteChar = '';
+
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i];
+    const next = command[i + 1] || '';
+
+    // Handle escape sequences
+    if (c === '\\' && !inQuote) {
+      current += c + next;
+      i++;
+      continue;
+    }
+    if (inQuote && quoteChar === '"' && c === '\\' && next) {
+      current += c + next;
+      i++;
+      continue;
+    }
+
+    // Track quotes
+    if (!inQuote && (c === '"' || c === "'")) {
+      inQuote = true;
+      quoteChar = c;
+      current += c;
+      continue;
+    }
+    if (inQuote && c === quoteChar) {
+      inQuote = false;
+      current += c;
+      continue;
+    }
+
+    // Split on operators outside quotes
+    if (!inQuote) {
+      if ((c === '&' && next === '&') || (c === '|' && next === '|')) {
+        if (current.trim()) parts.push(current.trim());
+        current = '';
+        i++;
+        continue;
+      }
+      if (c === '|' || c === ';') {
+        if (current.trim()) parts.push(current.trim());
+        current = '';
+        continue;
+      }
+    }
+
+    current += c;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+
+/**
+ * Check a single (non-compound) command for interactive behavior.
+ * Strips leading env-var assignments (e.g. GIT_EDITOR=true) before checking.
+ *
+ * @param {string} command - Single command string
+ * @returns {string|null} Error message with suggestion, or null if not interactive
+ */
+function checkSingleCommandInteractive(command) {
+  let effective = command.trim();
+
+  // Strip leading VAR=VALUE prefixes (e.g. "GIT_EDITOR=true git rebase --continue")
+  while (/^\w+=\S*\s/.test(effective)) {
+    effective = effective.replace(/^\w+=\S*\s+/, '');
+  }
+
+  const parts = effective.split(/\s+/);
+  const base = parts[0];
+  const args = parts.slice(1);
+
+  // ── Interactive editors ──
+  if (['vi', 'vim', 'nvim', 'nano', 'emacs', 'pico', 'joe', 'mcedit'].includes(base)) {
+    return `'${base}' is an interactive editor and cannot run without a terminal. Use non-interactive file manipulation commands instead.`;
+  }
+
+  // ── Interactive pagers ──
+  if (['less', 'more'].includes(base)) {
+    return `'${base}' is an interactive pager. Use 'cat', 'head', or 'tail' instead.`;
+  }
+
+  // ── Git commands that open an editor ──
+  if (base === 'git') {
+    const sub = args[0];
+
+    // git commit without -m / --message / -C / -c / --fixup / --squash / --no-edit
+    if (sub === 'commit') {
+      const hasNonInteractiveFlag = args.some(a =>
+        a === '-m' || a.startsWith('--message') ||
+        a === '-C' || a === '-c' ||
+        a.startsWith('--fixup') || a.startsWith('--squash') ||
+        a === '--allow-empty-message' || a === '--no-edit'
+      );
+      if (!hasNonInteractiveFlag) {
+        return "Interactive command: 'git commit' opens an editor for the commit message. Use 'git commit -m \"your message\"' instead.";
+      }
+    }
+
+    // git rebase --continue / --skip (opens editor for commit message)
+    if (sub === 'rebase' && (args.includes('--continue') || args.includes('--skip'))) {
+      return "Interactive command: 'git rebase --continue' opens an editor. Set environment variable GIT_EDITOR=true to accept default messages, e.g. pass env: {GIT_EDITOR: 'true'} or prepend GIT_EDITOR=true to the command.";
+    }
+
+    // git rebase -i / --interactive
+    if (sub === 'rebase' && (args.includes('-i') || args.includes('--interactive'))) {
+      return "Interactive command: 'git rebase -i' requires an interactive editor. Interactive rebase cannot run without a terminal.";
+    }
+
+    // git merge without --no-edit / --no-commit / --ff-only
+    if (sub === 'merge' && !args.includes('--no-edit') && !args.includes('--no-commit') && !args.includes('--ff-only')) {
+      return "Interactive command: 'git merge' may open an editor for the merge commit message. Add '--no-edit' to accept the default message.";
+    }
+
+    // git cherry-pick without --no-edit
+    if (sub === 'cherry-pick' && !args.includes('--no-edit')) {
+      return "Interactive command: 'git cherry-pick' may open an editor. Add '--no-edit' to accept the default message.";
+    }
+
+    // git revert without --no-edit
+    if (sub === 'revert' && !args.includes('--no-edit')) {
+      return "Interactive command: 'git revert' opens an editor. Add '--no-edit' to accept the default message.";
+    }
+
+    // git tag -a without -m
+    if (sub === 'tag' && args.includes('-a') && !args.some(a => a === '-m' || a.startsWith('--message'))) {
+      return "Interactive command: 'git tag -a' opens an editor for the tag message. Use 'git tag -a <name> -m \"message\"' instead.";
+    }
+
+    // git add -i / --interactive / -p / --patch
+    if (sub === 'add' && (args.includes('-i') || args.includes('--interactive') || args.includes('-p') || args.includes('--patch'))) {
+      return "Interactive command: 'git add -i/-p' requires interactive input. Use 'git add <files>' to stage specific files instead.";
+    }
+  }
+
+  // ── Interactive REPLs (no arguments = interactive mode) ──
+  if (['python', 'python3', 'node', 'irb', 'ghci', 'lua', 'R', 'ruby'].includes(base) && args.length === 0) {
+    return `Interactive command: '${base}' without arguments starts an interactive REPL. Provide a script file or use '-c'/'--eval' for inline code.`;
+  }
+
+  // ── Database clients without query flag ──
+  if (base === 'mysql' && !args.some(a => a === '-e' || a.startsWith('--execute'))) {
+    return "Interactive command: 'mysql' without -e flag starts an interactive session. Use 'mysql -e \"SQL QUERY\"' instead.";
+  }
+  if (base === 'psql' && !args.some(a => a === '-c' || a.startsWith('--command') || a === '-f' || a.startsWith('--file'))) {
+    return "Interactive command: 'psql' without -c flag starts an interactive session. Use 'psql -c \"SQL QUERY\"' instead.";
+  }
+
+  // ── Interactive TUI tools ──
+  if (['top', 'htop', 'btop', 'nmon'].includes(base)) {
+    return `Interactive command: '${base}' is an interactive TUI tool. Use 'ps aux' or 'top -b -n 1' for non-interactive process listing.`;
+  }
+
+  return null;
+}
+
+/**
+ * Check if a command (simple or complex) would require interactive TTY input.
+ * For complex commands (with &&, ||, |, ;), checks each component individually.
+ *
+ * @param {string} command - Full command string
+ * @returns {string|null} Error message with suggestion for non-interactive alternative, or null if OK
+ */
+export function checkInteractiveCommand(command) {
+  if (!command || typeof command !== 'string') return null;
+
+  const components = splitCommandComponents(command.trim());
+  for (const component of components) {
+    const result = checkSingleCommandInteractive(component);
+    if (result) return result;
+  }
+  return null;
+}
+
 /**
  * Execute a bash command with security controls
  * @param {string} command - Command to execute
@@ -50,6 +235,26 @@ export async function executeBashCommand(command, options = {}) {
 
   const startTime = Date.now();
 
+  // Check for interactive commands that would hang without a TTY
+  const interactiveError = checkInteractiveCommand(command);
+  if (interactiveError) {
+    if (debug) {
+      console.log(`[BashExecutor] Blocked interactive command: "${command}"`);
+      console.log(`[BashExecutor] Reason: ${interactiveError}`);
+    }
+    return {
+      success: false,
+      error: interactiveError,
+      stdout: '',
+      stderr: interactiveError,
+      exitCode: 1,
+      command,
+      workingDirectory: cwd,
+      duration: 0,
+      interactive: true
+    };
+  }
+
   if (debug) {
     console.log(`[BashExecutor] Executing command: "${command}"`);
     console.log(`[BashExecutor] Working directory: "${cwd}"`);
@@ -57,11 +262,16 @@ export async function executeBashCommand(command, options = {}) {
   }
 
   return new Promise((resolve, reject) => {
-    // Create environment
+    // Create environment with non-interactive safety defaults.
+    // These prevent commands from opening editors or TTY prompts
+    // when stdin is not available (which would cause hangs).
     const processEnv = {
       ...process.env,
       ...env
     };
+    // Only set defaults if not already provided by user config
+    if (!processEnv.GIT_EDITOR) processEnv.GIT_EDITOR = 'true';
+    if (!processEnv.GIT_TERMINAL_PROMPT) processEnv.GIT_TERMINAL_PROMPT = '0';
 
     // Check if this is a complex command (contains pipes, operators, etc.)
     const isComplex = isComplexCommand(command);
@@ -97,12 +307,17 @@ export async function executeBashCommand(command, options = {}) {
       useShell = false;
     }
 
-    // Spawn the process
+    // Spawn the process in a new session (detached: true → setsid on Linux).
+    // This detaches the child from the parent's controlling terminal, making
+    // /dev/tty unavailable. Any program that tries to open an interactive
+    // editor or TTY prompt (e.g. vim from git rebase) will get ENXIO and
+    // fail immediately instead of hanging forever.
     const child = spawn(cmd, cmdArgs, {
       cwd,
       env: processEnv,
       stdio: ['ignore', 'pipe', 'pipe'], // stdin ignored, capture stdout/stderr
       shell: useShell, // false for security
+      detached: true, // new session — no controlling terminal
       windowsHide: true
     });
 
@@ -111,17 +326,28 @@ export async function executeBashCommand(command, options = {}) {
     let killed = false;
     let timeoutHandle;
 
+    // Helper: kill the entire process group (negative PID) so that
+    // sub-processes spawned by the command (e.g. an editor) are also killed.
+    // Falls back to killing just the child if process.kill fails.
+    const killProcessGroup = (signal) => {
+      try {
+        if (child.pid) process.kill(-child.pid, signal);
+      } catch {
+        try { child.kill(signal); } catch { /* already dead */ }
+      }
+    };
+
     // Set timeout
     if (timeout > 0) {
       timeoutHandle = setTimeout(() => {
         if (!killed) {
           killed = true;
-          child.kill('SIGTERM');
-          
+          killProcessGroup('SIGTERM');
+
           // Force kill after 5 seconds if still running
           setTimeout(() => {
             if (child.exitCode === null) {
-              child.kill('SIGKILL');
+              killProcessGroup('SIGKILL');
             }
           }, 5000);
         }
@@ -137,7 +363,7 @@ export async function executeBashCommand(command, options = {}) {
         // Buffer overflow
         if (!killed) {
           killed = true;
-          child.kill('SIGTERM');
+          killProcessGroup('SIGTERM');
         }
       }
     });
@@ -151,7 +377,7 @@ export async function executeBashCommand(command, options = {}) {
         // Buffer overflow
         if (!killed) {
           killed = true;
-          child.kill('SIGTERM');
+          killProcessGroup('SIGTERM');
         }
       }
     });

package/src/agent/shared/prompts.js

@@ -87,6 +87,7 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 - Avoid implementing special cases when a general approach works
 - Never expose secrets, API keys, or credentials in generated code. Never log sensitive information.
 - Do not surprise the user with unrequested changes. Do what was asked, including reasonable follow-up actions, but do not refactor surrounding code or add features that were not requested.
+- When editing files, keep edits focused and minimal. For changes spanning more than a few lines, prefer line-targeted editing (start_line/end_line) over text replacement (old_string) — it constrains scope and prevents accidental removal of adjacent content. Never include unrelated sections in an edit operation.
 - After every significant change, verify the project still builds and passes linting. Do not wait until the end to discover breakage.
 
 # After Implementation
@@ -97,11 +98,33 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 
 # GitHub Integration
 - Use the \`gh\` CLI for all GitHub operations: issues, pull requests, checks, releases.
-- To create a pull request: commit your changes, push the branch, then use \`gh pr create --title "..." --body "..."\`.
 - To view issues or PRs: \`gh issue view <number>\`, \`gh pr view <number>\`.
 - If given a GitHub URL, use \`gh\` to fetch the relevant information rather than guessing.
 - Always return the pull request URL to the user after creating one.
-- When checking GitHub Actions, only read logs of failed jobs — do not waste time on successful ones. Use \`gh run view <run-id> --log-failed\` to fetch only the relevant output.`,
+- When checking GitHub Actions, only read logs of failed jobs — do not waste time on successful ones. Use \`gh run view <run-id> --log-failed\` to fetch only the relevant output.
+
+# Pull Request Creation
+- Commit your changes, push the branch, then use \`gh pr create --title "..." --body "..."\`.
+- **PR title**: Keep it short (under 72 characters). Use imperative mood describing the change (e.g. "Add retry logic for API calls", "Fix race condition in cache invalidation"). Prefix with the type of change when useful: \`fix:\`, \`feat:\`, \`refactor:\`, \`docs:\`, \`test:\`, \`chore:\`.
+- **PR body**: MUST follow this structure:
+
+\`\`\`
+## Problem / Task
+<What problem is being solved or what task was requested. If there is a linked issue, reference it with #number. Be specific about the root cause or motivation.>
+
+## Changes
+<Concise list of what was actually changed. Describe each meaningful change — files modified, logic added/removed, and why. Do NOT just list filenames; explain what each change does.>
+
+## Testing
+<What tests were added, modified, or run. Include:
+- New test names and what they verify
+- Whether existing tests still pass
+- Manual verification steps if applicable
+- Commands used to validate (e.g. \`make test\`, \`npm test\`)>
+\`\`\`
+
+- If the task originated from a GitHub issue, always reference it in the PR body (e.g. "Fixes #123" or "Closes #123") so the issue is automatically closed on merge. If it originated from an external ticket system (Jira, Linear, etc.), include the ticket ID and link in the Problem / Task section (e.g. "Resolves PROJ-456").
+- Do not leave the PR body empty or vague. Every PR must clearly communicate what was done and why so reviewers can understand the change without reading every line of diff.`,
 
   'support': `You are ProbeChat Support, a specialized AI assistant focused on helping developers troubleshoot issues and solve problems. Your primary function is to help users diagnose errors, understand unexpected behaviors, and find solutions using the provided code analysis tools.
 

package/src/tools/edit.js

@@ -448,6 +448,13 @@ Parameters:
           return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times in ${file_path}. To fix: (1) Set replace_all=true to replace all occurrences, or (2) Include more surrounding lines in old_string to make the match unique (add the full line or adjacent lines for context).`;
         }
 
+        // Guard against over-scoped text edits (replacing large blocks with tiny replacements)
+        const oldLines = matchTarget.split('\n').length;
+        const newLines = new_string.split('\n').length;
+        if (oldLines >= 20 && newLines < oldLines * 0.5) {
+          return `Error editing file: Edit scope too large — replacing ${oldLines} lines with ${newLines} lines risks accidental content deletion. To fix: (1) Use line-targeted editing (start_line/end_line) instead to constrain scope, or (2) Split into smaller, focused edits that each target only the lines you intend to change.`;
+        }
+
         // Perform the replacement
         let newContent;
         if (replace_all) {