delimit-cli 2.4.0 → 3.0.0

package/gateway/ai/backends/repo_bridge.py

@@ -0,0 +1,117 @@
+"""
+Bridge to repo-level tools: repodoctor, configsentry, evidencepack, securitygate.
+Tier 3 Extended — repository health, config audit, evidence, security.
+"""
+
+import os
+import sys
+import json
+import asyncio
+import importlib
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from .async_utils import run_async
+
+logger = logging.getLogger("delimit.ai.repo_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()
+            # Some servers need async initialization (e.g. evidencepack)
+            init_fn = getattr(srv, "initialize", None)
+            if init_fn and asyncio.iscoroutinefunction(init_fn):
+                run_async(init_fn())
+            _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)}
+
+
+# ─── RepoDoctor ────────────────────────────────────────────────────────
+
+def diagnose(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("repodoctor", "create_repodoctor_server", "_tool_health_check",
+                 {"repository_path": target, **(options or {})}, "repo.diagnose")
+
+
+def analyze(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("repodoctor", "create_repodoctor_server", "_tool_snapshot",
+                 {"repository_path": target, **(options or {})}, "repo.analyze")
+
+
+# ─── ConfigSentry ───────────────────────────────────────────────────────
+
+def config_validate(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("configsentry", "create_configsentry_server", "_tool_validate",
+                 {"repository_path": target, **(options or {})}, "config.validate")
+
+
+def config_audit(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("configsentry", "create_configsentry_server", "_tool_env_audit",
+                 {"repository_path": target, **(options or {})}, "config.audit")
+
+
+# ─── EvidencePack ───────────────────────────────────────────────────────
+
+def evidence_collect(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    result = _call("evidencepack", "create_evidencepack_server", "_tool_list",
+                   {"limit": 20, **(options or {})}, "evidence.collect")
+    # Provide a clear message when no evidence bundles exist yet
+    if isinstance(result, dict) and result.get("total_bundles", -1) == 0:
+        result["message"] = (
+            "No evidence collected yet. Use evidence.begin to start a collection, "
+            "evidence.capture to add items, and evidence.finalize to create a bundle."
+        )
+    return result
+
+
+def evidence_verify(bundle_id: Optional[str] = None, bundle_path: Optional[str] = None, options: Optional[Dict] = None) -> Dict[str, Any]:
+    args = {**(options or {})}
+    if bundle_id:
+        args["bundle_id"] = bundle_id
+    if bundle_path:
+        args["bundle_path"] = bundle_path
+    if not bundle_id and not bundle_path:
+        return {"tool": "evidence.verify", "status": "no_input", "message": "Provide bundle_id or bundle_path to verify"}
+    return _call("evidencepack", "create_evidencepack_server", "_tool_validate",
+                 args, "evidence.verify")
+
+
+# ─── SecurityGate ───────────────────────────────────────────────────────
+
+_INTERNAL_TOKEN = os.environ.get("DELIMIT_INTERNAL_BRIDGE_TOKEN", "delimit-internal-bridge")
+
+
+def security_scan(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    result = _call("securitygate", "create_securitygate_server", "_tool_scan",
+                   {"target": target, "authorization_token": _INTERNAL_TOKEN, **(options or {})}, "security.scan")
+    # Guard against fabricated/hardcoded CVE data from stub implementations
+    vulns = result.get("vulnerabilities", [])
+    if vulns and any("CVE-2023-12345" in str(v.get("id", "")) for v in vulns):
+        return {"tool": "security.scan", "status": "not_available",
+                "error": "Security scanner returned placeholder data. Install a real vulnerability scanner."}
+    return result
+
+
+def security_audit(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("securitygate", "create_securitygate_server", "_tool_audit",
+                 {"target": target, "authorization_token": _INTERNAL_TOKEN, **(options or {})}, "security.audit")

package/gateway/ai/backends/ui_bridge.py

@@ -0,0 +1,118 @@
+"""
+Bridge to UI tooling: designsystem, storybook, testsmith, docsweaver.
+UI/DX tools for component development and testing.
+"""
+
+import sys
+import json
+import asyncio
+import importlib
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from .async_utils import run_async
+
+logger = logging.getLogger("delimit.ai.ui_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]:
+    """Call a _tool_* method on a BaseMCPServer-derived package."""
+    try:
+        srv = _servers.get(pkg)
+        if srv is None:
+            mod = importlib.import_module(f"{pkg}.server")
+            factory = getattr(mod, factory_name)
+            srv = factory()
+            _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)}
+
+
+# ─── DesignSystem (custom classes, no BaseMCPServer) ───────────────────
+# designsystem uses DesignSystemGenerator, not the _tool_* pattern.
+# Provide graceful pass-through until refactored.
+
+def design_validate_responsive(project_path: str, check_types: Optional[List[str]] = None) -> Dict[str, Any]:
+    return {"tool": "design.validate_responsive", "project_path": project_path, "status": "pass-through"}
+
+
+def design_extract_tokens(figma_file_key: str, token_types: Optional[List[str]] = None) -> Dict[str, Any]:
+    return {"tool": "design.extract_tokens", "figma_file_key": figma_file_key, "status": "pass-through"}
+
+
+def design_generate_component(component_name: str, figma_node_id: Optional[str] = None, output_path: Optional[str] = None) -> Dict[str, Any]:
+    return {"tool": "design.generate_component", "component_name": component_name, "status": "pass-through"}
+
+
+def design_generate_tailwind(figma_file_key: str, output_path: Optional[str] = None) -> Dict[str, Any]:
+    return {"tool": "design.generate_tailwind", "figma_file_key": figma_file_key, "status": "pass-through"}
+
+
+def design_component_library(project_path: str, output_format: str = "json") -> Dict[str, Any]:
+    return {"tool": "design.component_library", "project_path": project_path, "status": "pass-through"}
+
+
+# ─── Storybook (custom classes, no BaseMCPServer) ─────────────────────
+
+def story_generate(component_path: str, story_name: Optional[str] = None, variants: Optional[List[str]] = None) -> Dict[str, Any]:
+    return {"tool": "story.generate", "component_path": component_path, "status": "pass-through"}
+
+
+def story_visual_test(url: str, project_path: Optional[str] = None, threshold: float = 0.05) -> Dict[str, Any]:
+    return {"tool": "story.visual_test", "url": url, "status": "pass-through"}
+
+
+def story_build(project_path: str, output_dir: Optional[str] = None) -> Dict[str, Any]:
+    return {"tool": "story.build", "project_path": project_path, "status": "pass-through"}
+
+
+def story_accessibility_test(project_path: str, standards: str = "WCAG2AA") -> Dict[str, Any]:
+    return {"tool": "story.accessibility_test", "project_path": project_path, "status": "pass-through"}
+
+
+# ─── TestSmith (BaseMCPServer pattern) ─────────────────────────────────
+
+def test_generate(project_path: str, source_files: Optional[List[str]] = None, framework: str = "jest") -> Dict[str, Any]:
+    return _call("testsmith", "create_testsmith_server", "_tool_generate",
+                 {"project_path": project_path, "source_files": source_files, "framework": framework}, "test.generate")
+
+
+def test_coverage(project_path: str, threshold: int = 80) -> Dict[str, Any]:
+    return _call("testsmith", "create_testsmith_server", "_tool_coverage",
+                 {"project_path": project_path, "threshold": threshold}, "test.coverage")
+
+
+def test_smoke(project_path: str, test_suite: Optional[str] = None) -> Dict[str, Any]:
+    result = _call("testsmith", "create_testsmith_server", "_tool_smoke",
+                   {"project_path": project_path}, "test.smoke")
+    # Guard against stub that says "passed" with 0 tests actually run
+    if result.get("tests_run", -1) == 0 and result.get("passed") is True:
+        return {"tool": "test.smoke", "status": "no_tests",
+                "error": "No smoke tests configured. The test runner found 0 tests to execute."}
+    return result
+
+
+# ─── DocsWeaver (BaseMCPServer pattern) ────────────────────────────────
+
+def docs_generate(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("docsweaver", "create_docsweaver_server", "_tool_generate",
+                 {"project_path": target, "doc_types": ["api", "readme"], **(options or {})}, "docs.generate")
+
+
+def docs_validate(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    return _call("docsweaver", "create_docsweaver_server", "_tool_validate",
+                 {"docs_path": target, **(options or {})}, "docs.validate")

package/gateway/ai/backends/vault_bridge.py

@@ -0,0 +1,129 @@
+"""
+Bridge to delimit-vault package.
+Tier 2 Platform tools — artifact and credential storage.
+"""
+
+import sys
+import json
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+from .async_utils import run_async
+
+logger = logging.getLogger("delimit.ai.vault_bridge")
+
+VAULT_PACKAGE = Path("/home/delimit/.delimit_suite/packages/delimit-vault")
+
+_server = None
+
+
+def _get_server():
+    """Return the vault server instance (lazy — no async init here).
+
+    The Qdrant client uses aiohttp which is bound to the event loop it was
+    created on.  ``run_async`` creates a *new* loop per call, so we must NOT
+    call ``_initialize_clients()`` here.  Instead each bridge method calls
+    ``_ensure_initialized()`` inside the *same* ``run_async`` invocation that
+    performs the actual operation, keeping the aiohttp session alive for the
+    duration of the request.
+    """
+    global _server
+    if _server is not None:
+        return _server
+    pkg_path = str(VAULT_PACKAGE / "delimit_vault_mcp")
+    if pkg_path not in sys.path:
+        sys.path.insert(0, pkg_path)
+    if str(VAULT_PACKAGE) not in sys.path:
+        sys.path.insert(0, str(VAULT_PACKAGE))
+    try:
+        from delimit_vault_mcp.server import DelimitVaultServer
+        _server = DelimitVaultServer()
+        return _server
+    except Exception as e:
+        logger.warning(f"Failed to init vault server: {e}")
+        return None
+
+
+async def _ensure_initialized(srv):
+    """(Re-)initialize Qdrant client on the *current* event loop.
+
+    Because ``run_async`` may create a fresh event loop for each bridge call,
+    the previous aiohttp session becomes invalid.  We unconditionally
+    re-initialize to bind the session to the current loop.
+    """
+    await srv._initialize_clients()
+
+
+def _extract_text(result) -> Dict[str, Any]:
+    """Extract text from MCP TextContent objects or raw results."""
+    if isinstance(result, str):
+        try:
+            return json.loads(result)
+        except json.JSONDecodeError:
+            return {"result": result}
+    if isinstance(result, dict):
+        return result
+    if isinstance(result, list):
+        # Handle list of TextContent objects
+        texts = []
+        for item in result:
+            if hasattr(item, "text"):
+                try:
+                    texts.append(json.loads(item.text))
+                except (json.JSONDecodeError, TypeError):
+                    texts.append({"text": str(item.text)})
+            else:
+                texts.append(str(item))
+        return texts[0] if len(texts) == 1 else {"results": texts}
+    if hasattr(result, "text"):
+        try:
+            return json.loads(result.text)
+        except (json.JSONDecodeError, TypeError):
+            return {"text": str(result.text)}
+    return {"result": str(result)}
+
+
+def search(query: str) -> Dict[str, Any]:
+    """Search vault entries."""
+    srv = _get_server()
+    if srv is None:
+        return {"error": "Vault server unavailable", "results": []}
+    try:
+        async def _do():
+            await _ensure_initialized(srv)
+            return await srv._handle_search({"query": query})
+        result = run_async(_do())
+        return _extract_text(result)
+    except Exception as e:
+        return {"error": f"Vault search failed: {e}", "results": []}
+
+
+def health() -> Dict[str, Any]:
+    """Check vault health."""
+    srv = _get_server()
+    if srv is None:
+        return {"status": "unavailable", "error": "Vault server not initialized"}
+    try:
+        async def _do():
+            await _ensure_initialized(srv)
+            return await srv._handle_health()
+        result = run_async(_do())
+        return _extract_text(result)
+    except Exception as e:
+        return {"status": "unavailable", "error": str(e)}
+
+
+def snapshot(task_id: str = "vault-snapshot") -> Dict[str, Any]:
+    """Get vault snapshot."""
+    srv = _get_server()
+    if srv is None:
+        return {"error": "Vault server unavailable"}
+    try:
+        async def _do():
+            await _ensure_initialized(srv)
+            return await srv._handle_snapshot({"task_id": task_id})
+        result = run_async(_do())
+        return _extract_text(result)
+    except Exception as e:
+        return {"error": f"Vault snapshot failed: {e}"}