@probelabs/visor 0.1.82 → 0.1.84

package/dist/sdk/sdk.d.mts

@@ -248,6 +248,8 @@ interface CheckConfig {
     claude_code?: ClaudeCodeConfig;
     /** Environment variables for this check */
     env?: EnvConfig;
+    /** Timeout in seconds for command execution (default: 60) */
+    timeout?: number;
     /** Check IDs that this check depends on (optional) */
     depends_on?: string[];
     /** Group name for comment separation (e.g., "code-review", "pr-overview") - optional */
@@ -258,8 +260,8 @@ interface CheckConfig {
     template?: CustomTemplateConfig;
     /** Condition to determine if check should run - runs if expression evaluates to true */
     if?: string;
-    /** Whether to reuse AI session from dependency checks (only works with depends_on) */
-    reuse_ai_session?: boolean;
+    /** Check name to reuse AI session from, or true to use first dependency (only works with depends_on) */
+    reuse_ai_session?: string | boolean;
     /** Simple fail condition - fails check if expression evaluates to true */
     fail_if?: string;
     /** Check-specific failure conditions - optional (deprecated, use fail_if) */

package/dist/sdk/sdk.d.ts

@@ -248,6 +248,8 @@ interface CheckConfig {
     claude_code?: ClaudeCodeConfig;
     /** Environment variables for this check */
     env?: EnvConfig;
+    /** Timeout in seconds for command execution (default: 60) */
+    timeout?: number;
     /** Check IDs that this check depends on (optional) */
     depends_on?: string[];
     /** Group name for comment separation (e.g., "code-review", "pr-overview") - optional */
@@ -258,8 +260,8 @@ interface CheckConfig {
     template?: CustomTemplateConfig;
     /** Condition to determine if check should run - runs if expression evaluates to true */
     if?: string;
-    /** Whether to reuse AI session from dependency checks (only works with depends_on) */
-    reuse_ai_session?: boolean;
+    /** Check name to reuse AI session from, or true to use first dependency (only works with depends_on) */
+    reuse_ai_session?: string | boolean;
     /** Simple fail condition - fails check if expression evaluates to true */
     fail_if?: string;
     /** Check-specific failure conditions - optional (deprecated, use fail_if) */

package/dist/sdk/sdk.js

@@ -4127,6 +4127,7 @@ var init_command_check_provider = __esm({
           try {
             const parsed = JSON.parse(rawOutput);
             output = parsed;
+            logger.debug(`\u{1F527} Debug: Parsed entire output as JSON successfully`);
           } catch {
             const extracted2 = this.extractJsonFromEnd(rawOutput);
             if (extracted2) {
@@ -4135,13 +4136,28 @@ var init_command_check_provider = __esm({
                 logger.debug(
                   `\u{1F527} Debug: Extracted and parsed JSON from end of output (${extracted2.length} chars from ${rawOutput.length} total)`
                 );
-              } catch {
+                logger.debug(`\u{1F527} Debug: Extracted JSON content: ${extracted2.slice(0, 200)}`);
+              } catch (parseError) {
+                logger.debug(
+                  `\u{1F527} Debug: Extracted text is not valid JSON: ${parseError instanceof Error ? parseError.message : "Unknown error"}`
+                );
                 output = rawOutput;
               }
             } else {
+              logger.debug(`\u{1F527} Debug: No JSON found in output, keeping as string`);
               output = rawOutput;
             }
           }
+          if (output !== rawOutput) {
+            try {
+              const outputType = Array.isArray(output) ? `array[${output.length}]` : typeof output;
+              logger.debug(`\u{1F527} Debug: Parsed output type: ${outputType}`);
+              if (typeof output === "object" && output !== null) {
+                logger.debug(`\u{1F527} Debug: Parsed output keys: ${Object.keys(output).join(", ")}`);
+              }
+            } catch {
+            }
+          }
           let finalOutput = output;
           if (transform) {
             try {
@@ -4316,6 +4332,16 @@ return ${returnTarget};
           return result;
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          let isTimeout = false;
+          if (error && typeof error === "object") {
+            const execError = error;
+            if (execError.killed && execError.signal === "SIGTERM") {
+              isTimeout = true;
+            }
+            if (execError.code === "ETIMEDOUT") {
+              isTimeout = true;
+            }
+          }
           let stderrOutput = "";
           if (error && typeof error === "object") {
             const execError = error;
@@ -4323,17 +4349,32 @@ return ${returnTarget};
               stderrOutput = execError.stderr.trim();
             }
           }
-          const detailedMessage = stderrOutput ? `Command execution failed: ${errorMessage}
+          let detailedMessage;
+          let ruleId;
+          if (isTimeout) {
+            const timeoutSeconds = config.timeout || 60;
+            detailedMessage = `Command execution timed out after ${timeoutSeconds} seconds`;
+            if (stderrOutput) {
+              detailedMessage += `
+
+Stderr output:
+${stderrOutput}`;
+            }
+            ruleId = "command/timeout";
+          } else {
+            detailedMessage = stderrOutput ? `Command execution failed: ${errorMessage}
 
 Stderr output:
 ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
+            ruleId = "command/execution_error";
+          }
           logger.error(`\u2717 ${detailedMessage}`);
           return {
             issues: [
               {
                 file: "command",
                 line: 0,
-                ruleId: "command/execution_error",
+                ruleId,
                 message: detailedMessage,
                 severity: "error",
                 category: "logic"
@@ -5411,6 +5452,14 @@ var init_failure_condition_evaluator = __esm({
        */
       buildEvaluationContext(checkName, checkSchema, checkGroup, reviewSummary, previousOutputs) {
         const { issues, debug } = reviewSummary;
+        const reviewSummaryWithOutput = reviewSummary;
+        const {
+          output: extractedOutput,
+          // Exclude issues from otherFields since we handle it separately
+          issues: _issues,
+          // eslint-disable-line @typescript-eslint/no-unused-vars
+          ...otherFields
+        } = reviewSummaryWithOutput;
         const context = {
           output: {
             issues: (issues || []).map((issue) => ({
@@ -5427,9 +5476,9 @@ var init_failure_condition_evaluator = __esm({
               replacement: issue.replacement
             })),
             // Include additional schema-specific data from reviewSummary
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            ...reviewSummary
-            // Pass through any additional fields
+            ...otherFields,
+            // Spread the extracted output directly (avoid output.output nesting)
+            ...extractedOutput && typeof extractedOutput === "object" ? extractedOutput : {}
           },
           outputs: (() => {
             if (!previousOutputs) return {};
@@ -6869,6 +6918,31 @@ ${expr}
         };
         providerConfig.forEach = checkConfig.forEach;
         const result = await provider.execute(prInfo, providerConfig);
+        if (checkConfig.forEach && (!result.issues || result.issues.length === 0)) {
+          const reviewSummaryWithOutput = result;
+          const validation = this.validateAndNormalizeForEachOutput(
+            checkName,
+            reviewSummaryWithOutput.output,
+            checkConfig.group
+          );
+          if (!validation.isValid) {
+            return validation.error;
+          }
+        }
+        if (config && (config.fail_if || checkConfig.fail_if)) {
+          const failureResults = await this.evaluateFailureConditions(checkName, result, config);
+          if (failureResults.length > 0) {
+            const failureIssues = failureResults.filter((f) => f.failed).map((f) => ({
+              file: "system",
+              line: 0,
+              ruleId: f.conditionName,
+              message: f.message || `Failure condition met: ${f.expression}`,
+              severity: f.severity || "error",
+              category: "logic"
+            }));
+            result.issues = [...result.issues || [], ...failureIssues];
+          }
+        }
         const content = await this.renderCheckContent(checkName, result, checkConfig, prInfo);
         return {
           checkName,
@@ -6879,6 +6953,53 @@ ${expr}
           // Include structured issues
         };
       }
+      /**
+       * Validate and normalize forEach output
+       * Returns normalized array or throws validation error result
+       */
+      validateAndNormalizeForEachOutput(checkName, output, checkGroup) {
+        if (output === void 0) {
+          logger.error(`\u2717 forEach check "${checkName}" produced undefined output`);
+          return {
+            isValid: false,
+            error: {
+              checkName,
+              content: "",
+              group: checkGroup || "default",
+              issues: [
+                {
+                  file: "system",
+                  line: 0,
+                  ruleId: "forEach/undefined_output",
+                  message: `forEach check "${checkName}" produced undefined output. Verify your command outputs valid data and your transform_js returns a value.`,
+                  severity: "error",
+                  category: "logic"
+                }
+              ]
+            }
+          };
+        }
+        let normalizedOutput;
+        if (Array.isArray(output)) {
+          normalizedOutput = output;
+        } else if (typeof output === "string") {
+          try {
+            const parsed = JSON.parse(output);
+            normalizedOutput = Array.isArray(parsed) ? parsed : [parsed];
+          } catch {
+            normalizedOutput = [output];
+          }
+        } else if (output === null) {
+          normalizedOutput = [];
+        } else {
+          normalizedOutput = [output];
+        }
+        logger.info(`  Found ${normalizedOutput.length} items for forEach iteration`);
+        return {
+          isValid: true,
+          normalizedOutput
+        };
+      }
       /**
        * Execute multiple checks with dependency awareness - return grouped results with statistics
        */
@@ -7088,10 +7209,14 @@ ${expr}
           const checkConfig = config.checks[checkName];
           if (checkConfig) {
             dependencies[checkName] = checkConfig.depends_on || [];
-            if (checkConfig.reuse_ai_session === true) {
+            if (checkConfig.reuse_ai_session) {
               sessionReuseChecks.add(checkName);
-              if (checkConfig.depends_on && checkConfig.depends_on.length > 0) {
-                sessionProviders.set(checkName, checkConfig.depends_on[0]);
+              if (typeof checkConfig.reuse_ai_session === "string") {
+                sessionProviders.set(checkName, checkConfig.reuse_ai_session);
+              } else if (checkConfig.reuse_ai_session === true) {
+                if (checkConfig.depends_on && checkConfig.depends_on.length > 0) {
+                  sessionProviders.set(checkName, checkConfig.depends_on[0]);
+                }
               }
             }
           } else {
@@ -7654,27 +7779,23 @@ ${expr}
               }
               const reviewResult = result.value.result;
               const reviewSummaryWithOutput = reviewResult;
-              if (checkConfig?.forEach && reviewSummaryWithOutput.output !== void 0) {
+              if (checkConfig?.forEach && (!reviewResult.issues || reviewResult.issues.length === 0)) {
+                const validation2 = this.validateAndNormalizeForEachOutput(
+                  checkName,
+                  reviewSummaryWithOutput.output,
+                  checkConfig.group
+                );
+                if (!validation2.isValid) {
+                  results.set(
+                    checkName,
+                    validation2.error.issues ? { issues: validation2.error.issues } : {}
+                  );
+                  continue;
+                }
+                const normalizedOutput = validation2.normalizedOutput;
                 logger.debug(
                   `\u{1F527} Debug: Raw output for forEach check ${checkName}: ${Array.isArray(reviewSummaryWithOutput.output) ? `array(${reviewSummaryWithOutput.output.length})` : typeof reviewSummaryWithOutput.output}`
                 );
-                const rawOutput = reviewSummaryWithOutput.output;
-                let normalizedOutput;
-                if (Array.isArray(rawOutput)) {
-                  normalizedOutput = rawOutput;
-                } else if (typeof rawOutput === "string") {
-                  try {
-                    const parsed = JSON.parse(rawOutput);
-                    normalizedOutput = Array.isArray(parsed) ? parsed : [parsed];
-                  } catch {
-                    normalizedOutput = [rawOutput];
-                  }
-                } else if (rawOutput === void 0 || rawOutput === null) {
-                  normalizedOutput = [];
-                } else {
-                  normalizedOutput = [rawOutput];
-                }
-                logger.info(`  Found ${normalizedOutput.length} items for forEach iteration`);
                 try {
                   const preview = JSON.stringify(normalizedOutput);
                   logger.debug(
@@ -9368,6 +9489,10 @@ var init_config_schema = __esm({
               $ref: "#/definitions/EnvConfig",
               description: "Environment variables for this check"
             },
+            timeout: {
+              type: "number",
+              description: "Timeout in seconds for command execution (default: 60)"
+            },
             depends_on: {
               type: "array",
               items: {
@@ -9399,8 +9524,8 @@ var init_config_schema = __esm({
               description: "Condition to determine if check should run - runs if expression evaluates to true"
             },
             reuse_ai_session: {
-              type: "boolean",
-              description: "Whether to reuse AI session from dependency checks (only works with depends_on)"
+              type: ["string", "boolean"],
+              description: "Check name to reuse AI session from, or true to use first dependency (only works with depends_on)"
             },
             fail_if: {
               type: "string",
@@ -10737,7 +10862,7 @@ var ConfigManager = class {
         if (!checkConfig.type) {
           checkConfig.type = "ai";
         }
-        this.validateCheckConfig(checkName, checkConfig, errors);
+        this.validateCheckConfig(checkName, checkConfig, errors, config);
         if (checkConfig.ai_mcp_servers) {
           this.validateMcpServersObject(
             checkConfig.ai_mcp_servers,
@@ -10837,7 +10962,7 @@ var ConfigManager = class {
   /**
    * Validate individual check configuration
    */
-  validateCheckConfig(checkName, checkConfig, errors) {
+  validateCheckConfig(checkName, checkConfig, errors, config) {
     if (!checkConfig.type) {
       checkConfig.type = "ai";
     }
@@ -10918,12 +11043,23 @@ var ConfigManager = class {
       }
     }
     if (checkConfig.reuse_ai_session !== void 0) {
-      if (typeof checkConfig.reuse_ai_session !== "boolean") {
+      const isString = typeof checkConfig.reuse_ai_session === "string";
+      const isBoolean = typeof checkConfig.reuse_ai_session === "boolean";
+      if (!isString && !isBoolean) {
         errors.push({
           field: `checks.${checkName}.reuse_ai_session`,
-          message: `Invalid reuse_ai_session value for "${checkName}": must be boolean`,
+          message: `Invalid reuse_ai_session value for "${checkName}": must be string (check name) or boolean`,
           value: checkConfig.reuse_ai_session
         });
+      } else if (isString) {
+        const targetCheckName = checkConfig.reuse_ai_session;
+        if (!config?.checks || !config.checks[targetCheckName]) {
+          errors.push({
+            field: `checks.${checkName}.reuse_ai_session`,
+            message: `Check "${checkName}" references non-existent check "${targetCheckName}" for session reuse`,
+            value: checkConfig.reuse_ai_session
+          });
+        }
       } else if (checkConfig.reuse_ai_session === true) {
         if (!checkConfig.depends_on || !Array.isArray(checkConfig.depends_on) || checkConfig.depends_on.length === 0) {
           errors.push({