delimit-cli 2.4.0 → 3.0.1

package/gateway/ai/backends/generate_bridge.py

@@ -0,0 +1,38 @@
+"""
+Bridge to delimit-generator MCP server.
+Tier 3 Extended — code generation and project scaffolding.
+"""
+
+import sys
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("delimit.ai.generate_bridge")
+
+GEN_PACKAGE = Path("/home/delimit/.delimit_suite/packages/delimit-generator")
+
+
+def _ensure_gen_path():
+    if str(GEN_PACKAGE) not in sys.path:
+        sys.path.insert(0, str(GEN_PACKAGE))
+
+
+def template(template_type: str, name: str, framework: str = "nextjs", features: Optional[List[str]] = None) -> Dict[str, Any]:
+    """Generate code template."""
+    _ensure_gen_path()
+    try:
+        from run_mcp import generate_template
+        return generate_template(template_type=template_type, name=name, framework=framework, features=features or [])
+    except (ImportError, AttributeError) as e:
+        return {"tool": "gen.template", "template_type": template_type, "name": name, "framework": framework, "features": features or [], "note": str(e)}
+
+
+def scaffold(project_type: str, name: str, packages: Optional[List[str]] = None) -> Dict[str, Any]:
+    """Scaffold new project structure."""
+    _ensure_gen_path()
+    try:
+        from run_mcp import scaffold_project
+        return scaffold_project(project_type=project_type, name=name, packages=packages or [])
+    except (ImportError, AttributeError) as e:
+        return {"tool": "gen.scaffold", "project_type": project_type, "name": name, "packages": packages or [], "note": str(e)}

package/gateway/ai/backends/governance_bridge.py

@@ -0,0 +1,196 @@
+"""
+Bridge to governance tools.
+Tier 2 Platform — governance policy enforcement and task management.
+
+health/status/policy: implemented with real filesystem checks.
+evaluate/new_task/run/verify: require governancegate package (honest error if missing).
+"""
+
+import json
+import subprocess
+import sys
+import logging
+import yaml
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger("delimit.ai.governance_bridge")
+
+
+def health(repo: str = ".") -> Dict[str, Any]:
+    """Check governance system health with real filesystem checks."""
+    repo_path = Path(repo).resolve()
+    delimit_dir = repo_path / ".delimit"
+    policies_file = delimit_dir / "policies.yml"
+    ledger_file = delimit_dir / "ledger" / "events.jsonl"
+
+    checks = {}
+
+    # Check .delimit/ directory
+    checks["delimit_dir"] = delimit_dir.is_dir()
+
+    # Check policies.yml
+    checks["policies_file"] = policies_file.is_file()
+
+    # Check ledger
+    ledger_entries = 0
+    if ledger_file.is_file():
+        try:
+            ledger_entries = sum(1 for line in ledger_file.read_text().splitlines() if line.strip())
+        except Exception:
+            pass
+    checks["ledger_exists"] = ledger_file.is_file()
+    checks["ledger_entries"] = ledger_entries
+
+    # Check git cleanliness
+    git_clean = None
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True, text=True, timeout=5, cwd=str(repo_path)
+        )
+        if result.returncode == 0:
+            git_clean = len(result.stdout.strip()) == 0
+    except Exception:
+        pass
+    checks["git_clean"] = git_clean
+
+    # Determine overall health
+    if not checks["delimit_dir"]:
+        overall = "not_initialized"
+    elif not checks["policies_file"]:
+        overall = "degraded"
+    else:
+        overall = "healthy"
+
+    return {
+        "tool": "gov.health",
+        "repo": str(repo_path),
+        "status": overall,
+        "checks": checks,
+    }
+
+
+def status(repo: str = ".") -> Dict[str, Any]:
+    """Get governance status by reading actual policy files."""
+    repo_path = Path(repo).resolve()
+    policies_file = repo_path / ".delimit" / "policies.yml"
+    ledger_file = repo_path / ".delimit" / "ledger" / "events.jsonl"
+
+    rules = []
+    if policies_file.is_file():
+        try:
+            data = yaml.safe_load(policies_file.read_text())
+            if isinstance(data, dict):
+                for rule in data.get("rules", []):
+                    rules.append({
+                        "id": rule.get("id", "unknown"),
+                        "name": rule.get("name", ""),
+                        "severity": rule.get("severity", "warning"),
+                        "action": rule.get("action", "warn"),
+                    })
+        except Exception as e:
+            logger.warning("Failed to parse policies.yml: %s", e)
+
+    ledger_entries = 0
+    if ledger_file.is_file():
+        try:
+            ledger_entries = sum(1 for line in ledger_file.read_text().splitlines() if line.strip())
+        except Exception:
+            pass
+
+    return {
+        "tool": "gov.status",
+        "repo": str(repo_path),
+        "policies_file": str(policies_file) if policies_file.is_file() else None,
+        "active_rules": len(rules),
+        "rules": rules,
+        "ledger_entries": ledger_entries,
+    }
+
+
+def policy(repo: str = ".") -> Dict[str, Any]:
+    """Load and return the actual policies.yml content."""
+    repo_path = Path(repo).resolve()
+    policies_file = repo_path / ".delimit" / "policies.yml"
+
+    if not policies_file.is_file():
+        return {
+            "tool": "gov.policy",
+            "repo": str(repo_path),
+            "status": "no_policy",
+            "error": f"No policies.yml found at {policies_file}. Run: delimit init",
+        }
+
+    try:
+        raw = policies_file.read_text()
+        parsed = yaml.safe_load(raw)
+        return {
+            "tool": "gov.policy",
+            "repo": str(repo_path),
+            "policy": parsed,
+            "raw": raw,
+        }
+    except Exception as e:
+        return {
+            "tool": "gov.policy",
+            "repo": str(repo_path),
+            "status": "parse_error",
+            "error": f"Failed to parse policies.yml: {e}",
+        }
+
+
+def evaluate_trigger(action: str, context: Optional[Dict] = None, repo: str = ".") -> Dict[str, Any]:
+    """Evaluate if governance is required for an action."""
+    return {
+        "tool": "gov.evaluate",
+        "status": "not_available",
+        "error": "Governance evaluation engine not running. This tool requires the governancegate package.",
+        "action": action,
+        "repo": repo,
+    }
+
+
+def new_task(title: str, scope: str, risk_level: str = "medium", repo: str = ".") -> Dict[str, Any]:
+    """Create a new governance task."""
+    return {
+        "tool": "gov.new_task",
+        "status": "not_available",
+        "error": "Governance task engine not running. This tool requires the governancegate package.",
+    }
+
+
+def run_task(task_id: str, repo: str = ".") -> Dict[str, Any]:
+    """Run a governance task."""
+    return {
+        "tool": "gov.run",
+        "status": "not_available",
+        "error": "Governance task engine not running. This tool requires the governancegate package.",
+    }
+
+
+def verify(task_id: str, repo: str = ".") -> Dict[str, Any]:
+    """Verify a governance task."""
+    return {
+        "tool": "gov.verify",
+        "status": "not_available",
+        "error": "Governance task engine not running. This tool requires the governancegate package.",
+    }
+
+
+def evidence_index(task_id: str, repo: str = ".") -> Dict[str, Any]:
+    """Get evidence index for a task."""
+    return {
+        "tool": "gov.evidence_index",
+        "status": "not_available",
+        "error": "Governance evidence engine not running. This tool requires the governancegate package.",
+    }
+
+
+def require_owner_approval(context: str, repo: str = ".") -> Dict[str, Any]:
+    """Check if owner approval is required."""
+    return {
+        "tool": "gov.require_owner_approval",
+        "status": "not_available",
+        "error": "Governance approval engine not running. This tool requires the governancegate package.",
+    }

package/gateway/ai/backends/intel_bridge.py

@@ -0,0 +1,59 @@
+"""
+Bridge to delimit-intel (wireintel) MCP server.
+Tier 3 Extended — data intelligence and versioned datasets.
+"""
+
+import sys
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("delimit.ai.intel_bridge")
+
+INTEL_PACKAGE = Path("/home/delimit/.delimit_suite/packages/wireintel")
+
+
+def _ensure_intel_path():
+    for p in [str(INTEL_PACKAGE), str(INTEL_PACKAGE / "wireintel")]:
+        if p not in sys.path:
+            sys.path.insert(0, p)
+
+
+def dataset_register(name: str, schema: Dict[str, Any], description: Optional[str] = None) -> Dict[str, Any]:
+    """Register a new dataset with schema."""
+    return {"tool": "wireintel.dataset.register", "name": name, "schema": schema, "description": description}
+
+
+def dataset_list() -> Dict[str, Any]:
+    """List registered datasets."""
+    return {"tool": "wireintel.dataset.list"}
+
+
+def dataset_freeze(dataset_id: str) -> Dict[str, Any]:
+    """Mark dataset as immutable."""
+    return {"tool": "wireintel.dataset.freeze", "dataset_id": dataset_id}
+
+
+def dataset_version_create(dataset_id: str, data: Any) -> Dict[str, Any]:
+    """Create new version of dataset."""
+    return {"tool": "wireintel.dataset.version_create", "dataset_id": dataset_id}
+
+
+def dataset_get_version(dataset_id: str, version: Optional[str] = None) -> Dict[str, Any]:
+    """Get specific dataset version."""
+    return {"tool": "wireintel.dataset.get_version", "dataset_id": dataset_id, "version": version}
+
+
+def snapshot_ingest(data: Dict[str, Any], provenance: Optional[Dict] = None) -> Dict[str, Any]:
+    """Store research snapshot with provenance."""
+    return {"tool": "wireintel.snapshot.ingest", "data": data, "provenance": provenance}
+
+
+def snapshot_get(snapshot_id: str) -> Dict[str, Any]:
+    """Retrieve snapshot by ID."""
+    return {"tool": "wireintel.snapshot.get", "snapshot_id": snapshot_id}
+
+
+def query_run(dataset_id: str, query: str, parameters: Optional[Dict] = None) -> Dict[str, Any]:
+    """Execute deterministic query on dataset."""
+    return {"tool": "wireintel.query.run", "dataset_id": dataset_id, "query": query, "parameters": parameters}

package/gateway/ai/backends/memory_bridge.py

@@ -0,0 +1,93 @@
+"""
+Bridge to delimit-memory package.
+Tier 2 Platform tools — semantic memory search and store.
+"""
+
+import sys
+import json
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger("delimit.ai.memory_bridge")
+
+MEM_PACKAGE = Path("/home/delimit/.delimit_suite/packages/delimit-memory")
+
+_server = None
+
+
+def _run_async(coro):
+    """Run an async coroutine from sync code, handling nested event loops."""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        # We're inside an async context (e.g., FastMCP) — use a new thread
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            return pool.submit(asyncio.run, coro).result(timeout=30)
+    else:
+        return asyncio.run(coro)
+
+
+def _get_server():
+    global _server
+    if _server is not None:
+        return _server
+    pkg_path = str(MEM_PACKAGE / "delimit_memory")
+    if pkg_path not in sys.path:
+        sys.path.insert(0, pkg_path)
+    if str(MEM_PACKAGE) not in sys.path:
+        sys.path.insert(0, str(MEM_PACKAGE))
+    try:
+        from delimit_memory.server import DelimitMemoryServer
+        _server = DelimitMemoryServer()
+        _run_async(_server._initialize_engine())
+        return _server
+    except Exception as e:
+        logger.warning(f"Failed to init memory server: {e}")
+        return None
+
+
+def search(query: str, limit: int = 10) -> Dict[str, Any]:
+    """Semantic search across conversation memory."""
+    srv = _get_server()
+    if srv is None:
+        return {"error": "Memory server unavailable", "results": []}
+    try:
+        result = _run_async(srv._handle_search({"query": query, "limit": limit}))
+        return json.loads(result) if isinstance(result, str) else result
+    except Exception as e:
+        return {"error": f"Memory search failed: {e}", "results": []}
+
+
+def store(content: str, tags: Optional[list] = None, context: Optional[str] = None) -> Dict[str, Any]:
+    """Store a memory entry."""
+    srv = _get_server()
+    if srv is None:
+        return {"error": "Memory server unavailable"}
+    try:
+        args = {"content": content}
+        if tags:
+            args["tags"] = tags
+        if context:
+            args["context"] = context
+        result = _run_async(srv._handle_store(args))
+        return json.loads(result) if isinstance(result, str) else result
+    except Exception as e:
+        return {"error": f"Memory store failed: {e}"}
+
+
+def get_recent(limit: int = 5) -> Dict[str, Any]:
+    """Get recent work summary."""
+    srv = _get_server()
+    if srv is None:
+        return {"error": "Memory server unavailable", "results": []}
+    try:
+        result = _run_async(srv._handle_get_recent_work({"limit": limit}))
+        return json.loads(result) if isinstance(result, str) else result
+    except Exception as e:
+        return {"error": f"Recent work failed: {e}", "results": []}

package/gateway/ai/backends/ops_bridge.py

@@ -0,0 +1,137 @@
+"""
+Bridge to operational tools: releasepilot, costguard, datasteward, observabilityops.
+Governance primitives + internal OS layer.
+"""
+
+import sys
+import json
+import asyncio
+import logging
+import importlib
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from .async_utils import run_async
+
+logger = logging.getLogger("delimit.ai.ops_bridge")
+
+PACKAGES = Path("/home/delimit/.delimit_suite/packages")
+
+# Add PACKAGES dir so `from shared.base_server import BaseMCPServer` resolves
+_packages = str(PACKAGES)
+if _packages not in sys.path:
+    sys.path.insert(0, _packages)
+
+_servers = {}
+
+
+def _call(pkg: str, factory_name: str, method: str, args: Dict, tool_label: str) -> Dict[str, Any]:
+    try:
+        srv = _servers.get(pkg)
+        if srv is None:
+            mod = importlib.import_module(f"{pkg}.server")
+            factory = getattr(mod, factory_name)
+            srv = factory()
+            # Disable DSN requirement for observabilityops in bridge context
+            if pkg == "observabilityops" and hasattr(srv, "require_dsn_validation"):
+                srv.require_dsn_validation = False
+            _servers[pkg] = srv
+        fn = getattr(srv, method, None)
+        if fn is None:
+            return {"tool": tool_label, "status": "not_implemented", "error": f"Method {method} not found"}
+        result = run_async(fn(args, None))
+        return json.loads(result) if isinstance(result, str) else result
+    except Exception as e:
+        return {"tool": tool_label, "error": str(e)}
+
+
+# ─── ReleasePilot (Governance Primitive) ────────────────────────────────
+
+def release_plan(environment: str, version: str, repository: str, services: Optional[List[str]] = None) -> Dict[str, Any]:
+    return _call("releasepilot", "create_releasepilot_server", "_tool_plan",
+                 {"environment": environment, "version": version, "repository": repository, "services": services or []}, "release.plan")
+
+
+def release_validate(environment: str, version: str) -> Dict[str, Any]:
+    return _call("releasepilot", "create_releasepilot_server", "_tool_validate",
+                 {"environment": environment, "version": version}, "release.validate")
+
+
+def release_status(environment: str) -> Dict[str, Any]:
+    return _call("releasepilot", "create_releasepilot_server", "_tool_status",
+                 {"environment": environment}, "release.status")
+
+
+def release_rollback(environment: str, version: str, to_version: str) -> Dict[str, Any]:
+    return _call("releasepilot", "create_releasepilot_server", "_tool_rollback",
+                 {"environment": environment, "version": version, "to_version": to_version}, "release.rollback")
+
+
+def release_history(environment: str, limit: int = 10) -> Dict[str, Any]:
+    return _call("releasepilot", "create_releasepilot_server", "_tool_history",
+                 {"environment": environment, "limit": limit}, "release.history")
+
+
+# ─── CostGuard (Governance Primitive) ──────────────────────────────────
+
+def cost_analyze(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    result = _call("costguard", "create_costguard_server", "_tool_analyze",
+                   {"target": target, **(options or {})}, "cost.analyze")
+    # Guard against hardcoded fake AWS cost data from stub implementation
+    if result.get("total_cost") == 1247.83 or result.get("total_cost") == "1247.83":
+        return {"tool": "cost.analyze", "status": "not_configured",
+                "error": "No cloud provider configured. Cost analyzer returned placeholder data. Set cloud credentials to enable real cost analysis."}
+    return result
+
+
+def cost_optimize(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("costguard", "create_costguard_server", "_tool_optimize",
+                 {"target": target, **(options or {})}, "cost.optimize")
+
+
+def cost_alert(action: str = "list", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("costguard", "create_costguard_server", "_tool_alerts",
+                 {"action": action, **(options or {})}, "cost.alert")
+
+
+# ─── DataSteward (Governance Primitive) ────────────────────────────────
+
+def data_validate(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    result = _call("datasteward", "create_datasteward_server", "_tool_integrity_check",
+                   {"database_url": target, **(options or {})}, "data.validate")
+    # Guard against stub that returns "passed" with 0 tables checked
+    if result.get("tables_checked", -1) == 0 and result.get("integrity_status") == "passed":
+        return {"tool": "data.validate", "status": "not_configured",
+                "error": "No database configured for validation. Provide a database_url or configure a data source."}
+    return result
+
+
+def data_migrate(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("datasteward", "create_datasteward_server", "_tool_migration_status",
+                 {"database_url": target, **(options or {})}, "data.migrate")
+
+
+def data_backup(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("datasteward", "create_datasteward_server", "_tool_backup_plan",
+                 {"database_url": target, **(options or {})}, "data.backup")
+
+
+# ─── ObservabilityOps (Internal OS) ────────────────────────────────────
+
+def obs_metrics(query: str, time_range: str = "1h", source: Optional[str] = None) -> Dict[str, Any]:
+    return _call("observabilityops", "create_observabilityops_server", "_tool_metrics",
+                 {"query": query, "time_range": time_range, "source": source}, "obs.metrics")
+
+
+def obs_logs(query: str, time_range: str = "1h", source: Optional[str] = None) -> Dict[str, Any]:
+    return _call("observabilityops", "create_observabilityops_server", "_tool_logs",
+                 {"query": query, "time_range": time_range, "source": source}, "obs.logs")
+
+
+def obs_alerts(action: str, alert_rule: Optional[Dict] = None, rule_id: Optional[str] = None) -> Dict[str, Any]:
+    return _call("observabilityops", "create_observabilityops_server", "_tool_alerts",
+                 {"action": action, "alert_rule": alert_rule, "rule_id": rule_id}, "obs.alerts")
+
+
+def obs_status() -> Dict[str, Any]:
+    return _call("observabilityops", "create_observabilityops_server", "_tool_status",
+                 {}, "obs.status")

package/gateway/ai/backends/os_bridge.py

@@ -0,0 +1,82 @@
+"""
+Bridge to delimit-os MCP server.
+Tier 2 Platform tools — pass-through to the OS orchestration layer.
+
+These do NOT re-implement OS logic. They translate requests
+and forward to the running delimit-os server via direct import.
+"""
+
+import sys
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("delimit.ai.os_bridge")
+
+OS_PACKAGE = Path("/home/delimit/.delimit_suite/packages/delimit-os")
+
+
+def _ensure_os_path():
+    if str(OS_PACKAGE) not in sys.path:
+        sys.path.insert(0, str(OS_PACKAGE))
+
+
+def create_plan(operation: str, target: str, parameters: Optional[Dict] = None, require_approval: bool = True) -> Dict[str, Any]:
+    """Create an execution plan via delimit-os."""
+    _ensure_os_path()
+    try:
+        from server import PLANS
+        import uuid, time
+
+        plan_id = f"PLAN-{str(uuid.uuid4())[:8].upper()}"
+        risk_level = "LOW"
+        if any(x in operation.lower() for x in ["prod", "delete", "drop", "rm"]):
+            risk_level = "HIGH"
+        elif any(x in operation.lower() for x in ["deploy", "restart", "update"]):
+            risk_level = "MEDIUM"
+
+        plan = {
+            "plan_id": plan_id,
+            "operation": operation,
+            "target": target,
+            "parameters": parameters or {},
+            "risk_level": risk_level,
+            "status": "PENDING_APPROVAL" if require_approval else "READY",
+            "created_at": time.time(),
+        }
+        PLANS[plan_id] = plan
+        return plan
+    except ImportError:
+        return {"error": "delimit-os not available", "fallback": True}
+
+
+def get_status() -> Dict[str, Any]:
+    """Get current OS status."""
+    _ensure_os_path()
+    try:
+        from server import PLANS, TASKS, TOKENS
+        return {
+            "status": "operational",
+            "plans": len(PLANS),
+            "tasks": len(TASKS),
+            "tokens": len(TOKENS),
+        }
+    except ImportError:
+        return {"status": "unavailable", "error": "delimit-os not loaded"}
+
+
+def check_gates(plan_id: str) -> Dict[str, Any]:
+    """Check governance gates for a plan."""
+    _ensure_os_path()
+    try:
+        from server import PLANS
+        plan = PLANS.get(plan_id)
+        if not plan:
+            return {"error": f"Plan {plan_id} not found"}
+        return {
+            "plan_id": plan_id,
+            "gates_passed": plan.get("status") in ("READY", "APPROVED"),
+            "status": plan.get("status"),
+        }
+    except ImportError:
+        return {"error": "delimit-os not available"}