loki-mode 5.51.0 → 5.52.1

package/src/plugins/gate-plugin.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const { execFile } = require('child_process');
+const { join } = require('path');
+
+// In-memory registry for custom gate plugins
+const _registeredGates = new Map();
+
+class GatePlugin {
+    /**
+     * Register a custom quality gate plugin.
+     *
+     * @param {object} pluginConfig - Validated quality gate plugin config
+     * @returns {{ success: boolean, error?: string }}
+     */
+    static register(pluginConfig) {
+        if (!pluginConfig || pluginConfig.type !== 'quality_gate') {
+            return { success: false, error: 'Invalid plugin config: type must be "quality_gate"' };
+        }
+
+        const name = pluginConfig.name;
+
+        if (_registeredGates.has(name)) {
+            return { success: false, error: `Gate plugin "${name}" is already registered` };
+        }
+
+        const gateDef = {
+            name: name,
+            description: pluginConfig.description,
+            phase: pluginConfig.phase || 'pre-commit',
+            command: pluginConfig.command,
+            timeout_ms: pluginConfig.timeout_ms || 30000,
+            blocking: pluginConfig.blocking !== undefined ? pluginConfig.blocking : true,
+            severity: pluginConfig.severity || 'high',
+            registered_at: new Date().toISOString(),
+        };
+
+        _registeredGates.set(name, gateDef);
+        return { success: true };
+    }
+
+    /**
+     * Unregister a custom quality gate plugin.
+     *
+     * @param {string} pluginName - Name of the gate plugin to remove
+     * @returns {{ success: boolean, error?: string }}
+     */
+    static unregister(pluginName) {
+        if (!_registeredGates.has(pluginName)) {
+            return { success: false, error: `Gate plugin "${pluginName}" is not registered` };
+        }
+
+        _registeredGates.delete(pluginName);
+        return { success: true };
+    }
+
+    /**
+     * Execute a quality gate command.
+     *
+     * @param {object} pluginConfig - The gate plugin config
+     * @param {string} projectDir - Project directory to run the command in
+     * @returns {Promise<{ passed: boolean, output: string, duration_ms: number }>}
+     */
+    static async execute(pluginConfig, projectDir) {
+        const command = pluginConfig.command;
+        const timeoutMs = pluginConfig.timeout_ms || 30000;
+        const startTime = Date.now();
+
+        if (!command) {
+            return {
+                passed: false,
+                output: 'Error: no command specified for quality gate',
+                duration_ms: 0,
+            };
+        }
+
+        return new Promise((resolve) => {
+            const cwd = projectDir || process.cwd();
+
+            // Split command into executable and args
+            // Use shell execution for simple commands
+            const child = execFile('/bin/sh', ['-c', command], {
+                cwd,
+                timeout: timeoutMs,
+                maxBuffer: 1024 * 1024, // 1MB
+                env: { ...process.env, LOKI_GATE: pluginConfig.name || 'unknown' },
+            }, (error, stdout, stderr) => {
+                const durationMs = Date.now() - startTime;
+                const output = (stdout || '') + (stderr ? '\n' + stderr : '');
+
+                if (error) {
+                    if (error.killed || error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+                        resolve({
+                            passed: false,
+                            output: `Timeout: command exceeded ${timeoutMs}ms limit`,
+                            duration_ms: durationMs,
+                        });
+                    } else {
+                        resolve({
+                            passed: false,
+                            output: output.trim() || error.message || 'Command failed',
+                            duration_ms: durationMs,
+                        });
+                    }
+                } else {
+                    resolve({
+                        passed: true,
+                        output: output.trim(),
+                        duration_ms: durationMs,
+                    });
+                }
+            });
+        });
+    }
+
+    /**
+     * Get all gates registered for a specific phase.
+     *
+     * @param {string} phase - SDLC phase
+     * @returns {object[]} Array of gate definitions
+     */
+    static getByPhase(phase) {
+        return Array.from(_registeredGates.values()).filter(g => g.phase === phase);
+    }
+
+    /**
+     * List all registered gate plugins.
+     *
+     * @returns {object[]} Array of gate definitions
+     */
+    static listRegistered() {
+        return Array.from(_registeredGates.values());
+    }
+
+    /**
+     * Check if a gate is registered.
+     *
+     * @param {string} name - Gate name
+     * @returns {boolean}
+     */
+    static isRegistered(name) {
+        return _registeredGates.has(name);
+    }
+
+    /**
+     * Clear all registered gates (primarily for testing).
+     */
+    static _clearAll() {
+        _registeredGates.clear();
+    }
+}
+
+module.exports = { GatePlugin };

package/src/plugins/index.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const { PluginValidator, BUILTIN_AGENT_NAMES, VALID_PLUGIN_TYPES } = require('./validator');
+const { PluginLoader, parseSimpleYAML } = require('./loader');
+const { AgentPlugin } = require('./agent-plugin');
+const { GatePlugin } = require('./gate-plugin');
+const { IntegrationPlugin } = require('./integration-plugin');
+const { MCPPlugin } = require('./mcp-plugin');
+
+// Plugin type to handler mapping
+const PLUGIN_HANDLERS = {
+    agent: AgentPlugin,
+    quality_gate: GatePlugin,
+    integration: IntegrationPlugin,
+    mcp_tool: MCPPlugin,
+};
+
+/**
+ * Initialize the plugin system: discover, load, validate, and register all plugins.
+ *
+ * @param {string} [pluginsDir='.loki/plugins'] - Path to plugins directory
+ * @param {string} [schemasDir] - Path to schemas directory (defaults to built-in schemas)
+ * @param {object} [options] - Additional options
+ * @param {object} [options.agentRegistry] - External agent registry to register agents into
+ * @param {boolean} [options.watch=false] - Watch for file changes
+ * @returns {{ loaded: number, failed: number, details: { loaded: object[], failed: object[] } }}
+ */
+function initializePlugins(pluginsDir, schemasDir, options) {
+    const opts = options || {};
+    const loader = new PluginLoader(pluginsDir, schemasDir);
+    const { loaded, failed } = loader.loadAll();
+
+    const registered = [];
+    const registrationErrors = [];
+
+    for (const plugin of loaded) {
+        const handler = PLUGIN_HANDLERS[plugin.config.type];
+        if (!handler) {
+            registrationErrors.push({
+                path: plugin.path,
+                errors: [`No handler for plugin type: ${plugin.config.type}`],
+            });
+            continue;
+        }
+
+        let result;
+        if (plugin.config.type === 'agent') {
+            result = handler.register(plugin.config, opts.agentRegistry);
+        } else {
+            result = handler.register(plugin.config);
+        }
+
+        if (result.success) {
+            registered.push(plugin);
+        } else {
+            registrationErrors.push({
+                path: plugin.path,
+                errors: [result.error],
+            });
+        }
+    }
+
+    // Set up file watching if requested
+    let stopWatching = null;
+    if (opts.watch) {
+        stopWatching = loader.watchForChanges((eventType, filePath) => {
+            const fs = require('fs');
+            const path = require('path');
+
+            // Handle file deletion
+            if (!fs.existsSync(filePath)) {
+                const name = path.basename(filePath, path.extname(filePath));
+                for (const handler of Object.values(PLUGIN_HANDLERS)) {
+                    if (handler.unregister) handler.unregister(name);
+                }
+                return;
+            }
+
+            const { config, errors } = loader.loadOne(filePath);
+            if (config) {
+                const handler = PLUGIN_HANDLERS[config.type];
+                if (handler) {
+                    // Only unregister AFTER successful load and validation
+                    if (handler.unregister) handler.unregister(config.name);
+                    handler.register(config, opts.agentRegistry);
+                }
+            }
+            // If loadOne fails, keep old plugin registered (fail-safe)
+        });
+    }
+
+    const allFailed = [...failed, ...registrationErrors];
+
+    return {
+        loaded: registered.length,
+        failed: allFailed.length,
+        details: {
+            loaded: registered,
+            failed: allFailed,
+        },
+        stopWatching: stopWatching || (() => {}),
+    };
+}
+
+module.exports = {
+    PluginValidator,
+    PluginLoader,
+    AgentPlugin,
+    GatePlugin,
+    IntegrationPlugin,
+    MCPPlugin,
+    initializePlugins,
+    parseSimpleYAML,
+    BUILTIN_AGENT_NAMES,
+    VALID_PLUGIN_TYPES,
+};

package/src/plugins/integration-plugin.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const { request } = require('https');
+const { request: httpRequest } = require('http');
+
+// In-memory registry for custom integration plugins
+const _registeredIntegrations = new Map();
+
+class IntegrationPlugin {
+    /**
+     * Register a custom integration plugin.
+     *
+     * @param {object} pluginConfig - Validated integration plugin config
+     * @returns {{ success: boolean, error?: string }}
+     */
+    static register(pluginConfig) {
+        if (!pluginConfig || pluginConfig.type !== 'integration') {
+            return { success: false, error: 'Invalid plugin config: type must be "integration"' };
+        }
+
+        const name = pluginConfig.name;
+
+        if (_registeredIntegrations.has(name)) {
+            return { success: false, error: `Integration plugin "${name}" is already registered` };
+        }
+
+        const intDef = {
+            name: name,
+            description: pluginConfig.description,
+            webhook_url: pluginConfig.webhook_url,
+            events: pluginConfig.events || [],
+            payload_template: pluginConfig.payload_template || '{"event": "{{event.type}}", "message": "{{event.message}}"}',
+            headers: pluginConfig.headers || {},
+            timeout_ms: pluginConfig.timeout_ms || 5000,
+            retry_count: pluginConfig.retry_count || 1,
+            registered_at: new Date().toISOString(),
+        };
+
+        _registeredIntegrations.set(name, intDef);
+        return { success: true };
+    }
+
+    /**
+     * Unregister a custom integration plugin.
+     *
+     * @param {string} pluginName - Name of the integration to remove
+     * @returns {{ success: boolean, error?: string }}
+     */
+    static unregister(pluginName) {
+        if (!_registeredIntegrations.has(pluginName)) {
+            return { success: false, error: `Integration plugin "${pluginName}" is not registered` };
+        }
+
+        _registeredIntegrations.delete(pluginName);
+        return { success: true };
+    }
+
+    /**
+     * Render a template string with event data.
+     * Replaces {{event.field}} patterns with actual event values.
+     *
+     * @param {string} template - Template string
+     * @param {object} event - Event data
+     * @returns {string} Rendered string
+     */
+    static renderTemplate(template, event) {
+        if (!template || typeof template !== 'string') return template || '';
+
+        return template.replace(/\{\{event\.(\w+(?:\.\w+)*)\}\}/g, (match, path) => {
+            const parts = path.split('.');
+            let value = event;
+            for (const part of parts) {
+                if (value === null || value === undefined) return '';
+                value = value[part];
+            }
+            if (value === undefined || value === null) return '';
+            if (typeof value === 'object') return JSON.stringify(value);
+            // JSON-safe escape: handles quotes, backslashes, control chars
+            return JSON.stringify(String(value)).slice(1, -1);
+        });
+    }
+
+    /**
+     * Handle an event by sending it to the integration webhook.
+     * Fire-and-forget with timeout.
+     *
+     * @param {object} pluginConfig - The integration plugin config
+     * @param {object} event - The event data
+     * @returns {Promise<{ sent: boolean, status?: number, error?: string }>}
+     */
+    static async handleEvent(pluginConfig, event) {
+        const webhookUrl = pluginConfig.webhook_url;
+        const timeoutMs = pluginConfig.timeout_ms || 5000;
+        const headers = { ...pluginConfig.headers, 'Content-Type': 'application/json' };
+
+        // Render payload template
+        const payload = IntegrationPlugin.renderTemplate(
+            pluginConfig.payload_template || '{"event": "{{event.type}}", "message": "{{event.message}}"}',
+            event
+        );
+
+        return new Promise((resolve) => {
+            try {
+                const url = new URL(webhookUrl);
+                const isHttps = url.protocol === 'https:';
+                const reqFn = isHttps ? request : httpRequest;
+
+                const options = {
+                    hostname: url.hostname,
+                    port: url.port || (isHttps ? 443 : 80),
+                    path: url.pathname + url.search,
+                    method: 'POST',
+                    headers: {
+                        ...headers,
+                        'Content-Length': Buffer.byteLength(payload),
+                    },
+                    timeout: timeoutMs,
+                };
+
+                const req = reqFn(options, (res) => {
+                    let body = '';
+                    res.on('data', (chunk) => { body += chunk; });
+                    res.on('end', () => {
+                        resolve({ sent: true, status: res.statusCode });
+                    });
+                });
+
+                req.on('error', (err) => {
+                    resolve({ sent: false, error: err.message });
+                });
+
+                req.on('timeout', () => {
+                    req.destroy();
+                    resolve({ sent: false, error: `Timeout after ${timeoutMs}ms` });
+                });
+
+                req.write(payload);
+                req.end();
+            } catch (err) {
+                resolve({ sent: false, error: err.message });
+            }
+        });
+    }
+
+    /**
+     * Get integrations subscribed to a specific event type.
+     *
+     * @param {string} eventType - The event type
+     * @returns {object[]} Matching integration definitions
+     */
+    static getByEvent(eventType) {
+        return Array.from(_registeredIntegrations.values()).filter(
+            i => i.events.includes(eventType) || i.events.includes('*')
+        );
+    }
+
+    /**
+     * List all registered integration plugins.
+     *
+     * @returns {object[]}
+     */
+    static listRegistered() {
+        return Array.from(_registeredIntegrations.values());
+    }
+
+    /**
+     * Clear all registered integrations (primarily for testing).
+     */
+    static _clearAll() {
+        _registeredIntegrations.clear();
+    }
+}
+
+module.exports = { IntegrationPlugin };