delimit-cli 1.0.0 → 2.1.1

package/.github/workflows/api-governance.yml

@@ -0,0 +1,43 @@
+name: API Governance
+
+on:
+  pull_request:
+    paths:
+      - '**/*.yaml'
+      - '**/*.yml'
+      - '**/*.json'
+      - 'lib/**'
+
+jobs:
+  api-check:
+    name: Delimit API Check
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.base.sha }}
+          path: base
+
+      - name: Check for spec changes
+        id: spec-check
+        run: |
+          # Find any OpenAPI/Swagger specs in the repo
+          SPECS=$(find . -path ./base -prune -o \( -name "openapi*.yaml" -o -name "openapi*.yml" -o -name "openapi*.json" -o -name "swagger*.yaml" -o -name "swagger*.json" \) -print | head -1)
+          if [ -n "$SPECS" ]; then
+            echo "spec_found=true" >> $GITHUB_OUTPUT
+            echo "spec_path=$SPECS" >> $GITHUB_OUTPUT
+          else
+            echo "spec_found=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Run Delimit
+        if: steps.spec-check.outputs.spec_found == 'true'
+        uses: delimit-ai/delimit-action@v1
+        with:
+          old_spec: base/${{ steps.spec-check.outputs.spec_path }}
+          new_spec: ${{ steps.spec-check.outputs.spec_path }}
+          mode: advisory

package/README.md

@@ -1,157 +1,114 @@
 # delimit-cli
 
-Official CLI tool for [Delimit API Governance Platform](https://delimit.ai) with built-in Privacy Shield™ technology.
+**ESLint for API contracts** — detect breaking changes, enforce semver, and generate migration guides for OpenAPI specs.
 
-## Features
+[![npm](https://img.shields.io/npm/v/delimit-cli)](https://www.npmjs.com/package/delimit-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-- 🛡️ **Privacy Shield™**: Automatically masks sensitive data before sending to API
-- ✅ **OpenAPI Validation**: Validate specs against governance rules
-- 🎨 **Beautiful Output**: Color-coded terminal output for easy reading
-- 🚀 **Fast & Lightweight**: Built with TypeScript for performance
-- 🔒 **Secure by Design**: Your sensitive API data never leaves your machine
-
-## Installation
+## Install
 
 ```bash
 npm install -g delimit-cli
 ```
 
-Or with yarn:
-
-```bash
-yarn global add delimit-cli
-```
+This installs the `delimit` command globally.
 
 ## Quick Start
 
-1. Get your API key from [RapidAPI](https://rapidapi.com/delimit/api/openapi-diff-api)
-
-2. Set your API key as an environment variable:
 ```bash
-export DELIMIT_API_KEY="your-api-key-here"
-```
+# Initialize a policy file in your repo
+delimit init
 
-3. Validate your OpenAPI specification:
-```bash
-delimit validate api-spec.yaml
+# Detect breaking changes between two specs
+delimit lint api/openapi-old.yaml api/openapi-new.yaml
+
+# See raw diff output
+delimit diff api/openapi-old.yaml api/openapi-new.yaml
+
+# Generate a human-readable explanation
+delimit explain api/openapi-old.yaml api/openapi-new.yaml
 ```
 
 ## Commands
 
-### `validate`
+| Command | Description |
+|---------|-------------|
+| `delimit init` | Create `.delimit/policies.yml` with default rules |
+| `delimit lint <old> <new>` | Diff + policy check with semver badge and violations |
+| `delimit diff <old> <new>` | Raw diff with `[BREAKING]`/`[safe]` tags |
+| `delimit explain <old> <new>` | Human-readable change explanation |
 
-Validate an OpenAPI specification against governance rules.
+### Options
 
 ```bash
-delimit validate <filepath>
-```
+# Specify explainer template (default: developer)
+delimit explain old.yaml new.yaml -t migration
+delimit explain old.yaml new.yaml -t pr_comment
+delimit explain old.yaml new.yaml -t changelog
 
-**Options:**
-- `--verbose` - Show detailed validation output
-- `--output <format>` - Output format: `text` (default) or `json`
+# Include semver classification
+delimit lint old.yaml new.yaml --current-version 1.0.0
 
-**Example:**
-```bash
-# Validate a YAML spec
-delimit validate openapi.yaml
-
-# Validate a JSON spec with verbose output
-delimit validate api.json --verbose
-
-# Get JSON output for CI/CD integration
-delimit validate spec.yaml --output json
+# Use custom policy file
+delimit lint old.yaml new.yaml -p .delimit/policies.yml
 ```
 
-### Coming Soon
-
-- `diff` - Compare two API versions for breaking changes
-- `analyze` - Analyze API changes for risks and soft breaks
-- `recommend` - Get version recommendations based on changes
-- `gate` - CI/CD release gate checks
+### Explainer Templates
 
-## Privacy Shield™
-
-The CLI includes built-in Privacy Shield technology that automatically removes sensitive information from your OpenAPI specifications before sending them for validation:
-
-**What gets masked:**
-- API descriptions and summaries
-- Example values and responses
-- Server URLs
-- Contact information
-- License and terms of service
-
-**What stays intact:**
-- API structure and schemas
-- Endpoints and methods
-- Parameters and types
-- Required fields and validations
-
-This ensures your proprietary business logic and sensitive documentation never leave your local environment.
+| Template | Audience |
+|----------|----------|
+| `developer` | Technical details for engineers |
+| `team_lead` | Summary for engineering managers |
+| `product` | Non-technical overview for PMs |
+| `migration` | Step-by-step migration guide |
+| `changelog` | Ready-to-paste changelog entry |
+| `pr_comment` | GitHub PR comment format |
+| `slack` | Slack message format |
 
 ## CI/CD Integration
 
-### GitHub Actions
+For automated PR checks, use the GitHub Action:
 
 ```yaml
-- name: Validate API Spec
-  run: |
-    npm install -g delimit-cli
-    export DELIMIT_API_KEY=${{ secrets.DELIMIT_API_KEY }}
-    delimit validate openapi.yaml
+- uses: delimit-ai/delimit-action@v1
+  with:
+    old_spec: base/api/openapi.yaml
+    new_spec: api/openapi.yaml
 ```
 
-### Jenkins
-
-```groovy
-stage('API Validation') {
-    steps {
-        sh '''
-            npm install -g delimit-cli
-            export DELIMIT_API_KEY=${DELIMIT_API_KEY}
-            delimit validate openapi.yaml
-        '''
-    }
-}
-```
+See [Delimit API Governance](https://github.com/marketplace/actions/delimit-api-governance) on the GitHub Marketplace.
+
+## Custom Policies
 
-### GitLab CI
+Create `.delimit/policies.yml`:
 
 ```yaml
-validate-api:
-  script:
-    - npm install -g delimit-cli
-    - export DELIMIT_API_KEY=$DELIMIT_API_KEY
-    - delimit validate openapi.yaml
+rules:
+  - id: no_endpoint_removal
+    change_types: [endpoint_removed]
+    severity: error
+    action: forbid
+    message: "Endpoints cannot be removed without deprecation"
+
+  - id: warn_type_change
+    change_types: [type_changed]
+    severity: warning
+    action: warn
+    message: "Type change may break clients"
 ```
 
-## Exit Codes
-
-- `0` - Validation passed
-- `1` - Validation failed or error occurred
+## Supported Specs
 
-## Environment Variables
+- OpenAPI 3.0.x and 3.1.x
+- Swagger 2.0
+- YAML and JSON formats
 
-- `DELIMIT_API_KEY` - Your RapidAPI key (required)
-- `DELIMIT_API_URL` - Override API URL (optional, for testing)
+## Links
 
-## Support
-
-- **Documentation**: https://api.delimit.ai/docs
-- **Issues**: https://github.com/delimit-ai/delimit-cli/issues
-- **Email**: support@delimit.ai
+- [GitHub Action](https://github.com/marketplace/actions/delimit-api-governance) — CI/CD integration
+- [GitHub](https://github.com/delimit-ai/delimit) — Source code
+- [Issues](https://github.com/delimit-ai/delimit/issues) — Bug reports and feature requests
 
 ## License
 
-MIT © Delimit.ai
-
-## Contributing
-
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
-
-## Security
-
-Found a security issue? Please email security@delimit.ai directly.
-
----
-
-Built with ❤️ by the Delimit team
+MIT

package/adapters/codex-skill.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Delimit™ Codex Skill Adapter
+ * Implements GitHub Codex "Skills" interface
+ */
+
+const axios = require('axios');
+const AGENT_URL = `http://127.0.0.1:${process.env.DELIMIT_AGENT_PORT || 7823}`;
+
+class DelimitCodexSkill {
+    constructor() {
+        this.name = 'delimit-governance';
+        this.version = '2.0.0';
+    }
+    
+    /**
+     * Codex Skills use onBeforeSuggestion and onAfterAccept events
+     */
+    async onBeforeSuggestion(context) {
+        console.log('[DELIMIT CODEX] Validating code suggestion...');
+        
+        try {
+            const { code, language, file } = context;
+            
+            // Check governance rules
+            const response = await axios.post(`${AGENT_URL}/evaluate`, {
+                action: 'codex_suggestion',
+                code: code,
+                language: language,
+                file: file,
+                tool: 'codex'
+            });
+            
+            if (response.data.action === 'block') {
+                return {
+                    allow: false,
+                    message: `[DELIMIT] Code blocked: ${response.data.reason}`
+                };
+            }
+            
+            if (response.data.action === 'prompt') {
+                return {
+                    allow: true,
+                    warning: response.data.message
+                };
+            }
+            
+            return { allow: true };
+        } catch (error) {
+            console.warn('[DELIMIT CODEX] Governance check failed:', error.message);
+            return { allow: true }; // Fail open
+        }
+    }
+    
+    async onAfterAccept(context) {
+        console.log('[DELIMIT CODEX] Recording accepted suggestion...');
+        
+        try {
+            // Collect evidence
+            await axios.post(`${AGENT_URL}/audit`, {
+                action: 'codex_accept',
+                context: context,
+                timestamp: new Date().toISOString()
+            });
+        } catch (error) {
+            // Silent fail for audit
+        }
+    }
+    
+    // Codex-specific command handler
+    async handleCommand(command, args) {
+        if (command === 'governance') {
+            const { execSync } = require('child_process');
+            return execSync('delimit status --verbose').toString();
+        }
+    }
+}
+
+// Export for Codex
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = new DelimitCodexSkill();
+}
+
+// Codex registration
+if (typeof registerSkill === 'function') {
+    registerSkill(new DelimitCodexSkill());
+}

package/adapters/cursor-extension.js

@@ -0,0 +1,190 @@
+#!/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

@@ -0,0 +1,93 @@
+#!/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());
+}