@probelabs/visor 0.1.80 → 0.1.82

package/dist/sdk/sdk.js

@@ -326,7 +326,9 @@ var init_session_registry = __esm({
     SessionRegistry = class _SessionRegistry {
       static instance;
       sessions = /* @__PURE__ */ new Map();
+      exitHandlerRegistered = false;
       constructor() {
+        this.registerExitHandlers();
       }
       /**
        * Get the singleton instance of SessionRegistry
@@ -360,7 +362,15 @@ var init_session_registry = __esm({
       unregisterSession(sessionId) {
         if (this.sessions.has(sessionId)) {
           console.error(`\u{1F5D1}\uFE0F  Unregistering AI session: ${sessionId}`);
+          const agent = this.sessions.get(sessionId);
           this.sessions.delete(sessionId);
+          if (agent && typeof agent.cleanup === "function") {
+            try {
+              agent.cleanup();
+            } catch (error) {
+              console.error(`\u26A0\uFE0F  Warning: Failed to cleanup ProbeAgent: ${error}`);
+            }
+          }
         }
       }
       /**
@@ -368,6 +378,14 @@ var init_session_registry = __esm({
        */
       clearAllSessions() {
         console.error(`\u{1F9F9} Clearing all AI sessions (${this.sessions.size} sessions)`);
+        for (const [, agent] of this.sessions.entries()) {
+          if (agent && typeof agent.cleanup === "function") {
+            try {
+              agent.cleanup();
+            } catch {
+            }
+          }
+        }
         this.sessions.clear();
       }
       /**
@@ -382,6 +400,44 @@ var init_session_registry = __esm({
       hasSession(sessionId) {
         return this.sessions.has(sessionId);
       }
+      /**
+       * Register process exit handlers to cleanup sessions on exit
+       */
+      registerExitHandlers() {
+        if (this.exitHandlerRegistered) {
+          return;
+        }
+        const cleanupAndExit = (signal) => {
+          if (this.sessions.size > 0) {
+            console.error(`
+\u{1F9F9} [${signal}] Cleaning up ${this.sessions.size} active AI sessions...`);
+            this.clearAllSessions();
+          }
+        };
+        process.on("exit", () => {
+          if (this.sessions.size > 0) {
+            console.error(`\u{1F9F9} [exit] Cleaning up ${this.sessions.size} active AI sessions...`);
+            for (const [, agent] of this.sessions.entries()) {
+              if (agent && typeof agent.cleanup === "function") {
+                try {
+                  agent.cleanup();
+                } catch {
+                }
+              }
+            }
+            this.sessions.clear();
+          }
+        });
+        process.on("SIGINT", () => {
+          cleanupAndExit("SIGINT");
+          process.exit(0);
+        });
+        process.on("SIGTERM", () => {
+          cleanupAndExit("SIGTERM");
+          process.exit(0);
+        });
+        this.exitHandlerRegistered = true;
+      }
     };
   }
 });
@@ -2283,20 +2339,6 @@ var init_liquid_extensions = __esm({
   }
 });
 
-// src/providers/claude-code-types.ts
-async function safeImport(moduleName) {
-  try {
-    return await import(moduleName);
-  } catch {
-    return null;
-  }
-}
-var init_claude_code_types = __esm({
-  "src/providers/claude-code-types.ts"() {
-    "use strict";
-  }
-});
-
 // src/providers/ai-check-provider.ts
 var import_promises2, import_path2, AICheckProvider;
 var init_ai_check_provider = __esm({
@@ -2309,7 +2351,6 @@ var init_ai_check_provider = __esm({
     init_liquid_extensions();
     import_promises2 = __toESM(require("fs/promises"));
     import_path2 = __toESM(require("path"));
-    init_claude_code_types();
     AICheckProvider = class extends CheckProvider {
       aiReviewService;
       liquidEngine;
@@ -2587,54 +2628,6 @@ var init_ai_check_provider = __esm({
           );
         }
       }
-      /**
-       * Setup MCP tools based on AI configuration
-       */
-      async setupMcpTools(aiConfig) {
-        const tools = [];
-        if (aiConfig.mcpServers) {
-          try {
-            const mcpModule = await safeImport("@modelcontextprotocol/sdk");
-            if (!mcpModule) {
-              console.warn("@modelcontextprotocol/sdk package not found. MCP servers disabled.");
-              return tools;
-            }
-            const createSdkMcpServer = mcpModule.createSdkMcpServer || mcpModule.default?.createSdkMcpServer;
-            if (typeof createSdkMcpServer === "function") {
-              for (const [serverName, serverConfig] of Object.entries(aiConfig.mcpServers)) {
-                try {
-                  const server = await createSdkMcpServer({
-                    name: serverName,
-                    command: serverConfig.command,
-                    args: serverConfig.args || [],
-                    env: { ...process.env, ...serverConfig.env }
-                  });
-                  const serverTools = await server.listTools();
-                  tools.push(
-                    ...serverTools.map((tool) => ({
-                      name: tool.name,
-                      server: serverName
-                    }))
-                  );
-                } catch (serverError) {
-                  console.warn(
-                    `Failed to setup MCP server ${serverName}: ${serverError instanceof Error ? serverError.message : "Unknown error"}`
-                  );
-                }
-              }
-            } else {
-              console.warn(
-                "createSdkMcpServer function not found in @modelcontextprotocol/sdk. MCP servers disabled."
-              );
-            }
-          } catch (error) {
-            console.warn(
-              `Failed to import MCP SDK: ${error instanceof Error ? error.message : "Unknown error"}. MCP servers disabled.`
-            );
-          }
-        }
-        return tools;
-      }
       async execute(prInfo, config, _dependencyResults, sessionInfo) {
         if (config.env) {
           const result = EnvironmentResolver.withTemporaryEnv(config.env, () => {
@@ -2691,11 +2684,9 @@ var init_ai_check_provider = __esm({
         }
         if (Object.keys(mcpServers).length > 0) {
           aiConfig.mcpServers = mcpServers;
-          const mcpConfig = { mcpServers };
-          const mcpTools = await this.setupMcpTools(mcpConfig);
           if (aiConfig.debug) {
             console.error(
-              `\u{1F527} Debug: AI check MCP configured with ${Object.keys(mcpServers).length} servers; discovered ${mcpTools.length} tools`
+              `\u{1F527} Debug: AI check MCP configured with ${Object.keys(mcpServers).length} servers`
             );
           }
         }
@@ -3566,6 +3557,20 @@ var init_log_check_provider = __esm({
   }
 });
 
+// src/providers/claude-code-types.ts
+async function safeImport(moduleName) {
+  try {
+    return await import(moduleName);
+  } catch {
+    return null;
+  }
+}
+var init_claude_code_types = __esm({
+  "src/providers/claude-code-types.ts"() {
+    "use strict";
+  }
+});
+
 // src/providers/claude-code-check-provider.ts
 function isClaudeCodeConstructor(value) {
   return typeof value === "function";
@@ -3679,59 +3684,6 @@ var init_claude_code_check_provider = __esm({
           );
         }
       }
-      /**
-       * Setup MCP tools based on configuration
-       */
-      async setupMcpTools(config) {
-        const tools = [];
-        if (config.allowedTools) {
-          for (const toolName of config.allowedTools) {
-            tools.push({ name: toolName });
-          }
-        }
-        if (config.mcpServers) {
-          try {
-            const mcpModule = await safeImport("@modelcontextprotocol/sdk");
-            if (!mcpModule) {
-              console.warn("@modelcontextprotocol/sdk package not found. MCP servers disabled.");
-              return tools;
-            }
-            const createSdkMcpServer = mcpModule.createSdkMcpServer || mcpModule.default?.createSdkMcpServer;
-            if (typeof createSdkMcpServer === "function") {
-              for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
-                try {
-                  const server = await createSdkMcpServer({
-                    name: serverName,
-                    command: serverConfig.command,
-                    args: serverConfig.args || [],
-                    env: { ...process.env, ...serverConfig.env }
-                  });
-                  const serverTools = await server.listTools();
-                  tools.push(
-                    ...serverTools.map((tool) => ({
-                      name: tool.name,
-                      server: serverName
-                    }))
-                  );
-                } catch (serverError) {
-                  console.warn(
-                    `Failed to setup MCP server ${serverName}: ${serverError instanceof Error ? serverError.message : "Unknown error"}`
-                  );
-                }
-              }
-            } else {
-              console.warn(
-                "createSdkMcpServer function not found in @modelcontextprotocol/sdk. MCP servers disabled."
-              );
-            }
-          } catch (error) {
-            console.warn(
-              `Failed to import MCP SDK: ${error instanceof Error ? error.message : "Unknown error"}. MCP servers disabled.`
-            );
-          }
-        }
-        return tools;
-      }
       /**
        * Group files by their file extension for template context
        */
@@ -3962,14 +3914,18 @@ var init_claude_code_check_provider = __esm({
         const startTime = Date.now();
         try {
           const client = await this.initializeClaudeCodeClient();
-          const tools = await this.setupMcpTools(claudeCodeConfig);
           const query = {
             query: processedPrompt,
-            tools: tools.length > 0 ? tools : void 0,
             maxTurns: claudeCodeConfig.maxTurns || 5,
             systemPrompt: claudeCodeConfig.systemPrompt,
             subagent: claudeCodeConfig.subagent
           };
+          if (claudeCodeConfig.allowedTools && claudeCodeConfig.allowedTools.length > 0) {
+            query.tools = claudeCodeConfig.allowedTools.map((name) => ({ name }));
+          }
+          if (claudeCodeConfig.mcpServers && Object.keys(claudeCodeConfig.mcpServers).length > 0) {
+            query.mcpServers = claudeCodeConfig.mcpServers;
+          }
           let response;
           if (sessionInfo?.reuseSession && sessionInfo.parentSessionId) {
             response = await client.query({
@@ -3997,8 +3953,7 @@ var init_claude_code_check_provider = __esm({
             // Claude Code specific debug info
             sessionId: response.session_id,
             turnCount: response.turn_count,
-            usage: response.usage,
-            toolsUsed: tools.map((t) => t.name)
+            usage: response.usage
           };
           const suppressionEnabled = config.suppressionEnabled !== false;
           const issueFilter = new IssueFilter(suppressionEnabled);
@@ -7369,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
+                        };
+                      }
+                    }
+                    if (debug) {
+                      log2(
+                        `\u{1F504} Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`
+                      );
                     }
-                    const shouldRun = await this.evaluateCheckCondition(
+                    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
+                      }
+                    );
+                    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
                     );
-                    if (!shouldRun) {
+                    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(
@@ -7763,14 +7733,6 @@ ${expr}
             }
           }
         }
-        const executionStatistics = this.buildExecutionStatistics();
-        if (logFn === console.log) {
-          this.logExecutionSummary(executionStatistics);
-        }
-        if (shouldStopExecution) {
-          logger.info("");
-          logger.warn(`\u26A0\uFE0F  Execution stopped early due to fail-fast`);
-        }
         if (debug) {
           if (shouldStopExecution) {
             log2(
@@ -7791,6 +7753,14 @@ ${expr}
             }
           }
         }
+        const executionStatistics = this.buildExecutionStatistics();
+        if (logFn === console.log) {
+          this.logExecutionSummary(executionStatistics);
+        }
+        if (shouldStopExecution) {
+          logger.info("");
+          logger.warn(`\u26A0\uFE0F  Execution stopped early due to fail-fast`);
+        }
         return this.aggregateDependencyAwareResults(
           results,
           dependencyGraph,