@probelabs/visor 0.1.72 → 0.1.73

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.72';
-process.env.PROBE_VERSION = '0.6.0-rc116';
+process.env.VISOR_VERSION = '0.1.73';
+process.env.PROBE_VERSION = '0.6.0-rc117';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -95099,6 +95099,7 @@ class CheckExecutionEngine {
     config;
     webhookContext;
     routingSandbox;
+    executionStats = new Map();
     constructor(workingDirectory) {
         this.workingDirectory = workingDirectory || process.cwd();
         this.gitAnalyzer = new git_repository_analyzer_1.GitRepositoryAnalyzer(this.workingDirectory);
@@ -95660,12 +95661,15 @@ class CheckExecutionEngine {
                     apiCallDetails: reviewSummary.debug.apiCallDetails,
                 };
             }
+            // Build execution statistics
+            const executionStatistics = this.buildExecutionStatistics();
             return {
                 repositoryInfo,
                 reviewSummary,
                 executionTime,
                 timestamp,
                 checksExecuted: filteredChecks,
+                executionStatistics,
                 debug: debugInfo,
             };
         }
@@ -95861,7 +95865,7 @@ class CheckExecutionEngine {
         });
     }
     /**
-     * Execute review checks and return grouped results for new architecture
+     * Execute review checks and return grouped results with statistics for new architecture
      */
     async executeGroupedChecks(prInfo, checks, timeout, config, outputFormat, debug, maxParallelism, failFast, tagFilter) {
         // Determine where to send log messages based on output format
@@ -95890,7 +95894,10 @@ class CheckExecutionEngine {
         // Check if we have any checks left after filtering
         if (checks.length === 0) {
             logger_1.logger.warn('⚠️ No checks remain after tag filtering');
-            return {};
+            return {
+                results: {},
+                statistics: this.buildExecutionStatistics(),
+            };
         }
         if (!config?.checks) {
             throw new Error('Config with check definitions required for grouped execution');
@@ -95914,10 +95921,16 @@ class CheckExecutionEngine {
             const checkResult = await this.executeSingleGroupedCheck(prInfo, checks[0], timeout, config, logFn, debug);
             const groupedResults = {};
             groupedResults[checkResult.group] = [checkResult];
-            return groupedResults;
+            return {
+                results: groupedResults,
+                statistics: this.buildExecutionStatistics(),
+            };
         }
         // No checks to execute
-        return {};
+        return {
+            results: {},
+            statistics: this.buildExecutionStatistics(),
+        };
     }
     /**
      * Execute single check and return grouped result
@@ -95962,13 +95975,19 @@ class CheckExecutionEngine {
         };
     }
     /**
-     * Execute multiple checks with dependency awareness - return grouped results
+     * Execute multiple checks with dependency awareness - return grouped results with statistics
      */
     async executeGroupedDependencyAwareChecks(prInfo, checks, timeout, config, logFn, debug, maxParallelism, failFast) {
         // Use the existing dependency-aware execution logic
         const reviewSummary = await this.executeDependencyAwareChecks(prInfo, checks, timeout, config, logFn, debug, maxParallelism, failFast);
+        // Build execution statistics
+        const executionStatistics = this.buildExecutionStatistics();
         // Convert the flat ReviewSummary to grouped CheckResults
-        return await this.convertReviewSummaryToGroupedResults(reviewSummary, checks, config, prInfo);
+        const groupedResults = await this.convertReviewSummaryToGroupedResults(reviewSummary, checks, config, prInfo);
+        return {
+            results: groupedResults,
+            statistics: executionStatistics,
+        };
     }
     /**
      * Convert ReviewSummary to GroupedCheckResults
@@ -96281,9 +96300,10 @@ class CheckExecutionEngine {
         let shouldStopExecution = false;
         let completedChecksCount = 0;
         const totalChecksCount = stats.totalChecks;
-        let skippedChecksCount = 0;
-        let failedChecksCount = 0;
-        const executionStartTime = Date.now();
+        // Initialize execution statistics for all checks
+        for (const checkName of checks) {
+            this.initializeCheckStats(checkName);
+        }
         for (let levelIndex = 0; levelIndex < dependencyGraph.executionOrder.length && !shouldStopExecution; levelIndex++) {
             const executionGroup = dependencyGraph.executionOrder[levelIndex];
             // Check if any checks in this level require session reuse - if so, force sequential execution
@@ -96416,9 +96436,13 @@ class CheckExecutionEngine {
                     // Handle forEach dependent execution
                     let finalResult;
                     if (isForEachDependent && forEachParentName) {
+                        // Record forEach preview items
+                        this.recordForEachPreview(checkName, forEachItems);
                         if (debug) {
                             log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
                         }
+                        // Log forEach processing start
+                        logger_1.logger.info(`  Processing ${forEachItems.length} items...`);
                         const allIssues = [];
                         const allOutputs = [];
                         const aggregatedContents = [];
@@ -96479,6 +96503,8 @@ class CheckExecutionEngine {
                             if (debug) {
                                 log(`🔄 Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`);
                             }
+                            // Track iteration start
+                            const iterationStart = this.recordIterationStart(checkName);
                             // Execute with retry/routing semantics per item
                             const itemResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, forEachDependencyResults, sessionInfo, config, dependencyGraph, debug, results, 
                             /*foreachContext*/ {
@@ -96486,6 +96512,11 @@ class CheckExecutionEngine {
                                 total: forEachItems.length,
                                 parent: forEachParentName,
                             });
+                            // Record iteration completion
+                            const iterationDuration = (Date.now() - iterationStart) / 1000;
+                            this.recordIterationComplete(checkName, iterationStart, true, itemResult.issues || [], itemResult.output);
+                            // Log iteration progress
+                            logger_1.logger.info(`  ✔ ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`);
                             return { index: itemIndex, itemResult };
                         });
                         const forEachConcurrency = Math.max(1, Math.min(forEachItems.length, effectiveMaxParallelism));
@@ -96537,8 +96568,9 @@ class CheckExecutionEngine {
                         if (checkConfig.if) {
                             const shouldRun = await this.evaluateCheckCondition(checkName, checkConfig.if, prInfo, results, debug);
                             if (!shouldRun) {
-                                skippedChecksCount++;
-                                logger_1.logger.info(`⏭  Skipping check: ${checkName} (if condition evaluated to false)`);
+                                // Record skip with condition
+                                this.recordSkip(checkName, 'if_condition', checkConfig.if);
+                                logger_1.logger.info(`⏭  Skipped (if: ${this.truncate(checkConfig.if, 40)})`);
                                 return {
                                     checkName,
                                     error: null,
@@ -96551,6 +96583,8 @@ class CheckExecutionEngine {
                         }
                         // Execute with retry/routing semantics
                         finalResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, dependencyResults, sessionInfo, config, dependencyGraph, debug, results);
+                        // Record normal (non-forEach) execution
+                        this.recordIterationComplete(checkName, checkStartTime, true, finalResult.issues || [], finalResult.output);
                         if (checkConfig.forEach) {
                             try {
                                 const finalResultWithOutput = finalResult;
@@ -96581,7 +96615,20 @@ class CheckExecutionEngine {
                     };
                     const checkDuration = ((Date.now() - checkStartTime) / 1000).toFixed(1);
                     const issueCount = enrichedIssues.length;
-                    if (issueCount > 0) {
+                    const checkStats = this.executionStats.get(checkName);
+                    // Enhanced completion message with forEach stats
+                    if (checkStats && checkStats.totalRuns > 1) {
+                        if (issueCount > 0) {
+                            logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${checkStats.totalRuns} runs, ${issueCount} issue${issueCount === 1 ? '' : 's'}`);
+                        }
+                        else {
+                            logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${checkStats.totalRuns} runs`);
+                        }
+                    }
+                    else if (checkStats && checkStats.outputsProduced && checkStats.outputsProduced > 0) {
+                        logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${checkStats.outputsProduced} items`);
+                    }
+                    else if (issueCount > 0) {
                         logger_1.logger.success(`Check complete: ${checkName} (${checkDuration}s) - ${issueCount} issue${issueCount === 1 ? '' : 's'} found`);
                     }
                     else {
@@ -96594,9 +96641,11 @@ class CheckExecutionEngine {
                     };
                 }
                 catch (error) {
-                    failedChecksCount++;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     const checkDuration = ((Date.now() - checkStartTime) / 1000).toFixed(1);
+                    // Record error in stats
+                    this.recordError(checkName, error instanceof Error ? error : new Error(String(error)));
+                    this.recordIterationComplete(checkName, checkStartTime, false, [], undefined);
                     logger_1.logger.error(`✖ Check failed: ${checkName} (${checkDuration}s) - ${errorMessage}`);
                     if (debug) {
                         log(`🔧 Debug: Error in check ${checkName}: ${errorMessage}`);
@@ -96714,20 +96763,18 @@ class CheckExecutionEngine {
                 }
             }
         }
-        // Log final execution summary
-        const executionDuration = ((Date.now() - executionStartTime) / 1000).toFixed(1);
-        const successfulChecks = totalChecksCount - failedChecksCount - skippedChecksCount;
-        logger_1.logger.info('');
-        logger_1.logger.step(`Execution complete (${executionDuration}s)`);
-        logger_1.logger.info(`  ✔ Successful: ${successfulChecks}/${totalChecksCount}`);
-        if (skippedChecksCount > 0) {
-            logger_1.logger.info(`  ⏭  Skipped: ${skippedChecksCount}`);
-        }
-        if (failedChecksCount > 0) {
-            logger_1.logger.info(`  ✖ Failed: ${failedChecksCount}`);
+        // Build and log final execution summary
+        const executionStatistics = this.buildExecutionStatistics();
+        // Show detailed summary table (only if logFn outputs to console)
+        // Skip when output format is JSON/SARIF to avoid polluting structured output
+        // Check if logFn is console.log (not a no-op or console.error)
+        if (logFn === console.log) {
+            this.logExecutionSummary(executionStatistics);
         }
+        // Add warning if execution stopped early
         if (shouldStopExecution) {
-            logger_1.logger.warn(`  ⚠️  Execution stopped early due to fail-fast`);
+            logger_1.logger.info('');
+            logger_1.logger.warn(`⚠️  Execution stopped early due to fail-fast`);
         }
         if (debug) {
             if (shouldStopExecution) {
@@ -97666,6 +97713,251 @@ class CheckExecutionEngine {
         // events, which don't generate PRInfo objects in the first place.
         return 'pr_updated';
     }
+    /**
+     * Initialize execution statistics for a check
+     */
+    initializeCheckStats(checkName) {
+        this.executionStats.set(checkName, {
+            checkName,
+            totalRuns: 0,
+            successfulRuns: 0,
+            failedRuns: 0,
+            skipped: false,
+            totalDuration: 0,
+            issuesFound: 0,
+            issuesBySeverity: {
+                critical: 0,
+                error: 0,
+                warning: 0,
+                info: 0,
+            },
+            perIterationDuration: [],
+        });
+    }
+    /**
+     * Record the start of a check iteration
+     * Returns the start timestamp for duration tracking
+     */
+    recordIterationStart(_checkName) {
+        return Date.now();
+    }
+    /**
+     * Record completion of a check iteration
+     */
+    recordIterationComplete(checkName, startTime, success, issues, output) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats)
+            return;
+        const duration = Date.now() - startTime;
+        stats.totalRuns++;
+        if (success) {
+            stats.successfulRuns++;
+        }
+        else {
+            stats.failedRuns++;
+        }
+        stats.totalDuration += duration;
+        stats.perIterationDuration.push(duration);
+        // Count issues by severity
+        for (const issue of issues) {
+            stats.issuesFound++;
+            if (issue.severity === 'critical')
+                stats.issuesBySeverity.critical++;
+            else if (issue.severity === 'error')
+                stats.issuesBySeverity.error++;
+            else if (issue.severity === 'warning')
+                stats.issuesBySeverity.warning++;
+            else if (issue.severity === 'info')
+                stats.issuesBySeverity.info++;
+        }
+        // Track outputs produced
+        if (output !== undefined) {
+            stats.outputsProduced = (stats.outputsProduced || 0) + 1;
+        }
+    }
+    /**
+     * Record that a check was skipped
+     */
+    recordSkip(checkName, reason, condition) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats)
+            return;
+        stats.skipped = true;
+        stats.skipReason = reason;
+        if (condition) {
+            stats.skipCondition = condition;
+        }
+    }
+    /**
+     * Record forEach preview items
+     */
+    recordForEachPreview(checkName, items) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats || !items.length)
+            return;
+        // Store preview of first 3 items
+        const preview = items.slice(0, 3).map(item => {
+            const str = typeof item === 'string' ? item : JSON.stringify(item);
+            return str.length > 50 ? str.substring(0, 47) + '...' : str;
+        });
+        if (items.length > 3) {
+            preview.push(`...${items.length - 3} more`);
+        }
+        stats.forEachPreview = preview;
+    }
+    /**
+     * Record an error for a check
+     */
+    recordError(checkName, error) {
+        const stats = this.executionStats.get(checkName);
+        if (!stats)
+            return;
+        stats.errorMessage = error instanceof Error ? error.message : String(error);
+    }
+    /**
+     * Build the final execution statistics object
+     */
+    buildExecutionStatistics() {
+        const checks = Array.from(this.executionStats.values());
+        const totalExecutions = checks.reduce((sum, s) => sum + s.totalRuns, 0);
+        const successfulExecutions = checks.reduce((sum, s) => sum + s.successfulRuns, 0);
+        const failedExecutions = checks.reduce((sum, s) => sum + s.failedRuns, 0);
+        const skippedChecks = checks.filter(s => s.skipped).length;
+        const totalDuration = checks.reduce((sum, s) => sum + s.totalDuration, 0);
+        return {
+            totalChecksConfigured: checks.length,
+            totalExecutions,
+            successfulExecutions,
+            failedExecutions,
+            skippedChecks,
+            totalDuration,
+            checks,
+        };
+    }
+    /**
+     * Truncate a string to max length with ellipsis
+     */
+    truncate(str, maxLen) {
+        if (str.length <= maxLen)
+            return str;
+        return str.substring(0, maxLen - 3) + '...';
+    }
+    /**
+     * Format the Status column for execution summary table
+     */
+    formatStatusColumn(stats) {
+        if (stats.skipped) {
+            if (stats.skipReason === 'if_condition')
+                return '⏭ if';
+            if (stats.skipReason === 'fail_fast')
+                return '⏭ ff';
+            if (stats.skipReason === 'dependency_failed')
+                return '⏭ dep';
+            return '⏭';
+        }
+        if (stats.totalRuns === 0)
+            return '-';
+        const symbol = stats.failedRuns === 0 ? '✔' : stats.successfulRuns === 0 ? '✖' : '✔/✖';
+        // Show iteration count if > 1
+        if (stats.totalRuns > 1) {
+            if (stats.failedRuns > 0 && stats.successfulRuns > 0) {
+                // Partial success
+                return `${symbol} ${stats.successfulRuns}/${stats.totalRuns}`;
+            }
+            else {
+                // All success or all failed
+                return `${symbol} ×${stats.totalRuns}`;
+            }
+        }
+        return symbol;
+    }
+    /**
+     * Format the Details column for execution summary table
+     */
+    formatDetailsColumn(stats) {
+        const parts = [];
+        // Outputs produced (forEach)
+        if (stats.outputsProduced && stats.outputsProduced > 0) {
+            parts.push(`→${stats.outputsProduced}`);
+        }
+        // Critical issues
+        if (stats.issuesBySeverity.critical > 0) {
+            parts.push(`${stats.issuesBySeverity.critical}🔴`);
+        }
+        // Warnings
+        if (stats.issuesBySeverity.warning > 0) {
+            parts.push(`${stats.issuesBySeverity.warning}⚠️`);
+        }
+        // Info (only if no critical/warnings)
+        if (stats.issuesBySeverity.info > 0 &&
+            stats.issuesBySeverity.critical === 0 &&
+            stats.issuesBySeverity.warning === 0) {
+            parts.push(`${stats.issuesBySeverity.info}💡`);
+        }
+        // Error message or skip condition
+        if (stats.errorMessage) {
+            parts.push(this.truncate(stats.errorMessage, 20));
+        }
+        else if (stats.skipCondition) {
+            parts.push(this.truncate(stats.skipCondition, 20));
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Log the execution summary table
+     */
+    logExecutionSummary(stats) {
+        const totalIssues = stats.checks.reduce((sum, s) => sum + s.issuesFound, 0);
+        const criticalIssues = stats.checks.reduce((sum, s) => sum + s.issuesBySeverity.critical, 0);
+        const warningIssues = stats.checks.reduce((sum, s) => sum + s.issuesBySeverity.warning, 0);
+        const durationSec = (stats.totalDuration / 1000).toFixed(1);
+        // Summary box
+        const summaryTable = new (__nccwpck_require__(25832))({
+            style: {
+                head: [],
+                border: [],
+            },
+            colWidths: [41],
+        });
+        summaryTable.push([`Execution Complete (${durationSec}s)`], [`Checks: ${stats.totalChecksConfigured} configured → ${stats.totalExecutions} executions`], [
+            `Status: ${stats.successfulExecutions} ✔ │ ${stats.failedExecutions} ✖ │ ${stats.skippedChecks} ⏭`,
+        ]);
+        if (totalIssues > 0) {
+            let issuesLine = `Issues: ${totalIssues} total`;
+            if (criticalIssues > 0)
+                issuesLine += ` (${criticalIssues} 🔴`;
+            if (warningIssues > 0)
+                issuesLine += `${criticalIssues > 0 ? ' ' : ' ('}${warningIssues} ⚠️)`;
+            else if (criticalIssues > 0)
+                issuesLine += ')';
+            summaryTable.push([issuesLine]);
+        }
+        logger_1.logger.info('');
+        logger_1.logger.info(summaryTable.toString());
+        // Details table
+        logger_1.logger.info('');
+        logger_1.logger.info('Check Details:');
+        const detailsTable = new (__nccwpck_require__(25832))({
+            head: ['Check', 'Duration', 'Status', 'Details'],
+            colWidths: [21, 10, 10, 21],
+            style: {
+                head: ['cyan'],
+                border: ['grey'],
+            },
+        });
+        for (const checkStats of stats.checks) {
+            const duration = checkStats.skipped
+                ? '-'
+                : `${(checkStats.totalDuration / 1000).toFixed(1)}s`;
+            const status = this.formatStatusColumn(checkStats);
+            const details = this.formatDetailsColumn(checkStats);
+            detailsTable.push([checkStats.checkName, duration, status, details]);
+        }
+        logger_1.logger.info(detailsTable.toString());
+        // Legend
+        logger_1.logger.info('');
+        logger_1.logger.info('Legend: ✔=success │ ✖=failed │ ⏭=skipped │ ×N=iterations │ →N=outputs │ N🔴=critical │ N⚠️=warnings');
+    }
 }
 exports.CheckExecutionEngine = CheckExecutionEngine;
 
@@ -97752,7 +98044,15 @@ async function main() {
             console.log(cli.getVersion());
             process.exit(0);
         }
+        // Configure logger based on output format and verbosity
+        logger_1.logger.configure({
+            outputFormat: options.output,
+            debug: options.debug,
+            verbose: options.verbose,
+            quiet: options.quiet,
+        });
         // Print runtime banner (info level): Visor + Probe versions
+        // Banner is automatically suppressed for JSON/SARIF by logger configuration
         try {
             const visorVersion = process.env.VISOR_VERSION || ((__nccwpck_require__(8330)/* .version */ .rE) ?? 'dev');
             let probeVersion = process.env.PROBE_VERSION || 'unknown';
@@ -97920,7 +98220,9 @@ async function main() {
         const prInfoWithContext = prInfo;
         prInfoWithContext.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);
+        const executionResult = await engine.executeGroupedChecks(prInfo, checksToRun, options.timeout, config, options.output, options.debug || false, options.maxParallelism, options.failFast, tagFilter);
+        // Extract results and statistics from the execution result
+        const { results: groupedResults, statistics: executionStatistics } = executionResult;
         const shouldFilterResults = explicitChecks && explicitChecks.size > 0 && !explicitChecks.has('all');
         const groupedResultsToUse = shouldFilterResults
             ? Object.fromEntries(Object.entries(groupedResults)
@@ -97945,7 +98247,8 @@ async function main() {
                 }
             }
         }
-        const executedCheckNames = Array.from(new Set(Object.values(groupedResultsToUse).flatMap((checks) => checks.map(check => check.checkName))));
+        // Get executed check names
+        const executedCheckNames = Array.from(new Set(Object.entries(groupedResultsToUse).flatMap(([, checks]) => checks.map(check => check.checkName))));
         // Format output based on format type
         logger_1.logger.step(`Formatting results as ${options.output}`);
         let output;
@@ -97958,12 +98261,14 @@ async function main() {
                 repositoryInfo,
                 reviewSummary: {
                     issues: Object.values(groupedResultsToUse)
-                        .flatMap((r) => r.map((check) => check.issues || []).flat())
+                        .flatMap(checks => checks.flatMap(check => check.issues || []))
                         .flat(),
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
                 checksExecuted: executedCheckNames,
+                executionStatistics,
+                isCodeReview: includeCodeContext,
             };
             output = output_formatters_1.OutputFormatters.formatAsSarif(analysisResult);
         }
@@ -97973,12 +98278,14 @@ async function main() {
                 repositoryInfo,
                 reviewSummary: {
                     issues: Object.values(groupedResultsToUse)
-                        .flatMap((r) => r.map((check) => check.issues || []).flat())
+                        .flatMap(checks => checks.flatMap(check => check.issues || []))
                         .flat(),
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
                 checksExecuted: executedCheckNames,
+                executionStatistics,
+                isCodeReview: includeCodeContext,
             };
             output = output_formatters_1.OutputFormatters.formatAsMarkdown(analysisResult);
         }
@@ -97988,12 +98295,14 @@ async function main() {
                 repositoryInfo,
                 reviewSummary: {
                     issues: Object.values(groupedResultsToUse)
-                        .flatMap((r) => r.map((check) => check.issues || []).flat())
+                        .flatMap(checks => checks.flatMap(check => check.issues || []))
                         .flat(),
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
                 checksExecuted: executedCheckNames,
+                executionStatistics,
+                isCodeReview: includeCodeContext,
             };
             output = output_formatters_1.OutputFormatters.formatAsTable(analysisResult, { showDetails: true });
         }
@@ -98014,7 +98323,7 @@ async function main() {
             console.log(output);
         }
         // Summarize execution (stderr only; suppressed in JSON/SARIF unless verbose/debug)
-        const allResults = Object.values(groupedResultsToUse).flat();
+        const allResults = Object.values(groupedResultsToUse).flatMap(checks => checks);
         const allIssues = allResults.flatMap((r) => r.issues || []);
         const counts = allIssues.reduce((acc, issue) => {
             const sev = (issue.severity || 'info').toLowerCase();
@@ -101537,14 +101846,15 @@ async function handleIssueEvent(octokit, owner, repo, context, inputs, config, c
     const { CheckExecutionEngine } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(80299)));
     const engine = new CheckExecutionEngine();
     try {
-        const result = await engine.executeGroupedChecks(prInfo, checksToRun, undefined, // timeout
+        const executionResult = await engine.executeGroupedChecks(prInfo, checksToRun, undefined, // timeout
         config, undefined, // outputFormat
         inputs.debug === 'true');
+        const { results } = executionResult;
         // Format and post results as a comment on the issue
-        if (Object.keys(result).length > 0) {
+        if (Object.keys(results).length > 0) {
             let commentBody = '';
             // Directly use check content without adding extra headers
-            for (const checks of Object.values(result)) {
+            for (const checks of Object.values(results)) {
                 for (const check of checks) {
                     if (check.content && check.content.trim()) {
                         commentBody += `${check.content}\n\n`;
@@ -101803,7 +102113,7 @@ async function handleIssueComment(octokit, owner, repo, context, inputs, actionC
                     console.log('📝 Skipping comment (comment-on-pr is disabled)');
                 }
                 // Calculate total check results from grouped results
-                const totalChecks = Object.values(groupedResults).flat().length;
+                const totalChecks = Object.values(groupedResults).flatMap(checks => checks).length;
                 (0, core_1.setOutput)('checks-executed', totalChecks.toString());
             }
             break;
@@ -102123,7 +102433,7 @@ async function completeGitHubChecks(octokit, owner, repo, checkRunMap, groupedRe
  */
 function extractIssuesFromGroupedResults(groupedResults) {
     const issues = [];
-    for (const [groupName, checkResults] of Object.entries(groupedResults)) {
+    for (const checkResults of Object.values(groupedResults)) {
         for (const checkResult of checkResults) {
             const { checkName, content } = checkResult;
             // First, check if structured issues are available
@@ -102152,7 +102462,7 @@ function extractIssuesFromGroupedResults(groupedResults) {
                     message: message.trim(),
                     severity,
                     category: 'logic', // Default category since we can't parse this from content
-                    group: groupName,
+                    group: checkResult.group,
                     timestamp: Date.now(),
                 };
                 issues.push(issue);
@@ -102716,19 +103026,35 @@ class OutputFormatters {
         const issues = result.reviewSummary.issues || [];
         const totalIssues = issues.length;
         const criticalIssues = issues.filter(i => i.severity === 'critical').length;
-        // Summary table
-        const summaryTable = new cli_table3_1.default({
-            head: ['Metric', 'Value'],
-            colWidths: [25, 30],
-            style: {
-                head: ['cyan', 'bold'],
-                border: ['grey'],
-            },
-        });
-        summaryTable.push(['Total Issues', totalIssues.toString()], ['Critical Issues', criticalIssues.toString()], ['Files Analyzed', result.repositoryInfo.files.length.toString()], ['Total Additions', result.repositoryInfo.totalAdditions.toString()], ['Total Deletions', result.repositoryInfo.totalDeletions.toString()], ['Execution Time', `${result.executionTime}ms`], ['Checks Executed', result.checksExecuted.join(', ')]);
-        output += 'Analysis Summary\n';
-        output += summaryTable.toString() + '\n';
-        output += '\n';
+        // Check if this is a code review context
+        const isCodeReview = result.isCodeReview || issues.some(i => i.schema === 'code-review');
+        // Only show "Analysis Summary" table for code review contexts or when there are issues
+        // For other contexts, the execution statistics table already provides summary
+        if (isCodeReview || totalIssues > 0) {
+            // Summary table
+            const summaryTable = new cli_table3_1.default({
+                head: ['Metric', 'Value'],
+                colWidths: [25, 30],
+                style: {
+                    head: ['cyan', 'bold'],
+                    border: ['grey'],
+                },
+            });
+            // Add issue metrics
+            summaryTable.push(['Total Issues', totalIssues.toString()]);
+            if (criticalIssues > 0) {
+                summaryTable.push(['Critical Issues', criticalIssues.toString()]);
+            }
+            // Add code-review specific metrics if in code review context
+            if (isCodeReview && result.repositoryInfo.files.length > 0) {
+                summaryTable.push(['Files Analyzed', result.repositoryInfo.files.length.toString()], ['Total Additions', result.repositoryInfo.totalAdditions.toString()], ['Total Deletions', result.repositoryInfo.totalDeletions.toString()]);
+            }
+            // Always show execution time and checks executed
+            summaryTable.push(['Execution Time', `${result.executionTime}ms`], ['Checks Executed', result.checksExecuted.join(', ')]);
+            output += 'Analysis Summary\n';
+            output += summaryTable.toString() + '\n';
+            output += '\n';
+        }
         // Issues by category table
         if (issues.length > 0) {
             if (groupByCategory) {
@@ -106563,8 +106889,8 @@ class PRReviewer {
         if (config && checks && checks.length > 0) {
             const { CheckExecutionEngine } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(80299)));
             const engine = new CheckExecutionEngine();
-            const groupedResults = await engine.executeGroupedChecks(prInfo, checks, undefined, config, undefined, debug);
-            return groupedResults;
+            const { results } = await engine.executeGroupedChecks(prInfo, checks, undefined, config, undefined, debug);
+            return results;
         }
         throw new Error('No configuration provided. Please create a .visor.yaml file with check definitions. ' +
             'Built-in prompts have been removed - all checks must be explicitly configured.');
@@ -156734,14 +157060,53 @@ var init_probeTool = __esm({
         if (!targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
           throw new Error("Path traversal attempt detected. Access denied.");
         }
+        const debug = process.env.DEBUG === "1";
+        if (debug) {
+          console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
+        }
         try {
-          const files = await listFilesByLevel({
-            directory: targetDir,
-            maxFiles: 100,
-            respectGitignore: !process.env.PROBE_NO_GITIGNORE || process.env.PROBE_NO_GITIGNORE === "",
-            cwd: secureBaseDir
+          const files = await import_fs4.promises.readdir(targetDir, { withFileTypes: true });
+          const formatSize = (size) => {
+            if (size < 1024) return `${size}B`;
+            if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
+            if (size < 1024 * 1024 * 1024) return `${(size / (1024 * 1024)).toFixed(1)}M`;
+            return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
+          };
+          const entries = await Promise.all(files.map(async (file) => {
+            const isDirectory = file.isDirectory();
+            const fullPath = import_path7.default.join(targetDir, file.name);
+            let size = 0;
+            try {
+              const stats = await import_fs4.promises.stat(fullPath);
+              size = stats.size;
+            } catch (statError) {
+              if (debug) {
+                console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
+              }
+            }
+            return {
+              name: file.name,
+              isDirectory,
+              size
+            };
+          }));
+          entries.sort((a3, b3) => {
+            if (a3.isDirectory && !b3.isDirectory) return -1;
+            if (!a3.isDirectory && b3.isDirectory) return 1;
+            return a3.name.localeCompare(b3.name);
           });
-          return files;
+          const formatted = entries.map((entry) => {
+            const type = entry.isDirectory ? "dir " : "file";
+            const sizeStr = formatSize(entry.size).padStart(8);
+            return `${type} ${sizeStr}  ${entry.name}`;
+          });
+          if (debug) {
+            console.log(`[DEBUG] Found ${entries.length} files/directories in ${targetDir}`);
+          }
+          const header = `${targetDir}:
+`;
+          const output = header + formatted.join("\n");
+          return output;
         } catch (error2) {
           throw new Error(`Failed to list files: ${error2.message}`);
         }
@@ -156759,6 +157124,9 @@ var init_probeTool = __esm({
         if (!targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
           throw new Error("Path traversal attempt detected. Access denied.");
         }
+        if (pattern.includes("**/**") || pattern.split("*").length > 10) {
+          throw new Error("Pattern too complex. Please use a simpler glob pattern.");
+        }
         try {
           const options = {
             cwd: targetDir,
@@ -156768,7 +157136,17 @@ var init_probeTool = __esm({
           if (!recursive) {
             options.deep = 1;
           }
-          const files = await (0, import_glob.glob)(pattern, options);
+          const timeoutPromise = new Promise((_2, reject2) => {
+            setTimeout(() => reject2(new Error("Search operation timed out after 10 seconds")), 1e4);
+          });
+          const files = await Promise.race([
+            (0, import_glob.glob)(pattern, options),
+            timeoutPromise
+          ]);
+          const maxResults = 1e3;
+          if (files.length > maxResults) {
+            return files.slice(0, maxResults);
+          }
           return files;
         } catch (error2) {
           throw new Error(`Failed to search files: ${error2.message}`);
@@ -184172,8 +184550,8 @@ When presented with a broken Mermaid diagram, analyze it thoroughly and provide
             debug: this.options.debug,
             tracer: this.options.tracer,
             allowEdit: this.options.allowEdit,
-            maxIterations: 2,
-            // Limit mermaid fixing to 2 iterations to prevent long loops
+            maxIterations: 10,
+            // Allow more iterations for mermaid fixing to handle complex diagrams
             disableMermaidValidation: true
             // CRITICAL: Disable mermaid validation in nested agent to prevent infinite recursion
           });
@@ -185073,6 +185451,18 @@ var init_ProbeAgent = __esm({
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
         }
         this.wrappedTools = wrappedTools;
+        if (this.debug) {
+          console.error("\n[DEBUG] ========================================");
+          console.error("[DEBUG] ProbeAgent Tools Initialized");
+          console.error("[DEBUG] Session ID:", this.sessionId);
+          console.error("[DEBUG] Available tools:");
+          for (const toolName of Object.keys(this.toolImplementations)) {
+            console.error(`[DEBUG]   - ${toolName}`);
+          }
+          console.error("[DEBUG] Allowed folders:", this.allowedFolders);
+          console.error("[DEBUG] Outline mode:", this.outline);
+          console.error("[DEBUG] ========================================\n");
+        }
       }
       /**
        * Initialize the AI model based on available API keys and forced provider setting
@@ -185843,12 +186233,28 @@ You are working with a repository located at: ${searchDirectory}
                 const { type } = parsedTool;
                 if (type === "mcp" && this.mcpBridge && this.mcpBridge.isMcpTool(toolName)) {
                   try {
-                    if (this.debug) console.log(`[DEBUG] Executing MCP tool '${toolName}' with params:`, params);
+                    if (this.debug) {
+                      console.error(`
+[DEBUG] ========================================`);
+                      console.error(`[DEBUG] Executing MCP tool: ${toolName}`);
+                      console.error(`[DEBUG] Arguments:`);
+                      for (const [key, value] of Object.entries(params)) {
+                        const displayValue = typeof value === "string" && value.length > 100 ? value.substring(0, 100) + "..." : value;
+                        console.error(`[DEBUG]   ${key}: ${JSON.stringify(displayValue)}`);
+                      }
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     const executionResult = await this.mcpBridge.mcpTools[toolName].execute(params);
                     const toolResultContent = typeof executionResult === "string" ? executionResult : JSON.stringify(executionResult, null, 2);
-                    const preview = createMessagePreview(toolResultContent);
                     if (this.debug) {
-                      console.log(`[DEBUG] MCP tool '${toolName}' executed successfully. Result preview: ${preview}`);
+                      const preview = toolResultContent.length > 500 ? toolResultContent.substring(0, 500) + "..." : toolResultContent;
+                      console.error(`[DEBUG] ========================================`);
+                      console.error(`[DEBUG] MCP tool '${toolName}' completed successfully`);
+                      console.error(`[DEBUG] Result preview:`);
+                      console.error(preview);
+                      console.error(`[DEBUG] ========================================
+`);
                     }
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${toolResultContent}
@@ -185856,7 +186262,13 @@ ${toolResultContent}
                   } catch (error2) {
                     console.error(`Error executing MCP tool ${toolName}:`, error2);
                     const toolResultContent = `Error executing MCP tool ${toolName}: ${error2.message}`;
-                    if (this.debug) console.log(`[DEBUG] MCP tool '${toolName}' execution FAILED.`);
+                    if (this.debug) {
+                      console.error(`[DEBUG] ========================================`);
+                      console.error(`[DEBUG] MCP tool '${toolName}' failed with error:`);
+                      console.error(`[DEBUG] ${error2.message}`);
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${toolResultContent}
 </tool_result>` });
@@ -185868,6 +186280,18 @@ ${toolResultContent}
                       sessionId: this.sessionId,
                       workingDirectory: this.allowedFolders && this.allowedFolders[0] || process.cwd()
                     };
+                    if (this.debug) {
+                      console.error(`
+[DEBUG] ========================================`);
+                      console.error(`[DEBUG] Executing tool: ${toolName}`);
+                      console.error(`[DEBUG] Arguments:`);
+                      for (const [key, value] of Object.entries(params)) {
+                        const displayValue = typeof value === "string" && value.length > 100 ? value.substring(0, 100) + "..." : value;
+                        console.error(`[DEBUG]   ${key}: ${JSON.stringify(displayValue)}`);
+                      }
+                      console.error(`[DEBUG] ========================================
+`);
+                    }
                     this.events.emit("toolCall", {
                       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                       name: toolName,
@@ -185909,6 +186333,15 @@ ${toolResultContent}
                       } else {
                         toolResult = await executeToolCall();
                       }
+                      if (this.debug) {
+                        const resultPreview = typeof toolResult === "string" ? toolResult.length > 500 ? toolResult.substring(0, 500) + "..." : toolResult : toolResult ? JSON.stringify(toolResult, null, 2).substring(0, 500) + "..." : "No Result";
+                        console.error(`[DEBUG] ========================================`);
+                        console.error(`[DEBUG] Tool '${toolName}' completed successfully`);
+                        console.error(`[DEBUG] Result preview:`);
+                        console.error(resultPreview);
+                        console.error(`[DEBUG] ========================================
+`);
+                      }
                       this.events.emit("toolCall", {
                         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                         name: toolName,
@@ -185917,6 +186350,13 @@ ${toolResultContent}
                         status: "completed"
                       });
                     } catch (toolError) {
+                      if (this.debug) {
+                        console.error(`[DEBUG] ========================================`);
+                        console.error(`[DEBUG] Tool '${toolName}' failed with error:`);
+                        console.error(`[DEBUG] ${toolError.message}`);
+                        console.error(`[DEBUG] ========================================
+`);
+                      }
                       this.events.emit("toolCall", {
                         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                         name: toolName,
@@ -185966,6 +186406,16 @@ Error: Unknown tool '${toolName}'. Available tools: ${allAvailableTools.join(",
                 }
               }
             } else {
+              const hasMermaidCodeBlock = /```mermaid\s*\n[\s\S]*?\n```/.test(assistantResponseContent);
+              const hasNoSchemaOrTools = !options.schema && validTools.length === 0;
+              if (hasMermaidCodeBlock && hasNoSchemaOrTools) {
+                finalResult = assistantResponseContent;
+                completionAttempted = true;
+                if (this.debug) {
+                  console.error(`[DEBUG] Accepting mermaid code block as valid completion (no schema, no tools)`);
+                }
+                break;
+              }
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
               let reminderContent;
               if (options.schema) {
@@ -186679,12 +187129,14 @@ __export(index_exports, {
   getBinaryPath: () => getBinaryPath,
   initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions,
   listFilesByLevel: () => listFilesByLevel,
+  listFilesToolInstance: () => listFilesToolInstance,
   parseXmlToolCall: () => parseXmlToolCall,
   query: () => query,
   querySchema: () => querySchema,
   queryTool: () => queryTool,
   queryToolDefinition: () => queryToolDefinition,
   search: () => search,
+  searchFilesToolInstance: () => searchFilesToolInstance,
   searchSchema: () => searchSchema,
   searchTool: () => searchTool,
   searchToolDefinition: () => searchToolDefinition,
@@ -186707,6 +187159,7 @@ var init_index = __esm({
     init_bash();
     init_ProbeAgent();
     init_simpleTelemetry();
+    init_probeTool();
   }
 });
 init_index();
@@ -216788,7 +217241,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"application/1d-interleaved-parityfec
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"0.1.72"};
+module.exports = {"rE":"0.1.73"};
 
 /***/ })