delimit-cli 1.0.0 → 2.1.1

package/lib/platform-adapters.js

@@ -0,0 +1,353 @@
+/**
+ * Delimit™ Platform Adapters
+ * Handles different naming conventions and integration methods for various AI platforms
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class PlatformAdapter {
+    constructor() {
+        this.HOME = os.homedir();
+    }
+    
+    /**
+     * GitHub Codex uses "Skills" instead of hooks
+     */
+    setupCodexSkills() {
+        const codexConfig = {
+            configPath: path.join(this.HOME, '.codex', 'skills'),
+            configFile: 'skills.json',
+            format: 'skill'
+        };
+        
+        const skills = {
+            "skills": [
+                {
+                    "name": "delimit-governance",
+                    "description": "Governance validation skill",
+                    "type": "validation",
+                    "handler": "/home/delimit/npm-delimit/adapters/codex-skill.js",
+                    "triggers": ["pre-code-generation", "pre-suggestion"],
+                    "enabled": true
+                },
+                {
+                    "name": "delimit-security",
+                    "description": "Security validation skill",
+                    "type": "security",
+                    "handler": "/home/delimit/npm-delimit/adapters/codex-security.js",
+                    "enabled": true
+                }
+            ],
+            "commands": {
+                "governance": {
+                    "description": "Check governance status",
+                    "handler": "/home/delimit/npm-delimit/bin/delimit-cli.js",
+                    "args": ["status"]
+                }
+            }
+        };
+        
+        // Create Codex skills directory
+        fs.mkdirSync(codexConfig.configPath, { recursive: true });
+        fs.writeFileSync(
+            path.join(codexConfig.configPath, codexConfig.configFile),
+            JSON.stringify(skills, null, 2)
+        );
+        
+        console.log('✓ Codex Skills configured');
+        return codexConfig;
+    }
+    
+    /**
+     * Google Gemini uses "Extensions" and "Actions"
+     */
+    setupGeminiExtensions() {
+        const geminiConfig = {
+            configPath: path.join(this.HOME, '.gemini', 'extensions'),
+            configFile: 'extensions.yaml',
+            format: 'extension'
+        };
+        
+        const extensions = `# Gemini Extensions Configuration
+extensions:
+  - id: delimit-governance
+    name: Delimit Governance Extension
+    version: 2.0.0
+    actions:
+      - id: validate-code
+        name: Validate Code
+        trigger: before_code_generation
+        handler: /home/delimit/npm-delimit/adapters/gemini-action.js
+      - id: collect-evidence
+        name: Collect Evidence
+        trigger: after_response
+        handler: /home/delimit/npm-delimit/adapters/gemini-evidence.js
+    commands:
+      - command: "@governance"
+        description: Check governance status
+        action: run_script
+        script: /home/delimit/npm-delimit/bin/delimit-cli.js
+        args: ["status"]
+`;
+        
+        // Create Gemini extensions directory
+        fs.mkdirSync(geminiConfig.configPath, { recursive: true });
+        fs.writeFileSync(
+            path.join(geminiConfig.configPath, geminiConfig.configFile),
+            extensions
+        );
+        
+        console.log('✓ Gemini Extensions configured');
+        return geminiConfig;
+    }
+    
+    /**
+     * xAI Grok uses "Plugins"
+     */
+    setupXAIPlugins() {
+        const xaiConfig = {
+            configPath: path.join(this.HOME, '.xai', 'plugins'),
+            configFile: 'plugins.toml',
+            format: 'plugin'
+        };
+        
+        const plugins = `# xAI Grok Plugins Configuration
+
+[[plugins]]
+name = "delimit-governance"
+version = "2.0.0"
+description = "Delimit Governance Plugin"
+entry_point = "/home/delimit/npm-delimit/adapters/xai-plugin.js"
+
+[plugins.hooks]
+pre_prompt = true
+post_response = true
+code_validation = true
+
+[plugins.commands]
+governance = { cmd = "/home/delimit/npm-delimit/bin/delimit-cli.js", args = ["status"] }
+audit = { cmd = "/home/delimit/npm-delimit/bin/delimit-cli.js", args = ["audit"] }
+`;
+        
+        // Create xAI plugins directory
+        fs.mkdirSync(xaiConfig.configPath, { recursive: true });
+        fs.writeFileSync(
+            path.join(xaiConfig.configPath, xaiConfig.configFile),
+            plugins
+        );
+        
+        console.log('✓ xAI Plugins configured');
+        return xaiConfig;
+    }
+    
+    /**
+     * OpenAI uses "Functions" and "Tools"
+     */
+    setupOpenAITools() {
+        const openaiConfig = {
+            configPath: path.join(this.HOME, '.openai', 'tools'),
+            configFile: 'tools.json',
+            format: 'function'
+        };
+        
+        const tools = {
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "delimit_governance_check",
+                        "description": "Check governance compliance",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "action": {
+                                    "type": "string",
+                                    "description": "The action to validate"
+                                },
+                                "context": {
+                                    "type": "object",
+                                    "description": "Context for validation"
+                                }
+                            }
+                        },
+                        "handler": "/home/delimit/npm-delimit/adapters/openai-function.js"
+                    }
+                }
+            ],
+            "plugins": [
+                {
+                    "name": "delimit-governance",
+                    "schema_version": "v1",
+                    "api": {
+                        "url": "http://localhost:7823/api",
+                        "is_user_authenticated": false
+                    }
+                }
+            ]
+        };
+        
+        // Create OpenAI tools directory
+        fs.mkdirSync(openaiConfig.configPath, { recursive: true });
+        fs.writeFileSync(
+            path.join(openaiConfig.configPath, openaiConfig.configFile),
+            JSON.stringify(tools, null, 2)
+        );
+        
+        console.log('✓ OpenAI Tools configured');
+        return openaiConfig;
+    }
+    
+    /**
+     * Cursor uses "Extensions" (VSCode-based)
+     */
+    setupCursorExtensions() {
+        const cursorConfig = {
+            configPath: path.join(this.HOME, '.cursor', 'extensions'),
+            configFile: 'extensions.json',
+            format: 'vscode-extension'
+        };
+        
+        const extensions = {
+            "extensions": [
+                {
+                    "id": "delimit.governance",
+                    "name": "Delimit Governance",
+                    "version": "2.0.0",
+                    "main": "/home/delimit/npm-delimit/adapters/cursor-extension.js",
+                    "activationEvents": [
+                        "onCommand:delimit.checkGovernance",
+                        "onLanguage:javascript",
+                        "onLanguage:typescript",
+                        "onLanguage:python"
+                    ],
+                    "contributes": {
+                        "commands": [
+                            {
+                                "command": "delimit.checkGovernance",
+                                "title": "Delimit: Check Governance"
+                            },
+                            {
+                                "command": "delimit.switchMode",
+                                "title": "Delimit: Switch Mode"
+                            }
+                        ],
+                        "configuration": {
+                            "type": "object",
+                            "properties": {
+                                "delimit.mode": {
+                                    "type": "string",
+                                    "default": "advisory",
+                                    "enum": ["advisory", "guarded", "enforce"]
+                                }
+                            }
+                        }
+                    }
+                }
+            ]
+        };
+        
+        // Create Cursor extensions directory
+        fs.mkdirSync(cursorConfig.configPath, { recursive: true });
+        fs.writeFileSync(
+            path.join(cursorConfig.configPath, cursorConfig.configFile),
+            JSON.stringify(extensions, null, 2)
+        );
+        
+        console.log('✓ Cursor Extensions configured');
+        return cursorConfig;
+    }
+    
+    /**
+     * Windsurf uses "Workflows" and "Automations"
+     */
+    setupWindsurfWorkflows() {
+        const windsurfConfig = {
+            configPath: path.join(this.HOME, '.windsurf', 'workflows'),
+            configFile: 'workflows.yaml',
+            format: 'workflow'
+        };
+        
+        const workflows = `# Windsurf Workflows Configuration
+workflows:
+  - name: delimit-governance
+    description: Governance validation workflow
+    version: 2.0.0
+    triggers:
+      - event: pre_generation
+        handler: /home/delimit/npm-delimit/adapters/windsurf-trigger.js
+      - event: post_generation
+        handler: /home/delimit/npm-delimit/adapters/windsurf-validate.js
+    automations:
+      - name: validate_code
+        trigger: on_code_change
+        action: run_validation
+      - name: collect_evidence
+        trigger: on_commit
+        action: store_evidence
+    commands:
+      governance:
+        description: Check governance status
+        script: /home/delimit/npm-delimit/bin/delimit-cli.js
+        args: [status]
+`;
+        
+        // Create Windsurf workflows directory
+        fs.mkdirSync(windsurfConfig.configPath, { recursive: true });
+        fs.writeFileSync(
+            path.join(windsurfConfig.configPath, windsurfConfig.configFile),
+            workflows
+        );
+        
+        console.log('✓ Windsurf Workflows configured');
+        return windsurfConfig;
+    }
+    
+    /**
+     * Anthropic Claude uses standard "hooks"
+     */
+    setupClaudeHooks() {
+        // This is already handled by the main hooks.json
+        console.log('✓ Claude hooks already configured');
+        return {
+            configPath: path.join(this.HOME, '.claude', 'hooks'),
+            configFile: 'hooks.json',
+            format: 'hook'
+        };
+    }
+    
+    /**
+     * Detect installed AI tools and setup appropriate configurations
+     */
+    async setupAllPlatforms() {
+        const results = {};
+        
+        // Check for each platform and set up if found
+        const platforms = [
+            { name: 'claude', check: '.claude', setup: () => this.setupClaudeHooks() },
+            { name: 'codex', check: '.codex', setup: () => this.setupCodexSkills() },
+            { name: 'gemini', check: '.gemini', setup: () => this.setupGeminiExtensions() },
+            { name: 'xai', check: '.xai', setup: () => this.setupXAIPlugins() },
+            { name: 'openai', check: '.openai', setup: () => this.setupOpenAITools() },
+            { name: 'cursor', check: '.cursor', setup: () => this.setupCursorExtensions() },
+            { name: 'windsurf', check: '.windsurf', setup: () => this.setupWindsurfWorkflows() }
+        ];
+        
+        for (const platform of platforms) {
+            const platformPath = path.join(this.HOME, platform.check);
+            // Always create the configuration, even if platform isn't installed yet
+            // This ensures it will work when the platform is installed later
+            try {
+                results[platform.name] = platform.setup();
+                console.log(`✓ ${platform.name} configuration created`);
+            } catch (error) {
+                console.error(`⚠️  Failed to configure ${platform.name}: ${error.message}`);
+            }
+        }
+        
+        return results;
+    }
+}
+
+module.exports = PlatformAdapter;

package/lib/proxy-handler.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+/**
+ * Delimit Proxy Handler - Intercepts AI tool commands
+ * This module wraps AI tools (claude, gemini, codex) with governance
+ */
+
+const { spawn } = require('child_process');
+const axios = require('axios');
+const path = require('path');
+const fs = require('fs');
+
+const AGENT_URL = `http://127.0.0.1:${process.env.DELIMIT_AGENT_PORT || 7823}`;
+
+async function proxyAITool(tool, args) {
+    console.log(`\x1b[34m\x1b[1m[Delimit]\x1b[0m Governance check for ${tool}...`);
+    
+    // Gather context for governance decision
+    const context = {
+        command: `ai-tool-${tool}`,
+        pwd: process.cwd(),
+        gitBranch: 'unknown',
+        files: [],
+        tool: tool,
+        args: args.join(' ')
+    };
+    
+    // Try to get Git branch if in repo
+    try {
+        const { execSync } = require('child_process');
+        context.gitBranch = execSync('git branch --show-current 2>/dev/null').toString().trim() || 'unknown';
+    } catch (e) {}
+    
+    // Check if agent is running
+    let decision;
+    try {
+        const response = await axios.post(`${AGENT_URL}/evaluate`, context);
+        decision = response.data;
+    } catch (e) {
+        // Agent not running - allow with warning
+        console.log(`\x1b[33m\x1b[1m[Delimit WARNING]\x1b[0m Agent not running - proceeding without governance`);
+        decision = { action: 'allow' };
+    }
+    
+    // Display decision
+    if (decision.message) {
+        console.log(decision.message);
+    }
+    
+    // Handle the decision
+    if (decision.action === 'block') {
+        console.error(`\x1b[31m\x1b[1m[Delimit BLOCKED]\x1b[0m ${tool} execution blocked by governance policy`);
+        console.error(`Run 'delimit explain last' for details`);
+        process.exit(1);
+    } else if (decision.action === 'prompt') {
+        // In non-interactive mode, treat as block
+        console.error(`\x1b[33m\x1b[1m[Delimit GUARDED]\x1b[0m ${tool} requires confirmation`);
+        console.error(`Use --force flag to bypass or switch to advisory mode`);
+        process.exit(1);
+    }
+    
+    // Find the real tool
+    const originalPath = process.env.PATH.replace(/[^:]*delimit[^:]*:?/g, '');
+    const realTool = findExecutable(tool, originalPath);
+    
+    if (!realTool) {
+        console.error(`\x1b[31m\x1b[1m[Delimit ERROR]\x1b[0m Original ${tool} not found`);
+        process.exit(127);
+    }
+    
+    // Execute the real tool
+    console.log(`\x1b[32m\x1b[1m[Delimit ALLOWED]\x1b[0m Executing ${tool}...`);
+    const child = spawn(realTool, args, {
+        stdio: 'inherit',
+        env: { ...process.env, DELIMIT_WRAPPED: 'true' }
+    });
+    
+    child.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+}
+
+function findExecutable(command, searchPath) {
+    const paths = searchPath.split(':');
+    for (const dir of paths) {
+        const fullPath = path.join(dir, command);
+        try {
+            fs.accessSync(fullPath, fs.constants.X_OK);
+            return fullPath;
+        } catch (e) {
+            // Continue searching
+        }
+    }
+    return null;
+}
+
+// Export for use as module
+module.exports = { proxyAITool };
+
+// If run directly, handle as CLI
+if (require.main === module) {
+    const tool = process.argv[2];
+    const args = process.argv.slice(3);
+    
+    if (!tool) {
+        console.error('Usage: proxy-handler <tool> [args...]');
+        process.exit(1);
+    }
+    
+    proxyAITool(tool, args).catch(err => {
+        console.error(`\x1b[31m\x1b[1m[Delimit ERROR]\x1b[0m`, err.message);
+        process.exit(1);
+    });
+}

package/package.json

@@ -1,50 +1,58 @@
 {
   "name": "delimit-cli",
-  "version": "1.0.0",
-  "description": "CLI tool for Delimit API governance with built-in Privacy Shield",
-  "main": "dist/index.js",
+  "version": "2.1.1",
+  "description": "ESLint for API contracts — detect breaking changes, enforce semver, and generate migration guides for OpenAPI specs",
+  "main": "index.js",
   "bin": {
-    "delimit": "./bin/delimit.js"
+    "delimit": "./bin/delimit-cli.js"
   },
   "scripts": {
-    "build": "tsc",
-    "dev": "ts-node src/index.ts",
-    "start": "node bin/delimit.js",
-    "prepublishOnly": "npm run build"
+    "postinstall": "echo 'Run \"delimit install\" to set up governance'",
+    "install": "bash ./hooks/install-hooks.sh install",
+    "install-mcp": "bash ./hooks/install-hooks.sh mcp-only", 
+    "test-mcp": "bash ./hooks/install-hooks.sh troubleshoot",
+    "fix-mcp": "bash ./hooks/install-hooks.sh fix-mcp",
+    "test": "echo 'Governance is context-aware' && exit 0"
   },
   "keywords": [
-    "api",
     "openapi",
-    "governance",
-    "validation",
-    "cli",
+    "swagger",
+    "api",
+    "breaking-changes",
+    "semver",
+    "lint",
+    "linter",
+    "api-governance",
+    "api-contracts",
+    "ci-cd",
+    "github-actions",
+    "migration",
+    "diff",
+    "schema-validation",
+    "api-versioning",
+    "eslint",
     "delimit",
-    "api-management",
-    "breaking-changes"
+    "openapi-diff",
+    "api-linter",
+    "contract-testing"
   ],
-  "author": "Delimit.ai",
+  "author": "Delimit AI <hello@delimit.ai>",
   "license": "MIT",
-  "homepage": "https://github.com/delimit-ai/delimit-cli",
+  "homepage": "https://delimit.ai",
   "repository": {
     "type": "git",
-    "url": "https://github.com/delimit-ai/delimit-cli.git"
-  },
-  "bugs": {
-    "url": "https://github.com/delimit-ai/delimit-cli/issues"
+    "url": "https://github.com/delimit-ai/delimit.git"
   },
   "dependencies": {
-    "axios": "^1.6.0",
+    "commander": "^9.0.0",
+    "axios": "^1.0.0",
     "chalk": "^4.1.2",
-    "commander": "^11.1.0",
-    "js-yaml": "^4.1.0"
-  },
-  "devDependencies": {
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.8.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.2.2"
+    "inquirer": "^8.2.0",
+    "express": "^4.18.0",
+    "js-yaml": "^4.1.0",
+    "minimatch": "^5.1.0"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=14.0.0"
   }
 }

package/scripts/infect.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const HOME_DIR = os.homedir();
+const DELIMIT_HOME = path.join(HOME_DIR, '.delimit');
+const SHIM_DIR = path.join(DELIMIT_HOME, 'shims');
+const HOOKS_DIR = path.join(DELIMIT_HOME, 'hooks');
+const BIN_DIR = path.join(DELIMIT_HOME, 'bin');
+
+console.log('\n🔵 Installing Delimit Governance Layer...');
+console.log('⚠️  WARNING: This will modify your system permanently.\n');
+
+try {
+    // 1. Create directory structure
+    [DELIMIT_HOME, SHIM_DIR, HOOKS_DIR, BIN_DIR].forEach(dir => {
+        fs.mkdirSync(dir, { recursive: true });
+    });
+    console.log('✓ Created ~/.delimit directory structure');
+
+    // 2. Copy the main Delimit CLI
+    const cliSource = path.join(__dirname, '..', 'bin', 'delimit.js');
+    const cliDest = path.join(BIN_DIR, 'delimit');
+    fs.copyFileSync(cliSource, cliDest);
+    fs.chmodSync(cliDest, '755');
+    console.log('✓ Installed Delimit CLI');
+
+    // 3. Install global Git hooks
+    const preCommitHook = `#!/bin/sh
+# Delimit Governance Hook - Pre-commit
+${cliDest} pre-commit-check`;
+
+    const prePushHook = `#!/bin/sh
+# Delimit Governance Hook - Pre-push  
+${cliDest} pre-push-check`;
+
+    fs.writeFileSync(path.join(HOOKS_DIR, 'pre-commit'), preCommitHook);
+    fs.writeFileSync(path.join(HOOKS_DIR, 'pre-push'), prePushHook);
+    fs.chmodSync(path.join(HOOKS_DIR, 'pre-commit'), '755');
+    fs.chmodSync(path.join(HOOKS_DIR, 'pre-push'), '755');
+    
+    execSync(`git config --global core.hooksPath ${HOOKS_DIR}`);
+    console.log('✓ Installed global Git hooks');
+
+    // 4. Create AI tool shims
+    const aiTools = ['claude', 'gemini', 'codex', 'copilot', 'gh', 'openai', 'anthropic'];
+    aiTools.forEach(tool => {
+        const shimContent = `#!/bin/sh
+# Delimit Governance Shim for ${tool}
+exec ${cliDest} proxy --tool=${tool} -- "$@"`;
+        
+        const shimPath = path.join(SHIM_DIR, tool);
+        fs.writeFileSync(shimPath, shimContent);
+        fs.chmodSync(shimPath, '755');
+    });
+    console.log(`✓ Created ${aiTools.length} AI tool shims`);
+
+    // 5. Inject into shell profiles
+    const shellProfiles = [
+        '.bashrc',
+        '.zshrc', 
+        '.profile',
+        '.bash_profile'
+    ].map(f => path.join(HOME_DIR, f));
+
+    const pathInjection = `
+# Delimit Governance Layer - DO NOT REMOVE
+export PATH="${SHIM_DIR}:$PATH"
+export DELIMIT_ACTIVE=true
+
+# Show governance status on shell start
+if [ -t 1 ]; then
+  echo -e "\\033[34m\\033[1m[Delimit]\\033[0m Governance active. All AI tools and Git operations are monitored."
+fi
+`;
+
+    let injected = false;
+    shellProfiles.forEach(profilePath => {
+        if (fs.existsSync(profilePath)) {
+            const content = fs.readFileSync(profilePath, 'utf8');
+            if (!content.includes('Delimit Governance Layer')) {
+                fs.appendFileSync(profilePath, pathInjection);
+                console.log(`✓ Injected into ${path.basename(profilePath)}`);
+                injected = true;
+            }
+        }
+    });
+
+    if (!injected) {
+        // Create a .profile if nothing exists
+        const profilePath = path.join(HOME_DIR, '.profile');
+        fs.writeFileSync(profilePath, pathInjection);
+        console.log('✓ Created .profile with governance');
+    }
+
+    // 6. Create global command link
+    try {
+        const globalBin = '/usr/local/bin/delimit';
+        if (fs.existsSync('/usr/local/bin')) {
+            if (fs.existsSync(globalBin)) {
+                fs.unlinkSync(globalBin);
+            }
+            fs.symlinkSync(cliDest, globalBin);
+            console.log('✓ Created global delimit command');
+        }
+    } catch (e) {
+        // Ignore if can't create global link
+    }
+
+    console.log('\n' + '═'.repeat(60));
+    console.log('🟢 DELIMIT GOVERNANCE LAYER INSTALLED SUCCESSFULLY');
+    console.log('═'.repeat(60));
+    console.log('\n⚡ IMPORTANT: Restart your terminal or run:');
+    console.log('   source ~/.bashrc (or ~/.zshrc)\n');
+    console.log('📊 Check status with: delimit status');
+    console.log('📖 Documentation: https://delimit.ai\n');
+    console.log('⚠️  WARNING: Governance is now mandatory.');
+    console.log('   All AI tools and Git operations are monitored.\n');
+
+} catch (error) {
+    console.error('\n❌ Installation failed:', error.message);
+    console.error('\nTry installing globally with sudo:');
+    console.error('   sudo npm install -g delimit\n');
+    process.exit(1);
+}