srcly 0.1.32__tar.gz → 0.1.34__tar.gz

{srcly-0.1.32 → srcly-0.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: srcly
-Version: 0.1.32
+Version: 0.1.34
 Summary: Interactive codebase treemap and metrics viewer.
 Requires-Python: >=3.13
 Requires-Dist: fastapi>=0.121.3

{srcly-0.1.32 → srcly-0.1.34}/app/config.py

@@ -19,6 +19,9 @@ IGNORE_DIRS: Set[str] = {
 }
 
 IGNORE_FILES: Set[str] = {
+    # In git worktrees and submodules `.git` is a pointer file, not a directory.
+    ".git",
+    ".DS_Store",
     "package-lock.json",
     "yarn.lock",
     "pnpm-lock.yaml",

{srcly-0.1.32 → srcly-0.1.34}/app/main.py

@@ -1,16 +1,66 @@
+from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from importlib import resources
 from pathlib import Path
 import os
+import signal
+import threading
+
+from app.routers import analysis, files, scans
+from app.services.scan_workers import cancel_all_scans
+
+_SHUTDOWN_SIGNALS = (signal.SIGINT, signal.SIGTERM)
+
+
+def _install_scan_cancelling_signal_handlers() -> dict:
+    """
+    Chain a "cancel running scans" step in front of the server's own
+    SIGINT/SIGTERM handlers.
+
+    Uvicorn handles Ctrl+C by waiting for in-flight requests to finish. A scan
+    can run for minutes, so without this the first Ctrl+C appears to do
+    nothing. Cancelling scans first lets their requests end promptly and the
+    normal graceful shutdown proceed. Works for `srcly` and plain `uvicorn`.
+    """
+    if threading.current_thread() is not threading.main_thread():
+        return {}
+
+    previous: dict = {}
+    for sig in _SHUTDOWN_SIGNALS:
+        prior = signal.getsignal(sig)
+
+        def handler(signum, frame, _prior=prior):
+            cancel_all_scans()
+            if callable(_prior):
+                _prior(signum, frame)
+            else:
+                # SIG_DFL / SIG_IGN: restore it and re-deliver the signal.
+                signal.signal(signum, _prior)
+                signal.raise_signal(signum)
+
+        previous[sig] = prior
+        signal.signal(sig, handler)
+    return previous
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    previous = _install_scan_cancelling_signal_handlers()
+    try:
+        yield
+    finally:
+        cancel_all_scans()
+        for sig, prior in previous.items():
+            signal.signal(sig, prior)
 
-from app.routers import analysis, files
 
 app = FastAPI(
     title="Srcly Server",
     description="API for static code analysis and file serving.",
     version="1.0.0",
+    lifespan=lifespan,
 )
 
 # Configure CORS
@@ -25,6 +75,7 @@ app.add_middleware(
 # Include Routers
 app.include_router(analysis.router)
 app.include_router(files.router)
+app.include_router(scans.router)
 
 
 def _find_static_dir() -> str | None:

{srcly-0.1.32 → srcly-0.1.34}/app/models.py

@@ -74,59 +74,3 @@ class DependencyGraph(BaseModel):
     nodes: List[DependencyNode]
     edges: List[DependencyEdge]
 
-
-class FocusOverlayRequest(BaseModel):
-    path: str
-    sliceStartLine: int
-    sliceEndLine: int
-    focusStartLine: int | None = None
-    focusEndLine: int | None = None
-
-
-class OverlayToken(BaseModel):
-    fileLine: int
-    startCol: int
-    endCol: int
-    category: str
-    symbolId: str
-    tooltip: str
-    definitionSnippet: str | None = None
-    definitionLine: int | None = None
-    scopeSnippet: str | None = None
-    scopeLine: int | None = None
-    scopeEndLine: int | None = None
-
-
-class FocusOverlayResponse(BaseModel):
-    tokens: List[OverlayToken] = Field(default_factory=list)
-
-
-# --- Scope Graph Models ---
-
-class ScopeGraphRequest(BaseModel):
-    path: str
-    focusStartLine: int
-    focusEndLine: int
-
-class SymbolNode(BaseModel):
-    id: str  # e.g. "var:expanded:L12:C5" or just a unique ID
-    name: str
-    kind: str  # "var", "func", "param", "class", "jsx_comp", etc.
-    declLine: int
-    isCaptured: bool = False
-    isDeclaredHere: bool = False
-
-class ScopeNode(BaseModel):
-    id: str
-    kind: str  # "function", "jsx", "block", "root"
-    name: str | None = None
-    startLine: int
-    endLine: int
-    children: List["ScopeNode"] = Field(default_factory=list)
-    declared: List[SymbolNode] = Field(default_factory=list)
-    captured: List[SymbolNode] = Field(default_factory=list)
-
-class ScopeGraph(BaseModel):
-    root: ScopeNode
-    # We might want edges later, but for MVP, nested scopes + lists are enough.
-

{srcly-0.1.32 → srcly-0.1.34}/app/routers/analysis.py

@@ -6,9 +6,9 @@ from typing import Dict, List, Optional, Tuple
 
 from app.models import Node, DependencyGraph, DependencyNode, DependencyEdge
 from app.services import analysis, cache
+from app.services.scan_workers import ScanCancelled
 from app.services.typescript import typescript_analysis
 from app.config import IGNORE_DIRS
-from app.models import FocusOverlayRequest, FocusOverlayResponse, ScopeGraphRequest, ScopeGraph
 
 router = APIRouter(prefix="/api/analysis", tags=["analysis"])
 
@@ -303,8 +303,18 @@ def _resolve_internal_file(spec_path: Path, file_to_id: Dict[Path, str]) -> Opti
 
     return None
 
+def _scan_or_503(target_path: Path) -> Node:
+    try:
+        return analysis.scan_codebase(target_path)
+    except ScanCancelled:
+        raise HTTPException(status_code=503, detail="Scan cancelled (server shutting down)")
+
+
+# Scan endpoints are plain `def` on purpose: FastAPI runs them in a worker
+# thread, so a long scan never blocks the event loop (which would also stop
+# uvicorn from reacting to Ctrl+C).
 @router.get("", response_model=Node)
-async def get_analysis(path: str = None):
+def get_analysis(path: str = None):
     """
     Get the static analysis of the codebase.
     Returns cached result if available, otherwise triggers a scan.
@@ -321,13 +331,12 @@ async def get_analysis(path: str = None):
     if cached_tree:
         return cached_tree
     
-    # If no cache, run scan synchronously (for now, could be async/background)
-    tree = analysis.scan_codebase(target_path)
+    tree = _scan_or_503(target_path)
     cache.save_analysis(target_path, tree)
     return tree
 
 @router.get("/dependencies", response_model=DependencyGraph)
-async def get_dependencies(path: str = None):
+def get_dependencies(path: str = None):
     """
     Build a dependency graph for the specified path.
     """
@@ -527,11 +536,11 @@ async def get_dependencies(path: str = None):
     return DependencyGraph(nodes=nodes, edges=edges)
 
 @router.post("/refresh", response_model=Node)
-async def refresh_analysis():
+def refresh_analysis():
     """
     Force a re-scan of the codebase.
     """
-    tree = analysis.scan_codebase(ROOT_PATH)
+    tree = _scan_or_503(ROOT_PATH)
     cache.save_analysis(ROOT_PATH, tree)
     return tree
 
@@ -564,7 +573,7 @@ def _estimate_counts(root: Path) -> tuple[int, int]:
 
 
 @router.get("/context")
-async def get_analysis_context():
+def get_analysis_context():
     """
     Return basic information about the current analysis root directory.
 
@@ -596,79 +605,3 @@ async def get_analysis_context():
         "repo_file_count": repo_file_count,
         "repo_folder_count": repo_folder_count,
     }
-
-@router.get("/data-flow")
-async def get_data_flow(path: str):
-    """
-    Analyze data flow for a specific file.
-    """
-    target_path = Path(path)
-    if not target_path.exists() or not target_path.is_file():
-        raise HTTPException(status_code=404, detail="File not found")
-    
-    from app.services.data_flow_analysis import DataFlowAnalyzer
-    analyzer = DataFlowAnalyzer()
-    
-    try:
-        graph = analyzer.analyze_file(str(target_path))
-        return graph
-    except Exception as e:
-        print(f"Error analyzing data flow for {path}: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.post("/focus/overlay", response_model=FocusOverlayResponse)
-async def get_focus_overlay(req: FocusOverlayRequest):
-    """
-    Return a minimal overlay model for a single file and a focus range.
-
-    The client uses this to decorate Shiki-rendered HTML with subtle identifier
-    background highlights + provenance tooltips.
-    """
-    target_path = Path(req.path)
-    if not target_path.exists() or not target_path.is_file():
-        raise HTTPException(status_code=404, detail="File not found")
-
-    # If no focus is provided, return an empty overlay.
-    if req.focusStartLine is None or req.focusEndLine is None:
-        return FocusOverlayResponse(tokens=[])
-
-    from app.services.focus_overlay import compute_focus_overlay
-
-    try:
-        return compute_focus_overlay(
-            file_path=str(target_path),
-            slice_start_line=req.sliceStartLine,
-            slice_end_line=req.sliceEndLine,
-            focus_start_line=req.focusStartLine,
-            focus_end_line=req.focusEndLine,
-        )
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(f"Error computing focus overlay for {req.path}: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.post("/focus/scope-graph", response_model=ScopeGraph)
-async def get_scope_graph(req: ScopeGraphRequest):
-    """
-    Return the nested scope graph for a focused region.
-    """
-    target_path = Path(req.path)
-    if not target_path.exists() or not target_path.is_file():
-        raise HTTPException(status_code=404, detail="File not found")
-
-    from app.services.focus_overlay import compute_scope_graph
-
-    try:
-        return compute_scope_graph(
-            file_path=str(target_path),
-            focus_start_line=req.focusStartLine,
-            focus_end_line=req.focusEndLine,
-        )
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(f"Error computing scope graph for {req.path}: {e}")
-        raise HTTPException(status_code=500, detail=str(e))

srcly-0.1.34/app/routers/scans.py

@@ -0,0 +1,121 @@
+"""
+Scan jobs with live progress over Server-Sent Events.
+
+    POST   /api/scans               start (or join) a scan    -> snapshot
+    GET    /api/scans/{id}          current snapshot (polling fallback)
+    GET    /api/scans/{id}/events   SSE stream of snapshots
+    GET    /api/scans/{id}/result   analysis tree once complete
+    DELETE /api/scans/{id}          cancel                    -> snapshot
+
+SSE rather than WebSockets: progress only flows server -> client, cancel is
+a plain HTTP call, and EventSource gives reconnects for free. Each stream
+sends the full snapshot (not deltas), so a reconnecting client is always
+consistent without replay. Snapshots are checked every ``STREAM_TICK_SECONDS``
+and sent when the job's version changed (which throttles bursts), or every
+``REFRESH_SECONDS`` regardless so elapsed and in-flight timers keep moving
+while a slow file holds things up. The refresh doubles as a keep-alive.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from app.models import Node
+from app.routers import analysis as analysis_router
+from app.services.scan_jobs import TERMINAL_PHASES, ScanJob, manager
+
+router = APIRouter(prefix="/api/scans", tags=["scans"])
+
+STREAM_TICK_SECONDS = 0.1
+REFRESH_SECONDS = 1.0
+CLIENT_RETRY_MS = 2000
+
+
+class StartScanRequest(BaseModel):
+    path: Optional[str] = None
+
+
+def _job_or_404(job_id: str) -> ScanJob:
+    job = manager.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail="Scan not found")
+    return job
+
+
+def _sse(event: str, data: dict, event_id: Optional[int] = None) -> str:
+    lines = [f"event: {event}"]
+    if event_id is not None:
+        lines.append(f"id: {event_id}")
+    lines.append(f"data: {json.dumps(data, separators=(',', ':'))}")
+    return "\n".join(lines) + "\n\n"
+
+
+@router.post("", status_code=202)
+def start_scan(req: StartScanRequest) -> dict:
+    target = Path(req.path) if req.path else analysis_router.ROOT_PATH
+    if not target.exists():
+        raise HTTPException(status_code=404, detail=f"Path not found: {target}")
+    return manager.start(target).snapshot()
+
+
+@router.get("/{job_id}")
+def get_scan(job_id: str) -> dict:
+    return _job_or_404(job_id).snapshot()
+
+
+@router.delete("/{job_id}")
+def cancel_scan(job_id: str) -> dict:
+    job = _job_or_404(job_id)
+    job.cancel()
+    return job.snapshot()
+
+
+@router.get("/{job_id}/result", response_model=Node)
+def get_scan_result(job_id: str):
+    job = _job_or_404(job_id)
+    if job.phase != "complete" or job.result is None:
+        raise HTTPException(status_code=409, detail=f"Scan is {job.phase}, not complete")
+    return job.result
+
+
+@router.get("/{job_id}/events")
+async def stream_scan(job_id: str, request: Request) -> StreamingResponse:
+    job = _job_or_404(job_id)
+
+    async def events():
+        yield f"retry: {CLIENT_RETRY_MS}\n\n"
+        sent_version = -1
+        last_write = time.monotonic()
+        while True:
+            snapshot = job.snapshot()
+            stale = time.monotonic() - last_write >= REFRESH_SECONDS
+            if snapshot["version"] != sent_version or stale:
+                sent_version = snapshot["version"]
+                last_write = time.monotonic()
+                if snapshot["phase"] in TERMINAL_PHASES:
+                    yield _sse(snapshot["phase"], snapshot, sent_version)
+                    return
+                yield _sse("progress", snapshot, sent_version)
+
+            if await request.is_disconnected():
+                return
+            await asyncio.sleep(STREAM_TICK_SECONDS)
+
+    return StreamingResponse(
+        events(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            # Disable proxy buffering (nginx and friends) so events flush immediately.
+            "X-Accel-Buffering": "no",
+        },
+    )

{srcly-0.1.32 → srcly-0.1.34}/app/run.py

@@ -10,6 +10,12 @@ from pathlib import Path
 import uvicorn
 
 from app.services import reporting
+from app.services.scan_workers import ScanCancelled
+
+# Seconds uvicorn waits for open connections after Ctrl+C before closing them.
+GRACEFUL_SHUTDOWN_SECONDS = 3
+# Conventional exit status for a process stopped by SIGINT.
+EXIT_INTERRUPTED = 130
 
 
 def _open_browser_later(url: str, delay: float = 1.0) -> None:
@@ -54,8 +60,17 @@ def _find_repo_root(start_path: str) -> str:
 
 
 def main(argv: list[str] | None = None) -> None:
+    """CLI entry point. Ctrl+C exits promptly with status 130 and no traceback."""
+    try:
+        _main(argv)
+    except (KeyboardInterrupt, ScanCancelled):
+        print("\nStopped.", file=sys.stderr, flush=True)
+        raise SystemExit(EXIT_INTERRUPTED)
+
+
+def _main(argv: list[str] | None = None) -> None:
     """
-    Entry point for the CLI.
+    Parse arguments and dispatch.
 
     - With no path argument, uses the enclosing Git repo root as the codebase root.
     - If a path is provided (including "."), uses that as the codebase root.
@@ -127,6 +142,7 @@ def main(argv: list[str] | None = None) -> None:
         host=args.host,
         port=port,
         reload=False,
+        timeout_graceful_shutdown=GRACEFUL_SHUTDOWN_SECONDS,
     )