@probelabs/visor 0.1.37 → 0.1.38

package/dist/index.js

@@ -94976,6 +94976,40 @@ class CheckExecutionEngine {
             provider.setWebhookContext(this.webhookContext.webhookData);
         }
     }
+    /**
+     * Filter checks based on tag filter configuration
+     */
+    filterChecksByTags(checks, config, tagFilter) {
+        if (!tagFilter || (!tagFilter.include && !tagFilter.exclude)) {
+            return checks;
+        }
+        const logFn = this.config?.output?.pr_comment ? console.error : console.log;
+        return checks.filter(checkName => {
+            const checkConfig = config?.checks?.[checkName];
+            if (!checkConfig) {
+                // If no config for this check, include it by default
+                return true;
+            }
+            const checkTags = checkConfig.tags || [];
+            // Check exclude tags first (if any exclude tag matches, skip the check)
+            if (tagFilter.exclude && tagFilter.exclude.length > 0) {
+                const hasExcludedTag = tagFilter.exclude.some(tag => checkTags.includes(tag));
+                if (hasExcludedTag) {
+                    logFn(`⏭️ Skipping check '${checkName}' - has excluded tag`);
+                    return false;
+                }
+            }
+            // Check include tags (if specified, at least one must match)
+            if (tagFilter.include && tagFilter.include.length > 0) {
+                const hasIncludedTag = tagFilter.include.some(tag => checkTags.includes(tag));
+                if (!hasIncludedTag) {
+                    logFn(`⏭️ Skipping check '${checkName}' - does not have required tags`);
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
     /**
      * Execute checks on the local repository
      */
@@ -95005,13 +95039,23 @@ class CheckExecutionEngine {
             }
             // Convert to PRInfo format for compatibility with existing reviewer
             const prInfo = this.gitAnalyzer.toPRInfo(repositoryInfo);
+            // Apply tag filtering if specified
+            const filteredChecks = this.filterChecksByTags(options.checks, options.config, options.tagFilter || options.config?.tag_filter);
+            if (filteredChecks.length === 0) {
+                logFn('⚠️ No checks match the tag filter criteria');
+                // Complete GitHub checks with no checks message if they were initialized
+                if (this.checkRunMap) {
+                    await this.completeGitHubChecksWithError('No checks match the tag filter criteria');
+                }
+                return this.createErrorResult(repositoryInfo, 'No checks match the tag filter criteria', startTime, timestamp, options.checks);
+            }
             // Update GitHub checks to in-progress status
             if (this.checkRunMap) {
                 await this.updateGitHubChecksInProgress(options);
             }
             // Execute checks using the existing PRReviewer
-            logFn(`🤖 Executing checks: ${options.checks.join(', ')}`);
-            const reviewSummary = await this.executeReviewChecks(prInfo, options.checks, options.timeout, options.config, options.outputFormat, options.debug, options.maxParallelism, options.failFast);
+            logFn(`🤖 Executing checks: ${filteredChecks.join(', ')}`);
+            const reviewSummary = await this.executeReviewChecks(prInfo, filteredChecks, options.timeout, options.config, options.outputFormat, options.debug, options.maxParallelism, options.failFast);
             // Complete GitHub checks with results
             if (this.checkRunMap) {
                 await this.completeGitHubChecksWithResults(reviewSummary, options);
@@ -95035,7 +95079,7 @@ class CheckExecutionEngine {
                 reviewSummary,
                 executionTime,
                 timestamp,
-                checksExecuted: options.checks,
+                checksExecuted: filteredChecks,
                 debug: debugInfo,
             };
         }
@@ -95237,7 +95281,7 @@ class CheckExecutionEngine {
     /**
      * Execute review checks and return grouped results for new architecture
      */
-    async executeGroupedChecks(prInfo, checks, timeout, config, outputFormat, debug, maxParallelism, failFast) {
+    async executeGroupedChecks(prInfo, checks, timeout, config, outputFormat, debug, maxParallelism, failFast, tagFilter) {
         // Determine where to send log messages based on output format
         const logFn = outputFormat === 'json' || outputFormat === 'sarif' ? console.error : console.log;
         // Only output debug messages if debug mode is enabled
@@ -95250,8 +95294,18 @@ class CheckExecutionEngine {
         if (filteredChecks.length !== checks.length && debug) {
             logFn(`🔧 Debug: Event filtering reduced checks from ${checks.length} to ${filteredChecks.length}: ${JSON.stringify(filteredChecks)}`);
         }
+        // Apply tag filtering if specified
+        const tagFilteredChecks = this.filterChecksByTags(filteredChecks, config, tagFilter || config?.tag_filter);
+        if (tagFilteredChecks.length !== filteredChecks.length && debug) {
+            logFn(`🔧 Debug: Tag filtering reduced checks from ${filteredChecks.length} to ${tagFilteredChecks.length}: ${JSON.stringify(tagFilteredChecks)}`);
+        }
         // Use filtered checks for execution
-        checks = filteredChecks;
+        checks = tagFilteredChecks;
+        // Check if we have any checks left after filtering
+        if (checks.length === 0) {
+            logFn('⚠️ No checks remain after tag filtering');
+            return {};
+        }
         if (!config?.checks) {
             throw new Error('Config with check definitions required for grouped execution');
         }
@@ -96799,17 +96853,35 @@ async function main() {
         logFn(`🤖 Executing checks: ${checksToRun.join(', ')}`);
         // Create CheckExecutionEngine for running checks
         const engine = new check_execution_engine_1.CheckExecutionEngine();
+        // Build tag filter from CLI options
+        const tagFilter = options.tags || options.excludeTags
+            ? {
+                include: options.tags,
+                exclude: options.excludeTags,
+            }
+            : undefined;
         // Execute checks with proper parameters (cast to PRInfo)
-        const groupedResults = await engine.executeGroupedChecks(repositoryInfo, checksToRun, options.timeout, config, options.output, options.debug || false);
+        const groupedResults = await engine.executeGroupedChecks(repositoryInfo, checksToRun, options.timeout, config, options.output, options.debug || false, options.maxParallelism, options.failFast, tagFilter);
         // Format output based on format type
         let output;
         if (options.output === 'json') {
             output = JSON.stringify(groupedResults, null, 2);
         }
         else if (options.output === 'sarif') {
-            // For SARIF output, we need to convert to SARIF format
-            // For now, output as JSON until proper SARIF formatting is implemented
-            output = JSON.stringify(groupedResults, null, 2);
+            // Build analysis result and format as SARIF
+            const analysisResult = {
+                repositoryInfo,
+                reviewSummary: {
+                    issues: Object.values(groupedResults)
+                        .flatMap((r) => r.map((check) => check.issues || []).flat())
+                        .flat(),
+                    suggestions: [],
+                },
+                executionTime: 0,
+                timestamp: new Date().toISOString(),
+                checksExecuted: checksToRun,
+            };
+            output = output_formatters_1.OutputFormatters.formatAsSarif(analysisResult);
         }
         else if (options.output === 'markdown') {
             // Create analysis result for markdown formatting
@@ -96958,6 +97030,8 @@ class CLI {
             .option('--max-parallelism <count>', 'Maximum number of checks to run in parallel (default: 3)', value => parseInt(value, 10))
             .option('--debug', 'Enable debug mode for detailed output')
             .option('--fail-fast', 'Stop execution on first failure condition')
+            .option('--tags <tags>', 'Include checks with these tags (comma-separated)')
+            .option('--exclude-tags <tags>', 'Exclude checks with these tags (comma-separated)')
             .option('--no-remote-extends', 'Disable loading configurations from remote URLs')
             .addHelpText('after', this.getExamplesText())
             .exitOverride(); // Prevent automatic process.exit for better error handling
@@ -96993,6 +97067,8 @@ class CLI {
                 .option('--max-parallelism <count>', 'Maximum number of checks to run in parallel (default: 3)', value => parseInt(value, 10))
                 .option('--debug', 'Enable debug mode for detailed output')
                 .option('--fail-fast', 'Stop execution on first failure condition')
+                .option('--tags <tags>', 'Include checks with these tags (comma-separated)')
+                .option('--exclude-tags <tags>', 'Exclude checks with these tags (comma-separated)')
                 .option('--allowed-remote-patterns <patterns>', 'Comma-separated list of allowed URL prefixes for remote config extends (e.g., "https://github.com/,https://raw.githubusercontent.com/")')
                 .allowUnknownOption(false)
                 .allowExcessArguments(false) // Don't allow positional arguments
@@ -97015,6 +97091,15 @@ class CLI {
                     .split(',')
                     .map((p) => p.trim());
             }
+            // Parse tag filters
+            let tags;
+            if (options.tags) {
+                tags = options.tags.split(',').map((t) => t.trim());
+            }
+            let excludeTags;
+            if (options.excludeTags) {
+                excludeTags = options.excludeTags.split(',').map((t) => t.trim());
+            }
             return {
                 checks: uniqueChecks,
                 output: options.output,
@@ -97023,6 +97108,8 @@ class CLI {
                 maxParallelism: options.maxParallelism,
                 debug: options.debug,
                 failFast: options.failFast,
+                tags,
+                excludeTags,
                 allowedRemotePatterns,
                 help: options.help,
                 version: options.version,
@@ -97129,7 +97216,10 @@ Examples:
   visor --check all --timeout 300000 --output json           # 5 minute timeout
   visor --check all --max-parallelism 5 --output json        # Run up to 5 checks in parallel
   visor --check all --debug --output markdown                # Enable debug mode
-  visor --check all --fail-fast --output json                # Stop on first failure`;
+  visor --check all --fail-fast --output json                # Stop on first failure
+  visor --tags local,fast --output table                      # Run checks tagged as 'local' or 'fast'
+  visor --exclude-tags slow,experimental --output json        # Skip checks tagged as 'slow' or 'experimental'
+  visor --tags security --exclude-tags slow                   # Run security checks but skip slow ones`;
     }
     /**
      * Display help
@@ -97270,6 +97360,7 @@ class ConfigManager {
         'http_input',
         'http_client',
         'noop',
+        'log',
     ];
     validEventTriggers = [
         'pr_opened',
@@ -97580,6 +97671,10 @@ class ConfigManager {
                 });
             }
         }
+        // Validate tag_filter if present
+        if (config.tag_filter) {
+            this.validateTagFilter(config.tag_filter, errors);
+        }
         if (errors.length > 0) {
             throw new Error(errors[0].message);
         }
@@ -97694,6 +97789,98 @@ class ConfigManager {
                 }
             }
         }
+        // Validate tags configuration
+        if (checkConfig.tags !== undefined) {
+            if (!Array.isArray(checkConfig.tags)) {
+                errors.push({
+                    field: `checks.${checkName}.tags`,
+                    message: `Invalid tags value for "${checkName}": must be an array of strings`,
+                    value: checkConfig.tags,
+                });
+            }
+            else {
+                // Validate each tag
+                const validTagPattern = /^[a-zA-Z0-9][a-zA-Z0-9-_]*$/;
+                checkConfig.tags.forEach((tag, index) => {
+                    if (typeof tag !== 'string') {
+                        errors.push({
+                            field: `checks.${checkName}.tags[${index}]`,
+                            message: `Invalid tag at index ${index} for "${checkName}": must be a string`,
+                            value: tag,
+                        });
+                    }
+                    else if (!validTagPattern.test(tag)) {
+                        errors.push({
+                            field: `checks.${checkName}.tags[${index}]`,
+                            message: `Invalid tag "${tag}" for "${checkName}": tags must be alphanumeric with hyphens or underscores (start with alphanumeric)`,
+                            value: tag,
+                        });
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * Validate tag filter configuration
+     */
+    validateTagFilter(tagFilter, errors) {
+        const validTagPattern = /^[a-zA-Z0-9][a-zA-Z0-9-_]*$/;
+        // Validate include tags
+        if (tagFilter.include !== undefined) {
+            if (!Array.isArray(tagFilter.include)) {
+                errors.push({
+                    field: 'tag_filter.include',
+                    message: 'tag_filter.include must be an array of strings',
+                    value: tagFilter.include,
+                });
+            }
+            else {
+                tagFilter.include.forEach((tag, index) => {
+                    if (typeof tag !== 'string') {
+                        errors.push({
+                            field: `tag_filter.include[${index}]`,
+                            message: `Invalid tag at index ${index}: must be a string`,
+                            value: tag,
+                        });
+                    }
+                    else if (!validTagPattern.test(tag)) {
+                        errors.push({
+                            field: `tag_filter.include[${index}]`,
+                            message: `Invalid tag "${tag}": tags must be alphanumeric with hyphens or underscores`,
+                            value: tag,
+                        });
+                    }
+                });
+            }
+        }
+        // Validate exclude tags
+        if (tagFilter.exclude !== undefined) {
+            if (!Array.isArray(tagFilter.exclude)) {
+                errors.push({
+                    field: 'tag_filter.exclude',
+                    message: 'tag_filter.exclude must be an array of strings',
+                    value: tagFilter.exclude,
+                });
+            }
+            else {
+                tagFilter.exclude.forEach((tag, index) => {
+                    if (typeof tag !== 'string') {
+                        errors.push({
+                            field: `tag_filter.exclude[${index}]`,
+                            message: `Invalid tag at index ${index}: must be a string`,
+                            value: tag,
+                        });
+                    }
+                    else if (!validTagPattern.test(tag)) {
+                        errors.push({
+                            field: `tag_filter.exclude[${index}]`,
+                            message: `Invalid tag "${tag}": tags must be alphanumeric with hyphens or underscores`,
+                            value: tag,
+                        });
+                    }
+                });
+            }
+        }
     }
     /**
      * Validate HTTP server configuration
@@ -99612,6 +99799,9 @@ async function run() {
             'max-parallelism': (0, core_1.getInput)('max-parallelism') || undefined,
             'ai-provider': (0, core_1.getInput)('ai-provider') || undefined,
             'ai-model': (0, core_1.getInput)('ai-model') || undefined,
+            // Tag filtering inputs
+            tags: (0, core_1.getInput)('tags') || undefined,
+            'exclude-tags': (0, core_1.getInput)('exclude-tags') || undefined,
             // Legacy inputs for backward compatibility
             'visor-config-path': (0, core_1.getInput)('visor-config-path') || undefined,
             'visor-checks': (0, core_1.getInput)('visor-checks') || undefined,
@@ -101683,6 +101873,7 @@ const issue_filter_1 = __nccwpck_require__(36879);
 const liquidjs_1 = __nccwpck_require__(48694);
 const promises_1 = __importDefault(__nccwpck_require__(91943));
 const path_1 = __importDefault(__nccwpck_require__(16928));
+const claude_code_types_1 = __nccwpck_require__(21710);
 /**
  * AI-powered check provider using probe agent
  */
@@ -101724,6 +101915,39 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
                 !['google', 'anthropic', 'openai', 'mock'].includes(cfg.ai.provider)) {
                 return false;
             }
+            // Validate mcpServers if present
+            if (cfg.ai.mcpServers) {
+                if (!this.validateMcpServers(cfg.ai.mcpServers)) {
+                    return false;
+                }
+            }
+        }
+        // Validate check-level MCP servers if present
+        if (cfg.ai_mcp_servers) {
+            if (!this.validateMcpServers(cfg.ai_mcp_servers)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate MCP servers configuration
+     */
+    validateMcpServers(mcpServers) {
+        if (typeof mcpServers !== 'object' || mcpServers === null) {
+            return false;
+        }
+        for (const serverConfig of Object.values(mcpServers)) {
+            if (!serverConfig || typeof serverConfig !== 'object') {
+                return false;
+            }
+            const config = serverConfig;
+            if (!config.command || typeof config.command !== 'string') {
+                return false;
+            }
+            if (config.args && !Array.isArray(config.args)) {
+                return false;
+            }
         }
         return true;
     }
@@ -101990,6 +102214,53 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
             throw new Error(`Failed to render prompt template: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    /**
+     * Setup MCP tools based on AI configuration
+     */
+    async setupMcpTools(aiConfig) {
+        const tools = [];
+        // Setup custom MCP servers if configured
+        if (aiConfig.mcpServers) {
+            try {
+                // Import MCP SDK for custom server creation using safe import
+                const mcpModule = await (0, claude_code_types_1.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 (createSdkMcpServer) {
+                    for (const [serverName, serverConfig] of Object.entries(aiConfig.mcpServers)) {
+                        try {
+                            // Create MCP server instance
+                            const server = await createSdkMcpServer({
+                                name: serverName,
+                                command: serverConfig.command,
+                                args: serverConfig.args || [],
+                                env: { ...process.env, ...serverConfig.env },
+                            });
+                            // Add server tools to available tools
+                            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) {
         // Apply environment configuration if present
         if (config.env) {
@@ -102038,6 +102309,32 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
         if (!customPrompt) {
             throw new Error(`No prompt defined for check. All checks must have prompts defined in .visor.yaml configuration.`);
         }
+        // Setup MCP tools from multiple configuration levels
+        const mcpServers = {};
+        // 1. Start with global MCP servers (from visor config root)
+        const globalConfig = config; // Cast to access potential global config
+        if (globalConfig.ai_mcp_servers) {
+            Object.assign(mcpServers, globalConfig.ai_mcp_servers);
+        }
+        // 2. Add check-level MCP servers (overrides global)
+        if (config.ai_mcp_servers) {
+            Object.assign(mcpServers, config.ai_mcp_servers);
+        }
+        // 3. Add ai.mcpServers (overrides everything)
+        if (config.ai?.mcpServers) {
+            Object.assign(mcpServers, config.ai.mcpServers);
+        }
+        // Setup MCP tools if any servers are configured
+        if (Object.keys(mcpServers).length > 0) {
+            const mcpConfig = { mcpServers };
+            const mcpTools = await this.setupMcpTools(mcpConfig);
+            if (mcpTools.length > 0) {
+                aiConfig.tools = mcpTools;
+                if (aiConfig.debug) {
+                    console.error(`🔧 Debug: AI check configured with ${mcpTools.length} MCP tools from ${Object.keys(mcpServers).length} servers`);
+                }
+            }
+        }
         // Process prompt with Liquid templates and file loading
         const processedPrompt = await this.processPrompt(customPrompt, prInfo, config.eventContext, _dependencyResults);
         // Create AI service with config - environment variables will be used if aiConfig is empty
@@ -102106,8 +102403,10 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
             'ai.model',
             'ai.apiKey',
             'ai.timeout',
+            'ai.mcpServers',
             'ai_model',
             'ai_provider',
+            'ai_mcp_servers',
             'env',
         ];
     }
@@ -102143,6 +102442,7 @@ const http_check_provider_1 = __nccwpck_require__(31115);
 const http_input_provider_1 = __nccwpck_require__(74423);
 const http_client_provider_1 = __nccwpck_require__(36270);
 const noop_check_provider_1 = __nccwpck_require__(53003);
+const log_check_provider_1 = __nccwpck_require__(24903);
 const claude_code_check_provider_1 = __nccwpck_require__(17985);
 /**
  * Registry for managing check providers
@@ -102174,6 +102474,7 @@ class CheckProviderRegistry {
         this.register(new http_input_provider_1.HttpInputProvider());
         this.register(new http_client_provider_1.HttpClientProvider());
         this.register(new noop_check_provider_1.NoopCheckProvider());
+        this.register(new log_check_provider_1.LogCheckProvider());
         // Try to register ClaudeCodeCheckProvider - it may fail if dependencies are missing
         try {
             this.register(new claude_code_check_provider_1.ClaudeCodeCheckProvider());
@@ -103555,6 +103856,205 @@ class HttpInputProvider extends check_provider_interface_1.CheckProvider {
 exports.HttpInputProvider = HttpInputProvider;
 
 
+/***/ }),
+
+/***/ 24903:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.LogCheckProvider = void 0;
+const check_provider_interface_1 = __nccwpck_require__(14131);
+const liquidjs_1 = __nccwpck_require__(48694);
+/**
+ * Check provider that outputs debugging and logging information.
+ * Useful for troubleshooting check workflows and understanding execution flow.
+ */
+class LogCheckProvider extends check_provider_interface_1.CheckProvider {
+    liquid;
+    constructor() {
+        super();
+        this.liquid = new liquidjs_1.Liquid({
+            strictVariables: false,
+            strictFilters: false,
+        });
+    }
+    getName() {
+        return 'log';
+    }
+    getDescription() {
+        return 'Output debugging and logging information for troubleshooting check workflows';
+    }
+    async validateConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return false;
+        }
+        const cfg = config;
+        // Type must be 'log'
+        if (cfg.type !== 'log') {
+            return false;
+        }
+        // Message is required
+        if (!cfg.message || typeof cfg.message !== 'string') {
+            return false;
+        }
+        // Validate log level if provided
+        if (cfg.level && !['debug', 'info', 'warn', 'error'].includes(cfg.level)) {
+            return false;
+        }
+        return true;
+    }
+    async execute(prInfo, config, dependencyResults, _sessionInfo) {
+        const message = config.message;
+        const level = config.level || 'info';
+        const includePrContext = config.include_pr_context !== false;
+        const includeDependencies = config.include_dependencies !== false;
+        const includeMetadata = config.include_metadata !== false;
+        // Prepare template context
+        const templateContext = this.buildTemplateContext(prInfo, dependencyResults, includePrContext, includeDependencies, includeMetadata);
+        // Render the log message template
+        const renderedMessage = await this.liquid.parseAndRender(message, templateContext);
+        // Build the log output
+        const logOutput = this.formatLogOutput(level, renderedMessage, templateContext, includePrContext, includeDependencies, includeMetadata);
+        return {
+            issues: [], // Log provider doesn't generate issues
+            suggestions: [logOutput], // Put formatted log output as the primary suggestion
+        };
+    }
+    buildTemplateContext(prInfo, dependencyResults, includePrContext = true, includeDependencies = true, includeMetadata = true) {
+        const context = {};
+        if (includePrContext) {
+            context.pr = {
+                number: prInfo.number,
+                title: prInfo.title,
+                body: prInfo.body,
+                author: prInfo.author,
+                base: prInfo.base,
+                head: prInfo.head,
+                totalAdditions: prInfo.totalAdditions,
+                totalDeletions: prInfo.totalDeletions,
+                files: prInfo.files.map(f => ({
+                    filename: f.filename,
+                    status: f.status,
+                    additions: f.additions,
+                    deletions: f.deletions,
+                    changes: f.changes,
+                })),
+            };
+            // Add convenience data
+            context.filenames = prInfo.files.map(f => f.filename);
+            context.fileCount = prInfo.files.length;
+        }
+        if (includeDependencies && dependencyResults) {
+            const dependencies = {};
+            context.dependencyCount = dependencyResults.size;
+            for (const [checkName, result] of dependencyResults.entries()) {
+                dependencies[checkName] = {
+                    issueCount: result.issues?.length || 0,
+                    suggestionCount: result.suggestions?.length || 0,
+                    issues: result.issues || [],
+                    suggestions: result.suggestions || [],
+                };
+            }
+            context.dependencies = dependencies;
+        }
+        if (includeMetadata) {
+            context.metadata = {
+                timestamp: new Date().toISOString(),
+                executionTime: Date.now(),
+                nodeVersion: process.version,
+                platform: process.platform,
+                workingDirectory: process.cwd(),
+            };
+        }
+        return context;
+    }
+    formatLogOutput(level, message, templateContext, includePrContext, includeDependencies, includeMetadata) {
+        const sections = [];
+        // Log level and message
+        const levelEmoji = this.getLevelEmoji(level);
+        sections.push(`${levelEmoji} **${level.toUpperCase()}**: ${message}`);
+        // PR context section
+        if (includePrContext && templateContext.pr) {
+            const pr = templateContext.pr;
+            sections.push('');
+            sections.push('### PR Context');
+            sections.push(`- **PR #${pr.number}**: ${pr.title}`);
+            sections.push(`- **Author**: ${pr.author}`);
+            sections.push(`- **Base**: ${pr.base} → **Head**: ${pr.head}`);
+            sections.push(`- **Changes**: +${pr.totalAdditions} -${pr.totalDeletions}`);
+            sections.push(`- **Files Modified**: ${templateContext.fileCount}`);
+        }
+        // Dependencies section
+        if (includeDependencies && templateContext.dependencies) {
+            const deps = templateContext.dependencies;
+            sections.push('');
+            sections.push('### Dependency Results');
+            if (Object.keys(deps).length === 0) {
+                sections.push('- No dependency results available');
+            }
+            else {
+                for (const [checkName, result] of Object.entries(deps)) {
+                    sections.push(`- **${checkName}**: ${result.issueCount} issues, ${result.suggestionCount} suggestions`);
+                }
+            }
+        }
+        // Metadata section
+        if (includeMetadata && templateContext.metadata) {
+            const meta = templateContext.metadata;
+            sections.push('');
+            sections.push('### Execution Metadata');
+            sections.push(`- **Timestamp**: ${meta.timestamp}`);
+            sections.push(`- **Node Version**: ${meta.nodeVersion}`);
+            sections.push(`- **Platform**: ${meta.platform}`);
+            sections.push(`- **Working Directory**: ${meta.workingDirectory}`);
+        }
+        return sections.join('\n');
+    }
+    getLevelEmoji(level) {
+        switch (level) {
+            case 'debug':
+                return '🐛';
+            case 'info':
+                return 'ℹ️';
+            case 'warn':
+                return '⚠️';
+            case 'error':
+                return '❌';
+            default:
+                return 'ℹ️';
+        }
+    }
+    getSupportedConfigKeys() {
+        return [
+            'type',
+            'message',
+            'level',
+            'include_pr_context',
+            'include_dependencies',
+            'include_metadata',
+            'group',
+            'command',
+            'depends_on',
+            'on',
+            'if',
+        ];
+    }
+    async isAvailable() {
+        // Log provider is always available
+        return true;
+    }
+    getRequirements() {
+        return [
+            'No external dependencies required',
+            'Used for debugging and logging check execution flow',
+        ];
+    }
+}
+exports.LogCheckProvider = LogCheckProvider;
+
+
 /***/ }),
 
 /***/ 53003: