@probelabs/visor 0.1.72 → 0.1.74

package/dist/sdk/sdk.js

@@ -1540,7 +1540,7 @@ var init_reviewer = __esm({
         if (config && checks && checks.length > 0) {
           const { CheckExecutionEngine: CheckExecutionEngine2 } = await Promise.resolve().then(() => (init_check_execution_engine(), check_execution_engine_exports));
           const engine = new CheckExecutionEngine2();
-          const groupedResults = await engine.executeGroupedChecks(
+          const { results } = await engine.executeGroupedChecks(
             prInfo,
             checks,
             void 0,
@@ -1548,7 +1548,7 @@ var init_reviewer = __esm({
             void 0,
             debug
           );
-          return groupedResults;
+          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."
@@ -6016,6 +6016,7 @@ var init_check_execution_engine = __esm({
       config;
       webhookContext;
       routingSandbox;
+      executionStats = /* @__PURE__ */ new Map();
       constructor(workingDirectory) {
         this.workingDirectory = workingDirectory || process.cwd();
         this.gitAnalyzer = new GitRepositoryAnalyzer(this.workingDirectory);
@@ -6554,12 +6555,14 @@ ${expr}
               apiCallDetails: reviewSummary.debug.apiCallDetails
             };
           }
+          const executionStatistics = this.buildExecutionStatistics();
           return {
             repositoryInfo,
             reviewSummary,
             executionTime,
             timestamp,
             checksExecuted: filteredChecks,
+            executionStatistics,
             debug: debugInfo
           };
         } catch (error) {
@@ -6752,7 +6755,7 @@ ${expr}
         });
       }
       /**
-       * 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) {
         const logFn = outputFormat === "json" || outputFormat === "sarif" ? debug ? console.error : () => {
@@ -6782,7 +6785,10 @@ ${expr}
         checks = tagFilteredChecks;
         if (checks.length === 0) {
           logger.warn("\u26A0\uFE0F 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");
@@ -6822,9 +6828,15 @@ ${expr}
           );
           const groupedResults = {};
           groupedResults[checkResult.group] = [checkResult];
-          return groupedResults;
+          return {
+            results: groupedResults,
+            statistics: this.buildExecutionStatistics()
+          };
         }
-        return {};
+        return {
+          results: {},
+          statistics: this.buildExecutionStatistics()
+        };
       }
       /**
        * Execute single check and return grouped result
@@ -6870,7 +6882,7 @@ ${expr}
         };
       }
       /**
-       * 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) {
         const reviewSummary = await this.executeDependencyAwareChecks(
@@ -6883,7 +6895,17 @@ ${expr}
           maxParallelism,
           failFast
         );
-        return await this.convertReviewSummaryToGroupedResults(reviewSummary, checks, config, prInfo);
+        const executionStatistics = this.buildExecutionStatistics();
+        const groupedResults = await this.convertReviewSummaryToGroupedResults(
+          reviewSummary,
+          checks,
+          config,
+          prInfo
+        );
+        return {
+          results: groupedResults,
+          statistics: executionStatistics
+        };
       }
       /**
        * Convert ReviewSummary to GroupedCheckResults
@@ -7146,9 +7168,9 @@ ${expr}
         let shouldStopExecution = false;
         let completedChecksCount = 0;
         const totalChecksCount = stats.totalChecks;
-        let skippedChecksCount = 0;
-        let failedChecksCount = 0;
-        const executionStartTime = Date.now();
+        for (const checkName of checks) {
+          this.initializeCheckStats(checkName);
+        }
         for (let levelIndex = 0; levelIndex < dependencyGraph.executionOrder.length && !shouldStopExecution; levelIndex++) {
           const executionGroup = dependencyGraph.executionOrder[levelIndex];
           const checksInLevel = executionGroup.parallel;
@@ -7278,11 +7300,13 @@ ${expr}
               }
               let finalResult;
               if (isForEachDependent && forEachParentName) {
+                this.recordForEachPreview(checkName, forEachItems);
                 if (debug) {
                   log2(
                     `\u{1F504} Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`
                   );
                 }
+                logger.info(`  Processing ${forEachItems.length} items...`);
                 const allIssues = [];
                 const allOutputs = [];
                 const aggregatedContents = [];
@@ -7339,6 +7363,7 @@ ${expr}
                       `\u{1F504} Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`
                     );
                   }
+                  const iterationStart = this.recordIterationStart(checkName);
                   const itemResult = await this.executeWithRouting(
                     checkName,
                     checkConfig,
@@ -7358,6 +7383,17 @@ ${expr}
                       parent: forEachParentName
                     }
                   );
+                  const iterationDuration = (Date.now() - iterationStart) / 1e3;
+                  this.recordIterationComplete(
+                    checkName,
+                    iterationStart,
+                    true,
+                    itemResult.issues || [],
+                    itemResult.output
+                  );
+                  logger.info(
+                    `  \u2714 ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`
+                  );
                   return { index: itemIndex, itemResult };
                 });
                 const forEachConcurrency = Math.max(
@@ -7419,8 +7455,8 @@ ${expr}
                     debug
                   );
                   if (!shouldRun) {
-                    skippedChecksCount++;
-                    logger.info(`\u23ED  Skipping check: ${checkName} (if condition evaluated to false)`);
+                    this.recordSkip(checkName, "if_condition", checkConfig.if);
+                    logger.info(`\u23ED  Skipped (if: ${this.truncate(checkConfig.if, 40)})`);
                     return {
                       checkName,
                       error: null,
@@ -7444,6 +7480,13 @@ ${expr}
                   debug,
                   results
                 );
+                this.recordIterationComplete(
+                  checkName,
+                  checkStartTime,
+                  true,
+                  finalResult.issues || [],
+                  finalResult.output
+                );
                 if (checkConfig.forEach) {
                   try {
                     const finalResultWithOutput = finalResult;
@@ -7473,7 +7516,22 @@ ${expr}
               };
               const checkDuration = ((Date.now() - checkStartTime) / 1e3).toFixed(1);
               const issueCount = enrichedIssues.length;
-              if (issueCount > 0) {
+              const checkStats = this.executionStats.get(checkName);
+              if (checkStats && checkStats.totalRuns > 1) {
+                if (issueCount > 0) {
+                  logger.success(
+                    `Check complete: ${checkName} (${checkDuration}s) - ${checkStats.totalRuns} runs, ${issueCount} issue${issueCount === 1 ? "" : "s"}`
+                  );
+                } else {
+                  logger.success(
+                    `Check complete: ${checkName} (${checkDuration}s) - ${checkStats.totalRuns} runs`
+                  );
+                }
+              } else if (checkStats && checkStats.outputsProduced && checkStats.outputsProduced > 0) {
+                logger.success(
+                  `Check complete: ${checkName} (${checkDuration}s) - ${checkStats.outputsProduced} items`
+                );
+              } else if (issueCount > 0) {
                 logger.success(
                   `Check complete: ${checkName} (${checkDuration}s) - ${issueCount} issue${issueCount === 1 ? "" : "s"} found`
                 );
@@ -7486,9 +7544,10 @@ ${expr}
                 result: enrichedResult
               };
             } catch (error) {
-              failedChecksCount++;
               const errorMessage = error instanceof Error ? error.message : String(error);
               const checkDuration = ((Date.now() - checkStartTime) / 1e3).toFixed(1);
+              this.recordError(checkName, error instanceof Error ? error : new Error(String(error)));
+              this.recordIterationComplete(checkName, checkStartTime, false, [], void 0);
               logger.error(`\u2716 Check failed: ${checkName} (${checkDuration}s) - ${errorMessage}`);
               if (debug) {
                 log2(`\u{1F527} Debug: Error in check ${checkName}: ${errorMessage}`);
@@ -7596,19 +7655,13 @@ ${expr}
             }
           }
         }
-        const executionDuration = ((Date.now() - executionStartTime) / 1e3).toFixed(1);
-        const successfulChecks = totalChecksCount - failedChecksCount - skippedChecksCount;
-        logger.info("");
-        logger.step(`Execution complete (${executionDuration}s)`);
-        logger.info(`  \u2714 Successful: ${successfulChecks}/${totalChecksCount}`);
-        if (skippedChecksCount > 0) {
-          logger.info(`  \u23ED  Skipped: ${skippedChecksCount}`);
-        }
-        if (failedChecksCount > 0) {
-          logger.info(`  \u2716 Failed: ${failedChecksCount}`);
+        const executionStatistics = this.buildExecutionStatistics();
+        if (logFn === console.log) {
+          this.logExecutionSummary(executionStatistics);
         }
         if (shouldStopExecution) {
-          logger.warn(`  \u26A0\uFE0F  Execution stopped early due to fail-fast`);
+          logger.info("");
+          logger.warn(`\u26A0\uFE0F  Execution stopped early due to fail-fast`);
         }
         if (debug) {
           if (shouldStopExecution) {
@@ -8563,6 +8616,220 @@ ${result.value.result.debug.rawResponse}`;
         }
         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);
+        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++;
+        }
+        if (output !== void 0) {
+          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;
+        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 "\u23ED if";
+          if (stats.skipReason === "fail_fast") return "\u23ED ff";
+          if (stats.skipReason === "dependency_failed") return "\u23ED dep";
+          return "\u23ED";
+        }
+        if (stats.totalRuns === 0) return "-";
+        const symbol = stats.failedRuns === 0 ? "\u2714" : stats.successfulRuns === 0 ? "\u2716" : "\u2714/\u2716";
+        if (stats.totalRuns > 1) {
+          if (stats.failedRuns > 0 && stats.successfulRuns > 0) {
+            return `${symbol} ${stats.successfulRuns}/${stats.totalRuns}`;
+          } else {
+            return `${symbol} \xD7${stats.totalRuns}`;
+          }
+        }
+        return symbol;
+      }
+      /**
+       * Format the Details column for execution summary table
+       */
+      formatDetailsColumn(stats) {
+        const parts = [];
+        if (stats.outputsProduced && stats.outputsProduced > 0) {
+          parts.push(`\u2192${stats.outputsProduced}`);
+        }
+        if (stats.issuesBySeverity.critical > 0) {
+          parts.push(`${stats.issuesBySeverity.critical}\u{1F534}`);
+        }
+        if (stats.issuesBySeverity.warning > 0) {
+          parts.push(`${stats.issuesBySeverity.warning}\u26A0\uFE0F`);
+        }
+        if (stats.issuesBySeverity.info > 0 && stats.issuesBySeverity.critical === 0 && stats.issuesBySeverity.warning === 0) {
+          parts.push(`${stats.issuesBySeverity.info}\u{1F4A1}`);
+        }
+        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 / 1e3).toFixed(1);
+        const summaryTable = new (require("cli-table3"))({
+          style: {
+            head: [],
+            border: []
+          },
+          colWidths: [41]
+        });
+        summaryTable.push(
+          [`Execution Complete (${durationSec}s)`],
+          [`Checks: ${stats.totalChecksConfigured} configured \u2192 ${stats.totalExecutions} executions`],
+          [
+            `Status: ${stats.successfulExecutions} \u2714 \u2502 ${stats.failedExecutions} \u2716 \u2502 ${stats.skippedChecks} \u23ED`
+          ]
+        );
+        if (totalIssues > 0) {
+          let issuesLine = `Issues: ${totalIssues} total`;
+          if (criticalIssues > 0) issuesLine += ` (${criticalIssues} \u{1F534}`;
+          if (warningIssues > 0) issuesLine += `${criticalIssues > 0 ? " " : " ("}${warningIssues} \u26A0\uFE0F)`;
+          else if (criticalIssues > 0) issuesLine += ")";
+          summaryTable.push([issuesLine]);
+        }
+        logger.info("");
+        logger.info(summaryTable.toString());
+        logger.info("");
+        logger.info("Check Details:");
+        const detailsTable = new (require("cli-table3"))({
+          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 / 1e3).toFixed(1)}s`;
+          const status = this.formatStatusColumn(checkStats);
+          const details = this.formatDetailsColumn(checkStats);
+          detailsTable.push([checkStats.checkName, duration, status, details]);
+        }
+        logger.info(detailsTable.toString());
+        logger.info("");
+        logger.info(
+          "Legend: \u2714=success \u2502 \u2716=failed \u2502 \u23ED=skipped \u2502 \xD7N=iterations \u2502 \u2192N=outputs \u2502 N\u{1F534}=critical \u2502 N\u26A0\uFE0F=warnings"
+        );
+      }
     };
   }
 });