delimit-cli 3.14.28 → 3.14.29

package/gateway/ai/backends/ui_bridge.py

@@ -57,9 +57,90 @@ from .tools_design import (
 
 
 def story_build(project_path: str, output_dir: Optional[str] = None) -> Dict[str, Any]:
-    """Story build remains a stub — requires Storybook installed."""
-    return {"tool": "story.build", "project_path": project_path, "status": "not_available",
-            "message": "Storybook build requires Storybook installed. Run: npx storybook init"}
+    """Build Storybook static site.  Works if Storybook is installed; helpful guidance otherwise."""
+    import shutil as _shutil
+    import subprocess as _subprocess
+
+    root = Path(project_path)
+    # Quick check: does the project have a Storybook config?
+    has_storybook_config = any(
+        (root / d).is_dir() for d in (".storybook",)
+    )
+    has_storybook_dep = False
+    pkg_json = root / "package.json"
+    if pkg_json.exists():
+        try:
+            pkg = json.loads(pkg_json.read_text())
+            all_deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+            has_storybook_dep = any("storybook" in k for k in all_deps)
+        except Exception:
+            pass
+
+    # Check if npx storybook is available
+    npx = _shutil.which("npx")
+    if not npx:
+        return {
+            "tool": "story.build",
+            "project_path": project_path,
+            "status": "no_npx",
+            "message": (
+                "npx is not available. Install Node.js and npm first, then:\n"
+                "  1. cd {project_path}\n"
+                "  2. npx storybook@latest init\n"
+                "  3. npx storybook build"
+            ).format(project_path=project_path),
+        }
+
+    if not has_storybook_config and not has_storybook_dep:
+        return {
+            "tool": "story.build",
+            "project_path": project_path,
+            "status": "not_configured",
+            "message": (
+                "Storybook is not configured in this project. To set it up:\n"
+                "  1. cd {project_path}\n"
+                "  2. npx storybook@latest init\n"
+                "  3. npx storybook build\n\n"
+                "Alternatively, use `delimit_story_generate` to create story files "
+                "without installing Storybook."
+            ).format(project_path=project_path),
+        }
+
+    # Storybook is present -- attempt to build
+    cmd = ["npx", "storybook", "build"]
+    if output_dir:
+        cmd += ["-o", output_dir]
+    try:
+        result = _subprocess.run(
+            cmd, cwd=str(root), capture_output=True, timeout=120,
+        )
+        if result.returncode == 0:
+            out_dir = output_dir or str(root / "storybook-static")
+            return {
+                "tool": "story.build",
+                "status": "ok",
+                "project_path": project_path,
+                "output_dir": out_dir,
+                "message": f"Storybook built successfully to {out_dir}",
+            }
+        else:
+            stderr = result.stderr.decode(errors="replace")[:800]
+            return {
+                "tool": "story.build",
+                "status": "build_error",
+                "project_path": project_path,
+                "error": stderr,
+                "hint": "Ensure dependencies are installed (npm install) and Storybook config is valid.",
+            }
+    except _subprocess.TimeoutExpired:
+        return {
+            "tool": "story.build",
+            "status": "timeout",
+            "project_path": project_path,
+            "message": "Storybook build timed out after 120 seconds.",
+        }
+    except Exception as e:
+        return {"tool": "story.build", "status": "error", "error": str(e)}
 
 
 def story_accessibility_test(project_path: str, standards: str = "WCAG2AA") -> Dict[str, Any]:
@@ -70,16 +151,43 @@ def story_accessibility_test(project_path: str, standards: str = "WCAG2AA") -> D
 # ─── TestSmith (Real implementations — tools_real.py) ─────────────────
 
 def test_generate(project_path: str, source_files: Optional[List[str]] = None, framework: str = "jest") -> Dict[str, Any]:
+    """Generate test skeletons for source files using the specified framework."""
     from .tools_real import test_generate as _real_test_generate
     return _real_test_generate(project_path=project_path, source_files=source_files, framework=framework)
 
 
 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")
+    """Estimate test coverage by counting test vs source files and checking config."""
+    root = Path(project_path).resolve()
+    skip = {"node_modules", "dist", ".next", ".git", "__pycache__", "build", ".cache", "venv", ".venv"}
+    src_files, test_files = [], []
+    src_exts = {".py", ".js", ".ts", ".jsx", ".tsx"}
+    test_patterns = {"test_", "_test.", ".test.", ".spec.", "tests/", "test/", "__tests__/"}
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in skip]
+        for f in filenames:
+            fp = os.path.join(dirpath, f)
+            ext = os.path.splitext(f)[1]
+            if ext not in src_exts:
+                continue
+            if any(p in fp for p in test_patterns):
+                test_files.append(fp)
+            else:
+                src_files.append(fp)
+    ratio = (len(test_files) / max(len(src_files), 1)) * 100
+    # Check for coverage config
+    cov_configs = [c for c in ["jest.config.js", "jest.config.ts", ".nycrc", "pytest.ini",
+                                "pyproject.toml", "setup.cfg", ".coveragerc"] if (root / c).exists()]
+    meets_threshold = ratio >= threshold
+    return {"tool": "test.coverage", "status": "ok", "project_path": str(root),
+            "source_files": len(src_files), "test_files": len(test_files),
+            "estimated_coverage_ratio": round(ratio, 1), "threshold": threshold,
+            "meets_threshold": meets_threshold, "coverage_configs": cov_configs,
+            "note": "File-count estimate. Run test runner with --coverage for precise line coverage."}
 
 
 def test_smoke(project_path: str, test_suite: Optional[str] = None) -> Dict[str, Any]:
+    """Run smoke tests for the project using the detected test framework."""
     from .tools_real import test_smoke as _real_test_smoke
     return _real_test_smoke(project_path=project_path, test_suite=test_suite)
 
@@ -87,10 +195,12 @@ def test_smoke(project_path: str, test_suite: Optional[str] = None) -> Dict[str,
 # ─── DocsWeaver (Real implementations — tools_real.py) ────────────────
 
 def docs_generate(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    """Generate API documentation from source code docstrings and comments."""
     from .tools_real import docs_generate as _real_docs_generate
     return _real_docs_generate(target=target, options=options)
 
 
 def docs_validate(target: str = ".", options: Optional[Dict] = None) -> Dict[str, Any]:
+    """Validate documentation quality, coverage, and link integrity."""
     from .tools_real import docs_validate as _real_docs_validate
     return _real_docs_validate(target=target, options=options)

package/gateway/ai/backends/vault_bridge.py

@@ -1,130 +1,85 @@
 """
-Bridge to delimit-vault package.
-Tier 2 Platform tools — artifact and credential storage.
+Vault bridge — file-based artifact and snapshot storage.
+Stores vault entries as JSON files in ~/.delimit/vault/.
 """
 
-import os
-import sys
 import json
-import asyncio
+import hashlib
 import logging
 from pathlib import Path
-from typing import Any, Dict, Optional
-from .async_utils import run_async
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger("delimit.ai.vault_bridge")
 
-VAULT_PACKAGE = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "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)}
+VAULT_DIR = Path.home() / ".delimit" / "vault"
 
 
-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 _ensure_dir():
+    VAULT_DIR.mkdir(parents=True, exist_ok=True)
+    (VAULT_DIR / "snapshots").mkdir(exist_ok=True)
+    (VAULT_DIR / "entries").mkdir(exist_ok=True)
 
 
-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 search(query: str) -> Dict[str, Any]:
+    """Search vault entries by keyword."""
+    _ensure_dir()
+    query_lower = query.lower()
+    results = []
+
+    for f in sorted((VAULT_DIR / "entries").glob("*.json"), reverse=True):
+        try:
+            entry = json.loads(f.read_text())
+            content = json.dumps(entry).lower()
+            if query_lower in content:
+                results.append({
+                    "id": entry.get("id", f.stem),
+                    "title": entry.get("title", f.stem),
+                    "type": entry.get("type", "unknown"),
+                    "created_at": entry.get("created_at", ""),
+                    "preview": str(entry.get("content", ""))[:200],
+                })
+            if len(results) >= 10:
+                break
+        except Exception:
+            pass
+
+    return {"query": query, "results": results, "count": len(results)}
 
 
 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}"}
+    """Create a vault snapshot."""
+    _ensure_dir()
+    ts = datetime.now(timezone.utc)
+    snap_id = f"snap-{ts.strftime('%Y%m%d_%H%M%S')}"
+
+    snapshot_data = {
+        "id": snap_id,
+        "task_id": task_id,
+        "label": snap_id,
+        "created_at": ts.isoformat(),
+        "entries_count": len(list((VAULT_DIR / "entries").glob("*.json"))),
+    }
+
+    (VAULT_DIR / "snapshots" / f"{snap_id}.json").write_text(
+        json.dumps(snapshot_data, indent=2)
+    )
+
+    return {"snapshot_id": snap_id, "created_at": ts.isoformat()}
+
+
+def health() -> Dict[str, Any]:
+    """Check vault health."""
+    _ensure_dir()
+
+    entries_count = len(list((VAULT_DIR / "entries").glob("*.json")))
+    snapshots_count = len(list((VAULT_DIR / "snapshots").glob("*.json")))
+    total_size = sum(f.stat().st_size for f in VAULT_DIR.rglob("*") if f.is_file())
+
+    return {
+        "status": "healthy",
+        "entries": entries_count,
+        "snapshots": snapshots_count,
+        "total_size_bytes": total_size,
+        "vault_path": str(VAULT_DIR),
+    }