@probelabs/visor 0.1.81 → 0.1.82

package/dist/sdk/sdk.js

@@ -7324,172 +7324,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(