codegraphy-lite 1.0.0__py3-none-any.whl

codegraphy_lite/server.py

@@ -0,0 +1,414 @@
+"""FastAPI server for CodeGraphy Lite.
+
+Hosts the interactive React Flow visual graph, REST APIs, WebSocket live sync,
+and STDIO/HTTP MCP configuration endpoints.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+from fastapi import FastAPI, HTTPException, Query, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, PlainTextResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+from codegraphy_lite import __version__
+from codegraphy_lite.models import (
+    GraphState,
+    NodeData,
+    ReactFlowNode,
+    ScanPreviewRequest,
+    ScanPreviewResponse,
+    TopicLane,
+    WorkspaceModel,
+)
+from codegraphy_lite.scanner import (
+    build_graph_and_workspace,
+    extract_ast_signatures,
+    scan_project,
+)
+from codegraphy_lite.storage import (
+    get_active_root,
+    get_storage_dir,
+    load_graph,
+    load_workspace,
+    parse_md_to_workspace,
+    save_graph,
+    save_workspace,
+    serialize_workspace_to_md,
+    set_active_root,
+)
+
+
+class RootPathPayload(BaseModel):
+    root_path: str
+
+
+class GeneratePromptRequest(BaseModel):
+    topic_ids: List[str]
+
+
+class WorkspaceWsManager:
+    def __init__(self) -> None:
+        self.active_connections: Set[WebSocket] = set()
+
+    async def connect(self, websocket: WebSocket) -> None:
+        await websocket.accept()
+        self.active_connections.add(websocket)
+
+    def disconnect(self, websocket: WebSocket) -> None:
+        self.active_connections.discard(websocket)
+
+    async def broadcast_update(self, event_type: str = "workspace_updated", extra: Optional[Dict[str, Any]] = None) -> None:
+        if not self.active_connections:
+            return
+        payload = {"type": event_type, "ts": time.time(), **(extra or {})}
+        dead: List[WebSocket] = []
+        for ws in list(self.active_connections):
+            try:
+                await ws.send_json(payload)
+            except Exception:
+                dead.append(ws)
+        for d in dead:
+            self.active_connections.discard(d)
+
+
+ws_manager = WorkspaceWsManager()
+
+
+def get_web_dir() -> Path:
+    """Returns directory containing built static frontend assets."""
+    packaged = Path(__file__).resolve().parent / "web"
+    if packaged.exists() and (packaged / "index.html").exists():
+        return packaged
+    # Fallback to local paths if running from source checkout
+    candidates = [
+        Path.cwd() / "web",
+        Path.cwd() / "frontend" / "dist",
+        Path(__file__).resolve().parent.parent / "web",
+    ]
+    for c in candidates:
+        if c.exists() and (c / "index.html").exists():
+            return c
+    return packaged
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Initialize workspace and ensure storage folder exists
+    get_storage_dir()
+    web_dir = get_web_dir()
+    assets_dir = web_dir / "assets"
+    if assets_dir.exists():
+        has_assets = any(getattr(r, "path", None) == "/assets" for r in app.routes)
+        if not has_assets:
+            app.mount("/assets", StaticFiles(directory=str(assets_dir)), name="assets")
+    yield
+
+
+app = FastAPI(title="CodeGraphy Lite API", version=__version__, lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.websocket("/ws/workspace")
+async def workspace_ws_endpoint(websocket: WebSocket):
+    await ws_manager.connect(websocket)
+    try:
+        while True:
+            data = await websocket.receive_text()
+            if data == "ping":
+                await websocket.send_text("pong")
+    except (WebSocketDisconnect, Exception):
+        ws_manager.disconnect(websocket)
+
+
+@app.get("/health")
+@app.get("/api/health")
+def health_check():
+    return {
+        "status": "ok",
+        "edition": "lite",
+        "version": __version__,
+        "open_source": True,
+        "max_scan_files": 35,
+    }
+
+
+@app.get("/api/workspace/root-path")
+def get_root_path():
+    return {"root_path": str(get_active_root())}
+
+
+@app.post("/api/workspace/root-path")
+def set_root_path_endpoint(payload: RootPathPayload):
+    new_root = set_active_root(payload.root_path)
+    return {"status": "ok", "root_path": str(new_root)}
+
+
+@app.get("/api/graph", response_model=GraphState)
+def get_graph():
+    return load_graph()
+
+
+@app.post("/api/graph")
+def post_graph(graph: GraphState):
+    save_graph(graph)
+    return {"status": "ok", "nodes_count": len(graph.nodes), "edges_count": len(graph.edges)}
+
+
+@app.get("/api/workspace", response_model=WorkspaceModel)
+def get_workspace():
+    return load_workspace()
+
+
+@app.post("/api/workspace")
+def post_workspace(ws: WorkspaceModel):
+    save_workspace(ws)
+    return {"status": "ok", "topics_count": len(ws.topics)}
+
+
+@app.get("/api/workspace/export-md", response_class=PlainTextResponse)
+def export_workspace_md():
+    ws = load_workspace()
+    return serialize_workspace_to_md(ws)
+
+
+@app.post("/api/workspace/import-md")
+def import_workspace_md(payload: Dict[str, str]):
+    md = payload.get("markdown", "")
+    if not md.strip():
+        raise HTTPException(status_code=400, detail="Markdown content is required.")
+    ws = parse_md_to_workspace(md)
+    save_workspace(ws)
+    return {"status": "ok", "topics_count": len(ws.topics), "edges_count": len(ws.edges)}
+
+
+@app.post("/api/workspace/scan-preview", response_model=ScanPreviewResponse)
+def scan_preview_endpoint(req: ScanPreviewRequest):
+    try:
+        target_path = Path(req.root_path).resolve() if req.root_path else get_active_root()
+        res = scan_project(target_path)
+        return res
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Scanner error: {str(e)}")
+
+
+@app.post("/api/lanes")
+def save_lanes_endpoint(lanes: List[TopicLane]):
+    ws = load_workspace()
+    ws.lanes = lanes
+    save_workspace(ws)
+    return {"status": "ok", "lanes_count": len(lanes)}
+
+
+@app.post("/api/tasks")
+def save_tasks_endpoint(tasks: List[Any]):
+    return {"status": "ok", "tasks_count": len(tasks)}
+
+
+@app.post("/api/topics/assign")
+def assign_topic_endpoint(payload: Dict[str, Any]):
+    return {"status": "ok"}
+
+
+# ─── AST Signature Context Compiler ─────────────────────────────────────────
+
+def compile_topic_prompt(topic_id: str, graph: GraphState, root: Path) -> str:
+    target_node = next((n for n in graph.nodes if n.id == topic_id or n.data.id == topic_id), None)
+    if not target_node:
+        raise HTTPException(status_code=404, detail=f"Topic '{topic_id}' not found.")
+
+    # 1-hop connected neighbors
+    neighbor_ids = set()
+    for e in graph.edges:
+        if e.source == target_node.id:
+            neighbor_ids.add(e.target)
+        elif e.target == target_node.id:
+            neighbor_ids.add(e.source)
+
+    neighbors = []
+    for n in graph.nodes:
+        if n.id in neighbor_ids:
+            neighbors.append(f"- **{n.data.label}** (`{n.data.status}`): {n.data.description}")
+
+    neighbors_str = "\n".join(neighbors) if neighbors else "No 1-hop dependencies connected."
+
+    file_sections = []
+    for f in target_node.data.attached_files:
+        full_p = root / f.filepath
+        if full_p.exists() and full_p.is_file():
+            try:
+                code = full_p.read_text(encoding="utf-8", errors="ignore")
+                sigs = extract_ast_signatures(code)
+            except Exception as e:
+                sigs = f"# Error reading file: {e}"
+        else:
+            sigs = f"# File not found on disk: {f.filepath}"
+
+        file_sections.append(
+            f"### File: `{f.filepath}`\n```python\n{sigs}\n```"
+        )
+
+    files_str = "\n\n".join(file_sections) if file_sections else "No attached files."
+
+    return (
+        f"# Architecture Context: {target_node.data.label}\n"
+        f"**Status:** `{target_node.data.status}`\n\n"
+        f"## Description\n{target_node.data.description or 'No description'}\n\n"
+        f"## Connected Dependencies (1-Hop)\n{neighbors_str}\n\n"
+        f"## File Signatures (AST Extracted)\n{files_str}"
+    )
+
+
+@app.get("/api/generate-prompt/{topic_id}")
+def generate_prompt_get(topic_id: str):
+    graph = load_graph()
+    prompt = compile_topic_prompt(topic_id, graph, get_active_root())
+    return {"prompt": prompt}
+
+
+@app.post("/api/generate-prompt")
+def generate_prompt_post(req: GeneratePromptRequest):
+    graph = load_graph()
+    root = get_active_root()
+    prompts = [compile_topic_prompt(tid, graph, root) for tid in req.topic_ids]
+    return {"prompt": "\n\n---\n\n".join(prompts)}
+
+
+# ─── MCP Client Configurations ──────────────────────────────────────────────
+
+@app.get("/api/mcp/configs")
+def get_mcp_configs():
+    py_exec = sys.executable or "python"
+    root_str = str(get_active_root())
+    return {
+        "claude_code": {
+            "mcpServers": {
+                "codegraphy": {
+                    "command": py_exec,
+                    "args": ["-m", "codegraphy_lite.mcp"],
+                    "env": {"CODEGRAPHY_ROOT": root_str},
+                }
+            }
+        },
+        "cursor": {
+            "mcpServers": {
+                "codegraphy": {
+                    "command": py_exec,
+                    "args": ["-m", "codegraphy_lite.mcp"],
+                    "env": {"CODEGRAPHY_ROOT": root_str},
+                }
+            }
+        },
+    }
+
+
+@app.get("/api/ai/discover")
+def discover_ai_providers():
+    return {
+        "providers": [
+            {
+                "id": "ollama",
+                "name": "Ollama (Local)",
+                "models": ["llama3.2", "qwen2.5-coder", "mistral", "deepseek-r1"],
+                "status": "available",
+            },
+            {
+                "id": "lmstudio",
+                "name": "LM Studio (Local)",
+                "models": ["local-model"],
+                "status": "available",
+            },
+        ]
+    }
+
+
+# ─── Pro Feature Interceptors ───────────────────────────────────────────────
+
+def _pro_required_response(feature_name: str, desc: str) -> JSONResponse:
+    return JSONResponse(
+        status_code=402,
+        content={
+            "detail": f"{feature_name} is a CodeGraphy Pro feature.",
+            "pro_feature": True,
+            "feature": feature_name,
+            "description": desc,
+            "upgrade_url": "https://github.com/noname/codegraphy-pro",
+        },
+    )
+
+
+@app.get("/api/git/diff")
+def get_git_diff_pro():
+    return _pro_required_response(
+        "Git Architecture Diff Overlay",
+        "Calculates visual architecture diffs and detects layer regressions between Git branches.",
+    )
+
+
+@app.post("/api/context/compile")
+def post_context_compile_pro():
+    return _pro_required_response(
+        "AST Smart Context (-85% Tokens)",
+        "Proprietary multi-language AST compression that saves 85% of LLM token costs.",
+    )
+
+
+@app.get("/api/tests/impact")
+@app.post("/api/tests/run")
+def tests_impact_pro():
+    return _pro_required_response(
+        "Test Impact Analysis",
+        "Static dependency mapping maps changed files to affected test suites and runs selective tests.",
+    )
+
+
+@app.post("/api/linter/analyze")
+@app.get("/api/linter/report")
+@app.get("/api/linter/export")
+def linter_pro():
+    return _pro_required_response(
+        "Enterprise Architecture Linter",
+        "Validates strict layer separation rules, cyclic dependency detection, and architectural constraints.",
+    )
+
+
+# ─── Static files & SPA fallback ───────────────────────────────────────────
+
+@app.get("/", response_class=FileResponse)
+async def serve_root_index():
+    web = get_web_dir()
+    index_file = web / "index.html"
+    if index_file.exists():
+        return FileResponse(index_file)
+    return HTMLResponse(
+        "<h1>CodeGraphy Lite</h1><p>Web UI bundle is initializing...</p>"
+    )
+
+
+@app.get("/{full_path:path}", response_class=FileResponse)
+async def serve_spa_fallback(full_path: str):
+    if full_path.startswith("api") or full_path.startswith("ws"):
+        raise HTTPException(status_code=404, detail="API endpoint not found")
+    web = get_web_dir()
+    target = web / full_path
+    if target.is_file():
+        return FileResponse(target)
+    index_file = web / "index.html"
+    if index_file.exists():
+        return FileResponse(index_file)
+    raise HTTPException(status_code=404, detail="File not found")

codegraphy_lite/storage.py

@@ -0,0 +1,201 @@
+"""Storage and markdown codec for CodeGraphy Lite.
+
+Handles atomic persistence of `.codegraphy/graph.json`, `.codegraphy/workspace.json`,
+and import/export of human-readable `.cg.md` workspace specifications.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from codegraphy_lite.models import (
+    EdgeData,
+    FileReference,
+    GraphState,
+    NodeData,
+    Position,
+    ReactFlowNode,
+    TaskItem,
+    Topic,
+    TopicLane,
+    WorkspaceModel,
+    new_id,
+    utc_now_iso,
+)
+
+_ACTIVE_ROOT: Path = Path.cwd()
+
+
+def set_active_root(path: str | Path) -> Path:
+    global _ACTIVE_ROOT
+    p = Path(path).resolve()
+    if p.is_file():
+        p = p.parent
+    _ACTIVE_ROOT = p
+    return _ACTIVE_ROOT
+
+
+def get_active_root() -> Path:
+    return _ACTIVE_ROOT
+
+
+def get_storage_dir(root: Optional[Path] = None) -> Path:
+    r = root or get_active_root()
+    d = r / ".codegraphy"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _atomic_write(target_path: Path, content: str) -> None:
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            dir=str(target_path.parent),
+            delete=False,
+            encoding="utf-8",
+            suffix=".tmp",
+        ) as tmp:
+            tmp_path = tmp.name
+            tmp.write(content)
+            tmp.flush()
+            os.fsync(tmp.fileno())
+        os.replace(tmp_path, str(target_path))
+    except Exception as exc:
+        if tmp_path and Path(tmp_path).exists():
+            os.remove(tmp_path)
+        raise exc
+
+
+def load_graph(root: Optional[Path] = None) -> GraphState:
+    gfile = get_storage_dir(root) / "graph.json"
+    if gfile.exists():
+        try:
+            data = json.loads(gfile.read_text(encoding="utf-8"))
+            return GraphState.model_validate(data)
+        except Exception:
+            pass
+    return GraphState(nodes=[], edges=[])
+
+
+def save_graph(graph: GraphState, root: Optional[Path] = None) -> None:
+    gfile = get_storage_dir(root) / "graph.json"
+    _atomic_write(gfile, graph.model_dump_json(indent=2))
+
+
+def load_workspace(root: Optional[Path] = None) -> WorkspaceModel:
+    wfile = get_storage_dir(root) / "workspace.json"
+    if wfile.exists():
+        try:
+            data = json.loads(wfile.read_text(encoding="utf-8"))
+            return WorkspaceModel.model_validate(data)
+        except Exception:
+            pass
+    return WorkspaceModel(root_path=str(root or get_active_root()))
+
+
+def save_workspace(ws: WorkspaceModel, root: Optional[Path] = None) -> None:
+    wfile = get_storage_dir(root) / "workspace.json"
+    ws.updated_at = utc_now_iso()
+    _atomic_write(wfile, ws.model_dump_json(indent=2))
+
+
+# ─── .cg.md Markdown Codec ──────────────────────────────────────────────────
+
+def serialize_workspace_to_md(ws: WorkspaceModel) -> str:
+    """Serializes WorkspaceModel to standard .cg.md format."""
+    lines = [
+        "---",
+        "format: codegraphy-workspace",
+        f"version: {ws.version}",
+        f"name: {ws.name}",
+        f"updated_at: {ws.updated_at}",
+        "---",
+        "",
+        f"# Workspace: {ws.name}",
+        "",
+        "## Lanes",
+    ]
+    for lane in sorted(ws.lanes, key=lambda x: x.order):
+        collapsed = "collapsed" if lane.collapsed else "expanded"
+        lines.append(f"- [{lane.id}] **{lane.title}** | order={lane.order} | color={lane.color} | {collapsed}")
+
+    lines.extend(["", "## Tasks"])
+    if not ws.tasks:
+        lines.append("_No tasks defined._")
+    for task in ws.tasks:
+        topics_str = ", ".join(task.topic_ids) if task.topic_ids else "none"
+        lines.append(f"### Task: {task.title} `{task.id}`")
+        lines.append(f"- status: `{task.status}`")
+        lines.append(f"- linked_topics: `{topics_str}`")
+        if task.description:
+            lines.append(f"- description: {task.description}")
+        lines.append("")
+
+    lines.extend(["## Topics"])
+    for topic in ws.topics:
+        lines.append(f"### Topic: {topic.label} `{topic.id}`")
+        lines.append(f"- status: `{topic.status}`")
+        lines.append(f"- lane: `{topic.lane_id or 'none'}`")
+        if topic.description:
+            lines.append(f"- description: {topic.description}")
+        if topic.attached_files:
+            lines.append("- files:")
+            for f in topic.attached_files:
+                lines.append(f"  - `{f.filepath}`")
+        lines.append("")
+
+    lines.extend(["## Dependencies"])
+    if not ws.edges:
+        lines.append("_No dependencies defined._")
+    for edge in ws.edges:
+        lines.append(f"- `{edge.source}` -> `{edge.target}`")
+
+    return "\n".join(lines)
+
+
+def parse_md_to_workspace(markdown: str) -> WorkspaceModel:
+    """Parses standard .cg.md into WorkspaceModel."""
+    ws = WorkspaceModel()
+    current_section = None
+
+    for line in markdown.splitlines():
+        line_str = line.strip()
+        if not line_str or line_str.startswith("---"):
+            continue
+
+        if line_str.startswith("# Workspace:"):
+            ws.name = line_str.replace("# Workspace:", "").strip()
+            continue
+
+        if line_str.startswith("## Lanes"):
+            current_section = "lanes"
+            continue
+        elif line_str.startswith("## Tasks"):
+            current_section = "tasks"
+            continue
+        elif line_str.startswith("## Topics"):
+            current_section = "topics"
+            continue
+        elif line_str.startswith("## Dependencies"):
+            current_section = "dependencies"
+            continue
+
+        if current_section == "topics" and line_str.startswith("### Topic:"):
+            match = re.search(r"### Topic:\s+(.*?)\s+`([^`]+)`", line_str)
+            if match:
+                lbl, tid = match.group(1), match.group(2)
+                ws.topics.append(Topic(id=tid, label=lbl, description=""))
+        elif current_section == "dependencies" and "->" in line_str:
+            match = re.search(r"`([^`]+)`\s*->\s*`([^`]+)`", line_str)
+            if match:
+                src, tgt = match.group(1), match.group(2)
+                ws.edges.append(EdgeData(id=f"edge_{src}_{tgt}", source=src, target=tgt))
+
+    return ws