contextsynapse 1.0.0__py3-none-any.whl

contextsynapse/api/playground_conn.py

@@ -0,0 +1,116 @@
+"""
+PlaygroundConn — Shared connection wrapper for playground simulation endpoints.
+
+Bridges the gap between the ToolContext interface (used by MCP tools) and the
+graph registry. Resolves tenant-scoped namespaces to bare graph names, loads
+graphs from disk, and proxies query/build_context/get_edges/get_node calls.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class PlaygroundConn:
+    """Connection wrapper that MCP tools can use via ToolContext.conn."""
+
+    def __init__(self, namespace: str, registry):
+        self.namespace = namespace
+        self._namespace = namespace  # context tools use _namespace
+        self.graph_registry = registry
+        self._graph_registry = registry  # context tools use _graph_registry
+
+        # Resolve graph: try scoped name, then bare name after ":"
+        self.db = None
+        self._resolved_ns = namespace
+        if namespace and registry:
+            self.db = registry.get_graph(namespace, load_if_missing=True)
+            if self.db is None and ":" in namespace:
+                bare = namespace.split(":", 1)[1]
+                self.db = registry.get_graph(bare, load_if_missing=True)
+                if self.db:
+                    self._resolved_ns = bare
+            if self.db is None:
+                self.db = registry.get_graph_for_request(namespace)
+
+        self.executor = None
+        try:
+            from ..aiql import AIQLExecutor
+            self.executor = AIQLExecutor(contextcore=self.db, graph_registry=registry)
+            if self._resolved_ns:
+                self.executor.active_namespace = self._resolved_ns
+        except Exception:
+            pass
+
+    def get_graph(self):
+        return self.db
+
+    def query(self, q: str):
+        if self.executor:
+            return self.executor.execute(q)
+        raise RuntimeError("No executor available — select a graph first")
+
+    def build_context(self, **kwargs):
+        if self.executor:
+            return self.executor.build_context(**kwargs)
+        raise RuntimeError("No executor available")
+
+    def get_edges(self, label: Optional[str] = None):
+        if self.db and hasattr(self.db, "get_all_edges"):
+            edges = self.db.get_all_edges()
+            if label:
+                edges = [e for e in edges if getattr(e, "label", "") == label]
+            return edges
+        return []
+
+    def get_node(self, node_id: str):
+        if self.db and hasattr(self.db, "get_node"):
+            return self.db.get_node(node_id)
+        return None
+
+    def get_nodes(self, label: str = None, where: dict = None):
+        """Return nodes from the graph, optionally filtered by label and properties.
+
+        Required by ProjectGraph.__init__ to find/create the Project node.
+        """
+        if not self.db or not hasattr(self.db, "get_all_nodes"):
+            return []
+        nodes = self.db.get_all_nodes()
+        if label:
+            nodes = [n for n in nodes if getattr(n, "label", "") == label]
+        if where:
+            filtered = []
+            for n in nodes:
+                props = getattr(n, "properties", {}) or {}
+                if all(props.get(k) == v for k, v in where.items()):
+                    filtered.append(n)
+            nodes = filtered
+        return nodes
+
+    def add_edge(self, source_id: str, target_id: str, label: str, properties: dict = None):
+        """Add an edge between two nodes. Required by ProjectGraph."""
+        if self.executor:
+            if properties:
+                props_str = ", ".join(f'{k}: "{v}"' for k, v in properties.items())
+                self.executor.execute(
+                    f'CREATE EDGE {label} FROM "{source_id}" TO "{target_id}" {{{props_str}}}'
+                )
+            else:
+                self.executor.execute(
+                    f'CREATE EDGE {label} FROM "{source_id}" TO "{target_id}"'
+                )
+
+
+def create_tool_context(conn: PlaygroundConn, agent_id: str, agent_name: str):
+    """Create a ToolContext with all required attributes for playground tools."""
+    from ..tools.registry import ToolContext
+    ctx = ToolContext(
+        conn=conn,
+        agent_id=agent_id,
+        agent_name=agent_name,
+    )
+    ctx.db = conn.db  # intelligence tools use ctx.db
+    return ctx

contextsynapse/api/projects_router.py

@@ -0,0 +1,131 @@
+"""
+Projects Router
+=================
+REST API for SDLC context projects. Each project is one namespace with
+typed SDLC nodes. Delegates to ProjectContext.
+"""
+import logging
+from typing import Any, Dict, List
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+try:
+    from ..project.code_context import CodeContext
+except Exception:
+    CodeContext = None  # type: ignore
+
+
+class CreateProjectRequest(BaseModel):
+    name: str
+
+
+def create_projects_router(user_auth=None, base_path: str = "contextcore_data") -> APIRouter:
+    """Create the /dashboard/projects router."""
+    from ..project.project_context import ProjectContext
+
+    router = APIRouter(prefix="/dashboard/projects", tags=["Projects"])
+
+    def _load(name: str) -> ProjectContext:
+        try:
+            return ProjectContext.load(name, base_path=base_path)
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail=str(exc))
+
+    def _list_project_names() -> List[str]:
+        return ProjectContext.list_names(base_path=base_path)
+
+    # ── CRUD ─────────────────────────────────────────────────────────────────
+
+    @router.post("", status_code=201)
+    async def create_project(req: CreateProjectRequest) -> Dict[str, Any]:
+        """Create (or open) a project namespace."""
+        pc = ProjectContext.create(req.name, base_path=base_path)
+        return {"name": pc.name, "status": "created"}
+
+    @router.get("")
+    async def list_projects() -> List[Dict[str, str]]:
+        """List all project namespaces."""
+        return [{"name": name} for name in sorted(_list_project_names())]
+
+    @router.get("/{name}")
+    async def get_project(name: str) -> Dict[str, Any]:
+        """Project overview including coverage scores."""
+        pc = _load(name)
+        return {"name": pc.name, "coverage": pc.coverage_score()}
+
+    # ── SDLC endpoints ───────────────────────────────────────────────────────
+
+    @router.get("/{name}/coverage")
+    async def get_coverage(name: str) -> Dict[str, Any]:
+        """Per-layer SDLC coverage scores."""
+        return _load(name).coverage_score()
+
+    @router.get("/{name}/stale")
+    async def get_stale(name: str) -> List[Dict[str, Any]]:
+        """All stale SDLC nodes in the project namespace."""
+        return _load(name).stale_report()
+
+    @router.get("/{name}/brief")
+    async def get_brief(
+        name: str,
+        topic: str = Query(default=""),
+        phase: str = Query(default=""),
+    ) -> Dict[str, Any]:
+        """Scoped context package for an agent about to work."""
+        return _load(name).agent_brief(topic=topic, phase=phase)
+
+    @router.get("/{name}/timeline")
+    async def get_timeline(
+        name: str,
+        limit: int = Query(default=50, ge=1, le=500),
+    ) -> List[Dict[str, Any]]:
+        """Recent graph changes in the project namespace."""
+        pc = _load(name)
+        try:
+            from ..core.time_travel import GraphTimeTraveler
+            tt = GraphTimeTraveler(pc.db)
+            events = tt.get_graph_timeline(limit=limit)
+            return events if isinstance(events, list) else []
+        except Exception:
+            return []
+
+    # ── Spec / Requirements ──────────────────────────────────
+
+    def _get_cc(name: str):
+        """Load a CodeContext by name."""
+        return CodeContext.load(name)
+
+    @router.post("/{name}/spec/ingest")
+    async def ingest_spec(name: str):
+        """Parse the project spec into Requirement/Feature/Constraint graph nodes."""
+        cc = _get_cc(name)
+        spec_text = cc.ns.get_metadata("spec") or ""
+        try:
+            ids = cc.ingest_spec(spec_text)
+            return {"ingested": ids, "count": len(ids)}
+        except Exception as e:
+            raise HTTPException(500, f"Spec ingestion failed: {e}")
+
+    @router.get("/{name}/spec/requirements")
+    async def get_requirements(name: str):
+        """Return all Requirement/Feature/Constraint nodes for the project."""
+        cc = _get_cc(name)
+        try:
+            nodes = cc.get_requirements()
+            return {"nodes": nodes, "total": len(nodes)}
+        except Exception as e:
+            raise HTTPException(500, f"Failed to load requirements: {e}")
+
+    @router.get("/{name}/spec/coverage")
+    async def get_coverage_spec(name: str):
+        """Return traceability coverage for the project's requirements."""
+        cc = _get_cc(name)
+        try:
+            return cc.check_coverage()
+        except Exception as e:
+            raise HTTPException(500, f"Coverage check failed: {e}")
+
+    return router

contextsynapse/api/queries_router.py

@@ -0,0 +1,282 @@
+"""
+Queries Router
+==============
+AIQL query execution, saved queries, and query history.
+
+POST   /dashboard/query/execute       — Execute AIQL query
+GET    /dashboard/queries/saved        — List saved queries
+POST   /dashboard/queries/saved        — Save a query
+DELETE /dashboard/queries/saved/{id}   — Delete saved query
+GET    /dashboard/queries/history      — Query execution history
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import secrets
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from .models import paginate
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Request models
+# ---------------------------------------------------------------------------
+
+class ExecuteQueryRequest(BaseModel):
+    query: str = Field(..., min_length=1, description="AIQL query")
+    graph: Optional[str] = Field(None, description="Target graph name")
+
+
+class SaveQueryRequest(BaseModel):
+    name: str = Field(..., min_length=1, max_length=100)
+    query: str = Field(..., min_length=1)
+    description: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Router factory
+# ---------------------------------------------------------------------------
+
+def create_queries_router(
+    user_registry,
+    tenant_registry,
+    graph_registry,
+    usage_meter=None,
+) -> APIRouter:
+    """Create the /dashboard/query and /dashboard/queries routers."""
+
+    from .auth import UserAuth
+    from ..aiql.engine import AIQLExecutor
+
+    router = APIRouter(tags=["queries"])
+    user_auth = UserAuth(user_registry)
+
+    def _get_tenant(user):
+        tenant_id = user_registry.get_primary_tenant_id(user.user_id)
+        if not tenant_id:
+            raise HTTPException(status_code=404, detail="No workspace found")
+        tenant = tenant_registry.get(tenant_id)
+        if not tenant:
+            raise HTTPException(status_code=404, detail="Workspace not found")
+        return tenant
+
+    # ------------------------------------------------------------------
+    # POST /dashboard/query/execute
+    # ------------------------------------------------------------------
+    @router.post("/dashboard/query/execute")
+    async def execute_query(req: ExecuteQueryRequest, user=Depends(user_auth)):
+        tenant = _get_tenant(user)
+
+        try:
+            executor = AIQLExecutor(graph_registry=graph_registry)
+
+            # Scope to tenant's graph if specified
+            if req.graph:
+                scoped_name = f"{tenant.tenant_id}:{req.graph}"
+                try:
+                    executor.execute(f"USE GRAPH {scoped_name}")
+                except Exception:
+                    # Try without namespace prefix
+                    executor.execute(f"USE GRAPH {req.graph}")
+
+            start = time.time()
+            result = executor.execute(req.query)
+            duration_ms = int((time.time() - start) * 1000)
+
+            # Record in metering
+            if usage_meter:
+                try:
+                    usage_meter.record(tenant.tenant_id, "query")
+                except Exception:
+                    pass
+
+            # Record in query history
+            _record_history(tenant.tenant_id, user.user_id, req.query, duration_ms, "success")
+
+            # Normalize result for frontend
+            if isinstance(result, list):
+                data = result
+            elif isinstance(result, dict):
+                data = result
+            else:
+                data = str(result)
+
+            # Also return graph nodes/edges for visualization
+            nodes_out = []
+            edges_out = []
+            try:
+                scoped_name = f"{tenant.tenant_id}:{req.graph}" if req.graph else None
+                graph = graph_registry.get_graph(scoped_name) if scoped_name else None
+                if not graph and req.graph:
+                    graph = graph_registry.get_graph(req.graph)
+                if graph:
+                    for n in graph.get_all_nodes():
+                        nodes_out.append({
+                            "id": n.id, "label": n.label,
+                            "name": n.name or (n.properties or {}).get("name", ""),
+                            "properties": n.properties or {},
+                        })
+                    for e in graph.get_all_edges():
+                        edges_out.append({
+                            "id": e.id, "source": e.source, "target": e.target,
+                            "label": e.label, "properties": e.properties or {},
+                        })
+            except Exception:
+                pass
+
+            return {
+                "data": data,
+                "query": req.query,
+                "duration_ms": duration_ms,
+                "row_count": len(data) if isinstance(data, list) else None,
+                "nodes": nodes_out,
+                "edges": edges_out,
+            }
+
+        except Exception as e:
+            _record_history(tenant.tenant_id, user.user_id, req.query, 0, "error", str(e))
+            raise HTTPException(status_code=400, detail=str(e))
+
+    # ------------------------------------------------------------------
+    # Saved queries — stored in user_registry's DB
+    # ------------------------------------------------------------------
+
+    @router.get("/dashboard/queries/saved")
+    async def list_saved(
+        limit: int = Query(50, ge=1, le=500),
+        offset: int = Query(0, ge=0),
+        user=Depends(user_auth),
+    ):
+        tenant = _get_tenant(user)
+        queries = _get_saved_queries(tenant.tenant_id, user.user_id)
+        page = paginate(queries, limit, offset)
+        return {"queries": page["items"], "total": page["total"], "limit": page["limit"], "offset": page["offset"]}
+
+    @router.post("/dashboard/queries/saved")
+    async def save_query(req: SaveQueryRequest, user=Depends(user_auth)):
+        tenant = _get_tenant(user)
+        query_id = secrets.token_hex(12)
+        now = datetime.now(timezone.utc).isoformat()
+        _insert_saved_query(query_id, tenant.tenant_id, user.user_id, req.name, req.query, req.description, now)
+        return {"query_id": query_id, "message": "Query saved"}
+
+    @router.delete("/dashboard/queries/saved/{query_id}")
+    async def delete_saved(query_id: str, user=Depends(user_auth)):
+        tenant = _get_tenant(user)
+        _delete_saved_query(query_id, tenant.tenant_id)
+        return {"message": "Query deleted"}
+
+    # ------------------------------------------------------------------
+    # Query history
+    # ------------------------------------------------------------------
+
+    @router.get("/dashboard/queries/history")
+    async def get_history(
+        limit: int = Query(50, ge=1, le=500),
+        offset: int = Query(0, ge=0),
+        user=Depends(user_auth),
+    ):
+        tenant = _get_tenant(user)
+        history = _get_query_history(tenant.tenant_id, user.user_id)
+        page = paginate(history, limit, offset)
+        return {"history": page["items"], "total": page["total"], "limit": page["limit"], "offset": page["offset"]}
+
+    # ------------------------------------------------------------------
+    # SQLite helpers (reuse user_registry's DB connection pattern)
+    # ------------------------------------------------------------------
+    import sqlite3
+    from pathlib import Path
+
+    _db_path = Path(__file__).resolve().parents[2] / "contextcore_data" / "queries.db"
+    _db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _get_conn():
+        conn = sqlite3.connect(str(_db_path))
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA journal_mode=WAL")
+        return conn
+
+    # Init tables
+    with _get_conn() as conn:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS saved_queries (
+                query_id TEXT PRIMARY KEY,
+                tenant_id TEXT NOT NULL,
+                user_id TEXT NOT NULL,
+                name TEXT NOT NULL,
+                query TEXT NOT NULL,
+                description TEXT,
+                created_at TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_saved_queries_tenant
+                ON saved_queries(tenant_id, user_id);
+
+            CREATE TABLE IF NOT EXISTS query_history (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                tenant_id TEXT NOT NULL,
+                user_id TEXT NOT NULL,
+                query TEXT NOT NULL,
+                duration_ms INTEGER DEFAULT 0,
+                status TEXT DEFAULT 'success',
+                error TEXT,
+                timestamp TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_query_history_tenant
+                ON query_history(tenant_id, user_id);
+        """)
+
+    def _get_saved_queries(tenant_id, user_id):
+        with _get_conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM saved_queries WHERE tenant_id = ? AND user_id = ? ORDER BY created_at DESC",
+                (tenant_id, user_id),
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+    def _insert_saved_query(query_id, tenant_id, user_id, name, query, description, created_at):
+        with _get_conn() as conn:
+            conn.execute(
+                "INSERT INTO saved_queries (query_id, tenant_id, user_id, name, query, description, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (query_id, tenant_id, user_id, name, query, description, created_at),
+            )
+
+    def _delete_saved_query(query_id, tenant_id):
+        with _get_conn() as conn:
+            conn.execute("DELETE FROM saved_queries WHERE query_id = ? AND tenant_id = ?", (query_id, tenant_id))
+
+    def _record_history(tenant_id, user_id, query, duration_ms, status, error=None):
+        try:
+            now = datetime.now(timezone.utc).isoformat()
+            with _get_conn() as conn:
+                conn.execute(
+                    "INSERT INTO query_history (tenant_id, user_id, query, duration_ms, status, error, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                    (tenant_id, user_id, query, duration_ms, status, error, now),
+                )
+                # Keep only last 100 entries per user
+                conn.execute(
+                    """DELETE FROM query_history WHERE id NOT IN (
+                        SELECT id FROM query_history WHERE tenant_id = ? AND user_id = ?
+                        ORDER BY timestamp DESC LIMIT 100
+                    ) AND tenant_id = ? AND user_id = ?""",
+                    (tenant_id, user_id, tenant_id, user_id),
+                )
+        except Exception:
+            pass
+
+    def _get_query_history(tenant_id, user_id):
+        with _get_conn() as conn:
+            rows = conn.execute(
+                "SELECT query, duration_ms, status, error, timestamp FROM query_history WHERE tenant_id = ? AND user_id = ? ORDER BY timestamp DESC LIMIT 20",
+                (tenant_id, user_id),
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+    return router

contextsynapse/api/quota.py

@@ -0,0 +1,95 @@
+"""
+Quota Enforcer
+==============
+FastAPI dependency that checks tenant usage against plan limits before
+allowing resource creation.
+
+Usage::
+
+    quota = QuotaEnforcer(billing_manager, usage_meter)
+
+    @app.post("/graphs")
+    async def create_graph(..., _=Depends(quota.check_graphs(tenant))):
+        ...
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from fastapi import HTTPException
+
+logger = logging.getLogger(__name__)
+
+
+class QuotaEnforcer:
+    """Checks current usage against plan limits and raises 429 if over quota."""
+
+    def __init__(self, billing_manager, usage_meter):
+        self._billing = billing_manager
+        self._meter = usage_meter
+
+    def check(self, tenant_id: str, resource: str, current_count: int = 0) -> None:
+        """
+        Check if tenant is within quota for a given resource.
+
+        Args:
+            tenant_id: The tenant to check.
+            resource: One of 'graphs', 'api_calls', 'agents', 'nodes'.
+            current_count: Current count of the resource (for graphs/agents/nodes).
+
+        Raises:
+            HTTPException 429 if over quota.
+        """
+        limits = self._billing.get_limits(tenant_id)
+
+        limit_map = {
+            "graphs": "max_graphs",
+            "api_calls": "max_api_calls",
+            "agents": "max_agents",
+            "nodes": "max_nodes",
+        }
+
+        limit_key = limit_map.get(resource)
+        if not limit_key:
+            return  # unknown resource, allow
+
+        max_val = limits.get(limit_key, -1)
+        if max_val == -1:
+            return  # unlimited
+
+        # For api_calls, check monthly usage
+        if resource == "api_calls":
+            usage = self._meter.get_summary(tenant_id)
+            current_count = usage.get("api_call", 0)
+
+        if current_count >= max_val:
+            plan = limits.get("plan", "free")
+            raise HTTPException(
+                status_code=429,
+                detail={
+                    "error": "quota_exceeded",
+                    "resource": resource,
+                    "current": current_count,
+                    "limit": max_val,
+                    "plan": plan,
+                    "message": f"You've reached the {resource} limit ({max_val}) on the {plan} plan. "
+                               f"Upgrade your plan to increase limits.",
+                },
+            )
+
+    def check_feature(self, tenant_id: str, feature: str) -> None:
+        """Check if tenant's plan includes a feature. Raises 403 if not."""
+        if not self._billing.has_feature(tenant_id, feature):
+            plan = self._billing.get_or_create(tenant_id).plan
+            raise HTTPException(
+                status_code=403,
+                detail={
+                    "error": "feature_not_available",
+                    "feature": feature,
+                    "plan": plan,
+                    "message": f"The '{feature}' feature is not available on the {plan} plan. "
+                               f"Upgrade to access this feature.",
+                },
+            )

contextsynapse/api/rate_limit.py

@@ -0,0 +1,64 @@
+"""
+Rate Limiting
+=============
+Per-tenant rate limiting using slowapi.  Reads ``rate_limit_rpm`` from the
+tenant's config dict (default: 60 req/min).
+
+Usage::
+
+    from .rate_limit import install_rate_limiter
+
+    install_rate_limiter(app)
+"""
+
+import logging
+import os
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+logger = logging.getLogger(__name__)
+
+# Default rates (requests per minute)
+_DEFAULT_RPM = int(os.environ.get("CONTEXTSYNAPSE_RATE_LIMIT_RPM") or os.environ.get("AICONTEXTDB_RATE_LIMIT_RPM", "300"))
+_PRO_RPM = 600
+
+
+def _key_func(request: Request) -> str:
+    """Rate-limit key: tenant_id if authenticated, else client IP."""
+    tenant = getattr(request.state, "tenant", None)
+    if tenant:
+        return f"tenant:{tenant.tenant_id}"
+    user = getattr(request.state, "user", None)
+    if user:
+        return f"user:{user.user_id}"
+    return f"ip:{request.client.host if request.client else 'unknown'}"
+
+
+def install_rate_limiter(app: FastAPI):
+    """Install rate limiting middleware on the FastAPI app."""
+    try:
+        from slowapi import Limiter, _rate_limit_exceeded_handler
+        from slowapi.errors import RateLimitExceeded
+    except ImportError:
+        logger.warning("slowapi not installed — rate limiting is disabled. Run: pip install slowapi")
+        return
+
+    limiter = Limiter(key_func=_key_func, default_limits=[f"{_DEFAULT_RPM}/minute"])
+    app.state.limiter = limiter
+
+    @app.exception_handler(RateLimitExceeded)
+    async def rate_limit_handler(request: Request, exc: RateLimitExceeded):
+        return JSONResponse(
+            status_code=429,
+            content={
+                "error_code": "RATE_LIMITED",
+                "message": f"Rate limit exceeded. Try again later.",
+                "detail": str(exc.detail) if hasattr(exc, "detail") else None,
+            },
+        )
+
+    # Apply limiter as middleware
+    from slowapi.middleware import SlowAPIMiddleware
+    app.add_middleware(SlowAPIMiddleware)
+    logger.info(f"Rate limiting enabled: {_DEFAULT_RPM} req/min default")