@probelabs/visor 0.1.81 → 0.1.82

package/dist/sdk/{chunk-V5PUTL5N.mjs → chunk-G24UL45Z.mjs}

@@ -1549,7 +1549,7 @@ var PRReviewer = class {
   async reviewPR(owner, repo, prNumber, prInfo, options = {}) {
     const { debug = false, config, checks } = options;
     if (config && checks && checks.length > 0) {
-      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-47OZJFUV.mjs");
+      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-PO5XKTHP.mjs");
       const engine = new CheckExecutionEngine2();
       const { results } = await engine.executeGroupedChecks(
         prInfo,
@@ -7055,172 +7055,187 @@ ${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`
+            if (forEachItems.length === 0) {
+              if (debug) {
+                log2(
+                  `\u{1F504} Debug: Skipping check "${checkName}" - forEach check "${forEachParentName}" returned 0 items`
+                );
+              }
+              logger.info(`  forEach: no items from "${forEachParentName}", skipping check...`);
+              finalResult = {
+                issues: [],
+                output: []
+              };
+              finalResult.isForEach = true;
+              finalResult.forEachItems = [];
+            } else {
+              if (debug) {
+                log2(
+                  `\u{1F504} Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`
+                );
+              }
+              logger.info(
+                `  forEach: processing ${forEachItems.length} items from "${forEachParentName}"...`
               );
-            }
-            logger.info(
-              `  forEach: processing ${forEachItems.length} items from "${forEachParentName}"...`
-            );
-            const allIssues = [];
-            const allOutputs = [];
-            const aggregatedContents = [];
-            const itemTasks = forEachItems.map((item, itemIndex) => async () => {
-              const forEachDependencyResults = /* @__PURE__ */ new Map();
-              for (const [depName, depResult] of dependencyResults) {
-                if (forEachParents.includes(depName)) {
-                  const depForEachResult = depResult;
-                  if (Array.isArray(depForEachResult.output) && depForEachResult.output[itemIndex] !== void 0) {
-                    const modifiedResult = {
-                      issues: [],
-                      output: depForEachResult.output[itemIndex]
-                    };
-                    forEachDependencyResults.set(depName, modifiedResult);
-                    const rawResult = {
-                      issues: [],
-                      output: depForEachResult.output
-                    };
-                    forEachDependencyResults.set(`${depName}-raw`, rawResult);
+              const allIssues = [];
+              const allOutputs = [];
+              const aggregatedContents = [];
+              const itemTasks = forEachItems.map((item, itemIndex) => async () => {
+                const forEachDependencyResults = /* @__PURE__ */ new Map();
+                for (const [depName, depResult] of dependencyResults) {
+                  if (forEachParents.includes(depName)) {
+                    const depForEachResult = depResult;
+                    if (Array.isArray(depForEachResult.output) && depForEachResult.output[itemIndex] !== void 0) {
+                      const modifiedResult = {
+                        issues: [],
+                        output: depForEachResult.output[itemIndex]
+                      };
+                      forEachDependencyResults.set(depName, modifiedResult);
+                      const rawResult = {
+                        issues: [],
+                        output: depForEachResult.output
+                      };
+                      forEachDependencyResults.set(`${depName}-raw`, rawResult);
+                    } else {
+                      forEachDependencyResults.set(depName, depResult);
+                    }
                   } else {
                     forEachDependencyResults.set(depName, depResult);
                   }
-                } else {
-                  forEachDependencyResults.set(depName, depResult);
                 }
-              }
-              if (checkConfig.if) {
-                const conditionResults = new Map(results);
-                for (const [depName, depResult] of forEachDependencyResults) {
-                  conditionResults.set(depName, depResult);
+                if (checkConfig.if) {
+                  const conditionResults = new Map(results);
+                  for (const [depName, depResult] of forEachDependencyResults) {
+                    conditionResults.set(depName, depResult);
+                  }
+                  const shouldRun = await this.evaluateCheckCondition(
+                    checkName,
+                    checkConfig.if,
+                    prInfo,
+                    conditionResults,
+                    debug
+                  );
+                  if (!shouldRun) {
+                    if (debug) {
+                      log2(
+                        `\u{1F504} Debug: Skipping forEach item ${itemIndex + 1} for check "${checkName}" (if condition evaluated to false)`
+                      );
+                    }
+                    return {
+                      index: itemIndex,
+                      itemResult: { issues: [] },
+                      skipped: true
+                    };
+                  }
                 }
-                const shouldRun = await this.evaluateCheckCondition(
+                if (debug) {
+                  log2(
+                    `\u{1F504} Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`
+                  );
+                }
+                const iterationStart = this.recordIterationStart(checkName);
+                const itemResult = await this.executeWithRouting(
                   checkName,
-                  checkConfig.if,
+                  checkConfig,
+                  provider,
+                  providerConfig,
                   prInfo,
-                  conditionResults,
-                  debug
+                  forEachDependencyResults,
+                  sessionInfo,
+                  config,
+                  dependencyGraph,
+                  debug,
+                  results,
+                  /*foreachContext*/
+                  {
+                    index: itemIndex,
+                    total: forEachItems.length,
+                    parent: forEachParentName
+                  }
                 );
-                if (!shouldRun) {
+                const hadFatalError = (itemResult.issues || []).some((issue) => {
+                  const id = issue.ruleId || "";
+                  return id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error");
+                });
+                const iterationDuration = (Date.now() - iterationStart) / 1e3;
+                this.recordIterationComplete(
+                  checkName,
+                  iterationStart,
+                  !hadFatalError,
+                  // Success if no fatal errors
+                  itemResult.issues || [],
+                  itemResult.output
+                );
+                logger.info(
+                  `  \u2714 ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`
+                );
+                return { index: itemIndex, itemResult };
+              });
+              const forEachConcurrency = Math.max(
+                1,
+                Math.min(forEachItems.length, effectiveMaxParallelism)
+              );
+              if (debug && forEachConcurrency > 1) {
+                log2(
+                  `\u{1F504} Debug: Limiting forEach concurrency for check "${checkName}" to ${forEachConcurrency}`
+                );
+              }
+              const forEachResults = await this.executeWithLimitedParallelism(
+                itemTasks,
+                forEachConcurrency,
+                false
+              );
+              for (const result of forEachResults) {
+                if (result.status === "rejected") {
+                  const error = result.reason;
+                  const errorMessage = error instanceof Error ? error.message : String(error);
+                  allIssues.push({
+                    ruleId: `${checkName}/forEach/iteration_error`,
+                    severity: "error",
+                    category: "logic",
+                    message: `forEach iteration failed: ${errorMessage}`,
+                    file: "",
+                    line: 0
+                  });
                   if (debug) {
                     log2(
-                      `\u{1F504} Debug: Skipping forEach item ${itemIndex + 1} for check "${checkName}" (if condition evaluated to false)`
+                      `\u{1F504} Debug: forEach iteration for check "${checkName}" failed: ${errorMessage}`
                     );
                   }
-                  return {
-                    index: itemIndex,
-                    itemResult: { issues: [] },
-                    skipped: true
-                  };
+                  continue;
                 }
-              }
-              if (debug) {
-                log2(
-                  `\u{1F504} Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`
-                );
-              }
-              const iterationStart = this.recordIterationStart(checkName);
-              const itemResult = await this.executeWithRouting(
-                checkName,
-                checkConfig,
-                provider,
-                providerConfig,
-                prInfo,
-                forEachDependencyResults,
-                sessionInfo,
-                config,
-                dependencyGraph,
-                debug,
-                results,
-                /*foreachContext*/
-                {
-                  index: itemIndex,
-                  total: forEachItems.length,
-                  parent: forEachParentName
+                if (result.value.skipped) {
+                  continue;
                 }
-              );
-              const hadFatalError = (itemResult.issues || []).some((issue) => {
-                const id = issue.ruleId || "";
-                return id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error");
-              });
-              const iterationDuration = (Date.now() - iterationStart) / 1e3;
-              this.recordIterationComplete(
-                checkName,
-                iterationStart,
-                !hadFatalError,
-                // Success if no fatal errors
-                itemResult.issues || [],
-                itemResult.output
-              );
-              logger.info(
-                `  \u2714 ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`
-              );
-              return { index: itemIndex, itemResult };
-            });
-            const forEachConcurrency = Math.max(
-              1,
-              Math.min(forEachItems.length, effectiveMaxParallelism)
-            );
-            if (debug && forEachConcurrency > 1) {
-              log2(
-                `\u{1F504} Debug: Limiting forEach concurrency for check "${checkName}" to ${forEachConcurrency}`
-              );
-            }
-            const forEachResults = await this.executeWithLimitedParallelism(
-              itemTasks,
-              forEachConcurrency,
-              false
-            );
-            for (const result of forEachResults) {
-              if (result.status === "rejected") {
-                const error = result.reason;
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                allIssues.push({
-                  ruleId: `${checkName}/forEach/iteration_error`,
-                  severity: "error",
-                  category: "logic",
-                  message: `forEach iteration failed: ${errorMessage}`,
-                  file: "",
-                  line: 0
-                });
-                if (debug) {
-                  log2(
-                    `\u{1F504} Debug: forEach iteration for check "${checkName}" failed: ${errorMessage}`
-                  );
+                const { itemResult } = result.value;
+                if (itemResult.issues) {
+                  allIssues.push(...itemResult.issues);
+                }
+                const resultWithOutput = itemResult;
+                if (resultWithOutput.output !== void 0) {
+                  allOutputs.push(resultWithOutput.output);
+                }
+                const itemContent = resultWithOutput.content;
+                if (typeof itemContent === "string" && itemContent.trim()) {
+                  aggregatedContents.push(itemContent.trim());
                 }
-                continue;
-              }
-              if (result.value.skipped) {
-                continue;
-              }
-              const { itemResult } = result.value;
-              if (itemResult.issues) {
-                allIssues.push(...itemResult.issues);
               }
-              const resultWithOutput = itemResult;
-              if (resultWithOutput.output !== void 0) {
-                allOutputs.push(resultWithOutput.output);
+              const finalOutput = allOutputs.length > 0 ? allOutputs : void 0;
+              finalResult = {
+                issues: allIssues,
+                ...finalOutput !== void 0 ? { output: finalOutput } : {}
+              };
+              if (allOutputs.length > 0) {
+                finalResult.isForEach = true;
+                finalResult.forEachItems = allOutputs;
               }
-              const itemContent = resultWithOutput.content;
-              if (typeof itemContent === "string" && itemContent.trim()) {
-                aggregatedContents.push(itemContent.trim());
+              if (aggregatedContents.length > 0) {
+                finalResult.content = aggregatedContents.join("\n");
               }
+              log2(
+                `\u{1F504} Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`
+              );
             }
-            const finalOutput = allOutputs.length > 0 ? allOutputs : void 0;
-            finalResult = {
-              issues: allIssues,
-              ...finalOutput !== void 0 ? { output: finalOutput } : {}
-            };
-            if (allOutputs.length > 0) {
-              finalResult.isForEach = true;
-              finalResult.forEachItems = allOutputs;
-            }
-            if (aggregatedContents.length > 0) {
-              finalResult.content = aggregatedContents.join("\n");
-            }
-            log2(
-              `\u{1F504} Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`
-            );
           } else {
             if (checkConfig.if) {
               const shouldRun = await this.evaluateCheckCondition(
@@ -8633,4 +8648,4 @@ export {
   logger,
   CheckExecutionEngine
 };
-//# sourceMappingURL=chunk-V5PUTL5N.mjs.map
+//# sourceMappingURL=chunk-G24UL45Z.mjs.map