@probelabs/visor 0.1.106 → 0.1.111

package/dist/sdk/chunk-HTOKWMPO.mjs

@@ -0,0 +1,157 @@
+import {
+  init_logger,
+  logger
+} from "./chunk-AGIZJ4UZ.mjs";
+import {
+  __esm
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/slack/prompt-state.ts
+function getPromptStateManager(ttlMs) {
+  if (!__promptState) __promptState = new PromptStateManager(ttlMs);
+  return __promptState;
+}
+function resetPromptStateManager() {
+  __promptState = void 0;
+}
+var PromptStateManager, __promptState;
+var init_prompt_state = __esm({
+  "src/slack/prompt-state.ts"() {
+    init_logger();
+    PromptStateManager = class {
+      waiting = /* @__PURE__ */ new Map();
+      // key: `${channel}:${threadTs}`
+      ttlMs;
+      timer;
+      firstMessage = /* @__PURE__ */ new Map();
+      summaryTs = /* @__PURE__ */ new Map();
+      // key: threadKey -> group -> ts
+      constructor(ttlMs = 60 * 60 * 1e3) {
+        this.ttlMs = ttlMs;
+        this.startCleanup();
+      }
+      key(channel, threadTs) {
+        return `${channel}:${threadTs}`;
+      }
+      setWaiting(channel, threadTs, info) {
+        const key = this.key(channel, threadTs);
+        const value = { ...info, timestamp: Date.now(), channel, threadTs };
+        this.waiting.set(key, value);
+        try {
+          logger.info(
+            `[prompt-state] waiting set for ${key} (check=${info.checkName}, prompt="${info.prompt.substring(
+              0,
+              60
+            )}\u2026")`
+          );
+        } catch {
+        }
+      }
+      getWaiting(channel, threadTs) {
+        const key = this.key(channel, threadTs);
+        const info = this.waiting.get(key);
+        if (!info) return void 0;
+        const age = Date.now() - info.timestamp;
+        if (age > this.ttlMs) {
+          this.waiting.delete(key);
+          try {
+            logger.warn(`[prompt-state] expired ${key} (age=${Math.round(age / 1e3)}s)`);
+          } catch {
+          }
+          return void 0;
+        }
+        return info;
+      }
+      clear(channel, threadTs) {
+        const key = this.key(channel, threadTs);
+        const had = this.waiting.delete(key);
+        if (had) {
+          try {
+            logger.info(`[prompt-state] cleared ${key}`);
+          } catch {
+          }
+        }
+        return had;
+      }
+      /** Merge updates into an existing waiting entry */
+      update(channel, threadTs, patch) {
+        const key = this.key(channel, threadTs);
+        const prev = this.waiting.get(key);
+        if (!prev) return void 0;
+        const next = { ...prev, ...patch };
+        this.waiting.set(key, next);
+        try {
+          if (patch.snapshotPath) {
+            logger.info(`[prompt-state] snapshotPath set for ${key}`);
+          }
+        } catch {
+        }
+        return next;
+      }
+      // First message capture helpers
+      setFirstMessage(channel, threadTs, text) {
+        const key = this.key(channel, threadTs);
+        if (!text || !text.trim()) return;
+        const existing = this.firstMessage.get(key);
+        if (!existing || existing.consumed) {
+          this.firstMessage.set(key, { text, consumed: false });
+        }
+      }
+      consumeFirstMessage(channel, threadTs) {
+        const key = this.key(channel, threadTs);
+        const entry = this.firstMessage.get(key);
+        if (entry && !entry.consumed) {
+          entry.consumed = true;
+          this.firstMessage.set(key, entry);
+          return entry.text;
+        }
+        return void 0;
+      }
+      hasUnconsumedFirstMessage(channel, threadTs) {
+        const key = this.key(channel, threadTs);
+        const e = this.firstMessage.get(key);
+        return !!(e && !e.consumed && e.text && e.text.trim());
+      }
+      startCleanup(intervalMs = 5 * 60 * 1e3) {
+        if (this.timer) clearInterval(this.timer);
+        this.timer = setInterval(() => this.cleanup(), intervalMs);
+        if (this.timer.unref) this.timer.unref();
+      }
+      cleanup() {
+        const now = Date.now();
+        let removed = 0;
+        for (const [key, info] of this.waiting.entries()) {
+          if (now - info.timestamp > this.ttlMs) {
+            this.waiting.delete(key);
+            removed++;
+          }
+        }
+        for (const [key] of this.firstMessage.entries()) {
+          const waitingInfo = this.waiting.get(key);
+          if (!waitingInfo) {
+            const entry = this.firstMessage.get(key);
+            if (entry?.consumed) {
+              this.firstMessage.delete(key);
+              removed++;
+            }
+          }
+        }
+        if (removed) {
+          try {
+            logger.info(`[prompt-state] cleanup removed ${removed} entries`);
+          } catch {
+          }
+        }
+        return removed;
+      }
+    };
+  }
+});
+
+export {
+  PromptStateManager,
+  getPromptStateManager,
+  resetPromptStateManager,
+  init_prompt_state
+};
+//# sourceMappingURL=chunk-HTOKWMPO.mjs.map

package/dist/sdk/chunk-HTOKWMPO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/slack/prompt-state.ts"],"sourcesContent":["import { logger } from '../logger';\n\nexport interface WaitingPromptInfo {\n  checkName: string;\n  prompt: string;\n  timestamp: number;\n  channel: string;\n  threadTs: string;\n  promptMessageTs?: string;\n  snapshotPath?: string;\n  promptsPosted?: number; // how many prompts we posted into this thread\n  context?: Record<string, unknown>;\n}\n\nexport class PromptStateManager {\n  private waiting = new Map<string, WaitingPromptInfo>(); // key: `${channel}:${threadTs}`\n  private ttlMs: number;\n  private timer?: NodeJS.Timeout;\n  private firstMessage = new Map<string, { text: string; consumed: boolean }>();\n  private summaryTs = new Map<string, Map<string, string>>(); // key: threadKey -> group -> ts\n\n  constructor(ttlMs: number = 60 * 60 * 1000) {\n    this.ttlMs = ttlMs;\n    this.startCleanup();\n  }\n\n  private key(channel: string, threadTs: string): string {\n    return `${channel}:${threadTs}`;\n  }\n\n  setWaiting(\n    channel: string,\n    threadTs: string,\n    info: Omit<WaitingPromptInfo, 'timestamp' | 'channel' | 'threadTs'>\n  ) {\n    const key = this.key(channel, threadTs);\n    const value: WaitingPromptInfo = { ...info, timestamp: Date.now(), channel, threadTs };\n    this.waiting.set(key, value);\n    try {\n      logger.info(\n        `[prompt-state] waiting set for ${key} (check=${info.checkName}, prompt=\"${info.prompt.substring(\n          0,\n          60\n        )}…\")`\n      );\n    } catch {}\n  }\n\n  getWaiting(channel: string, threadTs: string): WaitingPromptInfo | undefined {\n    const key = this.key(channel, threadTs);\n    const info = this.waiting.get(key);\n    if (!info) return undefined;\n    const age = Date.now() - info.timestamp;\n    if (age > this.ttlMs) {\n      this.waiting.delete(key);\n      try {\n        logger.warn(`[prompt-state] expired ${key} (age=${Math.round(age / 1000)}s)`);\n      } catch {}\n      return undefined;\n    }\n    return info;\n  }\n\n  clear(channel: string, threadTs: string): boolean {\n    const key = this.key(channel, threadTs);\n    const had = this.waiting.delete(key);\n    if (had) {\n      try {\n        logger.info(`[prompt-state] cleared ${key}`);\n      } catch {}\n    }\n    return had;\n  }\n\n  /** Merge updates into an existing waiting entry */\n  update(\n    channel: string,\n    threadTs: string,\n    patch: Partial<WaitingPromptInfo>\n  ): WaitingPromptInfo | undefined {\n    const key = this.key(channel, threadTs);\n    const prev = this.waiting.get(key);\n    if (!prev) return undefined;\n    const next = { ...prev, ...patch } as WaitingPromptInfo;\n    this.waiting.set(key, next);\n    try {\n      if (patch.snapshotPath) {\n        logger.info(`[prompt-state] snapshotPath set for ${key}`);\n      }\n    } catch {}\n    return next;\n  }\n\n  // First message capture helpers\n  setFirstMessage(channel: string, threadTs: string, text: string): void {\n    const key = this.key(channel, threadTs);\n    if (!text || !text.trim()) return;\n    const existing = this.firstMessage.get(key);\n    // Only set if: no entry exists OR the existing entry was already consumed\n    // This allows new messages to be captured after a resume cycle\n    if (!existing || existing.consumed) {\n      this.firstMessage.set(key, { text, consumed: false });\n    }\n  }\n  consumeFirstMessage(channel: string, threadTs: string): string | undefined {\n    const key = this.key(channel, threadTs);\n    const entry = this.firstMessage.get(key);\n    if (entry && !entry.consumed) {\n      entry.consumed = true;\n      this.firstMessage.set(key, entry);\n      return entry.text;\n    }\n    return undefined;\n  }\n  hasUnconsumedFirstMessage(channel: string, threadTs: string): boolean {\n    const key = this.key(channel, threadTs);\n    const e = this.firstMessage.get(key);\n    return !!(e && !e.consumed && e.text && e.text.trim());\n  }\n\n  private startCleanup(intervalMs: number = 5 * 60 * 1000) {\n    if (this.timer) clearInterval(this.timer);\n    this.timer = setInterval(() => this.cleanup(), intervalMs);\n    if (this.timer.unref) this.timer.unref();\n  }\n\n  private cleanup(): number {\n    const now = Date.now();\n    let removed = 0;\n    for (const [key, info] of this.waiting.entries()) {\n      if (now - info.timestamp > this.ttlMs) {\n        this.waiting.delete(key);\n        removed++;\n      }\n    }\n    // Also clean up stale firstMessage entries (consumed entries older than TTL)\n    // Keep unconsumed entries to avoid losing user messages\n    for (const [key] of this.firstMessage.entries()) {\n      const waitingInfo = this.waiting.get(key);\n      // If no corresponding waiting entry exists and the firstMessage was consumed,\n      // the conversation is likely complete - safe to remove\n      if (!waitingInfo) {\n        const entry = this.firstMessage.get(key);\n        if (entry?.consumed) {\n          this.firstMessage.delete(key);\n          removed++;\n        }\n      }\n    }\n    if (removed) {\n      try {\n        logger.info(`[prompt-state] cleanup removed ${removed} entries`);\n      } catch {}\n    }\n    return removed;\n  }\n}\n\nlet __promptState: PromptStateManager | undefined;\nexport function getPromptStateManager(ttlMs?: number): PromptStateManager {\n  if (!__promptState) __promptState = new PromptStateManager(ttlMs);\n  return __promptState;\n}\n\nexport function resetPromptStateManager(): void {\n  __promptState = undefined;\n}\n"],"mappings":"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","names":[]}

package/dist/sdk/chunk-NAW3DB3I.mjs

@@ -0,0 +1,197 @@
+import {
+  __esm,
+  __export
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/session-registry.ts
+var session_registry_exports = {};
+__export(session_registry_exports, {
+  SessionRegistry: () => SessionRegistry
+});
+var SessionRegistry;
+var init_session_registry = __esm({
+  "src/session-registry.ts"() {
+    SessionRegistry = class _SessionRegistry {
+      static instance;
+      sessions = /* @__PURE__ */ new Map();
+      exitHandlerRegistered = false;
+      constructor() {
+        this.registerExitHandlers();
+      }
+      /**
+       * Get the singleton instance of SessionRegistry
+       */
+      static getInstance() {
+        if (!_SessionRegistry.instance) {
+          _SessionRegistry.instance = new _SessionRegistry();
+        }
+        return _SessionRegistry.instance;
+      }
+      /**
+       * Register a ProbeAgent session
+       */
+      registerSession(sessionId, agent) {
+        console.error(`\u{1F504} Registering AI session: ${sessionId}`);
+        this.sessions.set(sessionId, agent);
+      }
+      /**
+       * Get an existing ProbeAgent session
+       */
+      getSession(sessionId) {
+        const agent = this.sessions.get(sessionId);
+        if (agent) {
+          console.error(`\u267B\uFE0F  Reusing AI session: ${sessionId}`);
+        }
+        return agent;
+      }
+      /**
+       * Remove a session from the registry
+       */
+      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}`);
+            }
+          }
+        }
+      }
+      /**
+       * Clear all sessions (useful for cleanup)
+       */
+      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();
+      }
+      /**
+       * Get all active session IDs
+       */
+      getActiveSessionIds() {
+        return Array.from(this.sessions.keys());
+      }
+      /**
+       * Check if a session exists
+       */
+      hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+      }
+      /**
+       * Clone a session with a new session ID using ProbeAgent's official clone() method
+       * This uses ProbeAgent's built-in cloning which automatically handles:
+       * - Intelligent filtering of internal messages (schema reminders, tool prompts, etc.)
+       * - Preserving system message for cache efficiency
+       * - Deep copying conversation history
+       * - Copying agent configuration
+       */
+      async cloneSession(sourceSessionId, newSessionId, checkName) {
+        const sourceAgent = this.sessions.get(sourceSessionId);
+        if (!sourceAgent) {
+          console.error(`\u26A0\uFE0F  Cannot clone session: ${sourceSessionId} not found`);
+          return void 0;
+        }
+        try {
+          const clonedAgent = sourceAgent.clone({
+            sessionId: newSessionId,
+            stripInternalMessages: true,
+            // Remove schema reminders, tool prompts, etc.
+            keepSystemMessage: true,
+            // Keep for cache efficiency
+            deepCopy: true
+            // Safe deep copy of history
+          });
+          if (sourceAgent.debug && checkName) {
+            try {
+              const { initializeTracer } = await import("./tracer-init-GSLPPLCD.mjs");
+              const tracerResult = await initializeTracer(newSessionId, checkName);
+              if (tracerResult) {
+                clonedAgent.tracer = tracerResult.tracer;
+                clonedAgent._telemetryConfig = tracerResult.telemetryConfig;
+                clonedAgent._traceFilePath = tracerResult.filePath;
+              }
+            } catch (traceError) {
+              console.error(
+                "\u26A0\uFE0F  Warning: Failed to initialize tracing for cloned session:",
+                traceError
+              );
+            }
+          }
+          if (sourceAgent._mcpInitialized && typeof clonedAgent.initialize === "function") {
+            try {
+              await clonedAgent.initialize();
+              console.error(`\u{1F527} Initialized MCP tools for cloned session`);
+            } catch (initError) {
+              console.error(`\u26A0\uFE0F  Warning: Failed to initialize cloned agent: ${initError}`);
+            }
+          }
+          const historyLength = clonedAgent.history?.length || 0;
+          console.error(
+            `\u{1F4CB} Cloned session ${sourceSessionId} \u2192 ${newSessionId} using ProbeAgent.clone() (${historyLength} messages, internal messages filtered)`
+          );
+          this.registerSession(newSessionId, clonedAgent);
+          return clonedAgent;
+        } catch (error) {
+          console.error(`\u26A0\uFE0F  Failed to clone session ${sourceSessionId}:`, error);
+          return void 0;
+        }
+      }
+      /**
+       * 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;
+      }
+    };
+  }
+});
+
+export {
+  SessionRegistry,
+  session_registry_exports,
+  init_session_registry
+};
+//# sourceMappingURL=chunk-NAW3DB3I.mjs.map

package/dist/sdk/chunk-NAW3DB3I.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/session-registry.ts"],"sourcesContent":["import { ProbeAgent } from '@probelabs/probe';\n\n/**\n * Extended ProbeAgent interface that includes tracing properties\n */\ninterface TracedProbeAgent extends ProbeAgent {\n  tracer?: any; // AppTracer removed from probe\n  _telemetryConfig?: any; // TelemetryConfig removed from probe\n  _traceFilePath?: string;\n}\n\n/**\n * Registry to manage active ProbeAgent sessions for session reuse\n */\nexport class SessionRegistry {\n  private static instance: SessionRegistry;\n  private sessions: Map<string, TracedProbeAgent> = new Map();\n  private exitHandlerRegistered = false;\n\n  private constructor() {\n    // Register process exit handlers to cleanup sessions\n    this.registerExitHandlers();\n  }\n\n  /**\n   * Get the singleton instance of SessionRegistry\n   */\n  public static getInstance(): SessionRegistry {\n    if (!SessionRegistry.instance) {\n      SessionRegistry.instance = new SessionRegistry();\n    }\n    return SessionRegistry.instance;\n  }\n\n  /**\n   * Register a ProbeAgent session\n   */\n  public registerSession(sessionId: string, agent: TracedProbeAgent): void {\n    console.error(`🔄 Registering AI session: ${sessionId}`);\n    this.sessions.set(sessionId, agent);\n  }\n\n  /**\n   * Get an existing ProbeAgent session\n   */\n  public getSession(sessionId: string): TracedProbeAgent | undefined {\n    const agent = this.sessions.get(sessionId);\n    if (agent) {\n      console.error(`♻️  Reusing AI session: ${sessionId}`);\n    }\n    return agent;\n  }\n\n  /**\n   * Remove a session from the registry\n   */\n  public unregisterSession(sessionId: string): void {\n    if (this.sessions.has(sessionId)) {\n      console.error(`🗑️  Unregistering AI session: ${sessionId}`);\n      const agent = this.sessions.get(sessionId);\n      this.sessions.delete(sessionId);\n\n      // Cleanup the ProbeAgent instance to prevent hanging processes\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if (agent && typeof (agent as any).cleanup === 'function') {\n        try {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (agent as any).cleanup();\n        } catch (error) {\n          console.error(`⚠️  Warning: Failed to cleanup ProbeAgent: ${error}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Clear all sessions (useful for cleanup)\n   */\n  public clearAllSessions(): void {\n    console.error(`🧹 Clearing all AI sessions (${this.sessions.size} sessions)`);\n\n    // Cleanup each ProbeAgent instance before clearing\n    for (const [, agent] of this.sessions.entries()) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if (agent && typeof (agent as any).cleanup === 'function') {\n        try {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (agent as any).cleanup();\n        } catch {\n          // Silent fail during bulk cleanup\n        }\n      }\n    }\n\n    this.sessions.clear();\n  }\n\n  /**\n   * Get all active session IDs\n   */\n  public getActiveSessionIds(): string[] {\n    return Array.from(this.sessions.keys());\n  }\n\n  /**\n   * Check if a session exists\n   */\n  public hasSession(sessionId: string): boolean {\n    return this.sessions.has(sessionId);\n  }\n\n  /**\n   * Clone a session with a new session ID using ProbeAgent's official clone() method\n   * This uses ProbeAgent's built-in cloning which automatically handles:\n   * - Intelligent filtering of internal messages (schema reminders, tool prompts, etc.)\n   * - Preserving system message for cache efficiency\n   * - Deep copying conversation history\n   * - Copying agent configuration\n   */\n  public async cloneSession(\n    sourceSessionId: string,\n    newSessionId: string,\n    checkName?: string\n  ): Promise<ProbeAgent | undefined> {\n    const sourceAgent = this.sessions.get(sourceSessionId);\n    if (!sourceAgent) {\n      console.error(`⚠️  Cannot clone session: ${sourceSessionId} not found`);\n      return undefined;\n    }\n\n    try {\n      // Use ProbeAgent's official clone() method with options\n      // This handles intelligent message filtering automatically\n      const clonedAgent = (sourceAgent as any).clone({\n        sessionId: newSessionId,\n        stripInternalMessages: true, // Remove schema reminders, tool prompts, etc.\n        keepSystemMessage: true, // Keep for cache efficiency\n        deepCopy: true, // Safe deep copy of history\n      }) as TracedProbeAgent;\n\n      // Set up tracing for cloned session if debug mode is enabled\n      if ((sourceAgent as any).debug && checkName) {\n        try {\n          const { initializeTracer } = await import('./utils/tracer-init');\n          const tracerResult = await initializeTracer(newSessionId, checkName);\n          if (tracerResult) {\n            clonedAgent.tracer = tracerResult.tracer;\n            // Store telemetry config and trace file path for proper shutdown\n            clonedAgent._telemetryConfig = tracerResult.telemetryConfig;\n            clonedAgent._traceFilePath = tracerResult.filePath;\n          }\n        } catch (traceError) {\n          console.error(\n            '⚠️  Warning: Failed to initialize tracing for cloned session:',\n            traceError\n          );\n        }\n      }\n\n      // Initialize MCP tools if the source agent had them initialized\n      if (\n        (sourceAgent as any)._mcpInitialized &&\n        typeof (clonedAgent as any).initialize === 'function'\n      ) {\n        try {\n          await (clonedAgent as any).initialize();\n          console.error(`🔧 Initialized MCP tools for cloned session`);\n        } catch (initError) {\n          console.error(`⚠️  Warning: Failed to initialize cloned agent: ${initError}`);\n        }\n      }\n\n      // Get history length for logging\n      const historyLength = (clonedAgent as any).history?.length || 0;\n\n      console.error(\n        `📋 Cloned session ${sourceSessionId} → ${newSessionId} using ProbeAgent.clone() (${historyLength} messages, internal messages filtered)`\n      );\n\n      // Register the cloned session\n      this.registerSession(newSessionId, clonedAgent);\n\n      return clonedAgent;\n    } catch (error) {\n      console.error(`⚠️  Failed to clone session ${sourceSessionId}:`, error);\n      return undefined;\n    }\n  }\n\n  /**\n   * Register process exit handlers to cleanup sessions on exit\n   */\n  private registerExitHandlers(): void {\n    if (this.exitHandlerRegistered) {\n      return;\n    }\n\n    const cleanupAndExit = (signal: string) => {\n      if (this.sessions.size > 0) {\n        console.error(`\\n🧹 [${signal}] Cleaning up ${this.sessions.size} active AI sessions...`);\n        this.clearAllSessions();\n      }\n    };\n\n    // Handle normal process exit\n    process.on('exit', () => {\n      if (this.sessions.size > 0) {\n        console.error(`🧹 [exit] Cleaning up ${this.sessions.size} active AI sessions...`);\n        // Note: async operations won't complete here, but sync cleanup methods will\n        for (const [, agent] of this.sessions.entries()) {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          if (agent && typeof (agent as any).cleanup === 'function') {\n            try {\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              (agent as any).cleanup();\n            } catch {\n              // Silent fail on exit\n            }\n          }\n        }\n        this.sessions.clear();\n      }\n    });\n\n    // Handle SIGINT (Ctrl+C)\n    process.on('SIGINT', () => {\n      cleanupAndExit('SIGINT');\n      process.exit(0);\n    });\n\n    // Handle SIGTERM\n    process.on('SIGTERM', () => {\n      cleanupAndExit('SIGTERM');\n      process.exit(0);\n    });\n\n    this.exitHandlerRegistered = true;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/sdk/chunk-O5EZDNYL.mjs

@@ -0,0 +1,274 @@
+import {
+  __esm,
+  __export
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/utils/config-merger.ts
+var config_merger_exports = {};
+__export(config_merger_exports, {
+  ConfigMerger: () => ConfigMerger
+});
+var ConfigMerger;
+var init_config_merger = __esm({
+  "src/utils/config-merger.ts"() {
+    ConfigMerger = class {
+      /**
+       * Merge two configurations with child overriding parent
+       * @param parent - Base configuration
+       * @param child - Configuration to merge on top
+       * @returns Merged configuration
+       */
+      merge(parent, child) {
+        const result = this.deepCopy(parent);
+        if (child.version !== void 0) result.version = child.version;
+        if (child.ai_model !== void 0) result.ai_model = child.ai_model;
+        if (child.ai_provider !== void 0) result.ai_provider = child.ai_provider;
+        if (child.max_parallelism !== void 0) result.max_parallelism = child.max_parallelism;
+        if (child.fail_fast !== void 0) result.fail_fast = child.fail_fast;
+        if (child.fail_if !== void 0) result.fail_if = child.fail_if;
+        if (child.failure_conditions !== void 0)
+          result.failure_conditions = child.failure_conditions;
+        if (child.env) {
+          result.env = this.mergeObjects(parent.env || {}, child.env);
+        }
+        if (child.output) {
+          result.output = this.mergeOutputConfig(parent.output, child.output);
+        }
+        if (child.checks) {
+          result.checks = this.mergeChecks(parent.checks || {}, child.checks);
+        }
+        if (child.steps) {
+          const parentSteps = parent.steps || {};
+          const childSteps = child.steps || {};
+          result.steps = this.mergeChecks(parentSteps, childSteps);
+        }
+        if (child.tools) {
+          result.tools = this.mergeObjects(parent.tools || {}, child.tools);
+        }
+        if (child.imports) {
+          const parentImports = parent.imports || [];
+          const childImports = child.imports || [];
+          result.imports = [.../* @__PURE__ */ new Set([...parentImports, ...childImports])];
+        }
+        return result;
+      }
+      /**
+       * Deep copy an object
+       */
+      deepCopy(obj) {
+        if (obj === null || obj === void 0) {
+          return obj;
+        }
+        if (obj instanceof Date) {
+          return new Date(obj.getTime());
+        }
+        if (obj instanceof Array) {
+          const copy = [];
+          for (const item of obj) {
+            copy.push(this.deepCopy(item));
+          }
+          return copy;
+        }
+        if (obj instanceof Object) {
+          const copy = {};
+          for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+              copy[key] = this.deepCopy(obj[key]);
+            }
+          }
+          return copy;
+        }
+        return obj;
+      }
+      /**
+       * Merge two objects (child overrides parent)
+       */
+      mergeObjects(parent, child) {
+        const result = { ...parent };
+        for (const key in child) {
+          if (Object.prototype.hasOwnProperty.call(child, key)) {
+            const parentValue = parent[key];
+            const childValue = child[key];
+            if (childValue === null || childValue === void 0) {
+              delete result[key];
+            } else if (typeof parentValue === "object" && typeof childValue === "object" && !Array.isArray(parentValue) && !Array.isArray(childValue) && parentValue !== null && childValue !== null) {
+              result[key] = this.mergeObjects(
+                parentValue,
+                childValue
+              );
+            } else {
+              result[key] = this.deepCopy(childValue);
+            }
+          }
+        }
+        return result;
+      }
+      /**
+       * Merge output configurations
+       */
+      mergeOutputConfig(parent, child) {
+        if (!child) return parent;
+        if (!parent) return child;
+        const result = this.deepCopy(parent);
+        if (child.pr_comment) {
+          result.pr_comment = this.mergeObjects(
+            parent.pr_comment || {},
+            child.pr_comment
+          );
+        }
+        if (child.file_comment !== void 0) {
+          if (child.file_comment === null) {
+            delete result.file_comment;
+          } else {
+            result.file_comment = this.mergeObjects(
+              parent.file_comment || {},
+              child.file_comment
+            );
+          }
+        }
+        if (child.github_checks !== void 0) {
+          if (child.github_checks === null) {
+            delete result.github_checks;
+          } else {
+            result.github_checks = this.mergeObjects(
+              parent.github_checks || {},
+              child.github_checks
+            );
+          }
+        }
+        return result;
+      }
+      /**
+       * Merge check configurations with special handling
+       */
+      mergeChecks(parent, child) {
+        const result = {};
+        for (const [checkName, checkConfig] of Object.entries(parent)) {
+          result[checkName] = this.deepCopy(checkConfig);
+        }
+        for (const [checkName, childConfig] of Object.entries(child)) {
+          const parentConfig = parent[checkName];
+          if (!parentConfig) {
+            const copiedConfig = this.deepCopy(childConfig);
+            if (!copiedConfig.type) {
+              copiedConfig.type = "ai";
+            }
+            if (!copiedConfig.on) {
+              copiedConfig.on = ["manual"];
+            }
+            if (copiedConfig.appendPrompt !== void 0) {
+              if (!copiedConfig.prompt) {
+                copiedConfig.prompt = copiedConfig.appendPrompt;
+              } else {
+                copiedConfig.prompt = copiedConfig.prompt + "\n\n" + copiedConfig.appendPrompt;
+              }
+              delete copiedConfig.appendPrompt;
+            }
+            result[checkName] = copiedConfig;
+          } else {
+            result[checkName] = this.mergeCheckConfig(parentConfig, childConfig);
+          }
+        }
+        return result;
+      }
+      /**
+       * Merge individual check configurations
+       */
+      mergeCheckConfig(parent, child) {
+        const result = this.deepCopy(parent);
+        if (child.type !== void 0) result.type = child.type;
+        if (!result.type) {
+          result.type = "ai";
+        }
+        if (child.prompt !== void 0) result.prompt = child.prompt;
+        if (child.appendPrompt !== void 0) {
+          if (result.prompt) {
+            result.prompt = result.prompt + "\n\n" + child.appendPrompt;
+          } else {
+            result.prompt = child.appendPrompt;
+          }
+          delete result.appendPrompt;
+        }
+        if (child.exec !== void 0) result.exec = child.exec;
+        if (child.stdin !== void 0) result.stdin = child.stdin;
+        if (child.url !== void 0) result.url = child.url;
+        if (child.focus !== void 0) result.focus = child.focus;
+        if (child.command !== void 0) result.command = child.command;
+        if (child.ai_model !== void 0) result.ai_model = child.ai_model;
+        if (child.ai_provider !== void 0) result.ai_provider = child.ai_provider;
+        if (child.group !== void 0) result.group = child.group;
+        if (child.schema !== void 0) result.schema = child.schema;
+        if (child.if !== void 0) result.if = child.if;
+        if (child.reuse_ai_session !== void 0) result.reuse_ai_session = child.reuse_ai_session;
+        if (child.fail_if !== void 0) result.fail_if = child.fail_if;
+        if (child.failure_conditions !== void 0)
+          result.failure_conditions = child.failure_conditions;
+        if (child.on !== void 0) {
+          if (Array.isArray(child.on) && child.on.length === 0) {
+            result.on = [];
+          } else {
+            result.on = [...child.on];
+          }
+        }
+        if (!result.on) {
+          result.on = ["manual"];
+        }
+        if (child.triggers !== void 0) {
+          result.triggers = child.triggers ? [...child.triggers] : void 0;
+        }
+        if (child.depends_on !== void 0) {
+          result.depends_on = child.depends_on ? [...child.depends_on] : void 0;
+        }
+        if (child.env) {
+          result.env = this.mergeObjects(
+            parent.env || {},
+            child.env
+          );
+        }
+        if (child.ai) {
+          result.ai = this.mergeObjects(
+            parent.ai || {},
+            child.ai
+          );
+        }
+        if (child.template) {
+          result.template = this.mergeObjects(
+            parent.template || {},
+            child.template
+          );
+        }
+        return result;
+      }
+      /**
+       * Check if a check is disabled (has empty 'on' array)
+       */
+      isCheckDisabled(check) {
+        return Array.isArray(check.on) && check.on.length === 0;
+      }
+      /**
+       * Remove disabled checks from the configuration
+       */
+      removeDisabledChecks(config) {
+        if (!config.checks) return config;
+        const result = this.deepCopy(config);
+        const enabledChecks = {};
+        for (const [checkName, checkConfig] of Object.entries(result.checks)) {
+          if (!this.isCheckDisabled(checkConfig)) {
+            enabledChecks[checkName] = checkConfig;
+          } else {
+            console.log(`\u2139\uFE0F  Check '${checkName}' is disabled (empty 'on' array)`);
+          }
+        }
+        result.checks = enabledChecks;
+        return result;
+      }
+    };
+  }
+});
+
+export {
+  ConfigMerger,
+  config_merger_exports,
+  init_config_merger
+};
+//# sourceMappingURL=chunk-O5EZDNYL.mjs.map