pygraph-mcp 0.1.0__tar.gz

pygraph_mcp-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: uv sync --group dev
+
+      - name: Run tests
+        run: uv run pytest
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        run: uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.UV_PUBLISH_TOKEN }}

pygraph_mcp-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.pygraph/
+.pygraph/ref-*.json
+.graph/
+*.egg
+venv/
+.venv/
+.env
+.coverage
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/

pygraph_mcp-0.1.0/AGENTS.md

@@ -0,0 +1,69 @@
+# pygraph — Project DNA
+
+## Vision
+A fast, local-only CLI tool that indexes Python / Flask codebases using AST parsing
+into a queryable graph.json for AI coding agents. Equivalent to gograph / tsgraph but for Python.
+Output is Markdown + JSON. No network calls, no telemetry, no SaaS backend.
+
+## Design Philosophy (Go/TS → Python Adaptation)
+pygraph is inspired by gograph (Go) and tsgraph (TypeScript) but adapted for Python / Flask.
+Key language-driven differences:
+- **Export model**: Python uses `__all__` and `_name` convention (private by underscore); `isExported` maps to `not name.startswith('_')` or `name in __all__`
+- **No goroutines/channels or async/promise** — Python has `asyncio`, threads, and generators
+- **No struct tags** — Python has no native equivalent; use `dataclass` fields or type annotations
+- **Router detection** is Flask route decorators (`@app.route`), Blueprints (`register_blueprint`), not Gin/mux or Next.js
+- **Flask components** are tracked: views, Blueprints, CLI commands (`@app.cli.command`), template rendering, error handlers
+- **Decorator support** — Python decorators are first-class; tracked as edges in the graph
+- **Interface satisfaction** — Python uses `ABC` / `Protocol` (PEP 544) structural subtyping
+- **Module-level code** — Python modules execute on import; side effects are tracked
+- **Class methods / static methods / properties** — `@classmethod`, `@staticmethod`, `@property` tracked distinctly
+- Go-specific concepts (structs with fields+tests, `MutationEdge`, `StructField.tags`) are replaced by Python equivalents (dataclass fields, test functions matching `test_*`)
+
+## Tech Stack
+- Runtime: Python 3.11+
+- Package manager: `uv`
+- AST: `ast` (stdlib) + `astroid` for enhanced traversal
+- CLI: `typer`
+- MCP: `mcp` Python SDK
+- Testing: `pytest` + `pytest-cov`
+- Linting: `ruff`
+- Type checking: `mypy` (strict mode)
+
+## Agent Rules
+
+### Task Management
+- READ TODOS.md at session start to know what's done and what's next
+- UPDATE TODOS.md when you start/finish a task (`[.]` in-progress, `[x]` done)
+- Work in phase order unless a task has no blockers
+- After a phase completes (all items `[x]`), run `git init` if not yet done, then commit: `git add -A && git commit -m "phase N: <title>"`
+
+### Orchestration
+- This is a single-orchestrator project. When a task has multiple independent
+  sub-tasks, delegate via the `task` tool (`subagent_type: general`) rather
+  than doing them sequentially.
+- For each delegated sub-task, specify:
+  1. Exact files the sub-agent may modify
+  2. Which phase from TODOS.md it belongs to
+  3. What to return (never let sub-agents commit or merge)
+- After all sub-tasks complete, run `uv run pytest && uv run mypy src && uv run ruff check` and fix any issues directly. Do NOT re-delegate broken builds.
+
+### Quality
+- Run `uv run pytest`, `uv run mypy src`, and `uv run ruff check` after every task completion
+- Fix all failures before marking `[x]`
+- If the project is already broken when you start, note it in TODOS.md and fix it first
+
+### Research
+- Use webfetch when unsure about an API — check Python `ast` docs, Flask docs,
+  or reference tsgraph source or gograph Go source
+- DO NOT guess API signatures
+
+### Code Style
+- No comments in source files unless logic is non-obvious
+- Type annotations everywhere, avoid `Any`
+- Follow patterns from adjacent files in the codebase
+- No emojis in source code or commit messages
+- Follow PEP 8 conventions (enforced by ruff)
+
+### Communication
+- Be concise. Use TODOS.md for status, respond with only what's needed.
+- If stuck, explain the blocker clearly rather than overthinking.

pygraph_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: pygraph-mcp
+Version: 0.1.0
+Summary: AST-based Python/Flask codebase indexer for AI agents
+Project-URL: Homepage, https://github.com/shvmgyl15/pygraph
+Project-URL: Repository, https://github.com/shvmgyl15/pygraph
+Project-URL: Issues, https://github.com/shvmgyl15/pygraph/issues
+Author-email: Shivam Goel <sg15rokz@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: astroid>=3.3
+Requires-Dist: mcp>=1.0
+Requires-Dist: pathspec>=1.1.1
+Requires-Dist: pydantic>=2.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# pygraph
+
+AST-based Python/Flask codebase indexer for AI coding agents.
+
+`pygraph` parses your Python project into a queryable graph (`graph.json`) using static analysis (AST). It detects Flask routes, blueprints, templates, CLI commands, decorators, dependencies, and more — with **zero network calls** and **no telemetry**.
+
+Designed as a companion tool for AI agents (opencode, Cline, etc.) via MCP, or for direct CLI use during development.
+
+---
+
+## Quick Start
+
+```bash
+pip install pygraph-mcp
+
+# Or with uv:
+uv pip install pygraph-mcp
+```
+
+Index your project and start querying:
+
+```bash
+cd my-python-project
+pygraph build
+pygraph public
+pygraph node "my_function"
+pygraph callers "my_function"
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `build` | Index project into `.pygraph/graph.json` |
+| `node` | Show details of a symbol |
+| `callers` | Show who calls the given symbol |
+| `callees` | Show what the given symbol calls |
+| `source` | Show source code of a file |
+| `query` | Search symbols by pattern (regex or substring) |
+| `context` | Show symbol with callers, callees, tests, and source |
+| `imports` | Show imports of a file |
+| `public` | List all exported (public) symbols |
+| `focus` | Show JSON detail for a symbol |
+| `impact` | Show downstream impact (BFS from symbol) |
+| `path` | Show shortest call path between two symbols |
+| `orphans` | List uncalled private symbols |
+| `trace` | Find error messages and trace their call paths |
+| `complexity` | Show McCabe cyclomatic complexity |
+| `coupling` | Show afferent/efferent coupling metrics |
+| `hotspot` | Show high-risk symbols (complexity x coupling) |
+| `deps` | List external dependencies |
+| `boundaries` | Check architecture boundary violations |
+| `changes` | Show symbol changes since a git ref |
+| `stale` | List files not modified in N days |
+| `plan` | Generate a change plan report |
+| `review` | Generate a Markdown code review report |
+| `graph-report` | Generate a Markdown report about the codebase |
+| `add-opencode-plugin` | Create `.opencode.json` with pygraph MCP config |
+| `mcp` | Start MCP stdio server for AI agent integration |
+
+---
+
+## MCP Integration
+
+Start the MCP server and connect your AI agent:
+
+```bash
+pygraph mcp --root /path/to/project
+```
+
+All query commands are exposed as MCP tools, making them callable from opencode, Cline, and any MCP-compatible client.
+
+---
+
+## Flask Support
+
+pygraph detects Flask-specific constructs out of the box:
+
+- Route decorators (`@app.route`) with HTTP methods and URL parameters
+- Blueprint creation and registration (`register_blueprint`)
+- Template rendering (`render_template`, `render_template_string`)
+- Error handlers (`@app.errorhandler`)
+- CLI commands (`@app.cli.command`)
+- Flask extension usage
+
+---
+
+## Architecture Enforcement
+
+Create `.pygraph/boundaries.json`:
+
+```json
+{
+  "layers": [
+    {"name": "views",     "pattern": "src/views/",     "allowed": ["services"]},
+    {"name": "services",  "pattern": "src/services/",  "allowed": ["models", "repos"]},
+    {"name": "models",    "pattern": "src/models/",    "allowed": []},
+    {"name": "repos",     "pattern": "src/repos/",     "allowed": ["models"]}
+  ]
+}
+```
+
+Then run:
+
+```bash
+pygraph boundaries
+```
+
+---
+
+## Requirements
+
+- Python 3.11+
+- `uv` (recommended) or `pip`
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/shvmgyl15/pygraph.git
+cd pygraph
+uv sync
+uv run pytest
+uv run mypy src
+uv run ruff check
+```
+
+---
+
+## How It Works
+
+```
+┌──────────┐    ┌──────────────┐    ┌───────────┐
+│  Scanner  │ → │  Extractors  │ → │   Graph   │
+│ (walker)  │   │ (AST, Flask) │   │  (JSON)   │
+└──────────┘    └──────────────┘    └───────────┘
+                                          ↓
+                                   ┌──────────┐
+                                   │  Query   │
+                                   │  Engine  │
+                                   └──────────┘
+```
+
+1. **Scan** — walks the project tree, respects `.gitignore`, classifies files
+2. **Extract** — parses Python source with `ast`, extracts symbols, calls, imports, Flask decorators, dependencies
+3. **Graph** — serializes everything to `.pygraph/graph.json` (incremental builds supported)
+4. **Query** — CLI or MCP tools query the graph for callers, callees, impact, paths, orphans, complexity, coupling, etc.
+
+---
+
+## Inspiration
+
+pygraph was inspired by and follows the same design philosophy as:
+
+- [tsgraph](https://github.com/shvmgyl15/tsgraph) — TypeScript codebase indexer
+- [gograph](https://github.com/ozgurcd/gograph) — Go codebase indexer
+
+Both projects use AST-based static analysis to create queryable code graphs for AI coding agents. pygraph adapts the same concept to Python and Flask.

pygraph_mcp-0.1.0/README.md

@@ -0,0 +1,161 @@
+# pygraph
+
+AST-based Python/Flask codebase indexer for AI coding agents.
+
+`pygraph` parses your Python project into a queryable graph (`graph.json`) using static analysis (AST). It detects Flask routes, blueprints, templates, CLI commands, decorators, dependencies, and more — with **zero network calls** and **no telemetry**.
+
+Designed as a companion tool for AI agents (opencode, Cline, etc.) via MCP, or for direct CLI use during development.
+
+---
+
+## Quick Start
+
+```bash
+pip install pygraph-mcp
+
+# Or with uv:
+uv pip install pygraph-mcp
+```
+
+Index your project and start querying:
+
+```bash
+cd my-python-project
+pygraph build
+pygraph public
+pygraph node "my_function"
+pygraph callers "my_function"
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `build` | Index project into `.pygraph/graph.json` |
+| `node` | Show details of a symbol |
+| `callers` | Show who calls the given symbol |
+| `callees` | Show what the given symbol calls |
+| `source` | Show source code of a file |
+| `query` | Search symbols by pattern (regex or substring) |
+| `context` | Show symbol with callers, callees, tests, and source |
+| `imports` | Show imports of a file |
+| `public` | List all exported (public) symbols |
+| `focus` | Show JSON detail for a symbol |
+| `impact` | Show downstream impact (BFS from symbol) |
+| `path` | Show shortest call path between two symbols |
+| `orphans` | List uncalled private symbols |
+| `trace` | Find error messages and trace their call paths |
+| `complexity` | Show McCabe cyclomatic complexity |
+| `coupling` | Show afferent/efferent coupling metrics |
+| `hotspot` | Show high-risk symbols (complexity x coupling) |
+| `deps` | List external dependencies |
+| `boundaries` | Check architecture boundary violations |
+| `changes` | Show symbol changes since a git ref |
+| `stale` | List files not modified in N days |
+| `plan` | Generate a change plan report |
+| `review` | Generate a Markdown code review report |
+| `graph-report` | Generate a Markdown report about the codebase |
+| `add-opencode-plugin` | Create `.opencode.json` with pygraph MCP config |
+| `mcp` | Start MCP stdio server for AI agent integration |
+
+---
+
+## MCP Integration
+
+Start the MCP server and connect your AI agent:
+
+```bash
+pygraph mcp --root /path/to/project
+```
+
+All query commands are exposed as MCP tools, making them callable from opencode, Cline, and any MCP-compatible client.
+
+---
+
+## Flask Support
+
+pygraph detects Flask-specific constructs out of the box:
+
+- Route decorators (`@app.route`) with HTTP methods and URL parameters
+- Blueprint creation and registration (`register_blueprint`)
+- Template rendering (`render_template`, `render_template_string`)
+- Error handlers (`@app.errorhandler`)
+- CLI commands (`@app.cli.command`)
+- Flask extension usage
+
+---
+
+## Architecture Enforcement
+
+Create `.pygraph/boundaries.json`:
+
+```json
+{
+  "layers": [
+    {"name": "views",     "pattern": "src/views/",     "allowed": ["services"]},
+    {"name": "services",  "pattern": "src/services/",  "allowed": ["models", "repos"]},
+    {"name": "models",    "pattern": "src/models/",    "allowed": []},
+    {"name": "repos",     "pattern": "src/repos/",     "allowed": ["models"]}
+  ]
+}
+```
+
+Then run:
+
+```bash
+pygraph boundaries
+```
+
+---
+
+## Requirements
+
+- Python 3.11+
+- `uv` (recommended) or `pip`
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/shvmgyl15/pygraph.git
+cd pygraph
+uv sync
+uv run pytest
+uv run mypy src
+uv run ruff check
+```
+
+---
+
+## How It Works
+
+```
+┌──────────┐    ┌──────────────┐    ┌───────────┐
+│  Scanner  │ → │  Extractors  │ → │   Graph   │
+│ (walker)  │   │ (AST, Flask) │   │  (JSON)   │
+└──────────┘    └──────────────┘    └───────────┘
+                                          ↓
+                                   ┌──────────┐
+                                   │  Query   │
+                                   │  Engine  │
+                                   └──────────┘
+```
+
+1. **Scan** — walks the project tree, respects `.gitignore`, classifies files
+2. **Extract** — parses Python source with `ast`, extracts symbols, calls, imports, Flask decorators, dependencies
+3. **Graph** — serializes everything to `.pygraph/graph.json` (incremental builds supported)
+4. **Query** — CLI or MCP tools query the graph for callers, callees, impact, paths, orphans, complexity, coupling, etc.
+
+---
+
+## Inspiration
+
+pygraph was inspired by and follows the same design philosophy as:
+
+- [tsgraph](https://github.com/shvmgyl15/tsgraph) — TypeScript codebase indexer
+- [gograph](https://github.com/ozgurcd/gograph) — Go codebase indexer
+
+Both projects use AST-based static analysis to create queryable code graphs for AI coding agents. pygraph adapts the same concept to Python and Flask.

pygraph_mcp-0.1.0/TODOS.md

@@ -0,0 +1,109 @@
+# pygraph — Implementation Plan
+
+## Phase 1: Project Scaffold
+- [x] Update opencode.json with AGENTS.md reference
+- [x] Create AGENTS.md with project DNA
+- [x] Create TODOS.md (this file)
+- [x] Git init + Phase 1 commit
+- [x] Initialize pyproject.toml with dependencies (typer, astroid, mcp, pytest, mypy, ruff)
+- [x] Configure mypy (strict mode)
+- [x] Configure ruff (PEP 8, import sorting)
+- [x] Create src/pygraph directory structure (commands/, scanner/, graph/, extractors/)
+- [x] Setup pytest config (conftest.py, test fixtures)
+
+## Phase 2: Core Data Model
+- [x] Define graph types (Graph, PackageNode, FileNode, SymbolNode, and all edge types)
+- [x] Add JSON serialization / deserialization (dataclasses)
+- [x] Write unit tests for graph types (42 tests)
+
+## Phase 3: Scanner + Parser Core
+- [x] Implement file scanner (walk tree, gitignore support, file classification)
+- [x] Implement symbol extractor (ast: functions, classes, methods, variables, constants)
+- [x] Implement call expression extractor
+- [x] Implement import edge + dependency extractor (requirements.txt, pyproject.toml)
+- [x] Implement decorator tracking (inline in symbol extraction)
+- [x] Wire up `build` command end-to-end (builder.py orchestrates scan → parse → write)
+- [x] Write parser/scanner unit tests (25 tests for scanner + extractors)
+
+## Phase 4: Query Commands
+- [x] GraphQuery engine (query.py) — symbol lookup, callers/callees, imports, regex, context, impact, path, orphans, trace/errorflow
+- [x] callers / callees CLI commands
+- [x] node / source / query CLI commands
+- [x] context (bundle — node + source + callers + callees + tests)
+- [x] imports / public / focus CLI commands
+- [x] impact / path / orphans / trace CLI commands (basic BFS, refined in Phase 7)
+- [x] query regex support (fallback to substring)
+- [x] Write query command tests (60 tests)
+
+## Phase 5: Flask-Specific Extractors
+- [x] Route detection (`@app.route`, method, URL params)
+- [x] Blueprint detection and registration
+- [x] Template rendering detection (`render_template`)
+- [x] Error handler detection (`@app.errorhandler`)
+- [x] CLI command detection (`@app.cli.command`)
+- [x] Flask extension detection and usage
+- [x] Write extractor tests
+
+## Phase 6: Analysis Commands
+- [x] complexity (McCabe / cyclomatic)
+- [x] hotspot / coupling / deps
+- [x] Write analysis tests
+
+## Phase 7: Graph Traversal
+- [x] impact (BFS downstream blast radius with deque, max_depth, transitive)
+- [x] path (BFS shortest path with deque, file/line in steps)
+- [x] orphans (dead code detection via reachability from entry points)
+- [x] trace / errorflow (reverse BFS from string literal through callers)
+- [x] Write traversal tests (169 tests, up from 159)
+
+## Phase 8: MCP Server
+- [x] MCP stdio server wrapping all query tools (`src/pygraph/server.py`)
+- [x] Tool definition for each search/query command (18 tools)
+- [x] MCP unit test (30 tests, unit-test style via `_query_override`)
+- [x] `--root` flag for running MCP server against any project
+
+## Phase 9: Advanced Features
+- [x] boundaries (architecture enforcement via .pygraph/boundaries.json)
+- [x] Incremental builds (mtime tracking, merge unchanged data, skip re-parse)
+- [x] changes / stale (git-aware incremental analysis)
+- [x] plan / review (change planning reports)
+- [x] add-opencode-plugin (auto-configure opencode MCP + agent)
+- [x] Enhanced GRAPH_REPORT.md (hotspots, boundaries, coupling, stale)
+
+## Phase 10: Query Engine Fixes + Missing Extractors
+- [x] Rewrite `_resolve_callee` to parse `ClassName(args).method()` patterns
+- [x] Fix `get_callers` to use `_resolve_callee`
+- [x] Fix `get_callees` to aggregate calls from class methods
+- [x] Fix coupling/hotspot to use qualified names (`ClassName.method`)
+- [x] Fix `_callers_by_name` index to also key by receiver
+- [x] Fix `get_path` visited tracking redundant check
+- [x] Build env_reads extractor (`os.environ.get`, `os.getenv`, `environ[]`)
+- [x] Build errors extractor (`raise` / `raise ... from ...`)
+- [x] Build test_edges extractor (test functions → called project symbols)
+- [x] Build implements extractor (ABC/Protocol subclassing)
+- [x] Better error messages for `changes`/`plan`/`review` snapshot misses
+- [x] `orphans --all` flag for public uncalled symbols
+- [x] `context` structured summary (source behind `--source` flag)
+- [x] P0: Fix `caller_symbol_id` mismatch — qualify class.method name in calls.py
+- [x] P1: Add `app.add_url_rule()` route extractor in flask.py
+- [x] P2: Add Poetry dependency parsing in imports.py
+- [x] P4: Auto-build graph from git ref with caching (`._load_git_graph` fallback)
+- [x] P4: Update `.gitignore` for `ref-*.json` cache files
+- [x] Run `pytest && mypy src && ruff check` — fix all failures
+
+## Phase 11: Post-Build Plugin System
+- [x] Add `src/pygraph/config.py` — load `[tool.pygraph]` from `pyproject.toml`
+- [x] Add `_run_plugins()` in `builder.py` — import & run each plugin script's `run(graph)`
+- [x] Wire into `build_graph()` — plugins run after graph assembly, before return
+- [x] Errors, missing scripts, missing `run` function all warn and continue
+- [x] Multiple plugins supported in order; failure of one doesn't block the next
+- [x] Tests: plugin runs + adds edges, missing plugin, no run function, exception, no plugins, multiple, partial failure
+
+## Phase 12: PyPI Publishing Prep
+- [x] Add author, license, readme, classifiers, urls to pyproject.toml
+- [x] Add `__version__` to `src/pygraph/__init__.py`
+- [x] Update package name to `pygraph-mcp` (pygraph taken on PyPI)
+- [x] Update README.md install instructions for PyPI
+- [x] Create `.github/workflows/publish.yml` for auto-publishing on tags
+- [x] Fix unwanted imports in tests/test_plugins.py
+- [x] Verify build, tests, mypy, ruff all pass

pygraph_mcp-0.1.0/opencode.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "opencode-go/deepseek-v4-flash",
+  "default_agent": "plan",
+  "instructions": ["AGENTS.md"],
+  "permission": {
+    "read": {
+      "*": "allow",
+      "*.env": "allow",
+      "*.env.*": "allow"
+    },
+    "external_directory": {
+      "/tmp/**": "allow"
+    },
+    "grep": "allow",
+    "glob": "allow",
+    "lsp": "allow",
+    "skill": "allow",
+    "webfetch": "allow",
+    "websearch": "allow"
+  }
+}

pygraph_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "pygraph-mcp"
+version = "0.1.0"
+description = "AST-based Python/Flask codebase indexer for AI agents"
+requires-python = ">=3.11"
+authors = [{name = "Shivam Goel", email = "sg15rokz@gmail.com"}]
+license = "MIT"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Code Generators",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "typer>=0.12",
+    "astroid>=3.3",
+    "mcp>=1.0",
+    "pydantic>=2.0",
+    "pathspec>=1.1.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/shvmgyl15/pygraph"
+Repository = "https://github.com/shvmgyl15/pygraph"
+Issues = "https://github.com/shvmgyl15/pygraph/issues"
+
+[project.scripts]
+pygraph = "pygraph.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pygraph"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.mypy]
+strict = true
+python_version = "3.11"
+files = ["src"]
+exclude = ["tests/"]
+disallow_any_unimported = true
+disallow_any_decorated = true
+disallow_subclassing_any = true
+warn_unused_ignores = true
+warn_redundant_casts = true
+warn_return_any = true
+no_implicit_optional = true
+check_untyped_defs = true
+
+[tool.ruff]
+src = ["src"]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP", "B", "SIM"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-v --cov=pygraph --cov-report=term-missing"
+
+[dependency-groups]
+dev = [
+    "mypy>=2.1.0",
+    "pytest>=9.0.3",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.13",
+]

pygraph_mcp-0.1.0/src/pygraph/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pygraph_mcp-0.1.0/src/pygraph/__main__.py

@@ -0,0 +1,3 @@
+from pygraph.cli import app
+
+app()