fastgraph-mcp 0.2.0__tar.gz

fastgraph_mcp-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[dev]"
+      - name: Test
+        run: python -m pytest tests/ -q

fastgraph_mcp-0.2.0/.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.fastgraph/
+.serena/
+.venv/
+venv/
+.pytest_cache/
+参考项目/
+# test scratch directories
+tests/work/
+tests/work_*/
+tests/*_work/
+tests/*_work*/
+tests/*_analysis/

fastgraph_mcp-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FastGraph-MCP contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastgraph_mcp-0.2.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.5
+Name: fastgraph-mcp
+Version: 0.2.0
+Summary: Lightweight real-time code intelligence MCP: AST + incremental index + code graph, no embeddings, low memory & low context.
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: mcp>=1.11
+Requires-Dist: tree-sitter-c>=0.23
+Requires-Dist: tree-sitter-cpp>=0.23
+Requires-Dist: tree-sitter-go>=0.23
+Requires-Dist: tree-sitter-java>=0.23
+Requires-Dist: tree-sitter-javascript>=0.23
+Requires-Dist: tree-sitter-python>=0.23
+Requires-Dist: tree-sitter-rust>=0.23
+Requires-Dist: tree-sitter-typescript>=0.23
+Requires-Dist: tree-sitter<0.28,>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# FastGraph-MCP
+
+轻量级代码智能 [MCP](https://modelcontextprotocol.io) 服务器：AST + 增量索引 + 调用图。无 embedding、无图数据库、无 LSP，低内存、低 context。
+
+定位是**代码导航层**：代码在哪、谁调用谁、改了影响谁、刚改了什么——补 grep（分不清定义与调用点）和 LSP（无全局调用图/影响分析）的短板。读改代码、重构、diagnostics 交给编辑器/LSP 工具。
+
+## 特性
+
+- **快**：首次索引中型项目数秒~十几秒；之后增量更新只重解析改动文件，典型查询 <100ms
+- **轻**：无 embedding 模型、无图数据库、无 LSP；常驻内存 <50MB
+- **省 context**：所有工具只返回 `file / symbol / line / relation`，不返回文件正文（仅 `read_file` / `symbol_body` 例外，且有硬上限）
+- **诚实**：调用图是名字解析的近似而非类型推断；解析不了的边显式报 `unresolved_incoming`/`unresolved_outgoing`，绝不猜、绝不把"空列表"伪装成"没人用"
+
+## 安装
+
+```bash
+cd /path/to/FastGraph-mcp
+python -m pip install .        # 日常使用（装完源码目录可删）
+python -m pip install -e ".[dev]"   # 开发者（改动即时生效）
+```
+
+要求 Python ≥ 3.11。
+
+## 快速开始
+
+**1. 配置 MCP**（零配置：不写 `--root`、不写 `cwd`，打开哪个项目就索引哪个项目）
+
+Claude Code（`~/.claude.json` 或项目 `.mcp.json`）：
+
+```json
+{
+  "mcpServers": {
+    "fastgraph": {
+      "command": "python",
+      "args": ["-m", "fastgraph"]
+    }
+  }
+}
+```
+
+OpenCode（`opencode.json`）：
+
+```json
+{
+  "mcp": {
+    "fastgraph": {
+      "type": "local",
+      "enabled": true,
+      "command": ["python", "-m", "fastgraph"]
+    }
+  }
+}
+```
+
+**2. 使用**：打开任意项目，调用任意工具（推荐先 `project_overview`）即自动建索引，之后增量更新。
+
+桌面客户端（Claude Desktop 等，以固定 cwd 启动 MCP 进程）先调一次 `activate_project(root="/abs/path")` 激活项目；换项目再调一次。要固定分析某个目录，启动参数加 `--root D:/work/my-project`（或环境变量 `FASTGRAPH_ROOT`）。
+
+> Windows 注意：`python` 不要用微软商店别名（用 `where python` 确认）；JSON 路径推荐写正斜杠 `D:/work/project`。
+
+## 让模型主动使用
+
+MCP 工具对模型是可选的——不引导，模型默认用自己顺手的 grep/read。最有效的一步：把下面这段粘贴进项目的 `CLAUDE.md` / `AGENTS.md`（服务端 instructions 与工具描述已内置同样的决策表）：
+
+```md
+## 代码导航：用 FastGraph MCP，不要先用 grep
+- 找代码在哪 / 找用法：先 code_search
+- 打开不熟悉的文件前：先 file_symbols(path) 看结构
+- 回答"谁调用了 X"：用 find_callers（结果为空但带 unresolved_incoming>0 表示有调用者未解析，不能当无人使用）
+- 改函数/类之前：先 impact_analysis(symbol) 看影响面
+- 改 import 前：file_deps(path)；查架构：module_cycles()
+- 只读一个符号：symbol_body(name)；整文件才用 read_file
+- 改完代码：changed_context() 复查波及范围
+- 进陌生仓库：先 project_overview()
+```
+
+## 工具（13 个）
+
+| 任务 | 工具 |
+| --- | --- |
+| 桌面端激活项目 | `activate_project(root)` |
+| 陌生仓库看全局 | `project_overview()` |
+| 按关键词/自然语言定位代码 | `code_search(query, kind?, limit?)` |
+| 一个符号是什么 | `symbol_info(symbol)` |
+| 文件结构（先看结构再读正文） | `file_symbols(path)` |
+| 读文件 / 行区间 | `read_file(path, start_line?, end_line?)` |
+| 只读一个符号的源码 | `symbol_body(symbol)` |
+| 谁调用它（`depth≥2` 传递） | `find_callers(symbol, depth?)` |
+| 它调用谁 | `find_callees(symbol, depth?)` |
+| 改动前看影响面 | `impact_analysis(symbol)` |
+| import 了什么 / 被谁 import | `file_deps(path)` |
+| 文件间 import 环（架构健康） | `module_cycles()` |
+| 改完看变更波及（支持 `base="main"` 对比整个分支） | `changed_context(base?)` |
+
+推荐节奏：`project_overview` → `code_search` 定位 → `file_symbols`/`symbol_body` 读 → `impact_analysis` 改前 → `changed_context` 改后。
+
+所有工具都接受可选 `root=` 参数做单次跨项目查询（按 LRU 缓存 8 个项目）。输出行号全部 1-based。另有 resource `fastgraph://overview` 与 prompt `fastgraph-workflow` 可选配。
+
+## 支持语言
+
+Python、TypeScript/TSX、JavaScript、Vue、Svelte、Go、Rust、Java、C/C++（`.wxml` 模板引用亦支持）。
+
+依赖图按各语言 import 写法解析，含 tsconfig paths / vite alias / uni-app `@` 别名、Go `go.mod` 模块根、Rust crate 根、目录入口（`index.*` / `__init__.*`）。
+
+## 调用图的边界（重要）
+
+真实仓库上约 21%~40% 的调用边能唯一连到符号，其余要么指向外部库，要么接收者类型无法静态确定——后者**不连边、不猜**，而是计数报出：
+
+- `find_callers` 每条结果带 `via`：`resolved`（确证的调用边）或 `text`（同名文本折叠的猜测）
+- 出现 `unresolved_incoming` / `unresolved_outgoing` 字段时，**空列表 ≠ 没有调用者**，按"未知"处理，不能据此判定可删
+- `self.x()`、接口实现、回调注册、动态派发不会连边——宁可漏，不可错
+
+## 开发
+
+```bash
+python -m pytest tests/          # 测试
+python bench/bench.py <项目路径>  # 性能基准（冷索引/增量/查询时延）
+```
+
+## 路线图
+
+- [x] Phase 1-3.5：MCP Server、调用图、影响分析、git 变更感知、多语言依赖解析
+- [ ] Phase 4：可选 BM25/embedding 语义搜索
+- [ ] Phase 5：多项目 workspace
+
+## License
+
+[MIT](LICENSE)

fastgraph_mcp-0.2.0/README.md

@@ -0,0 +1,128 @@
+# FastGraph-MCP
+
+轻量级代码智能 [MCP](https://modelcontextprotocol.io) 服务器：AST + 增量索引 + 调用图。无 embedding、无图数据库、无 LSP，低内存、低 context。
+
+定位是**代码导航层**：代码在哪、谁调用谁、改了影响谁、刚改了什么——补 grep（分不清定义与调用点）和 LSP（无全局调用图/影响分析）的短板。读改代码、重构、diagnostics 交给编辑器/LSP 工具。
+
+## 特性
+
+- **快**：首次索引中型项目数秒~十几秒；之后增量更新只重解析改动文件，典型查询 <100ms
+- **轻**：无 embedding 模型、无图数据库、无 LSP；常驻内存 <50MB
+- **省 context**：所有工具只返回 `file / symbol / line / relation`，不返回文件正文（仅 `read_file` / `symbol_body` 例外，且有硬上限）
+- **诚实**：调用图是名字解析的近似而非类型推断；解析不了的边显式报 `unresolved_incoming`/`unresolved_outgoing`，绝不猜、绝不把"空列表"伪装成"没人用"
+
+## 安装
+
+```bash
+cd /path/to/FastGraph-mcp
+python -m pip install .        # 日常使用（装完源码目录可删）
+python -m pip install -e ".[dev]"   # 开发者（改动即时生效）
+```
+
+要求 Python ≥ 3.11。
+
+## 快速开始
+
+**1. 配置 MCP**（零配置：不写 `--root`、不写 `cwd`，打开哪个项目就索引哪个项目）
+
+Claude Code（`~/.claude.json` 或项目 `.mcp.json`）：
+
+```json
+{
+  "mcpServers": {
+    "fastgraph": {
+      "command": "python",
+      "args": ["-m", "fastgraph"]
+    }
+  }
+}
+```
+
+OpenCode（`opencode.json`）：
+
+```json
+{
+  "mcp": {
+    "fastgraph": {
+      "type": "local",
+      "enabled": true,
+      "command": ["python", "-m", "fastgraph"]
+    }
+  }
+}
+```
+
+**2. 使用**：打开任意项目，调用任意工具（推荐先 `project_overview`）即自动建索引，之后增量更新。
+
+桌面客户端（Claude Desktop 等，以固定 cwd 启动 MCP 进程）先调一次 `activate_project(root="/abs/path")` 激活项目；换项目再调一次。要固定分析某个目录，启动参数加 `--root D:/work/my-project`（或环境变量 `FASTGRAPH_ROOT`）。
+
+> Windows 注意：`python` 不要用微软商店别名（用 `where python` 确认）；JSON 路径推荐写正斜杠 `D:/work/project`。
+
+## 让模型主动使用
+
+MCP 工具对模型是可选的——不引导，模型默认用自己顺手的 grep/read。最有效的一步：把下面这段粘贴进项目的 `CLAUDE.md` / `AGENTS.md`（服务端 instructions 与工具描述已内置同样的决策表）：
+
+```md
+## 代码导航：用 FastGraph MCP，不要先用 grep
+- 找代码在哪 / 找用法：先 code_search
+- 打开不熟悉的文件前：先 file_symbols(path) 看结构
+- 回答"谁调用了 X"：用 find_callers（结果为空但带 unresolved_incoming>0 表示有调用者未解析，不能当无人使用）
+- 改函数/类之前：先 impact_analysis(symbol) 看影响面
+- 改 import 前：file_deps(path)；查架构：module_cycles()
+- 只读一个符号：symbol_body(name)；整文件才用 read_file
+- 改完代码：changed_context() 复查波及范围
+- 进陌生仓库：先 project_overview()
+```
+
+## 工具（13 个）
+
+| 任务 | 工具 |
+| --- | --- |
+| 桌面端激活项目 | `activate_project(root)` |
+| 陌生仓库看全局 | `project_overview()` |
+| 按关键词/自然语言定位代码 | `code_search(query, kind?, limit?)` |
+| 一个符号是什么 | `symbol_info(symbol)` |
+| 文件结构（先看结构再读正文） | `file_symbols(path)` |
+| 读文件 / 行区间 | `read_file(path, start_line?, end_line?)` |
+| 只读一个符号的源码 | `symbol_body(symbol)` |
+| 谁调用它（`depth≥2` 传递） | `find_callers(symbol, depth?)` |
+| 它调用谁 | `find_callees(symbol, depth?)` |
+| 改动前看影响面 | `impact_analysis(symbol)` |
+| import 了什么 / 被谁 import | `file_deps(path)` |
+| 文件间 import 环（架构健康） | `module_cycles()` |
+| 改完看变更波及（支持 `base="main"` 对比整个分支） | `changed_context(base?)` |
+
+推荐节奏：`project_overview` → `code_search` 定位 → `file_symbols`/`symbol_body` 读 → `impact_analysis` 改前 → `changed_context` 改后。
+
+所有工具都接受可选 `root=` 参数做单次跨项目查询（按 LRU 缓存 8 个项目）。输出行号全部 1-based。另有 resource `fastgraph://overview` 与 prompt `fastgraph-workflow` 可选配。
+
+## 支持语言
+
+Python、TypeScript/TSX、JavaScript、Vue、Svelte、Go、Rust、Java、C/C++（`.wxml` 模板引用亦支持）。
+
+依赖图按各语言 import 写法解析，含 tsconfig paths / vite alias / uni-app `@` 别名、Go `go.mod` 模块根、Rust crate 根、目录入口（`index.*` / `__init__.*`）。
+
+## 调用图的边界（重要）
+
+真实仓库上约 21%~40% 的调用边能唯一连到符号，其余要么指向外部库，要么接收者类型无法静态确定——后者**不连边、不猜**，而是计数报出：
+
+- `find_callers` 每条结果带 `via`：`resolved`（确证的调用边）或 `text`（同名文本折叠的猜测）
+- 出现 `unresolved_incoming` / `unresolved_outgoing` 字段时，**空列表 ≠ 没有调用者**，按"未知"处理，不能据此判定可删
+- `self.x()`、接口实现、回调注册、动态派发不会连边——宁可漏，不可错
+
+## 开发
+
+```bash
+python -m pytest tests/          # 测试
+python bench/bench.py <项目路径>  # 性能基准（冷索引/增量/查询时延）
+```
+
+## 路线图
+
+- [x] Phase 1-3.5：MCP Server、调用图、影响分析、git 变更感知、多语言依赖解析
+- [ ] Phase 4：可选 BM25/embedding 语义搜索
+- [ ] Phase 5：多项目 workspace
+
+## License
+
+[MIT](LICENSE)

fastgraph_mcp-0.2.0/bench/bench.py

@@ -0,0 +1,125 @@
+"""Reproducible benchmark for FastGraph's headline numbers.
+
+Measures on a target repo (any project directory):
+  1. cold first index      (delete .fastgraph, run one tool call)
+  2. no-op refresh         (query again, nothing changed)
+  3. incremental refresh   (touch one file's content, query again)
+  4. typical query latency (code_search / symbol_info / find_callers / file_deps)
+
+Usage:
+    python bench/bench.py /path/to/project [--keep]
+
+`--keep` preserves the built index (default: the pre-existing .fastgraph state
+is restored — the bench never leaves its own index behind unless asked).
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import statistics
+import sys
+import time
+from pathlib import Path
+
+from fastgraph.db import DB
+from fastgraph.index import Indexer
+from fastgraph import graph
+from fastgraph.search import code_search
+
+
+def _timed(fn, *args, **kwargs):
+    t0 = time.perf_counter()
+    out = fn(*args, **kwargs)
+    return (time.perf_counter() - t0) * 1000.0, out
+
+
+def _query_suite(db: DB, probe_symbol: str | None) -> dict[str, float]:
+    """Latency of one representative call of each query family."""
+    res: dict[str, float] = {}
+    res["code_search"] = _timed(code_search, db, "config", limit=10)[0]
+    res["project_overview"] = _timed(graph.project_overview, db)[0]
+    target = probe_symbol or _first_function(db)
+    if target:
+        res["symbol_info"] = _timed(graph.find_symbols, db, target)[0]
+        res["find_callers"] = _timed(graph.find_callers, db, target, limit=30)[0]
+        res["impact_analysis"] = _timed(graph.impact_analysis, db, target)[0]
+    paths = [r[0] for r in db.conn.execute("SELECT path FROM files LIMIT 1")]
+    if paths:
+        res["file_deps"] = _timed(graph.module_dependencies, db, paths[0])[0]
+    res["module_cycles"] = _timed(graph.module_cycles, db)[0]
+    return res
+
+
+def _first_function(db: DB) -> str | None:
+    row = db.conn.execute(
+        "SELECT name FROM symbols WHERE kind='function' ORDER BY id LIMIT 1"
+    ).fetchone()
+    return row[0] if row else None
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="FastGraph benchmark")
+    ap.add_argument("root", type=Path, help="project directory to benchmark")
+    ap.add_argument("--keep", action="store_true", help="leave the built index in place")
+    args = ap.parse_args(argv)
+    root = args.root.resolve()
+    if not root.is_dir():
+        print(f"error: {root} is not a directory", file=sys.stderr)
+        return 1
+
+    index_dir = root / ".fastgraph"
+    backup: Path | None = None
+    if index_dir.exists():
+        backup = root / ".fastgraph.bench-backup"
+        shutil.move(str(index_dir), str(backup))
+
+    try:
+        db = DB(root)
+        indexer = Indexer(root, db)
+
+        cold_ms, stats = _timed(indexer.refresh)
+        print(f"files={stats.total_files}  symbols={stats.total_symbols}")
+        print(f"cold first index : {cold_ms:8.1f} ms")
+
+        noop_ms, _ = _timed(indexer.refresh)
+        print(f"no-op refresh    : {noop_ms:8.1f} ms")
+
+        # touch one content change: append a harmless line to a random indexed file
+        touched = None
+        for (p,) in db.conn.execute("SELECT path FROM files LIMIT 50"):
+            f = root / p
+            if f.is_file():
+                touched = f
+                break
+        if touched is not None:
+            orig = touched.read_bytes()
+            touched.write_bytes(orig + b"\n# bench touch\n")
+            try:
+                inc_ms, _ = _timed(indexer.refresh)
+                print(f"incremental (1f) : {inc_ms:8.1f} ms")
+            finally:
+                touched.write_bytes(orig)
+
+        # run the query suite several times, report median
+        runs: list[dict[str, float]] = []
+        for _ in range(5):
+            runs.append(_query_suite(db, None))
+        print("\nquery latency (median of 5):")
+        keys = sorted({k for r in runs for k in r})
+        for k in keys:
+            vals = [r[k] for r in runs if k in r]
+            print(f"  {k:<18} {statistics.median(vals):8.1f} ms")
+
+        db.close()
+        if not args.keep:
+            shutil.rmtree(index_dir, ignore_errors=True)
+        return 0
+    finally:
+        if backup is not None and not args.keep:
+            shutil.rmtree(index_dir, ignore_errors=True)
+            shutil.move(str(backup), str(index_dir))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fastgraph_mcp-0.2.0/fastgraph/__init__.py

@@ -0,0 +1,3 @@
+"""FastGraph-MCP: lightweight code intelligence for coding agents."""
+
+__version__ = "0.1.0"

fastgraph_mcp-0.2.0/fastgraph/__main__.py

@@ -0,0 +1,7 @@
+# mypy: disable-error-code=import-untyped
+"""Entry point for `python -m fastgraph`."""
+
+from fastgraph.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fastgraph_mcp-0.2.0/fastgraph/cli.py

@@ -0,0 +1,106 @@
+"""CLI entrypoint: fastgraph [--root <path>] (stdio MCP server).
+
+Without --root, the project root is auto-detected: walk up from the current
+directory to the nearest git root (repo boundary); non-git locations fall
+back to the current directory. MCP clients that launch the server with their
+working directory set to the opened folder therefore index that folder -
+open any project, no config per project.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def detect_root(start: Path) -> Path:
+    """Nearest git root above ``start``, or ``start`` itself if none found.
+
+    ``.git`` may be a directory (normal repo) or a file (gitfile in
+    submodules / worktrees), so ``.exists()`` covers both.
+    """
+    cur = start
+    while True:
+        if (cur / ".git").exists():
+            return cur
+        parent = cur.parent
+        if parent == cur:  # filesystem root: nothing found above
+            return start
+        cur = parent
+
+
+def _writable(path: Path) -> bool:
+    """True if a `.fastgraph` index dir can be created under ``path``."""
+    try:
+        probe = path / ".fastgraph_probe"
+        probe.mkdir(parents=True, exist_ok=True)
+        probe.rmdir()
+        return True
+    except OSError:
+        return False
+
+
+def resolve_root(start: Path) -> Path:
+    """Root to index: nearest git root above ``start`` if writable.
+
+    Falls back through ancestors to the first writable dir (desktop apps
+    launch stdio servers with cwd=C:\\Windows\\System32 etc., which is not
+    writable); final fallback is the user home dir. Prints a hint to stderr
+    whenever the detected root is not `start` itself.
+    """
+    from os import getenv
+
+    home = Path(getenv("USERPROFILE") or Path.home())
+    root = detect_root(start)
+    if not _writable(root):
+        # Desktop apps launch stdio servers with cwd=C:\Windows\System32 etc.
+        # - not writable. Prefer the user home over climbing to a system root.
+        print(
+            f"notice: {root} is not writable, falling back to {home}",
+            file=sys.stderr,
+        )
+        root = home
+    elif root != start:
+        print(f"notice: indexing git root {root} (cwd: {start})", file=sys.stderr)
+    return root
+
+
+def main(argv: list[str] | None = None) -> int:
+    from os import getenv
+
+    parser = argparse.ArgumentParser(
+        prog="fastgraph",
+        description="FastGraph-MCP stdio server (default root: auto-detected from cwd)",
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=None,
+        help="project root to index (default: $FASTGRAPH_ROOT, else nearest git root above cwd, else cwd)",
+    )
+    args = parser.parse_args(argv)
+
+    explicit = args.root or (
+        Path(getenv("FASTGRAPH_ROOT")) if getenv("FASTGRAPH_ROOT") else None
+    )
+    root = (
+        explicit.resolve()
+        if explicit is not None
+        else resolve_root(Path.cwd())
+    )
+    if not root.is_dir():
+        print(f"error: {root} is not a directory", file=sys.stderr)
+        return 1
+
+    try:
+        from fastgraph.server import run_stdio
+
+        run_stdio(root)
+    except KeyboardInterrupt:
+        return 0
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())