@probelabs/visor 0.1.39 → 0.1.41

package/dist/index.js

@@ -94115,6 +94115,21 @@ ${prContext}
     formatPRContext(prInfo) {
         // Check if this is an issue (not a PR)
         const isIssue = prInfo.isIssue === true;
+        // Check if we should include code context (diffs)
+        const isPRContext = prInfo.isPRContext === true;
+        // In PR context, always include diffs. Otherwise check the flag.
+        const includeCodeContext = isPRContext || prInfo.includeCodeContext !== false;
+        // Log the decision for transparency
+        const log = this.config.debug ? console.error : () => { };
+        if (isPRContext) {
+            log('🔍 Including full code diffs in AI context (PR mode)');
+        }
+        else if (!includeCodeContext) {
+            log('📊 Including only file summary in AI context (no diffs)');
+        }
+        else {
+            log('🔍 Including code diffs in AI context');
+        }
         if (isIssue) {
             // Format as issue context
             let context = `<issue>
@@ -94236,31 +94251,39 @@ ${this.escapeXml(prInfo.body)}
 ${this.escapeXml(prInfo.body)}
   </description>`;
         }
-        // Add full diff if available (for complete PR review)
-        if (prInfo.fullDiff) {
-            context += `
+        // Add diffs only if includeCodeContext is true (or in PR mode)
+        if (includeCodeContext) {
+            // Add full diff if available (for complete PR review)
+            if (prInfo.fullDiff) {
+                context += `
   <!-- Complete unified diff showing all changes in the pull request -->
   <full_diff>
 ${this.escapeXml(prInfo.fullDiff)}
   </full_diff>`;
-        }
-        // Add incremental commit diff if available (for new commit analysis)
-        if (prInfo.isIncremental) {
-            if (prInfo.commitDiff && prInfo.commitDiff.length > 0) {
-                context += `
+            }
+            // Add incremental commit diff if available (for new commit analysis)
+            if (prInfo.isIncremental) {
+                if (prInfo.commitDiff && prInfo.commitDiff.length > 0) {
+                    context += `
   <!-- Diff of only the latest commit for incremental analysis -->
   <commit_diff>
 ${this.escapeXml(prInfo.commitDiff)}
   </commit_diff>`;
-            }
-            else {
-                context += `
+                }
+                else {
+                    context += `
   <!-- Commit diff could not be retrieved - falling back to full diff analysis -->
   <commit_diff>
 ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
   </commit_diff>`;
+                }
             }
         }
+        else {
+            // When not including diffs, add a note about it
+            context += `
+  <!-- Code diffs excluded to reduce token usage (no code-review schema detected or disabled by flag) -->`;
+        }
         // Add file summary for context
         if (prInfo.files.length > 0) {
             context += `
@@ -95612,8 +95635,7 @@ class CheckExecutionEngine {
         // Execute checks level by level
         const results = new Map();
         const sessionRegistry = (__nccwpck_require__(46059).SessionRegistry).getInstance();
-        const provider = this.providerRegistry.getProviderOrThrow('ai');
-        this.setProviderWebhookContext(provider);
+        // Note: We'll get the provider dynamically per check, not a single one for all
         const sessionIds = new Map(); // checkName -> sessionId
         let shouldStopExecution = false;
         for (let levelIndex = 0; levelIndex < dependencyGraph.executionOrder.length && !shouldStopExecution; levelIndex++) {
@@ -95661,15 +95683,24 @@ class CheckExecutionEngine {
                             };
                         }
                     }
+                    // Get the appropriate provider for this check type
+                    const providerType = checkConfig.type || 'ai';
+                    const provider = this.providerRegistry.getProviderOrThrow(providerType);
+                    this.setProviderWebhookContext(provider);
                     // Create provider config for this specific check
                     const providerConfig = {
-                        type: 'ai',
+                        type: providerType,
                         prompt: checkConfig.prompt,
+                        exec: checkConfig.exec,
                         focus: checkConfig.focus || this.mapCheckNameToFocus(checkName),
                         schema: checkConfig.schema,
                         group: checkConfig.group,
                         checkName: checkName, // Add checkName for sessionID
                         eventContext: prInfo.eventContext, // Pass event context for templates
+                        transform: checkConfig.transform,
+                        level: checkConfig.level,
+                        message: checkConfig.message,
+                        env: checkConfig.env,
                         ai: {
                             timeout: timeout || 600000,
                             debug: debug,
@@ -95678,9 +95709,19 @@ class CheckExecutionEngine {
                     };
                     // Pass results from dependencies if needed
                     const dependencyResults = new Map();
+                    let isForEachDependent = false;
+                    let forEachItems = [];
+                    let forEachParentName;
                     for (const depId of checkConfig.depends_on || []) {
                         if (results.has(depId)) {
-                            dependencyResults.set(depId, results.get(depId));
+                            const depResult = results.get(depId);
+                            dependencyResults.set(depId, depResult);
+                            // Check if this dependency has forEach enabled
+                            if (depResult.isForEach && depResult.forEachItems) {
+                                isForEachDependent = true;
+                                forEachItems = depResult.forEachItems;
+                                forEachParentName = depId;
+                            }
                         }
                     }
                     // Determine if we should use session reuse
@@ -95709,10 +95750,54 @@ class CheckExecutionEngine {
                         // Add session ID to provider config
                         providerConfig.sessionId = currentSessionId;
                     }
-                    const result = await provider.execute(prInfo, providerConfig, dependencyResults, sessionInfo);
-                    log(`🔧 Debug: Completed check: ${checkName}, issues found: ${(result.issues || []).length}`);
+                    // Handle forEach dependent execution
+                    let finalResult;
+                    if (isForEachDependent && forEachParentName) {
+                        log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
+                        const allIssues = [];
+                        const allOutputs = [];
+                        // Execute check for each item in the forEach array
+                        for (let itemIndex = 0; itemIndex < forEachItems.length; itemIndex++) {
+                            const item = forEachItems[itemIndex];
+                            // Create modified dependency results with current item
+                            const forEachDependencyResults = new Map();
+                            for (const [depName, depResult] of dependencyResults) {
+                                if (depName === forEachParentName) {
+                                    // Replace the forEach parent's output with the current item
+                                    const modifiedResult = {
+                                        ...depResult,
+                                        output: item,
+                                    };
+                                    forEachDependencyResults.set(depName, modifiedResult);
+                                }
+                                else {
+                                    forEachDependencyResults.set(depName, depResult);
+                                }
+                            }
+                            log(`🔄 Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`);
+                            const itemResult = await provider.execute(prInfo, providerConfig, forEachDependencyResults, sessionInfo);
+                            // Collect issues from each iteration
+                            if (itemResult.issues) {
+                                allIssues.push(...itemResult.issues);
+                            }
+                            // Collect outputs from each iteration
+                            if (itemResult.output) {
+                                allOutputs.push(itemResult.output);
+                            }
+                        }
+                        finalResult = {
+                            issues: allIssues,
+                            output: allOutputs.length > 0 ? allOutputs : undefined,
+                        };
+                        log(`🔄 Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`);
+                    }
+                    else {
+                        // Normal single execution
+                        finalResult = await provider.execute(prInfo, providerConfig, dependencyResults, sessionInfo);
+                        log(`🔧 Debug: Completed check: ${checkName}, issues found: ${(finalResult.issues || []).length}`);
+                    }
                     // Add group, schema, template info and timestamp to issues from config
-                    const enrichedIssues = (result.issues || []).map(issue => ({
+                    const enrichedIssues = (finalResult.issues || []).map(issue => ({
                         ...issue,
                         ruleId: `${checkName}/${issue.ruleId}`,
                         group: checkConfig.group,
@@ -95721,7 +95806,7 @@ class CheckExecutionEngine {
                         timestamp: Date.now(),
                     }));
                     const enrichedResult = {
-                        ...result,
+                        ...finalResult,
                         issues: enrichedIssues,
                     };
                     return {
@@ -95746,8 +95831,34 @@ class CheckExecutionEngine {
             for (let i = 0; i < levelResults.length; i++) {
                 const checkName = executionGroup.parallel[i];
                 const result = levelResults[i];
+                const checkConfig = config.checks[checkName];
                 if (result.status === 'fulfilled' && result.value.result && !result.value.error) {
-                    results.set(checkName, result.value.result);
+                    const reviewResult = result.value.result;
+                    // Handle forEach logic - process array outputs
+                    if (checkConfig?.forEach && reviewResult.output) {
+                        let outputArray = reviewResult.output;
+                        // Ensure output is an array
+                        if (!Array.isArray(outputArray)) {
+                            // Try to parse as JSON if it's a string
+                            if (typeof outputArray === 'string') {
+                                try {
+                                    const parsed = JSON.parse(outputArray);
+                                    outputArray = Array.isArray(parsed) ? parsed : [parsed];
+                                }
+                                catch {
+                                    outputArray = [outputArray];
+                                }
+                            }
+                            else {
+                                outputArray = [outputArray];
+                            }
+                        }
+                        log(`🔄 Debug: Check "${checkName}" has forEach enabled, processing ${outputArray.length} items`);
+                        // Store the array for iteration by dependent checks
+                        reviewResult.forEachItems = outputArray;
+                        reviewResult.isForEach = true;
+                    }
+                    results.set(checkName, reviewResult);
                 }
                 else {
                     // Store error result for dependency tracking
@@ -96781,10 +96892,6 @@ async function main() {
                 .findAndLoadConfig()
                 .catch(() => configManager.getDefaultConfig());
         }
-        // Get repository info using GitRepositoryAnalyzer
-        const { GitRepositoryAnalyzer } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(71259)));
-        const analyzer = new GitRepositoryAnalyzer(process.cwd());
-        const repositoryInfo = await analyzer.analyzeRepository();
         // Determine checks to run and validate check types early
         const checksToRun = options.checks.length > 0 ? options.checks : Object.keys(config.checks || {});
         // Validate that all requested checks exist in the configuration
@@ -96794,13 +96901,58 @@ async function main() {
             console.error(`❌ Error: No configuration found for check: ${invalidChecks[0]}`);
             process.exit(1);
         }
-        // Check if we're in a git repository and handle error early
+        // Use stderr for status messages when outputting formatted results to stdout
+        const logFn = console.error;
+        // Determine if we should include code context (diffs)
+        // In CLI mode (local), we do smart detection. PR mode always includes context.
+        const isPRContext = false; // This is CLI mode, not GitHub Action
+        let includeCodeContext = false;
+        if (isPRContext) {
+            // ALWAYS include full context in PR/GitHub Action mode
+            includeCodeContext = true;
+            logFn('📝 Code context: ENABLED (PR context - always included)');
+        }
+        else if (options.codeContext === 'enabled') {
+            includeCodeContext = true;
+            logFn('📝 Code context: ENABLED (forced by --enable-code-context)');
+        }
+        else if (options.codeContext === 'disabled') {
+            includeCodeContext = false;
+            logFn('📝 Code context: DISABLED (forced by --disable-code-context)');
+        }
+        else {
+            // Auto-detect based on schemas (CLI mode only)
+            const hasCodeReviewSchema = checksToRun.some(check => config.checks?.[check]?.schema === 'code-review');
+            includeCodeContext = hasCodeReviewSchema;
+            if (hasCodeReviewSchema) {
+                logFn('📝 Code context: ENABLED (code-review schema detected in local mode)');
+            }
+            else {
+                logFn('📝 Code context: DISABLED (no code-review schema found in local mode)');
+            }
+        }
+        // Get repository info using GitRepositoryAnalyzer
+        const { GitRepositoryAnalyzer } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(71259)));
+        const analyzer = new GitRepositoryAnalyzer(process.cwd());
+        let repositoryInfo;
+        try {
+            repositoryInfo = await analyzer.analyzeRepository(includeCodeContext);
+        }
+        catch (error) {
+            console.error('❌ Error analyzing git repository:', error);
+            console.error('💡 Make sure you are in a git repository or initialize one with "git init"');
+            process.exit(1);
+        }
+        // Check if we're in a git repository
         if (!repositoryInfo.isGitRepository) {
-            console.error('❌ Error: Not a git repository or no changes found');
+            console.error('❌ Error: Not a git repository. Run "git init" to initialize a repository.');
+            process.exit(1);
+        }
+        // Check if there are any changes to analyze
+        if (repositoryInfo.files.length === 0) {
+            console.error('❌ Error: No changes to analyze. Make some file changes first.');
             process.exit(1);
         }
-        // Use stderr for status messages when outputting formatted results to stdout
-        const logFn = console.error;
         logFn('🔍 Visor - AI-powered code review tool');
         logFn(`Configuration version: ${config.version}`);
         logFn(`Configuration source: ${options.configPath || 'default search locations'}`);
@@ -96823,8 +96975,12 @@ async function main() {
                 exclude: options.excludeTags,
             }
             : undefined;
-        // Execute checks with proper parameters (cast to PRInfo)
-        const groupedResults = await engine.executeGroupedChecks(repositoryInfo, checksToRun, options.timeout, config, options.output, options.debug || false, options.maxParallelism, options.failFast, tagFilter);
+        // Convert repository info to PRInfo format
+        const prInfo = analyzer.toPRInfo(repositoryInfo, includeCodeContext);
+        // Store the includeCodeContext flag in prInfo for downstream use
+        prInfo.includeCodeContext = includeCodeContext;
+        // Execute checks with proper parameters
+        const groupedResults = await engine.executeGroupedChecks(prInfo, checksToRun, options.timeout, config, options.output, options.debug || false, options.maxParallelism, options.failFast, tagFilter);
         // Format output based on format type
         let output;
         if (options.output === 'json') {
@@ -96993,6 +97149,8 @@ class CLI {
             .option('--tags <tags>', 'Include checks with these tags (comma-separated)')
             .option('--exclude-tags <tags>', 'Exclude checks with these tags (comma-separated)')
             .option('--no-remote-extends', 'Disable loading configurations from remote URLs')
+            .option('--enable-code-context', 'Force include code diffs in analysis (CLI mode)')
+            .option('--disable-code-context', 'Force exclude code diffs from analysis (CLI mode)')
             .addHelpText('after', this.getExamplesText())
             .exitOverride(); // Prevent automatic process.exit for better error handling
         // Add validation for options
@@ -97030,6 +97188,8 @@ class CLI {
                 .option('--tags <tags>', 'Include checks with these tags (comma-separated)')
                 .option('--exclude-tags <tags>', 'Exclude checks with these tags (comma-separated)')
                 .option('--allowed-remote-patterns <patterns>', 'Comma-separated list of allowed URL prefixes for remote config extends (e.g., "https://github.com/,https://raw.githubusercontent.com/")')
+                .option('--enable-code-context', 'Force include code diffs in analysis (CLI mode)')
+                .option('--disable-code-context', 'Force exclude code diffs from analysis (CLI mode)')
                 .allowUnknownOption(false)
                 .allowExcessArguments(false) // Don't allow positional arguments
                 .addHelpText('after', this.getExamplesText())
@@ -97060,6 +97220,14 @@ class CLI {
             if (options.excludeTags) {
                 excludeTags = options.excludeTags.split(',').map((t) => t.trim());
             }
+            // Determine code context mode
+            let codeContext = 'auto';
+            if (options.enableCodeContext) {
+                codeContext = 'enabled';
+            }
+            else if (options.disableCodeContext) {
+                codeContext = 'disabled';
+            }
             return {
                 checks: uniqueChecks,
                 output: options.output,
@@ -97073,6 +97241,7 @@ class CLI {
                 allowedRemotePatterns,
                 help: options.help,
                 version: options.version,
+                codeContext,
             };
         }
         catch (error) {
@@ -97141,6 +97310,10 @@ class CLI {
             .option('--max-parallelism <count>', 'Maximum number of checks to run in parallel (default: 3)', value => parseInt(value, 10))
             .option('--debug', 'Enable debug mode for detailed output')
             .option('--fail-fast', 'Stop execution on first failure condition')
+            .option('--tags <tags>', 'Include checks with these tags (comma-separated)')
+            .option('--exclude-tags <tags>', 'Exclude checks with these tags (comma-separated)')
+            .option('--enable-code-context', 'Force include code diffs in analysis (CLI mode)')
+            .option('--disable-code-context', 'Force exclude code diffs from analysis (CLI mode)')
             .addHelpText('after', this.getExamplesText());
         // Get the basic help and append examples manually if addHelpText doesn't work
         const basicHelp = tempProgram.helpInformation();
@@ -97315,7 +97488,7 @@ class ConfigManager {
     validCheckTypes = [
         'ai',
         'claude-code',
-        'tool',
+        'command',
         'http',
         'http_input',
         'http_client',
@@ -97661,11 +97834,11 @@ class ConfigManager {
                 message: `Invalid check configuration for "${checkName}": missing prompt (required for AI checks)`,
             });
         }
-        // Tool checks require exec field
-        if (checkConfig.type === 'tool' && !checkConfig.exec) {
+        // Command checks require exec field
+        if (checkConfig.type === 'command' && !checkConfig.exec) {
             errors.push({
                 field: `checks.${checkName}.exec`,
-                message: `Invalid check configuration for "${checkName}": missing exec field (required for tool checks)`,
+                message: `Invalid check configuration for "${checkName}": missing exec field (required for command checks)`,
             });
         }
         // HTTP output checks require url and body fields
@@ -98692,7 +98865,7 @@ class GitRepositoryAnalyzer {
     /**
      * Analyze the current git repository state and return data compatible with PRInfo interface
      */
-    async analyzeRepository() {
+    async analyzeRepository(includeContext = true) {
         // Check if we're in a git repository
         const isRepo = await this.isGitRepository();
         if (!isRepo) {
@@ -98705,15 +98878,36 @@ class GitRepositoryAnalyzer {
                 this.getCurrentBranch(),
             ]);
             // Get uncommitted changes
-            const uncommittedFiles = await this.getUncommittedChanges();
-            // Get recent commit info
-            const recentCommits = await this.git.log({ maxCount: 1 });
-            const lastCommit = recentCommits.latest;
+            const uncommittedFiles = await this.getUncommittedChanges(includeContext);
+            // Get recent commit info (handle repos with no commits)
+            let lastCommit = null;
+            try {
+                const recentCommits = await this.git.log({ maxCount: 1 });
+                lastCommit = recentCommits.latest;
+            }
+            catch {
+                // Repository has no commits yet - this is OK
+                console.log('📝 Repository has no commits yet, analyzing uncommitted changes');
+            }
+            // Get author from git config if no commits exist
+            let author = lastCommit?.author_name;
+            if (!author) {
+                try {
+                    const [userName, userEmail] = await Promise.all([
+                        this.git.raw(['config', 'user.name']).catch(() => null),
+                        this.git.raw(['config', 'user.email']).catch(() => null),
+                    ]);
+                    author = userName?.trim() || userEmail?.trim() || 'unknown';
+                }
+                catch {
+                    author = 'unknown';
+                }
+            }
             // Create repository info
             const repositoryInfo = {
                 title: this.generateTitle(status, currentBranch),
                 body: this.generateDescription(status, lastCommit),
-                author: lastCommit?.author_name || 'unknown',
+                author,
                 base: await this.getBaseBranch(),
                 head: currentBranch,
                 files: uncommittedFiles,
@@ -98725,14 +98919,32 @@ class GitRepositoryAnalyzer {
             return repositoryInfo;
         }
         catch (error) {
-            console.error('Error analyzing git repository:', error);
+            // Don't log the full error object to avoid confusing stack traces
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error('Error analyzing git repository:', errorMessage);
             return this.createEmptyRepositoryInfo('Error analyzing git repository');
         }
     }
     /**
      * Convert GitRepositoryInfo to PRInfo format for compatibility with existing PRReviewer
      */
-    toPRInfo(repositoryInfo) {
+    toPRInfo(repositoryInfo, includeContext = true) {
+        const files = repositoryInfo.files.map((file) => ({
+            filename: file.filename,
+            additions: file.additions,
+            deletions: file.deletions,
+            changes: file.changes,
+            patch: includeContext ? file.patch : undefined,
+            status: file.status,
+        }));
+        // Generate fullDiff from patches if includeContext is true
+        let fullDiff;
+        if (includeContext) {
+            fullDiff = files
+                .filter(file => file.patch)
+                .map(file => `--- ${file.filename}\n${file.patch}`)
+                .join('\n\n');
+        }
         return {
             number: 0, // Local analysis doesn't have PR number
             title: repositoryInfo.title,
@@ -98740,16 +98952,10 @@ class GitRepositoryAnalyzer {
             author: repositoryInfo.author,
             base: repositoryInfo.base,
             head: repositoryInfo.head,
-            files: repositoryInfo.files.map((file) => ({
-                filename: file.filename,
-                additions: file.additions,
-                deletions: file.deletions,
-                changes: file.changes,
-                patch: file.patch,
-                status: file.status,
-            })),
+            files,
             totalAdditions: repositoryInfo.totalAdditions,
             totalDeletions: repositoryInfo.totalDeletions,
+            fullDiff,
         };
     }
     async isGitRepository() {
@@ -98799,7 +99005,7 @@ class GitRepositoryAnalyzer {
             return null;
         }
     }
-    async getUncommittedChanges() {
+    async getUncommittedChanges(includeContext = true) {
         try {
             const status = await this.git.status();
             const changes = [];
@@ -98815,7 +99021,7 @@ class GitRepositoryAnalyzer {
             ];
             for (const { file, status } of fileChanges) {
                 const filePath = path.join(this.cwd, file);
-                const fileChange = await this.analyzeFileChange(file, status, filePath);
+                const fileChange = await this.analyzeFileChange(file, status, filePath, includeContext);
                 changes.push(fileChange);
             }
             return changes;
@@ -98825,14 +99031,14 @@ class GitRepositoryAnalyzer {
             return [];
         }
     }
-    async analyzeFileChange(filename, status, filePath) {
+    async analyzeFileChange(filename, status, filePath, includeContext = true) {
         let additions = 0;
         let deletions = 0;
         let patch;
         let content;
         try {
             // Get diff for the file if it exists and is not binary
-            if (status !== 'added' && fs.existsSync(filePath)) {
+            if (includeContext && status !== 'added' && fs.existsSync(filePath)) {
                 const diff = await this.git.diff(['--', filename]).catch(() => '');
                 if (diff) {
                     patch = diff;
@@ -98842,15 +99048,28 @@ class GitRepositoryAnalyzer {
                     deletions = lines.filter(line => line.startsWith('-')).length;
                 }
             }
-            // For added files, count lines as additions
+            else if (status !== 'added' && fs.existsSync(filePath)) {
+                // If not including context, still count changes for statistics
+                const diff = await this.git.diff(['--', filename]).catch(() => '');
+                if (diff) {
+                    const lines = diff.split('\n');
+                    additions = lines.filter(line => line.startsWith('+')).length;
+                    deletions = lines.filter(line => line.startsWith('-')).length;
+                }
+            }
+            // For added files
             if (status === 'added' && fs.existsSync(filePath)) {
                 try {
                     const stats = fs.statSync(filePath);
                     if (stats.isFile() && stats.size < 1024 * 1024) {
                         // Skip files larger than 1MB
-                        content = fs.readFileSync(filePath, 'utf8');
-                        additions = content.split('\n').length;
-                        patch = content; // For new files, the entire content is the "patch"
+                        if (includeContext) {
+                            content = fs.readFileSync(filePath, 'utf8');
+                            patch = content; // For new files, the entire content is the "patch"
+                        }
+                        // Always count additions for statistics
+                        const fileContent = includeContext ? content : fs.readFileSync(filePath, 'utf8');
+                        additions = fileContent.split('\n').length;
                     }
                 }
                 catch {
@@ -100232,6 +100451,9 @@ async function handleIssueComment(octokit, owner, repo, context, inputs, actionC
                     prInfo = await analyzer.fetchPRDiff(owner, repo, prNumber, undefined, 'issue_comment');
                     // Add event context for templates and XML generation
                     prInfo.eventContext = context.event;
+                    // PR context always includes code diffs
+                    prInfo.includeCodeContext = true;
+                    prInfo.isPRContext = true;
                 }
                 else {
                     // It's an issue comment - create a minimal PRInfo structure for issue assistant
@@ -100337,11 +100559,16 @@ async function handlePullRequestWithConfig(octokit, owner, repo, inputs, config,
     // Map the action to event type
     const eventType = mapGitHubEventToTrigger('pull_request', action);
     // Fetch PR diff (handle test scenarios gracefully)
+    // In PR context, ALWAYS include full diffs for proper code review
+    console.log('📝 Code context: ENABLED (PR context - always included)');
     let prInfo;
     try {
         prInfo = await analyzer.fetchPRDiff(owner, repo, prNumber, undefined, eventType);
         // Add event context for templates and XML generation
         prInfo.eventContext = context.event;
+        // Mark that we're in PR context and should always include diffs
+        prInfo.includeCodeContext = true;
+        prInfo.isPRContext = true;
     }
     catch (error) {
         // Handle test scenarios with mock repos
@@ -102367,13 +102594,13 @@ exports.AICheckProvider = AICheckProvider;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CheckProviderRegistry = void 0;
 const ai_check_provider_1 = __nccwpck_require__(98901);
-const tool_check_provider_1 = __nccwpck_require__(70477);
 const http_check_provider_1 = __nccwpck_require__(31115);
 const http_input_provider_1 = __nccwpck_require__(74423);
 const http_client_provider_1 = __nccwpck_require__(36270);
 const noop_check_provider_1 = __nccwpck_require__(53003);
 const log_check_provider_1 = __nccwpck_require__(24903);
 const claude_code_check_provider_1 = __nccwpck_require__(17985);
+const command_check_provider_1 = __nccwpck_require__(11878);
 /**
  * Registry for managing check providers
  */
@@ -102399,7 +102626,7 @@ class CheckProviderRegistry {
     registerDefaultProviders() {
         // Register all built-in providers
         this.register(new ai_check_provider_1.AICheckProvider());
-        this.register(new tool_check_provider_1.ToolCheckProvider());
+        this.register(new command_check_provider_1.CommandCheckProvider());
         this.register(new http_check_provider_1.HttpCheckProvider());
         this.register(new http_input_provider_1.HttpInputProvider());
         this.register(new http_client_provider_1.HttpClientProvider());
@@ -103183,6 +103410,244 @@ async function safeImport(moduleName) {
 }
 
 
+/***/ }),
+
+/***/ 11878:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CommandCheckProvider = void 0;
+const check_provider_interface_1 = __nccwpck_require__(14131);
+const liquidjs_1 = __nccwpck_require__(48694);
+/**
+ * Check provider that executes shell commands and captures their output
+ * Supports JSON parsing and integration with forEach functionality
+ */
+class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
+    liquid;
+    constructor() {
+        super();
+        this.liquid = new liquidjs_1.Liquid({
+            cache: false,
+            strictFilters: false,
+            strictVariables: false,
+        });
+    }
+    getName() {
+        return 'command';
+    }
+    getDescription() {
+        return 'Execute shell commands and capture output for processing';
+    }
+    async validateConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return false;
+        }
+        const cfg = config;
+        // Must have exec specified
+        if (!cfg.exec || typeof cfg.exec !== 'string') {
+            return false;
+        }
+        return true;
+    }
+    async execute(prInfo, config, dependencyResults) {
+        const command = config.exec;
+        const transform = config.transform;
+        // Prepare template context for Liquid rendering
+        const templateContext = {
+            pr: {
+                number: prInfo.number,
+                title: prInfo.title,
+                author: prInfo.author,
+                branch: prInfo.head,
+                base: prInfo.base,
+            },
+            files: prInfo.files,
+            fileCount: prInfo.files.length,
+            outputs: this.buildOutputContext(dependencyResults),
+            env: this.getSafeEnvironmentVariables(),
+        };
+        try {
+            // Render the command with Liquid templates if needed
+            let renderedCommand = command;
+            if (command.includes('{{') || command.includes('{%')) {
+                renderedCommand = await this.liquid.parseAndRender(command, templateContext);
+            }
+            // Prepare environment variables - convert all to strings
+            const scriptEnv = {};
+            for (const [key, value] of Object.entries(process.env)) {
+                if (value !== undefined) {
+                    scriptEnv[key] = value;
+                }
+            }
+            if (config.env) {
+                for (const [key, value] of Object.entries(config.env)) {
+                    if (value !== undefined && value !== null) {
+                        scriptEnv[key] = String(value);
+                    }
+                }
+            }
+            // Execute the script using dynamic import to avoid Jest issues
+            const { exec } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(35317)));
+            const { promisify } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(39023)));
+            const execAsync = promisify(exec);
+            const { stdout, stderr } = await execAsync(renderedCommand, {
+                env: scriptEnv,
+                timeout: 60000, // 60 second timeout
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+            });
+            if (stderr && process.env.DEBUG) {
+                console.error(`Command stderr: ${stderr}`);
+            }
+            // Try to parse output as JSON
+            let output = stdout.trim();
+            try {
+                // Attempt to parse as JSON
+                const parsed = JSON.parse(stdout.trim());
+                output = parsed;
+            }
+            catch {
+                // If not JSON, keep as string
+                output = stdout.trim();
+            }
+            // Apply transform if specified
+            let finalOutput = output;
+            if (transform) {
+                try {
+                    const transformContext = {
+                        ...templateContext,
+                        output,
+                    };
+                    const rendered = await this.liquid.parseAndRender(transform, transformContext);
+                    // Try to parse the transformed result as JSON
+                    try {
+                        finalOutput = JSON.parse(rendered.trim());
+                    }
+                    catch {
+                        finalOutput = rendered.trim();
+                    }
+                }
+                catch (error) {
+                    return {
+                        issues: [
+                            {
+                                file: 'command',
+                                line: 0,
+                                ruleId: 'command/transform_error',
+                                message: `Failed to apply transform: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                                severity: 'error',
+                                category: 'logic',
+                            },
+                        ],
+                    };
+                }
+            }
+            // Return the output as part of the review summary
+            // The output will be available to dependent checks
+            return {
+                issues: [],
+                output: finalOutput,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                issues: [
+                    {
+                        file: 'command',
+                        line: 0,
+                        ruleId: 'command/execution_error',
+                        message: `Command execution failed: ${errorMessage}`,
+                        severity: 'error',
+                        category: 'logic',
+                    },
+                ],
+            };
+        }
+    }
+    buildOutputContext(dependencyResults) {
+        if (!dependencyResults) {
+            return {};
+        }
+        const outputs = {};
+        for (const [checkName, result] of dependencyResults) {
+            if (result.output !== undefined) {
+                outputs[checkName] = result.output;
+            }
+            else {
+                outputs[checkName] = {
+                    issueCount: result.issues?.length || 0,
+                    issues: result.issues || [],
+                };
+            }
+        }
+        return outputs;
+    }
+    getSafeEnvironmentVariables() {
+        const safeVars = {};
+        const allowedPrefixes = ['CI_', 'GITHUB_', 'RUNNER_', 'NODE_', 'npm_', 'PATH', 'HOME', 'USER'];
+        for (const [key, value] of Object.entries(process.env)) {
+            if (value !== undefined && allowedPrefixes.some(prefix => key.startsWith(prefix))) {
+                safeVars[key] = value;
+            }
+        }
+        // Add current working directory
+        safeVars['PWD'] = process.cwd();
+        return safeVars;
+    }
+    getSupportedConfigKeys() {
+        return ['type', 'exec', 'transform', 'env', 'depends_on', 'on', 'if', 'group', 'forEach'];
+    }
+    async isAvailable() {
+        // Command provider is always available as long as we can execute commands
+        return true;
+    }
+    getRequirements() {
+        return [
+            'Valid shell command to execute',
+            'Shell environment available',
+            'Optional: Transform template for processing output',
+        ];
+    }
+}
+exports.CommandCheckProvider = CommandCheckProvider;
+
+
 /***/ }),
 
 /***/ 31115:
@@ -104041,181 +104506,6 @@ class NoopCheckProvider extends check_provider_interface_1.CheckProvider {
 exports.NoopCheckProvider = NoopCheckProvider;
 
 
-/***/ }),
-
-/***/ 70477:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ToolCheckProvider = void 0;
-const check_provider_interface_1 = __nccwpck_require__(14131);
-const issue_filter_1 = __nccwpck_require__(36879);
-const child_process_1 = __nccwpck_require__(35317);
-const liquidjs_1 = __nccwpck_require__(48694);
-/**
- * Check provider that executes external tools and commands with Liquid template support
- * Supports both simple commands and complex templated execution with stdin
- */
-class ToolCheckProvider extends check_provider_interface_1.CheckProvider {
-    liquid;
-    constructor() {
-        super();
-        this.liquid = new liquidjs_1.Liquid({
-            strictVariables: false,
-            strictFilters: false,
-        });
-    }
-    getName() {
-        return 'tool';
-    }
-    getDescription() {
-        return 'Execute external code analysis tools (ESLint, Prettier, etc.)';
-    }
-    async validateConfig(config) {
-        if (!config || typeof config !== 'object') {
-            return false;
-        }
-        const cfg = config;
-        // Type must be 'tool'
-        if (cfg.type !== 'tool') {
-            return false;
-        }
-        // Must have exec specified for tool execution
-        if (typeof cfg.exec !== 'string' || !cfg.exec) {
-            return false;
-        }
-        return true;
-    }
-    async execute(prInfo, config, _dependencyResults, _sessionInfo) {
-        const execTemplate = config.exec;
-        const stdinTemplate = config.stdin;
-        // Prepare template context
-        const templateContext = {
-            pr: {
-                number: prInfo.number,
-                title: prInfo.title,
-                body: prInfo.body,
-                author: prInfo.author,
-                base: prInfo.base,
-                head: prInfo.head,
-                totalAdditions: prInfo.totalAdditions,
-                totalDeletions: prInfo.totalDeletions,
-            },
-            files: prInfo.files.map(f => ({
-                filename: f.filename,
-                status: f.status,
-                additions: f.additions,
-                deletions: f.deletions,
-                changes: f.changes,
-                patch: f.patch,
-            })),
-            // Add convenience arrays for common use cases
-            filenames: prInfo.files.map(f => f.filename),
-            config: config, // Allow access to config values in templates
-        };
-        // Render the command template
-        const renderedCommand = await this.liquid.parseAndRender(execTemplate, templateContext);
-        // Render stdin if provided
-        let renderedStdin;
-        if (stdinTemplate) {
-            renderedStdin = await this.liquid.parseAndRender(stdinTemplate, templateContext);
-        }
-        // Execute the tool
-        const output = await this.executeCommand(renderedCommand.trim(), renderedStdin);
-        // Parse tool output (this would be customized per tool)
-        const comments = this.parseToolOutput(output, renderedCommand);
-        const issues = comments.map(comment => ({
-            file: comment.file,
-            line: comment.line,
-            endLine: undefined,
-            ruleId: `tool/${comment.category}`,
-            message: comment.message,
-            severity: comment.severity,
-            category: comment.category,
-            suggestion: undefined,
-            replacement: undefined,
-        }));
-        // Apply issue suppression filtering
-        const suppressionEnabled = config.suppressionEnabled !== false;
-        const issueFilter = new issue_filter_1.IssueFilter(suppressionEnabled);
-        const filteredIssues = issueFilter.filterIssues(issues, process.cwd());
-        return {
-            issues: filteredIssues,
-        };
-    }
-    async executeCommand(command, stdin) {
-        return new Promise((resolve, reject) => {
-            // Parse command and arguments (handle quoted arguments)
-            const parts = command.match(/(?:[^\s"]+|"[^"]*")+/g) || [command];
-            const cmd = parts[0];
-            const args = parts.slice(1).map(arg => arg.replace(/^"(.*)"$/, '$1'));
-            const child = (0, child_process_1.spawn)(cmd, args, {
-                shell: false,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            let output = '';
-            let error = '';
-            child.stdout.on('data', data => {
-                output += data.toString();
-            });
-            child.stderr.on('data', data => {
-                error += data.toString();
-            });
-            // Send stdin data if provided
-            if (stdin) {
-                child.stdin.write(stdin);
-                child.stdin.end();
-            }
-            child.on('close', _code => {
-                // Many tools return non-zero on issues found
-                resolve(output || error);
-            });
-            child.on('error', err => {
-                reject(new Error(`Failed to execute ${cmd}: ${err.message}`));
-            });
-        });
-    }
-    parseToolOutput(output, _command) {
-        const comments = [];
-        // This is a simplified parser - real implementation would handle specific tool formats
-        const lines = output.split('\n');
-        for (const line of lines) {
-            // Example: file.js:10:5: error: Missing semicolon
-            const match = line.match(/^(.+?):(\d+):(\d+):\s*(critical|error|warning|info):\s*(.+)$/);
-            if (match) {
-                const severity = match[4];
-                comments.push({
-                    file: match[1],
-                    line: parseInt(match[2]),
-                    message: match[5],
-                    severity: severity,
-                    category: 'style',
-                });
-            }
-        }
-        return comments;
-    }
-    getSupportedConfigKeys() {
-        return ['type', 'exec', 'command', 'stdin', 'timeout', 'workingDirectory'];
-    }
-    async isAvailable() {
-        // Check if common tools are available
-        // In a real implementation, this would check for specific tools based on config
-        return true;
-    }
-    getRequirements() {
-        return [
-            'External tool must be installed (e.g., eslint, prettier)',
-            'Tool must be accessible in PATH',
-            'Appropriate configuration files for the tool',
-        ];
-    }
-}
-exports.ToolCheckProvider = ToolCheckProvider;
-
-
 /***/ }),
 
 /***/ 532:
@@ -125696,7 +125986,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
       console.error(`[DELEGATE] Using binary at: ${binaryPath}`);
       console.error(`[DELEGATE] Command args: ${args.join(" ")}`);
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
       const process2 = (0, import_child_process5.spawn)(binaryPath, args, {
         stdio: ["pipe", "pipe", "pipe"],
@@ -125761,7 +126051,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
               delegationSpan.end();
             }
           }
-          resolve(response);
+          resolve2(response);
         } else {
           const errorMessage = stderr.trim() || `Delegate process failed with exit code ${code}`;
           if (debug) {
@@ -126193,13 +126483,19 @@ For GitHub-compatible mermaid diagrams, avoid single quotes and parentheses in n
 
 **Rules:**
 - NO single quotes in any node labels: 'text' \u2192 "text" or text
-- NO parentheses in square brackets: [Text (detail)] \u2192 [Text - detail]
+- NO parentheses in square brackets: [Text (detail)] \u2192 [Text - detail]  
 - NO complex expressions in diamonds: {a && b} \u2192 {condition}
+- NO HTML tags in node labels: [<pre>code</pre>] \u2192 ["code block"] or [Code Block]
 - USE single quotes for styles and classes: classDef highlight fill:'#ff9999'
+- CRITICAL: When using quotes in node labels, place them INSIDE the brackets: ["quoted text"], NOT [quoted text"]
 
 **Examples:**
 - \u2705 [Load Config] ["Run command"] {Valid?}
+- \u2705 ["depends_on: [generate-items]"] (correct quote placement)
+- \u2705 ["Code Block"] (clean text instead of HTML)
 - \u274C [Load (config)] [Run 'command'] {isValid('x')}
+- \u274C [depends_on: [generate-items"] (incorrect quote placement - quote ends inside bracket)
+- \u274C [<pre>depends_on: [generate-items]</pre>] (HTML tags in node labels)
 
 **Diagram Type Selection:**
 
@@ -127015,7 +127311,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        await new Promise((resolve2) => setTimeout(resolve2, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -128840,7 +129136,7 @@ var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
-var import_anthropic, import_openai, import_google, import_ai2, import_crypto5, import_events2, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, ProbeAgent;
+var import_anthropic, import_openai, import_google, import_ai2, import_crypto5, import_events2, import_fs5, import_promises, import_path7, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, SUPPORTED_IMAGE_EXTENSIONS, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -128850,6 +129146,9 @@ var init_ProbeAgent = __esm({
     import_ai2 = __nccwpck_require__(86619);
     import_crypto5 = __nccwpck_require__(76982);
     import_events2 = __nccwpck_require__(24434);
+    import_fs5 = __nccwpck_require__(79896);
+    import_promises = __nccwpck_require__(91943);
+    import_path7 = __nccwpck_require__(16928);
     init_tokenCounter();
     init_tools2();
     init_common();
@@ -128860,6 +129159,8 @@ var init_ProbeAgent = __esm({
     init_mcp();
     MAX_TOOL_ITERATIONS = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
     MAX_HISTORY_MESSAGES = 100;
+    SUPPORTED_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "webp", "gif", "bmp", "svg"];
+    MAX_IMAGE_FILE_SIZE = 20 * 1024 * 1024;
     ProbeAgent = class {
       /**
        * Create a new ProbeAgent instance
@@ -128903,6 +129204,8 @@ var init_ProbeAgent = __esm({
         }
         this.initializeTools();
         this.history = [];
+        this.pendingImages = /* @__PURE__ */ new Map();
+        this.currentImages = [];
         this.events = new import_events2.EventEmitter();
         this.enableMcp = !!options.enableMcp || process.env.ENABLE_MCP === "1";
         this.mcpConfigPath = options.mcpConfigPath || null;
@@ -129028,6 +129331,175 @@ var init_ProbeAgent = __esm({
           console.log(`Using Google API with model: ${this.model}${apiUrl ? ` (URL: ${apiUrl})` : ""}`);
         }
       }
+      /**
+       * Process assistant response content and detect/load image references
+       * @param {string} content - The assistant's response content
+       * @returns {Promise<void>}
+       */
+      async processImageReferences(content) {
+        if (!content) return;
+        const extensionsPattern = `(?:${SUPPORTED_IMAGE_EXTENSIONS.join("|")})`;
+        const imagePatterns = [
+          // Direct file path mentions: "./screenshot.png", "/path/to/image.jpg", etc.
+          new RegExp(`(?:\\.?\\.\\/)?[^\\s"'<>\\[\\]]+\\.${extensionsPattern}(?!\\w)`, "gi"),
+          // Contextual mentions: "look at image.png", "the file screenshot.jpg shows"
+          new RegExp(`(?:image|file|screenshot|diagram|photo|picture|graphic)\\s*:?\\s*([^\\s"'<>\\[\\]]+\\.${extensionsPattern})(?!\\w)`, "gi"),
+          // Tool result mentions: often contain file paths
+          new RegExp(`(?:found|saved|created|generated).*?([^\\s"'<>\\[\\]]+\\.${extensionsPattern})(?!\\w)`, "gi")
+        ];
+        const foundPaths = /* @__PURE__ */ new Set();
+        for (const pattern of imagePatterns) {
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            const imagePath = match[1] || match[0];
+            if (imagePath && imagePath.length > 0) {
+              foundPaths.add(imagePath.trim());
+            }
+          }
+        }
+        if (foundPaths.size === 0) return;
+        if (this.debug) {
+          console.log(`[DEBUG] Found ${foundPaths.size} potential image references:`, Array.from(foundPaths));
+        }
+        for (const imagePath of foundPaths) {
+          await this.loadImageIfValid(imagePath);
+        }
+      }
+      /**
+       * Load and cache an image if it's valid and accessible
+       * @param {string} imagePath - Path to the image file
+       * @returns {Promise<boolean>} - True if image was loaded successfully
+       */
+      async loadImageIfValid(imagePath) {
+        try {
+          if (this.pendingImages.has(imagePath)) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image already loaded: ${imagePath}`);
+            }
+            return true;
+          }
+          const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
+          let absolutePath;
+          let isPathAllowed = false;
+          if ((0, import_path7.isAbsolute)(imagePath)) {
+            absolutePath = imagePath;
+            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith((0, import_path7.resolve)(dir)));
+          } else {
+            for (const dir of allowedDirs) {
+              const resolvedPath = (0, import_path7.resolve)(dir, imagePath);
+              if (resolvedPath.startsWith((0, import_path7.resolve)(dir))) {
+                absolutePath = resolvedPath;
+                isPathAllowed = true;
+                break;
+              }
+            }
+          }
+          if (!isPathAllowed) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image path outside allowed directories: ${imagePath}`);
+            }
+            return false;
+          }
+          let fileStats;
+          try {
+            fileStats = await (0, import_promises.stat)(absolutePath);
+          } catch (error) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image file not found: ${absolutePath}`);
+            }
+            return false;
+          }
+          if (fileStats.size > MAX_IMAGE_FILE_SIZE) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image file too large: ${absolutePath} (${fileStats.size} bytes, max: ${MAX_IMAGE_FILE_SIZE})`);
+            }
+            return false;
+          }
+          const extension = absolutePath.toLowerCase().split(".").pop();
+          if (!SUPPORTED_IMAGE_EXTENSIONS.includes(extension)) {
+            if (this.debug) {
+              console.log(`[DEBUG] Unsupported image format: ${extension}`);
+            }
+            return false;
+          }
+          const mimeTypes = {
+            "png": "image/png",
+            "jpg": "image/jpeg",
+            "jpeg": "image/jpeg",
+            "webp": "image/webp",
+            "gif": "image/gif",
+            "bmp": "image/bmp",
+            "svg": "image/svg+xml"
+          };
+          const mimeType = mimeTypes[extension];
+          const fileBuffer = await (0, import_promises.readFile)(absolutePath);
+          const base64Data = fileBuffer.toString("base64");
+          const dataUrl = `data:${mimeType};base64,${base64Data}`;
+          this.pendingImages.set(imagePath, dataUrl);
+          if (this.debug) {
+            console.log(`[DEBUG] Successfully loaded image: ${imagePath} (${fileBuffer.length} bytes)`);
+          }
+          return true;
+        } catch (error) {
+          if (this.debug) {
+            console.log(`[DEBUG] Failed to load image ${imagePath}: ${error.message}`);
+          }
+          return false;
+        }
+      }
+      /**
+       * Get all currently loaded images as an array for AI model consumption
+       * @returns {Array<string>} - Array of base64 data URLs
+       */
+      getCurrentImages() {
+        return Array.from(this.pendingImages.values());
+      }
+      /**
+       * Clear loaded images (useful for new conversations)
+       */
+      clearLoadedImages() {
+        this.pendingImages.clear();
+        this.currentImages = [];
+        if (this.debug) {
+          console.log("[DEBUG] Cleared all loaded images");
+        }
+      }
+      /**
+       * Prepare messages for AI consumption, adding images to the latest user message if available
+       * @param {Array} messages - Current conversation messages
+       * @returns {Array} - Messages formatted for AI SDK with potential image content
+       */
+      prepareMessagesWithImages(messages) {
+        const loadedImages = this.getCurrentImages();
+        if (loadedImages.length === 0) {
+          return messages;
+        }
+        const messagesWithImages = [...messages];
+        const lastUserMessageIndex = messagesWithImages.map((m) => m.role).lastIndexOf("user");
+        if (lastUserMessageIndex === -1) {
+          if (this.debug) {
+            console.log("[DEBUG] No user messages found to attach images to");
+          }
+          return messages;
+        }
+        const lastUserMessage = messagesWithImages[lastUserMessageIndex];
+        if (typeof lastUserMessage.content === "string") {
+          messagesWithImages[lastUserMessageIndex] = {
+            ...lastUserMessage,
+            content: [
+              { type: "text", text: lastUserMessage.content },
+              ...loadedImages.map((imageData) => ({
+                type: "image",
+                image: imageData
+              }))
+            ]
+          };
+          if (this.debug) {
+            console.log(`[DEBUG] Added ${loadedImages.length} images to the latest user message`);
+          }
+        }
+        return messagesWithImages;
+      }
       /**
        * Initialize mock model for testing
        */
@@ -129127,7 +129599,7 @@ Examples:
 </extract>
 
 <attempt_completion>
-<result>The configuration is loaded from src/config.js lines 15-25 which contains the database settings.</result>
+The configuration is loaded from src/config.js lines 15-25 which contains the database settings.
 </attempt_completion>
 
 # Special Case: Quick Completion
@@ -129154,7 +129626,7 @@ I need to find code related to error handling in the search module. The most app
 6. Wait for the tool execution result, which will be provided in the next message (within a <tool_result> block).
 7. Analyze the tool result and decide the next step. If more tool calls are needed, repeat steps 2-6.
 8. If the task is fully complete and all previous steps were successful, use the \`<attempt_completion>\` tool to provide the final answer. This is the ONLY way to finish the task.
-9. If you cannot proceed (e.g., missing information, invalid request), explain the issue clearly before using \`<attempt_completion>\` with an appropriate message in the \`<result>\` tag.
+9. If you cannot proceed (e.g., missing information, invalid request), use \`<attempt_completion>\` to explain the issue clearly with an appropriate message directly inside the tags.
 10. If your previous response was already correct and complete, you may use \`<attempt_complete>\` as a shorthand.
 
 Available Tools:
@@ -129409,9 +129881,10 @@ You are working with a repository located at: ${searchDirectory}
             let assistantResponseContent = "";
             try {
               const executeAIRequest = async () => {
+                const messagesForAI = this.prepareMessagesWithImages(currentMessages);
                 const result = await (0, import_ai2.streamText)({
                   model: this.provider(this.model),
-                  messages: currentMessages,
+                  messages: messagesForAI,
                   maxTokens: maxResponseTokens,
                   temperature: 0.3
                 });
@@ -129445,6 +129918,9 @@ You are working with a repository located at: ${searchDirectory}
               const assistantPreview = createMessagePreview(assistantResponseContent);
               console.log(`[DEBUG] Assistant response (${assistantResponseContent.length} chars): ${assistantPreview}`);
             }
+            if (assistantResponseContent) {
+              await this.processImageReferences(assistantResponseContent);
+            }
             const validTools = [
               "search",
               "query",
@@ -129569,12 +130045,17 @@ ${toolResultContent}
                       throw toolError;
                     }
                     currentMessages.push({ role: "assistant", content: assistantResponseContent });
+                    const toolResultContent = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult, null, 2);
+                    const toolResultMessage = `<tool_result>
+${toolResultContent}
+</tool_result>`;
                     currentMessages.push({
                       role: "user",
-                      content: `<tool_result>
-${typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult, null, 2)}
-</tool_result>`
+                      content: toolResultMessage
                     });
+                    if (toolResultContent) {
+                      await this.processImageReferences(toolResultContent);
+                    }
                     if (this.debug) {
                       console.log(`[DEBUG] Tool ${toolName} executed successfully. Result length: ${typeof toolResult === "string" ? toolResult.length : JSON.stringify(toolResult).length}`);
                     }
@@ -130072,12 +130553,12 @@ function initializeSimpleTelemetryFromOptions(options) {
   });
   return telemetry;
 }
-var import_fs5, import_path7, SimpleTelemetry, SimpleAppTracer;
+var import_fs6, import_path8, SimpleTelemetry, SimpleAppTracer;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
-    import_fs5 = __nccwpck_require__(79896);
-    import_path7 = __nccwpck_require__(16928);
+    import_fs6 = __nccwpck_require__(79896);
+    import_path8 = __nccwpck_require__(16928);
     SimpleTelemetry = class {
       constructor(options = {}) {
         this.serviceName = options.serviceName || "probe-agent";
@@ -130091,11 +130572,11 @@ var init_simpleTelemetry = __esm({
       }
       initializeFileExporter() {
         try {
-          const dir = (0, import_path7.dirname)(this.filePath);
-          if (!(0, import_fs5.existsSync)(dir)) {
-            (0, import_fs5.mkdirSync)(dir, { recursive: true });
+          const dir = (0, import_path8.dirname)(this.filePath);
+          if (!(0, import_fs6.existsSync)(dir)) {
+            (0, import_fs6.mkdirSync)(dir, { recursive: true });
           }
-          this.stream = (0, import_fs5.createWriteStream)(this.filePath, { flags: "a" });
+          this.stream = (0, import_fs6.createWriteStream)(this.filePath, { flags: "a" });
           this.stream.on("error", (error) => {
             console.error(`[SimpleTelemetry] Stream error: ${error.message}`);
           });
@@ -130156,20 +130637,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve) => {
-            this.stream.once("drain", resolve);
+          return new Promise((resolve2) => {
+            this.stream.once("drain", resolve2);
             if (!this.stream.writableNeedDrain) {
-              resolve();
+              resolve2();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve) => {
+          return new Promise((resolve2) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve();
+              resolve2();
             });
           });
         }