delimit-cli 2.4.0 → 3.0.1

package/adapters/cursor-extension.js

@@ -1,190 +0,0 @@
-#!/usr/bin/env node
-/**
- * Delimit™ Cursor Extension Adapter
- * Implements VSCode-style extension for Cursor
- */
-
-const vscode = typeof acquireVsCodeApi !== 'undefined' ? acquireVsCodeApi() : null;
-const axios = require('axios');
-const AGENT_URL = `http://127.0.0.1:${process.env.DELIMIT_AGENT_PORT || 7823}`;
-
-class DelimitCursorExtension {
-    constructor() {
-        this.extensionId = 'delimit.governance';
-        this.version = '2.0.0';
-    }
-    
-    /**
-     * Extension activation
-     */
-    async activate(context) {
-        console.log('[DELIMIT CURSOR] Extension activated');
-        
-        // Register commands
-        this.registerCommands(context);
-        
-        // Register code action provider
-        this.registerCodeActions(context);
-        
-        // Register diagnostics
-        this.registerDiagnostics(context);
-        
-        return {
-            extendMarkdownIt: (md) => this.extendMarkdown(md)
-        };
-    }
-    
-    registerCommands(context) {
-        const commands = {
-            'delimit.checkGovernance': async () => {
-                const { execSync } = require('child_process');
-                const result = execSync('delimit status --verbose').toString();
-                this.showMessage(result);
-            },
-            'delimit.switchMode': async () => {
-                const mode = await this.showQuickPick(['advisory', 'guarded', 'enforce']);
-                if (mode) {
-                    const { execSync } = require('child_process');
-                    execSync(`delimit mode ${mode}`);
-                    this.showMessage(`Switched to ${mode} mode`);
-                }
-            },
-            'delimit.viewAudit': async () => {
-                const { execSync } = require('child_process');
-                const audit = execSync('delimit audit --tail 20').toString();
-                this.showMessage(audit, 'Audit Log');
-            }
-        };
-        
-        Object.entries(commands).forEach(([cmd, handler]) => {
-            if (vscode) {
-                context.subscriptions.push(
-                    vscode.commands.registerCommand(cmd, handler)
-                );
-            }
-        });
-    }
-    
-    registerCodeActions(context) {
-        // Register code action provider for all languages
-        const provider = {
-            provideCodeActions: async (document, range, context) => {
-                const actions = [];
-                
-                // Check if there are any governance issues
-                const text = document.getText(range);
-                const issues = await this.checkGovernance(text, document.languageId);
-                
-                if (issues.length > 0) {
-                    actions.push({
-                        title: '🛡️ Fix Governance Issues',
-                        command: 'delimit.fixIssues',
-                        arguments: [issues]
-                    });
-                }
-                
-                return actions;
-            }
-        };
-        
-        if (vscode) {
-            context.subscriptions.push(
-                vscode.languages.registerCodeActionsProvider('*', provider)
-            );
-        }
-    }
-    
-    registerDiagnostics(context) {
-        const diagnosticCollection = vscode ? 
-            vscode.languages.createDiagnosticCollection('delimit') : null;
-        
-        // Watch for document changes
-        if (vscode) {
-            vscode.workspace.onDidChangeTextDocument(async (event) => {
-                const document = event.document;
-                const diagnostics = [];
-                
-                // Check governance
-                const text = document.getText();
-                const issues = await this.checkGovernance(text, document.languageId);
-                
-                issues.forEach(issue => {
-                    diagnostics.push({
-                        range: new vscode.Range(
-                            issue.line || 0, 
-                            issue.column || 0,
-                            issue.line || 0,
-                            issue.columnEnd || 100
-                        ),
-                        message: issue.message,
-                        severity: issue.severity === 'error' ? 
-                            vscode.DiagnosticSeverity.Error :
-                            vscode.DiagnosticSeverity.Warning
-                    });
-                });
-                
-                diagnosticCollection.set(document.uri, diagnostics);
-            });
-        }
-        
-        context.subscriptions.push(diagnosticCollection);
-    }
-    
-    async checkGovernance(code, language) {
-        try {
-            const response = await axios.post(`${AGENT_URL}/evaluate`, {
-                action: 'cursor_validation',
-                code: code,
-                language: language,
-                tool: 'cursor'
-            });
-            
-            if (response.data.issues) {
-                return response.data.issues;
-            }
-            
-            return [];
-        } catch (error) {
-            return [];
-        }
-    }
-    
-    showMessage(message, title = 'Delimit') {
-        if (vscode) {
-            vscode.window.showInformationMessage(`${title}: ${message}`);
-        } else {
-            console.log(`[${title}] ${message}`);
-        }
-    }
-    
-    async showQuickPick(items) {
-        if (vscode) {
-            return await vscode.window.showQuickPick(items);
-        }
-        return items[0];
-    }
-    
-    extendMarkdown(md) {
-        // Add custom markdown rendering for governance info
-        return md.use((md) => {
-            md.renderer.rules.delimit_governance = (tokens, idx) => {
-                return `<div class="delimit-governance">${tokens[idx].content}</div>`;
-            };
-        });
-    }
-    
-    deactivate() {
-        console.log('[DELIMIT CURSOR] Extension deactivated');
-    }
-}
-
-// Export for Cursor/VSCode
-if (typeof module !== 'undefined' && module.exports) {
-    module.exports = new DelimitCursorExtension();
-}
-
-// VSCode activation
-if (vscode) {
-    exports.activate = (context) => new DelimitCursorExtension().activate(context);
-    exports.deactivate = () => new DelimitCursorExtension().deactivate();
-}

package/adapters/gemini-action.js

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-/**
- * Delimit™ Gemini Action Adapter
- * Implements Google Gemini Extensions interface
- */
-
-const axios = require('axios');
-const AGENT_URL = `http://127.0.0.1:${process.env.DELIMIT_AGENT_PORT || 7823}`;
-
-class DelimitGeminiAction {
-    constructor() {
-        this.id = 'delimit-governance';
-        this.version = '2.0.0';
-    }
-    
-    /**
-     * Gemini uses action handlers for extension points
-     */
-    async beforeCodeGeneration(request) {
-        console.log('[DELIMIT GEMINI] Pre-generation validation...');
-        
-        try {
-            const { prompt, context, model } = request;
-            
-            // Check if the request involves sensitive operations
-            const response = await axios.post(`${AGENT_URL}/evaluate`, {
-                action: 'gemini_generation',
-                prompt: prompt,
-                context: context,
-                model: model || 'gemini-pro',
-                tool: 'gemini'
-            });
-            
-            if (response.data.action === 'block') {
-                throw new Error(`[DELIMIT] Generation blocked: ${response.data.reason}`);
-            }
-            
-            if (response.data.action === 'prompt') {
-                console.warn(`[DELIMIT] Warning: ${response.data.message}`);
-            }
-            
-            return request; // Pass through
-        } catch (error) {
-            if (error.message.includes('[DELIMIT]')) {
-                throw error; // Re-throw governance blocks
-            }
-            console.warn('[DELIMIT GEMINI] Governance check failed:', error.message);
-            return request; // Fail open
-        }
-    }
-    
-    async afterResponse(response) {
-        console.log('[DELIMIT GEMINI] Processing response...');
-        
-        try {
-            // Collect evidence
-            await axios.post(`${AGENT_URL}/audit`, {
-                action: 'gemini_response',
-                response: {
-                    model: response.model,
-                    tokens: response.usage,
-                    timestamp: new Date().toISOString()
-                }
-            });
-        } catch (error) {
-            // Silent fail for audit
-        }
-        
-        return response;
-    }
-    
-    // Gemini command handler (uses @ prefix)
-    async handleCommand(command, args) {
-        const commands = {
-            '@governance': 'delimit status',
-            '@audit': 'delimit audit',
-            '@mode': 'delimit mode'
-        };
-        
-        if (commands[command]) {
-            const { execSync } = require('child_process');
-            return execSync(commands[command]).toString();
-        }
-    }
-}
-
-// Export for Gemini
-module.exports = new DelimitGeminiAction();
-
-// Gemini registration (if available)
-if (typeof registerExtension === 'function') {
-    registerExtension(new DelimitGeminiAction());
-}

package/adapters/openai-function.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-/**
- * Delimit™ OpenAI Function Adapter
- * Implements OpenAI Functions/Tools interface
- */
-
-const axios = require('axios');
-const AGENT_URL = `http://127.0.0.1:${process.env.DELIMIT_AGENT_PORT || 7823}`;
-
-class DelimitOpenAIFunction {
-    constructor() {
-        this.name = 'delimit_governance_check';
-        this.description = 'Check governance compliance for code operations';
-    }
-    
-    /**
-     * OpenAI Functions are called as tools
-     */
-    async execute(args) {
-        console.log('[DELIMIT OPENAI] Function called with:', args);
-        
-        try {
-            const { action, context } = args;
-            
-            // Validate the action
-            const response = await axios.post(`${AGENT_URL}/evaluate`, {
-                action: action || 'openai_function',
-                context: context,
-                tool: 'openai'
-            });
-            
-            return {
-                allowed: response.data.action !== 'block',
-                action: response.data.action,
-                message: response.data.message || 'Check complete',
-                rule: response.data.rule
-            };
-        } catch (error) {
-            console.warn('[DELIMIT OPENAI] Governance check failed:', error.message);
-            return {
-                allowed: true,
-                message: 'Governance unavailable, proceeding with caution'
-            };
-        }
-    }
-    
-    /**
-     * OpenAI Plugins interface
-     */
-    async handleRequest(request) {
-        const { method, path, body } = request;
-        
-        if (path === '/governance/check') {
-            return await this.execute(body);
-        }
-        
-        if (path === '/governance/status') {
-            const { execSync } = require('child_process');
-            const status = execSync('delimit status --json').toString();
-            return JSON.parse(status);
-        }
-        
-        if (path === '/governance/audit') {
-            const { execSync } = require('child_process');
-            const audit = execSync('delimit audit --json').toString();
-            return JSON.parse(audit);
-        }
-        
-        return { error: 'Unknown endpoint' };
-    }
-    
-    /**
-     * Tool definition for OpenAI
-     */
-    toToolDefinition() {
-        return {
-            type: 'function',
-            function: {
-                name: this.name,
-                description: this.description,
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        action: {
-                            type: 'string',
-                            description: 'The action to validate'
-                        },
-                        context: {
-                            type: 'object',
-                            description: 'Context for validation',
-                            properties: {
-                                code: { type: 'string' },
-                                language: { type: 'string' },
-                                file: { type: 'string' },
-                                operation: { type: 'string' }
-                            }
-                        }
-                    },
-                    required: ['action']
-                }
-            }
-        };
-    }
-}
-
-// Export for OpenAI
-module.exports = new DelimitOpenAIFunction();
-
-// OpenAI registration (if available)
-if (typeof registerFunction === 'function') {
-    registerFunction(new DelimitOpenAIFunction());
-}

package/adapters/xai-plugin.js

@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-/**
- * Delimit™ xAI Grok Plugin Adapter
- * Implements xAI Plugin interface
- */
-
-const axios = require('axios');
-const AGENT_URL = `http://127.0.0.1:${process.env.DELIMIT_AGENT_PORT || 7823}`;
-
-class DelimitXAIPlugin {
-    constructor() {
-        this.name = 'delimit-governance';
-        this.version = '2.0.0';
-        this.capabilities = ['code_validation', 'security_check', 'audit_logging'];
-    }
-    
-    /**
-     * xAI Plugins use hooks for different stages
-     */
-    async prePrompt(context) {
-        console.log('[DELIMIT XAI] Pre-prompt validation...');
-        
-        try {
-            const { prompt, session, user } = context;
-            
-            // Check for risky prompts
-            const riskyPatterns = [
-                /sudo/i,
-                /rm\s+-rf/i,
-                /password/i,
-                /credential/i,
-                /secret/i
-            ];
-            
-            const isRisky = riskyPatterns.some(pattern => pattern.test(prompt));
-            
-            if (isRisky) {
-                const response = await axios.post(`${AGENT_URL}/evaluate`, {
-                    action: 'xai_prompt',
-                    prompt: prompt,
-                    riskLevel: 'high',
-                    session: session,
-                    tool: 'xai'
-                });
-                
-                if (response.data.action === 'block') {
-                    return {
-                        block: true,
-                        message: `[DELIMIT] Prompt blocked: ${response.data.reason}`
-                    };
-                }
-                
-                if (response.data.action === 'prompt') {
-                    return {
-                        warning: response.data.message
-                    };
-                }
-            }
-            
-            return { allow: true };
-        } catch (error) {
-            console.warn('[DELIMIT XAI] Governance check failed:', error.message);
-            return { allow: true }; // Fail open
-        }
-    }
-    
-    async postResponse(context) {
-        console.log('[DELIMIT XAI] Post-response processing...');
-        
-        try {
-            const { response, session, metrics } = context;
-            
-            // Collect evidence
-            await axios.post(`${AGENT_URL}/audit`, {
-                action: 'xai_response',
-                session: session,
-                metrics: metrics,
-                timestamp: new Date().toISOString()
-            });
-            
-            // Check for sensitive data in response
-            const sensitivePatterns = [
-                /\b[A-Z0-9]{20,}\b/g, // API keys
-                /-----BEGIN.*KEY-----/g, // Private keys
-                /Bearer\s+[A-Za-z0-9\-._~+\/]+=*/g // Bearer tokens
-            ];
-            
-            for (const pattern of sensitivePatterns) {
-                if (pattern.test(response)) {
-                    console.warn('[DELIMIT XAI] ⚠️  Sensitive data detected in response');
-                    // Could redact or block here
-                }
-            }
-        } catch (error) {
-            // Silent fail for audit
-        }
-        
-        return context;
-    }
-    
-    async validateCode(code, language) {
-        console.log('[DELIMIT XAI] Validating code...');
-        
-        try {
-            const response = await axios.post(`${AGENT_URL}/evaluate`, {
-                action: 'code_validation',
-                code: code,
-                language: language,
-                tool: 'xai'
-            });
-            
-            return {
-                valid: response.data.action !== 'block',
-                issues: response.data.issues || [],
-                message: response.data.message
-            };
-        } catch (error) {
-            return { valid: true, message: 'Validation unavailable' };
-        }
-    }
-    
-    // xAI command interface
-    async executeCommand(command, args) {
-        const commands = {
-            'governance': () => this.runCLI('status'),
-            'audit': () => this.runCLI('audit'),
-            'mode': () => this.runCLI('mode', args),
-            'policy': () => this.runCLI('policy')
-        };
-        
-        if (commands[command]) {
-            return await commands[command]();
-        }
-        
-        return `Unknown command: ${command}`;
-    }
-    
-    runCLI(command, args = []) {
-        const { execSync } = require('child_process');
-        const cmd = `delimit ${command} ${args.join(' ')}`.trim();
-        return execSync(cmd).toString();
-    }
-}
-
-// Export for xAI
-module.exports = new DelimitXAIPlugin();
-
-// xAI registration
-if (typeof registerPlugin === 'function') {
-    registerPlugin(new DelimitXAIPlugin());
-}