delimit-cli 2.4.0 → 3.0.0

package/bin/delimit-setup.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/**
+ * delimit setup — Install Delimit MCP governance tools into Claude Code.
+ *
+ * What it does:
+ * 1. Creates ~/.delimit/ directory with the MCP server + core engine
+ * 2. Adds "delimit" to Claude Code's MCP config (~/.mcp.json or .mcp.json)
+ * 3. Installs default agents into ~/.claude/agents/
+ * 4. Prints next steps
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const os = require('os');
+
+const DELIMIT_HOME = path.join(os.homedir(), '.delimit');
+const MCP_CONFIG = path.join(os.homedir(), '.mcp.json');
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const AGENTS_DIR = path.join(CLAUDE_DIR, 'agents');
+
+// Colors
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const blue = (s) => `\x1b[34m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+
+function log(msg) { console.log(msg); }
+function step(n, msg) { log(`\n${blue(`[${n}]`)} ${msg}`); }
+
+async function main() {
+    log('');
+    log(bold('  Delimit Setup'));
+    log(dim('  AI agent guardrails for developers'));
+    log('');
+
+    // Step 1: Check prerequisites
+    step(1, 'Checking prerequisites...');
+
+    // Python 3.9+
+    let python = null;
+    for (const cmd of ['python3', 'python']) {
+        try {
+            const ver = execSync(`${cmd} --version 2>&1`, { encoding: 'utf-8' }).trim();
+            const match = ver.match(/(\d+)\.(\d+)/);
+            if (match && (parseInt(match[1]) >= 3 && parseInt(match[2]) >= 9)) {
+                python = cmd;
+                log(`  ${green('✓')} ${ver}`);
+                break;
+            }
+        } catch {}
+    }
+    if (!python) {
+        log(`  ${yellow('✗')} Python 3.9+ not found. Install Python first.`);
+        process.exit(1);
+    }
+
+    // Check if Claude Code is available
+    let hasClaude = false;
+    try {
+        execSync('claude --version 2>/dev/null', { encoding: 'utf-8' });
+        hasClaude = true;
+        log(`  ${green('✓')} Claude Code detected`);
+    } catch {
+        log(`  ${yellow('!')} Claude Code not detected — MCP config will still be created`);
+    }
+
+    // Step 2: Install Delimit MCP server
+    step(2, 'Installing Delimit MCP server...');
+
+    // Create ~/.delimit directory
+    fs.mkdirSync(path.join(DELIMIT_HOME, 'server', 'core', 'zero_spec'), { recursive: true });
+    fs.mkdirSync(path.join(DELIMIT_HOME, 'server', 'tasks'), { recursive: true });
+    fs.mkdirSync(path.join(DELIMIT_HOME, 'deploys'), { recursive: true });
+    fs.mkdirSync(path.join(DELIMIT_HOME, 'ledger'), { recursive: true });
+    fs.mkdirSync(path.join(DELIMIT_HOME, 'evidence'), { recursive: true });
+
+    // Copy the gateway core from our bundled copy
+    const gatewaySource = path.join(__dirname, '..', 'gateway');
+    if (fs.existsSync(gatewaySource)) {
+        copyDir(gatewaySource, path.join(DELIMIT_HOME, 'server'));
+        log(`  ${green('✓')} Core engine installed`);
+    } else {
+        // Fallback: try to clone from GitHub
+        log(`  ${dim('  Downloading from GitHub...')}`);
+        try {
+            execSync(`git clone --depth 1 https://github.com/delimit-ai/delimit-gateway.git "${path.join(DELIMIT_HOME, 'server')}" 2>/dev/null`, { stdio: 'pipe' });
+            log(`  ${green('✓')} Core engine cloned`);
+        } catch {
+            log(`  ${yellow('!')} Could not download. Clone manually: git clone https://github.com/delimit-ai/delimit-gateway.git ~/.delimit/server`);
+        }
+    }
+
+    // Copy the MCP server file
+    const serverSource = path.join(__dirname, '..', 'mcp-server.py');
+    if (fs.existsSync(serverSource)) {
+        fs.copyFileSync(serverSource, path.join(DELIMIT_HOME, 'server', 'mcp-server.py'));
+    }
+
+    // Install Python deps
+    log(`  ${dim('  Installing Python dependencies...')}`);
+    try {
+        execSync(`${python} -m pip install --quiet fastmcp pyyaml pydantic packaging 2>/dev/null`, { stdio: 'pipe' });
+        log(`  ${green('✓')} Python dependencies installed`);
+    } catch {
+        log(`  ${yellow('!')} pip install failed — run manually: pip install fastmcp pyyaml pydantic packaging`);
+    }
+
+    // Step 3: Configure Claude Code MCP
+    step(3, 'Configuring Claude Code MCP...');
+
+    let mcpConfig = {};
+    if (fs.existsSync(MCP_CONFIG)) {
+        try {
+            mcpConfig = JSON.parse(fs.readFileSync(MCP_CONFIG, 'utf-8'));
+        } catch {}
+    }
+    if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+
+    const serverPath = path.join(DELIMIT_HOME, 'server', 'ai', 'server.py');
+    const serverPathAlt = path.join(DELIMIT_HOME, 'server', 'mcp-server.py');
+    const actualServer = fs.existsSync(serverPath) ? serverPath : serverPathAlt;
+
+    if (mcpConfig.mcpServers.delimit) {
+        log(`  ${green('✓')} Delimit MCP already configured`);
+    } else {
+        mcpConfig.mcpServers.delimit = {
+            type: 'stdio',
+            command: python,
+            args: [actualServer],
+            cwd: path.join(DELIMIT_HOME, 'server'),
+            env: {
+                PYTHONPATH: path.join(DELIMIT_HOME, 'server')
+            },
+            description: 'Delimit — AI agent guardrails'
+        };
+        fs.writeFileSync(MCP_CONFIG, JSON.stringify(mcpConfig, null, 2));
+        log(`  ${green('✓')} Added delimit to ${MCP_CONFIG}`);
+    }
+
+    // Step 4: Install default agents
+    step(4, 'Installing governance agents...');
+
+    fs.mkdirSync(AGENTS_DIR, { recursive: true });
+
+    const agents = {
+        'lint.md': `---
+name: lint
+description: Lint OpenAPI specs for breaking changes and policy violations
+tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - mcp__delimit__delimit_lint
+  - mcp__delimit__delimit_diff
+  - mcp__delimit__delimit_policy
+  - mcp__delimit__delimit_impact
+  - mcp__delimit__delimit_ledger
+---
+
+# Lint Agent
+
+Run API governance checks. Use delimit_lint to compare specs, delimit_policy to check rules, delimit_impact for downstream analysis.
+`,
+        'engineering.md': `---
+name: engineering
+description: Build features, fix bugs, write tests, refactor code
+tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+  - Edit
+  - Write
+  - mcp__delimit__delimit_lint
+  - mcp__delimit__delimit_diff
+  - mcp__delimit__delimit_test_generate
+  - mcp__delimit__delimit_test_coverage
+---
+
+# Engineering Agent
+
+Execute code directives. Use delimit_test_coverage to verify coverage targets. Use delimit_lint to check API compatibility after changes.
+`,
+        'governance.md': `---
+name: governance
+description: Run governance checks on the current project
+tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - mcp__delimit__delimit_gov_health
+  - mcp__delimit__delimit_gov_status
+  - mcp__delimit__delimit_gov_policy
+  - mcp__delimit__delimit_security_scan
+  - mcp__delimit__delimit_security_audit
+  - mcp__delimit__delimit_evidence_collect
+  - mcp__delimit__delimit_repo_analyze
+  - mcp__delimit__delimit_repo_config_validate
+---
+
+# Governance Agent
+
+Run full governance compliance checks. Verify security, policy compliance, evidence collection, and repo health.
+`
+    };
+
+    let installed = 0;
+    for (const [filename, content] of Object.entries(agents)) {
+        const agentPath = path.join(AGENTS_DIR, filename);
+        if (!fs.existsSync(agentPath)) {
+            fs.writeFileSync(agentPath, content);
+            installed++;
+        }
+    }
+    log(`  ${green('✓')} ${installed} agents installed (${Object.keys(agents).length - installed} already existed)`);
+
+    // Step 5: Summary
+    step(5, 'Done!');
+    log('');
+    log(`  ${green('Delimit is installed.')} Your AI agents are now monitored.`);
+    log('');
+    log('  What happens next:');
+    log(`  ${dim('1.')} Start Claude Code in any project`);
+    log(`  ${dim('2.')} The delimit MCP tools load automatically`);
+    log(`  ${dim('3.')} Use agents: ${blue('/lint')}, ${blue('/governance')}, ${blue('/engineering')}`);
+    log(`  ${dim('4.')} Or ask: "check governance health" / "run test coverage"`);
+    log('');
+    log(`  ${dim('Config:')} ${MCP_CONFIG}`);
+    log(`  ${dim('Server:')} ${actualServer}`);
+    log(`  ${dim('Agents:')} ${AGENTS_DIR}`);
+    log('');
+    log(`  ${dim('Docs:')} https://delimit.ai/docs`);
+    log(`  ${dim('GitHub:')} https://github.com/delimit-ai/delimit`);
+    log('');
+}
+
+function copyDir(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.name === '__pycache__' || entry.name === 'node_modules' || entry.name === '.git') continue;
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+main().catch(err => {
+    console.error('Setup failed:', err.message);
+    process.exit(1);
+});

package/gateway/ai/backends/async_utils.py

@@ -0,0 +1,21 @@
+"""Shared async utilities for gateway bridge modules."""
+import asyncio
+import concurrent.futures
+
+
+def run_async(coro):
+    """Run an async coroutine from sync code, handling nested event loops.
+
+    When called from inside an already-running event loop (FastMCP, AnyIO),
+    offloads to a ThreadPoolExecutor. Otherwise uses asyncio.run() directly.
+    """
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            return pool.submit(asyncio.run, coro).result(timeout=30)
+    else:
+        return asyncio.run(coro)

package/gateway/ai/backends/deploy_bridge.py

@@ -0,0 +1,150 @@
+"""
+Bridge to deploy tracking — file-based deploy plan management.
+Tier 3 Extended — tracks deploy plans, builds, and rollbacks locally.
+
+No external server required. Plans stored at ~/.delimit/deploys/.
+"""
+
+import json
+import logging
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("delimit.ai.deploy_bridge")
+
+DEPLOY_DIR = Path.home() / ".delimit" / "deploys"
+
+
+def _ensure_dir():
+    DEPLOY_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _list_plans(app: Optional[str] = None, env: Optional[str] = None) -> List[Dict]:
+    """List all deploy plans, optionally filtered by app and/or env."""
+    _ensure_dir()
+    plans = []
+    for f in sorted(DEPLOY_DIR.glob("PLAN-*.json"), reverse=True):
+        try:
+            data = json.loads(f.read_text())
+            if app and data.get("app") != app:
+                continue
+            if env and data.get("env") != env:
+                continue
+            plans.append(data)
+        except Exception:
+            continue
+    return plans
+
+
+def plan(app: str, env: str, git_ref: Optional[str] = None) -> Dict[str, Any]:
+    """Create a deploy plan."""
+    _ensure_dir()
+    plan_id = f"PLAN-{uuid.uuid4().hex[:8].upper()}"
+    now = datetime.now(timezone.utc).isoformat()
+    data = {
+        "plan_id": plan_id,
+        "app": app,
+        "env": env,
+        "git_ref": git_ref or "HEAD",
+        "status": "planned",
+        "created_at": now,
+        "updated_at": now,
+        "history": [{"status": "planned", "at": now}],
+    }
+    (DEPLOY_DIR / f"{plan_id}.json").write_text(json.dumps(data, indent=2))
+    return data
+
+
+def status(app: str, env: str) -> Dict[str, Any]:
+    """Get latest deploy status for an app+env."""
+    plans = _list_plans(app=app, env=env)
+    if not plans:
+        return {
+            "app": app,
+            "env": env,
+            "status": "no_deploys",
+            "message": f"No deploy plans found for {app} in {env}.",
+        }
+    latest = plans[0]
+    return {
+        "app": app,
+        "env": env,
+        "latest_plan": latest["plan_id"],
+        "status": latest["status"],
+        "git_ref": latest.get("git_ref"),
+        "updated_at": latest.get("updated_at"),
+        "total_plans": len(plans),
+    }
+
+
+def build(app: str, git_ref: Optional[str] = None) -> Dict[str, Any]:
+    """Check if a Dockerfile exists and return build info."""
+    dockerfile = Path.cwd() / "Dockerfile"
+    if not dockerfile.exists():
+        # Check app-specific paths
+        for candidate in [Path(f"/home/delimit/{app}/Dockerfile"), Path(f"./{app}/Dockerfile")]:
+            if candidate.exists():
+                dockerfile = candidate
+                break
+
+    if dockerfile.exists():
+        return {
+            "app": app,
+            "git_ref": git_ref or "HEAD",
+            "dockerfile": str(dockerfile),
+            "status": "ready",
+            "message": f"Dockerfile found at {dockerfile}. Ready to build.",
+        }
+    return {
+        "app": app,
+        "git_ref": git_ref or "HEAD",
+        "status": "no_dockerfile",
+        "message": f"No Dockerfile found for {app}. Create one to enable Docker builds.",
+    }
+
+
+def publish(app: str, git_ref: Optional[str] = None) -> Dict[str, Any]:
+    """Update latest plan status to published."""
+    plans = _list_plans(app=app)
+    if not plans:
+        return {"error": f"No deploy plans found for {app}"}
+    latest = plans[0]
+    now = datetime.now(timezone.utc).isoformat()
+    latest["status"] = "published"
+    latest["updated_at"] = now
+    latest["history"].append({"status": "published", "at": now})
+    (DEPLOY_DIR / f"{latest['plan_id']}.json").write_text(json.dumps(latest, indent=2))
+    return latest
+
+
+def verify(app: str, env: str, git_ref: Optional[str] = None) -> Dict[str, Any]:
+    """Verify deployment health (stub — returns plan status)."""
+    plans = _list_plans(app=app, env=env)
+    if not plans:
+        return {"app": app, "env": env, "status": "no_deploys", "healthy": False}
+    latest = plans[0]
+    return {
+        "app": app,
+        "env": env,
+        "plan_id": latest["plan_id"],
+        "status": latest["status"],
+        "healthy": latest["status"] in ("published", "planned"),
+        "message": "Health check is a stub — no real endpoint verification yet.",
+    }
+
+
+def rollback(app: str, env: str, to_sha: Optional[str] = None) -> Dict[str, Any]:
+    """Mark latest plan as rolled back."""
+    plans = _list_plans(app=app, env=env)
+    if not plans:
+        return {"error": f"No deploy plans found for {app} in {env}"}
+    latest = plans[0]
+    now = datetime.now(timezone.utc).isoformat()
+    latest["status"] = "rolled_back"
+    latest["updated_at"] = now
+    latest["rolled_back_to"] = to_sha
+    latest["history"].append({"status": "rolled_back", "at": now, "to_sha": to_sha})
+    (DEPLOY_DIR / f"{latest['plan_id']}.json").write_text(json.dumps(latest, indent=2))
+    return latest

package/gateway/ai/backends/gateway_core.py

@@ -0,0 +1,261 @@
+"""
+Backend bridge to delimit-gateway core engine.
+
+Adapter Boundary Contract v1.0:
+- Pure translation layer: no governance logic here
+- Deterministic error on failure (never swallow)
+- Zero state (stateless between calls)
+- No schema forking (gateway types are canonical)
+"""
+
+import sys
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("delimit.ai.gateway_core")
+
+# Add gateway root to path so we can import core modules
+GATEWAY_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(GATEWAY_ROOT) not in sys.path:
+    sys.path.insert(0, str(GATEWAY_ROOT))
+
+
+def _load_specs(spec_path: str) -> Dict[str, Any]:
+    """Load an OpenAPI spec from a file path."""
+    import json
+    import yaml
+
+    p = Path(spec_path)
+    if not p.exists():
+        raise FileNotFoundError(f"Spec file not found: {spec_path}")
+
+    content = p.read_text(encoding="utf-8")
+    if p.suffix in (".yaml", ".yml"):
+        return yaml.safe_load(content)
+    return json.loads(content)
+
+
+def run_lint(old_spec: str, new_spec: str, policy_file: Optional[str] = None) -> Dict[str, Any]:
+    """Run the full lint pipeline: diff + policy evaluation.
+
+    This is the Tier 1 primary tool — combines diff detection with
+    policy enforcement into a single pass/fail decision.
+    """
+    from core.policy_engine import evaluate_with_policy
+
+    old = _load_specs(old_spec)
+    new = _load_specs(new_spec)
+
+    return evaluate_with_policy(old, new, policy_file)
+
+
+def run_diff(old_spec: str, new_spec: str) -> Dict[str, Any]:
+    """Run diff engine only — no policy evaluation."""
+    from core.diff_engine_v2 import OpenAPIDiffEngine
+
+    old = _load_specs(old_spec)
+    new = _load_specs(new_spec)
+
+    engine = OpenAPIDiffEngine()
+    changes = engine.compare(old, new)
+
+    breaking = [c for c in changes if c.is_breaking]
+
+    return {
+        "total_changes": len(changes),
+        "breaking_changes": len(breaking),
+        "changes": [
+            {
+                "type": c.type.value,
+                "path": c.path,
+                "message": c.message,
+                "is_breaking": c.is_breaking,
+                "details": c.details,
+            }
+            for c in changes
+        ],
+    }
+
+
+def run_policy(spec_files: List[str], policy_file: Optional[str] = None) -> Dict[str, Any]:
+    """Evaluate specs against governance policy without diffing."""
+    from core.policy_engine import PolicyEngine
+
+    engine = PolicyEngine(policy_file)
+
+    return {
+        "rules_loaded": len(engine.rules),
+        "custom_rules": len(engine.custom_rules),
+        "policy_file": policy_file,
+        "template": engine.create_policy_template() if not policy_file else None,
+    }
+
+
+def query_ledger(
+    ledger_path: str,
+    api_name: Optional[str] = None,
+    repository: Optional[str] = None,
+    validate_chain: bool = False,
+) -> Dict[str, Any]:
+    """Query the contract ledger."""
+    from core.contract_ledger import ContractLedger
+
+    ledger = ContractLedger(ledger_path)
+
+    if not ledger.exists():
+        return {"error": "Ledger not found", "path": ledger_path}
+
+    result: Dict[str, Any] = {"path": ledger_path, "event_count": ledger.get_event_count()}
+
+    if validate_chain:
+        try:
+            ledger.validate_chain()
+            result["chain_valid"] = True
+        except Exception as e:
+            result["chain_valid"] = False
+            result["chain_error"] = str(e)
+
+    if api_name:
+        result["events"] = ledger.get_api_timeline(api_name)
+    elif repository:
+        result["events"] = ledger.get_events_by_repository(repository)
+    else:
+        latest = ledger.get_latest_event()
+        result["latest_event"] = latest
+
+    return result
+
+
+def run_impact(api_name: str, dependency_file: Optional[str] = None) -> Dict[str, Any]:
+    """Analyze downstream impact of an API change."""
+    from core.dependency_graph import DependencyGraph
+    from core.impact_analyzer import ImpactAnalyzer
+
+    graph = DependencyGraph()
+    if dependency_file:
+        graph.load_from_file(dependency_file)
+
+    analyzer = ImpactAnalyzer(graph)
+    return analyzer.analyze(api_name)
+
+
+def run_semver(
+    old_spec: str,
+    new_spec: str,
+    current_version: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Classify the semver bump for a spec change.
+
+    Returns detailed breakdown: bump level, per-category counts,
+    and optionally the bumped version string.
+    """
+    from core.diff_engine_v2 import OpenAPIDiffEngine
+    from core.semver_classifier import classify_detailed, bump_version, classify
+
+    old = _load_specs(old_spec)
+    new = _load_specs(new_spec)
+
+    engine = OpenAPIDiffEngine()
+    changes = engine.compare(old, new)
+    result = classify_detailed(changes)
+
+    if current_version:
+        bump = classify(changes)
+        result["current_version"] = current_version
+        result["next_version"] = bump_version(current_version, bump)
+
+    return result
+
+
+def run_explain(
+    old_spec: str,
+    new_spec: str,
+    template: str = "developer",
+    old_version: Optional[str] = None,
+    new_version: Optional[str] = None,
+    api_name: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Generate a human-readable explanation of API changes.
+
+    Supports 7 templates: developer, team_lead, product, migration,
+    changelog, pr_comment, slack.
+    """
+    from core.diff_engine_v2 import OpenAPIDiffEngine
+    from core.explainer import explain, TEMPLATES
+
+    old = _load_specs(old_spec)
+    new = _load_specs(new_spec)
+
+    engine = OpenAPIDiffEngine()
+    changes = engine.compare(old, new)
+
+    output = explain(
+        changes,
+        template=template,
+        old_version=old_version,
+        new_version=new_version,
+        api_name=api_name,
+    )
+
+    return {
+        "template": template,
+        "available_templates": TEMPLATES,
+        "output": output,
+    }
+
+
+def run_zero_spec(
+    project_dir: str = ".",
+    python_bin: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Detect framework and extract OpenAPI spec from source code.
+
+    Currently supports FastAPI. Returns the extracted spec or an error
+    with guidance on how to fix it.
+    """
+    from core.zero_spec.detector import detect_framework, Framework
+    from core.zero_spec.express_extractor import extract_express_spec
+    from core.zero_spec.fastapi_extractor import extract_fastapi_spec
+    from core.zero_spec.nestjs_extractor import extract_nestjs_spec
+
+    info = detect_framework(project_dir)
+
+    result: Dict[str, Any] = {
+        "framework": info.framework.value,
+        "confidence": info.confidence,
+        "message": info.message,
+    }
+
+    if info.framework == Framework.FASTAPI:
+        extraction = extract_fastapi_spec(
+            info, project_dir, python_bin=python_bin
+        )
+        result.update(extraction)
+        if extraction["success"] and info.app_locations:
+            loc = info.app_locations[0]
+            result["app_file"] = loc.file
+            result["app_variable"] = loc.variable
+            result["app_line"] = loc.line
+    elif info.framework == Framework.NESTJS:
+        extraction = extract_nestjs_spec(info, project_dir)
+        result.update(extraction)
+        if extraction["success"] and info.app_locations:
+            loc = info.app_locations[0]
+            result["app_file"] = loc.file
+            result["app_variable"] = loc.variable
+            result["app_line"] = loc.line
+    elif info.framework == Framework.EXPRESS:
+        extraction = extract_express_spec(info, project_dir)
+        result.update(extraction)
+        if extraction["success"] and info.app_locations:
+            loc = info.app_locations[0]
+            result["app_file"] = loc.file
+            result["app_variable"] = loc.variable
+            result["app_line"] = loc.line
+    else:
+        result["success"] = False
+        result["error"] = "No supported API framework found. Provide an OpenAPI spec file."
+        result["error_type"] = "no_framework"
+
+    return result