codegraphcontext 0.5.2__tar.gz → 0.5.3__tar.gz

{codegraphcontext-0.5.2/src/codegraphcontext.egg-info → codegraphcontext-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.5.2
+Version: 0.5.3
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -25,8 +25,8 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
-Project-URL: Homepage, https://github.com/Shashankss1205/CodeGraphContext
-Project-URL: Bug Tracker, https://github.com/Shashankss1205/CodeGraphContext/issues
+Project-URL: Homepage, https://github.com/CodeGraphContext/CodeGraphContext
+Project-URL: Bug Tracker, https://github.com/CodeGraphContext/CodeGraphContext/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -60,7 +60,7 @@ Requires-Dist: falkordb<1.6,>=1.0
 Requires-Dist: falkordblite<0.10,>=0.7; sys_platform != "win32" and python_version >= "3.12"
 Requires-Dist: requests>=2.28.0
 Requires-Dist: protobuf<3.21,>=3.20
-Requires-Dist: kuzu; sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10")
+Requires-Dist: kuzu; python_version < "3.14" or sys_platform == "linux"
 Requires-Dist: ladybug; sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10")
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: fastapi>=0.100.0
@@ -77,7 +77,7 @@ Provides-Extra: falkordb-remote
 Requires-Dist: falkordb<1.6,>=1.0; extra == "falkordb-remote"
 Requires-Dist: redis<6,>=5; extra == "falkordb-remote"
 Provides-Extra: kuzu
-Requires-Dist: kuzu; (sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10")) and extra == "kuzu"
+Requires-Dist: kuzu; (python_version < "3.14" or sys_platform == "linux") and extra == "kuzu"
 Provides-Extra: ladybug
 Requires-Dist: ladybug; (sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10")) and extra == "ladybug"
 Provides-Extra: neo4j
@@ -272,6 +272,26 @@ flowchart LR
 
 
 ---
+## Architecture Overview
+
+CodeGraphContext transforms source code into a queryable knowledge graph that can be explored through the CLI or AI assistants via MCP.
+
+```mermaid
+flowchart TD
+    A[Code Repository] --> B[Tree-sitter / SCIP Indexing]
+    B --> C[Knowledge Graph]
+    C --> D[Graph Database]
+    D --> E[CLI Toolkit]
+    D --> F[MCP Server]
+    F --> G[AI Assistant]
+```
+
+### Workflow
+
+1. Source code is parsed using Tree-sitter or SCIP indexers.
+2. Relationships between functions, classes, imports, and calls are extracted.
+3. A knowledge graph is generated and stored in a graph database.
+4. Users can query the graph through the CLI or AI assistants using MCP.
 
 ## 🏗️ Architecture & Workflow
 

{codegraphcontext-0.5.2 → codegraphcontext-0.5.3}/README.md

@@ -174,6 +174,26 @@ flowchart LR
 
 
 ---
+## Architecture Overview
+
+CodeGraphContext transforms source code into a queryable knowledge graph that can be explored through the CLI or AI assistants via MCP.
+
+```mermaid
+flowchart TD
+    A[Code Repository] --> B[Tree-sitter / SCIP Indexing]
+    B --> C[Knowledge Graph]
+    C --> D[Graph Database]
+    D --> E[CLI Toolkit]
+    D --> F[MCP Server]
+    F --> G[AI Assistant]
+```
+
+### Workflow
+
+1. Source code is parsed using Tree-sitter or SCIP indexers.
+2. Relationships between functions, classes, imports, and calls are extracted.
+3. A knowledge graph is generated and stored in a graph database.
+4. Users can query the graph through the CLI or AI assistants using MCP.
 
 ## 🏗️ Architecture & Workflow
 

{codegraphcontext-0.5.2 → codegraphcontext-0.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.5.2"
+version = "0.5.3"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"
@@ -58,7 +58,20 @@ dependencies = [
     "falkordblite>=0.7,<0.10; sys_platform != 'win32' and python_version >= '3.12'",
     "requests>=2.28.0",
     "protobuf>=3.20,<3.21",
-    "kuzu; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10')",
+    # ------------------------------------------------------------------
+    # KùzuDB was archived upstream on 2025-10-10; 0.11.3 is the final
+    # release and its wheel matrix stops at cp313 for macOS and Windows.
+    # Only Linux (manylinux x86_64 / aarch64) got cp314 wheels. Without a
+    # marker, `pip install codegraphcontext` on macOS/Windows + Python 3.14
+    # falls back to the kuzu sdist and tries a full C++/CMake source build,
+    # which fails and takes the whole install down with it.
+    #
+    # Keep kuzu where a wheel actually exists; elsewhere the backend is
+    # simply absent and `database_kuzu` reports its install hint at runtime.
+    # LadybugDB (the maintained Kùzu fork, see issue #852) publishes cp314
+    # wheels for all three platforms and remains the unconditional default.
+    # ------------------------------------------------------------------
+    "kuzu; python_version < '3.14' or sys_platform == 'linux'",
     "ladybug; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10')",
     "mcp>=1.0.0",
     "fastapi>=0.100.0",
@@ -85,7 +98,9 @@ falkordb-remote = [
     "redis>=5,<6",
 ]
 kuzu = [
-    "kuzu; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10')",
+    # Same wheel-availability marker as the core dependency above: no
+    # cp314 wheels exist for macOS/Windows and the sdist cannot be built.
+    "kuzu; python_version < '3.14' or sys_platform == 'linux'",
 ]
 ladybug = [
     "ladybug; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10')",
@@ -112,8 +127,8 @@ datasources = [
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/Shashankss1205/CodeGraphContext"
-"Bug Tracker" = "https://github.com/Shashankss1205/CodeGraphContext/issues"
+"Homepage" = "https://github.com/CodeGraphContext/CodeGraphContext"
+"Bug Tracker" = "https://github.com/CodeGraphContext/CodeGraphContext/issues"
 
 [project.scripts]
 cgc = "codegraphcontext.cli.main:app"

{codegraphcontext-0.5.2 → codegraphcontext-0.5.3}/src/codegraphcontext/api/app.py

@@ -4,9 +4,14 @@ from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
 from .router import router
+from .auth import log_auth_status
 from .mcp_sse import handle_sse, handle_messages
 
 def create_app() -> FastAPI:
+    # Log whether API-key auth is active. Emits a prominent security warning
+    # when the gateway is running unauthenticated (CGC_API_KEY unset).
+    log_auth_status()
+
     app = FastAPI(
         title="CodeGraphContext Gateway",
         description="HTTP API gateway for CodeGraphContext MCP server. Enables integration with ChatGPT Actions, Claude, and web frontends.",
@@ -61,7 +66,7 @@ def create_app() -> FastAPI:
                     <a href="/docs" class="btn">View API Docs</a>
                     <div class="links">
                         <a href="/openapi.json">OpenAPI Spec</a>
-                        <a href="https://github.com/Shashankss1205/CodeGraphContext" target="_blank">GitHub</a>
+                        <a href="https://github.com/CodeGraphContext/CodeGraphContext" target="_blank">GitHub</a>
                     </div>
                 </div>
             </body>

codegraphcontext-0.5.3/src/codegraphcontext/api/auth.py

@@ -0,0 +1,123 @@
+# src/codegraphcontext/api/auth.py
+"""Optional API-key authentication for the CodeGraphContext HTTP API.
+
+Backward-compatible and opt-in:
+
+* When **no** key is configured, the API behaves exactly as it did before
+  (every endpoint is unauthenticated) but a prominent security warning is
+  logged at startup so operators know the gateway is wide open.
+* When a key **is** configured (via the ``CGC_API_KEY`` environment variable
+  or the standard config mechanism), every protected router endpoint requires
+  it, supplied as either ``Authorization: Bearer <key>`` or ``X-API-Key: <key>``.
+  Missing/incorrect keys receive an HTTP ``401``.
+
+The comparison uses :func:`secrets.compare_digest` to avoid timing side
+channels.
+"""
+
+import logging
+import os
+import secrets
+from typing import Optional
+
+from fastapi import Header, HTTPException
+
+logger = logging.getLogger(__name__)
+
+# Config/env key that holds the API key. Reused as the config_manager key so
+# ``cgc config set CGC_API_KEY <value>`` works as well.
+API_KEY_ENV = "CGC_API_KEY"
+
+
+def get_configured_api_key() -> Optional[str]:
+    """Return the configured API key, or ``None`` when auth is disabled.
+
+    Resolution order (highest priority first):
+
+    1. The ``CGC_API_KEY`` environment variable (read directly so auth works
+       even when no config file is present).
+    2. The value stored via the existing config mechanism
+       (:func:`codegraphcontext.cli.config_manager.get_config_value`).
+
+    Empty / whitespace-only values are treated as "not configured".
+    """
+    env_val = os.getenv(API_KEY_ENV)
+    if env_val and env_val.strip():
+        return env_val.strip()
+
+    # Fall back to the existing config mechanism (global/local .env, defaults).
+    try:
+        from codegraphcontext.cli.config_manager import get_config_value
+
+        cfg_val = get_config_value(API_KEY_ENV)
+        if cfg_val and cfg_val.strip():
+            return cfg_val.strip()
+    except Exception:  # pragma: no cover - config lookup is best-effort here
+        pass
+
+    return None
+
+
+def _extract_provided_key(
+    authorization: Optional[str], x_api_key: Optional[str]
+) -> Optional[str]:
+    """Pull the caller-supplied key from the Authorization or X-API-Key header."""
+    if authorization:
+        value = authorization.strip()
+        if value.lower().startswith("bearer "):
+            return value[len("bearer ") :].strip()
+        # Accept a bare token in the Authorization header as a convenience.
+        return value or None
+    if x_api_key and x_api_key.strip():
+        return x_api_key.strip()
+    return None
+
+
+def _keys_match(provided: str, configured: str) -> bool:
+    """Constant-time comparison that never raises on non-ASCII input."""
+    try:
+        return secrets.compare_digest(
+            provided.encode("utf-8"), configured.encode("utf-8")
+        )
+    except (TypeError, AttributeError):
+        return False
+
+
+async def require_api_key(
+    authorization: Optional[str] = Header(default=None),
+    x_api_key: Optional[str] = Header(default=None, alias="X-API-Key"),
+) -> None:
+    """FastAPI dependency that enforces the API key when one is configured.
+
+    No-op (backward compatible) when no key is set; otherwise requires a valid
+    key via ``Authorization: Bearer <key>`` or ``X-API-Key: <key>``, returning
+    HTTP ``401`` on a missing or incorrect key.
+    """
+    configured = get_configured_api_key()
+    if not configured:
+        # Auth disabled -> preserve the pre-existing unauthenticated behavior.
+        return
+
+    provided = _extract_provided_key(authorization, x_api_key)
+    if not provided or not _keys_match(provided, configured):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid or missing API key",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+
+def log_auth_status() -> None:
+    """Log the authentication status at app startup.
+
+    Emits a prominent WARNING when the API is unauthenticated so the insecure
+    default is impossible to miss in logs.
+    """
+    if get_configured_api_key():
+        logger.info("API key authentication is ENABLED (CGC_API_KEY is set).")
+    else:
+        logger.warning(
+            "⚠️  CodeGraphContext API is running WITHOUT authentication. "
+            "Anyone who can reach this server can index code, run Cypher queries "
+            "and call tools. Set CGC_API_KEY to require a key."
+        )

{codegraphcontext-0.5.2 → codegraphcontext-0.5.3}/src/codegraphcontext/api/router.py

@@ -5,17 +5,21 @@ from typing import Dict, Any, List
 from pathlib import Path
 
 from .schemas import (
-    IndexRequest, 
-    QueryRequest, 
-    SearchRequest, 
-    ToolCallRequest, 
+    IndexRequest,
+    QueryRequest,
+    SearchRequest,
+    ToolCallRequest,
     ApiResponse
 )
+from .auth import require_api_key
 from codegraphcontext.server import MCPServer
 
 import socket
 
-router = APIRouter()
+# Optional API-key auth is enforced on every route below via require_api_key.
+# It is a no-op (backward compatible) unless CGC_API_KEY is configured, in
+# which case each request must supply the key. See codegraphcontext.api.auth.
+router = APIRouter(dependencies=[Depends(require_api_key)])
 
 # Global server instance (initialized on startup)
 _server_instance: MCPServer = None

{codegraphcontext-0.5.2 → codegraphcontext-0.5.3}/src/codegraphcontext/cli/cli_helpers.py

@@ -112,6 +112,9 @@ def _print_index_execution_summary(graph_builder: GraphBuilder) -> None:
         "Files by extension",
         _format_extension_counts(summary.get("files_by_extension", {})),
     )
+    failed_files = summary.get("failed_files", 0)
+    if failed_files:
+        table.add_row("[red]Files failed to parse[/red]", f"[red]{failed_files}[/red]")
     table.add_row("Function nodes", str(summary.get("function_nodes", 0)))
     table.add_row("Class nodes", str(summary.get("class_nodes", 0)))
     table.add_row("CALLS edges", str(summary.get("call_edges", 0)))
@@ -353,7 +356,7 @@ def index_helper(path: str, context: Optional[str] = None):
         elapsed = time_end - time_start
         _print_call_resolution_diagnostics(graph_builder)
         _print_index_execution_summary(graph_builder)
-        console.print(f"[green]Successfully finished indexing: {path} in {elapsed:.2f} seconds[/green]")
+        console.print(f"[green]Successfully finished indexing: {path_obj} in {elapsed:.2f} seconds[/green]")
         
         # Check if auto-watch is enabled
         try:
@@ -454,8 +457,13 @@ def delete_helper(repo_path: str, context: Optional[str] = None):
         else:
             console.print(f"[yellow]Repository not found in graph: {repo_path}[/yellow]")
             console.print("[dim]Tip: Use 'cgc list' to see available repositories.[/dim]")
+            raise typer.Exit(code=1)
+    except typer.Exit:
+        # Control flow, not an error — let it through so the exit code survives.
+        raise
     except Exception as e:
         console.print(f"[bold red]An error occurred:[/bold red] {e}")
+        raise typer.Exit(code=1)
     finally:
         db_manager.close_driver()
 
@@ -519,7 +527,13 @@ def cypher_helper(query: str, context: Optional[str] = None):
         raise typer.Exit(code=1)
 
     backend = getattr(db_manager, "get_backend_type", lambda: "neo4j")()
-    session_kwargs = {"default_access_mode": "READ"} if backend == "neo4j" else {}
+    # Neo4j honours default_access_mode natively; FalkorDB routes READ sessions
+    # through GRAPH.RO_QUERY for server-enforced read-only execution.
+    session_kwargs = (
+        {"default_access_mode": "READ"}
+        if backend in ("neo4j", "falkordb", "falkordb-remote")
+        else {}
+    )
 
     try:
         with db_manager.get_driver().session(**session_kwargs) as session:
@@ -564,6 +578,119 @@ import uvicorn
 import urllib.parse
 from ..viz.server import run_server, set_db_manager
 
+_OFFLINE_VIZ_DEFAULT_QUERY = """
+MATCH (n)-[r]->(m)
+RETURN n, r, m
+LIMIT 300
+"""
+
+
+def _render_offline_visualization(
+    db_manager,
+    repo_path: Optional[str] = None,
+    cypher_query: Optional[str] = None,
+    output_path: Optional[str] = None,
+) -> None:
+    """Render the graph with the dependency-free single-file HTML renderer.
+
+    The React frontend in ``viz/dist`` is not shipped in the wheel, which made
+    every visualization entry point a hard failure on a plain ``pip install``.
+    ``utils/visualize_graph.py`` is a complete, zero-dependency renderer that
+    was sitting in the package with no callers — this wires it up so the
+    command degrades to a working (simpler) view instead of exiting 1.
+    """
+    from ..utils.visualize_graph import open_in_browser, build_graph_data
+
+    query = cypher_query or _OFFLINE_VIZ_DEFAULT_QUERY
+    nodes: Dict[Any, Dict[str, Any]] = {}
+    edges: List[Dict[str, Any]] = []
+
+    def _ident(value) -> Optional[str]:
+        return None if value is None else str(value)
+
+    # Neo4j/Falkor return driver objects carrying .labels / .type; Kùzu and
+    # Ladybug return plain dicts carrying _label plus _src/_dst. Check the
+    # driver attributes first — a driver object may also be dict-like.
+    def _is_relationship(value) -> bool:
+        if hasattr(value, "labels"):
+            return False
+        if hasattr(value, "type"):
+            return True
+        return isinstance(value, dict) and "_src" in value and "_dst" in value
+
+    def _is_node(value) -> bool:
+        if hasattr(value, "labels"):
+            return True
+        if hasattr(value, "type"):
+            return False
+        # Kùzu relationships also carry _label, so _src/_dst is what
+        # distinguishes them from nodes.
+        return isinstance(value, dict) and "_label" in value and "_src" not in value
+
+    def _node_payload(value) -> Dict[str, Any]:
+        if hasattr(value, "labels"):
+            props = dict(value)
+            labels = list(getattr(value, "labels", []) or [])
+            label = labels[0] if labels else "Node"
+            node_id = getattr(value, "element_id", None) or getattr(value, "id", None)
+        else:
+            props, label = dict(value), value.get("_label", "Node")
+            node_id = value.get("_id")
+        if node_id is None:
+            node_id = props.get("path") or props.get("name")
+        return {
+            "id": _ident(node_id),
+            "label": label,
+            "name": props.get("name") or props.get("path") or "",
+            "file_path": props.get("path", ""),
+            "line_number": props.get("line_number"),
+        }
+
+    def _edge_payload(value) -> Optional[Dict[str, Any]]:
+        start = getattr(value, "start_node", None)
+        end = getattr(value, "end_node", None)
+        if start is not None and end is not None:
+            return {
+                "source": _ident(getattr(start, "element_id", None) or getattr(start, "id", None)),
+                "target": _ident(getattr(end, "element_id", None) or getattr(end, "id", None)),
+                "type": getattr(value, "type", "RELATED"),
+            }
+        if isinstance(value, dict):
+            return {
+                "source": _ident(value.get("_src")),
+                "target": _ident(value.get("_dst")),
+                "type": value.get("_label", "RELATED"),
+            }
+        return None
+
+    with db_manager.get_driver().session() as session:
+        for record in session.run(query):
+            values = list(record.values()) if hasattr(record, "values") else list(record)
+            for value in values:
+                if _is_node(value):
+                    payload = _node_payload(value)
+                    if payload["id"] is not None:
+                        nodes[payload["id"]] = payload
+                elif _is_relationship(value):
+                    edge = _edge_payload(value)
+                    if edge and edge["source"] and edge["target"]:
+                        edges.append(edge)
+
+    if not nodes:
+        console.print(
+            "[yellow]No graph data returned — index a repository first "
+            "with 'cgc index <path>'.[/yellow]"
+        )
+        raise typer.Exit(code=1)
+
+    title = f"CGC Code Graph — {Path(repo_path).name}" if repo_path else "CGC Code Graph"
+    graph_data = build_graph_data(list(nodes.values()), edges)
+    path = open_in_browser(graph_data, title=title, output_path=output_path)
+    console.print(
+        f"[green]Rendered {len(nodes)} nodes and {len(edges)} edges to[/green] {path}"
+    )
+
+
 def visualize_helper(
     repo_path: Optional[str] = None,
     host: str = "127.0.0.1",
@@ -625,8 +752,15 @@ def visualize_helper(
                     "[dim]then sync[/dim] [cyan]website/dist[/cyan] [dim]→[/dim] "
                     "[cyan]src/codegraphcontext/viz/dist[/cyan][dim].[/dim]"
                 )
-                db_manager.close_driver()
-                raise SystemExit(1)
+                console.print(
+                    "\n[yellow]Falling back to the built-in offline renderer.[/yellow]"
+                )
+                try:
+                    return _render_offline_visualization(
+                        db_manager, repo_path=repo_path, cypher_query=cypher_query
+                    )
+                finally:
+                    db_manager.close_driver()
 
     index_html = static_dir / "index.html"
     if not index_html.is_file():
@@ -815,17 +949,23 @@ def stats_helper(path: str = None, context: Optional[str] = None):
                     return
                 
                 # Get stats
-                # Get stats using separate queries to handle depth and avoid Cartesian products
+                # Get stats using separate queries to handle depth and avoid Cartesian products.
+                # `count(x)` counts *rows*, and a variable-length CONTAINS* match
+                # yields one row per distinct path to the node: a method is
+                # reachable as Repo->..->File->Function and again as
+                # Repo->..->File->Class->Function, a nested function three ways.
+                # count(DISTINCT x) is required or the totals are inflated —
+                # functions were over-reported by ~55% on CGC's own repo.
                 # 1. Files
-                file_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(f) as c"
+                file_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(DISTINCT f) as c"
                 file_count = session.run(file_query, path=repo_path_str).single()["c"]
-                
+
                 # 2. Functions (including methods in classes)
-                func_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(func:Function) RETURN count(func) as c"
+                func_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(func:Function) RETURN count(DISTINCT func) as c"
                 func_count = session.run(func_query, path=repo_path_str).single()["c"]
-                
+
                 # 3. Classes
-                class_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(c:Class) RETURN count(c) as c"
+                class_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(c:Class) RETURN count(DISTINCT c) as c"
                 class_count = session.run(class_query, path=repo_path_str).single()["c"]
                 
                 # 4. Modules (imported) - Note: Module nodes are outside the repo structure usually, connected via IMPORTS
@@ -1017,19 +1157,38 @@ def watch_helper(
 
 
 def unwatch_helper(path: str):
-    """Stop watching a directory."""
-    console.print(f"[yellow]⚠️  Note: 'cgc unwatch' only works when the watcher is running via MCP server.[/yellow]")
-    console.print(f"[dim]For CLI watch mode, simply press Ctrl+C in the watch terminal.[/dim]")
-    console.print(f"\n[cyan]Path specified:[/cyan] {Path(path).resolve()}")
+    """Report that unwatching is not available from the CLI.
+
+    This command touches no watcher state at all — it never has. It used to
+    print a note, echo the requested path back as "Path specified:" (which
+    reads like confirmation that something happened, even for a path that was
+    never watched and does not exist) and exit 0.
+    """
+    console.print(
+        "[bold red]Error:[/bold red] 'cgc unwatch' is not supported from the CLI — "
+        "it cannot reach a watcher started in another process."
+    )
+    console.print("[dim]For CLI watch mode, press Ctrl+C in the terminal running 'cgc watch'.[/dim]")
+    console.print(
+        "[dim]For MCP mode, call the 'unwatch_directory' tool from your IDE.[/dim]"
+    )
+    raise typer.Exit(code=1)
 
 
 def list_watching_helper():
-    """List all directories currently being watched."""
-    console.print(f"[yellow]⚠️  Note: 'cgc watching' only works when the watcher is running via MCP server.[/yellow]")
-    console.print(f"[dim]For CLI watch mode, check the terminal where you ran 'cgc watch'.[/dim]")
-    console.print(f"\n[cyan]To see watched directories in MCP mode:[/cyan]")
-    console.print(f"  1. Start the MCP server: cgc mcp start")
-    console.print(f"  2. Use the 'list_watched_paths' MCP tool from your IDE")
+    """Report that listing watched paths is not available from the CLI.
+
+    Same as unwatch: no watcher state is consulted, so exiting 0 advertised a
+    successful listing of nothing.
+    """
+    console.print(
+        "[bold red]Error:[/bold red] 'cgc watching' is not supported from the CLI — "
+        "it cannot reach a watcher started in another process."
+    )
+    console.print("[dim]For CLI watch mode, check the terminal where you ran 'cgc watch'.[/dim]")
+    console.print("[dim]For MCP mode: start 'cgc mcp start', then call the "
+                  "'list_watched_paths' tool from your IDE.[/dim]")
+    raise typer.Exit(code=1)
 
 
 def setup_scip_helper() -> None: