graphlint 0.2.0__tar.gz → 0.3.0__tar.gz

{graphlint-0.2.0 → graphlint-0.3.0}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.0] - 2026-07-23
+
+### Added
+- Experimental Rust language analysis via `tree-sitter-rust` (opt-in via `[rust]`
+  optional dependency group)
+- `query --public-as-entry` option: treats all public functions/methods as entry
+  points for dead-code reachability analysis
+- `pub_api` entry rule template (disabled by default) for projects that want
+  public API surface as the primary entry
+
+
 ## [0.2.0] - 2026-07-22
 
 ### Added

{graphlint-0.2.0/graphlint.egg-info → graphlint-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphlint
-Version: 0.2.0
+Version: 0.3.0
 Summary: A static analysis tool for identifying dead code in a codebase. It provides Python API and CLI for use by agents.
 Author-email: Yutong Zou <yutong.zou.24@alumni.ucl.ac.uk>
 License-Expression: MIT
@@ -27,6 +27,9 @@ License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-cov>=4; extra == "dev"
+Provides-Extra: rust
+Requires-Dist: tree-sitter<0.25,>=0.22; extra == "rust"
+Requires-Dist: tree-sitter-rust<0.25,>=0.22; extra == "rust"
 Dynamic: license-file
 
 # graphlint
@@ -35,20 +38,31 @@ Dynamic: license-file
 [![Python](https://img.shields.io/pypi/pyversions/graphlint)](https://pypi.org/project/graphlint/)
 [![License](https://img.shields.io/pypi/l/graphlint)](https://github.com/AngelosZou/graphlint/blob/main/LICENSE)
 
-[![en](https://img.shields.io/badge/lang-en-red.svg)](https://github.com/AngelosZou/graphlint/blob/main/README.md)
-[![zh](https://img.shields.io/badge/lang-zh--CN-blue.svg)](https://github.com/AngelosZou/graphlint/blob/main/docs/zh/README.md)
+[English](https://github.com/AngelosZou/graphlint/blob/main/README.md) | [简体中文](https://github.com/AngelosZou/graphlint/blob/main/docs/zh/README.md)
 
-**Dead code detection for AI-generated Python codebases.**
+**Dead code detection for AI-generated codebases.**
 
-AI agents generate code rapidly, leaving behind dead and redundant code that pollutes the LLM's context window and dilutes attention. Graphlint analyzes your Python codebase's dependency graph to identify entry points and **detect dead code** — components unreachable from any entry point — so agents can self-clean and keep the codebase lean.
+AI agents generate code rapidly, leaving behind dead and redundant code that pollutes the LLM's context window and dilutes attention. Graphlint analyzes your codebase's dependency graph to identify entry points and **detect dead code** — components unreachable from any entry point — so agents can self-clean and keep the codebase lean.
+
+## Supported Languages
+
+| Language | Status | Parser | Features |
+|----------|--------|--------|----------|
+| **Python** (`.py`) | Built-in | `ast` (stdlib) | Decorators, type annotations, dynamic imports, framework-aware entry detection |
+| **Rust** (`.rs`) | Built-in (opt-in deps) | `tree-sitter` | Attribute macros, traits, `pub` visibility, `macro_rules!` |
+
+Install with Rust support: `pip install graphlint[rust]` (adds `tree-sitter` and `tree-sitter-rust`).
 
 ## Features
 
 - **Dead code detection** — finds components unreachable from any entry point via graph traversal
-- **AST parsing** — extracts classes, functions, methods, variables, and fields; aware of type annotations and unpacked variables (e.g., loop bindings)
+- **Multi-language support** — Python and Rust backends via a language adapter abstraction; Python uses stdlib `ast`, Rust uses `tree-sitter`
+- **Language-specific awareness** — Python decorators, Rust attribute macros (`#[tokio::main]`, `#[test]`), trait implementations, `pub` visibility, and more
+- **AST/CST parsing** — extracts functions, methods, structs, enums, traits, impls, macros, variables, and fields; aware of type annotations and unpacked variables
 - **Dependency graph** — builds directed edges: `read`, `write`, `call`, `inherit`, `decorate`
-- **Entry point detection** — 10 built-in rules (main, FastAPI, Flask, Django, Click, Typer, Celery, pytest, plus package and test entries) and custom rules
-- **Multi-language architecture** — language adapter abstraction layer, laying the foundation for future multi-language support
+- **Entry point detection** — 17 built-in rules covering Python frameworks (FastAPI, Flask, Django, Click, Typer, Celery, pytest) and Rust conventions (main, async runtimes, WASM, proc macros, FFI, tests, pub API) plus custom rules
+- **Configurable entry templates** — add custom entry rules via `ast_pattern` prefixes including `function_call:`, `function_def:`, `decorator:`, `file_match:`, `visibility:pub` (Rust), `trait_impl:` (Rust), `macro_def:` (Rust), and more
+- **`--public-as-entry` flag** — treat all public items (Rust `pub`) as entry points for library-crate analysis
 - **Warning detection** — 11 warning types including circular references, unused imports, write-only variables, and more
 - **Python API + CLI** — integrate into any Tool, CI pipeline, or let agents self-analyze and self-clean
 
@@ -60,6 +74,12 @@ pip install graphlint
 
 **Requirements:** Python >= 3.9
 
+For Rust support (`.rs` files), install the optional `tree-sitter` dependencies:
+
+```bash
+pip install graphlint[rust]
+```
+
 ## Quick Start
 
 ### Agent Integration
@@ -96,6 +116,9 @@ graphlint query -g 1 --detail full
 # Exit non-zero when dead code or circular refs found (for CI)
 graphlint query --json --fail-on dead_code,circular_ref
 
+# Treat all public items as entry points (library-crate mode)
+graphlint query --public-as-entry
+
 # Rebuild index
 graphlint build --force
 
@@ -193,7 +216,10 @@ Full documentation is available in the [docs/](https://github.com/AngelosZou/gra
 
 ## Limitations
 
-- **Static analysis only** — graphlint performs static analysis and cannot detect runtime linkage such as `getattr`, `importlib`, or dynamic dispatch patterns, which may result in false positives. **Mitigation:** add custom entry rules matching your codebase's conventions. For example, graphlint's own codebase uses `function_def:_detect_*` and `function_def:visit_*` patterns to prevent functions discovered via `getattr` from being flagged as dead.
+- **Static analysis only** — graphlint performs static analysis and cannot detect runtime linkage such as `getattr`, `importlib`, or dynamic dispatch patterns, which may result in false positives. This primarily affects Python; Rust's static dispatch model produces fewer false positives. **Mitigation:** add custom entry rules matching your codebase's conventions. For example, graphlint's own codebase uses `function_def:_detect_*` and `function_def:visit_*` patterns to prevent functions discovered via `getattr` from being flagged as dead.
+- **Python dynamic imports** — due to Python's dynamic import mechanisms (`importlib`, `getattr`, metaclasses, etc.), the default entry templates may produce false positives in codebases that rely heavily on runtime dispatch. Users should tune the `entry_rules` configuration to match their project's conventions.
+- **Rust macro expansion** — tree-sitter parses unexpanded source; procedural macros and `macro_rules!` bodies appear as opaque token trees. Some macro-generated call paths may be missed. `#[derive]` attributes are partially recognized via implicit `inherit` edges.
+- **`--public-as-entry` scope** — this flag only applies to languages with `public` visibility declarations (Rust `pub`). It has no effect on Python files. Toggling this flag triggers a full re-index. For long-term library-crate analysis, prefer enabling the `rust_pub_api` entry rule via `graphlint config` to persist the setting.
 - **Large codebase build time** — on a large codebase with 700+ `.py` files, 1,000+ classes, and 14,000+ functions, a full rebuild takes approximately 200 seconds (actual performance depends on hardware). Small projects (~60 files) complete in ~1 second. **Best practice:** run `query` before making changes to plan your work, and avoid invoking `query` during refactoring to prevent unnecessary index rebuilds.
 
 ## License

{graphlint-0.2.0 → graphlint-0.3.0}/README.md

@@ -4,20 +4,31 @@
 [![Python](https://img.shields.io/pypi/pyversions/graphlint)](https://pypi.org/project/graphlint/)
 [![License](https://img.shields.io/pypi/l/graphlint)](https://github.com/AngelosZou/graphlint/blob/main/LICENSE)
 
-[![en](https://img.shields.io/badge/lang-en-red.svg)](README.md)
-[![zh](https://img.shields.io/badge/lang-zh--CN-blue.svg)](docs/zh/README.md)
+[English](README.md) | [简体中文](docs/zh/README.md)
 
-**Dead code detection for AI-generated Python codebases.**
+**Dead code detection for AI-generated codebases.**
 
-AI agents generate code rapidly, leaving behind dead and redundant code that pollutes the LLM's context window and dilutes attention. Graphlint analyzes your Python codebase's dependency graph to identify entry points and **detect dead code** — components unreachable from any entry point — so agents can self-clean and keep the codebase lean.
+AI agents generate code rapidly, leaving behind dead and redundant code that pollutes the LLM's context window and dilutes attention. Graphlint analyzes your codebase's dependency graph to identify entry points and **detect dead code** — components unreachable from any entry point — so agents can self-clean and keep the codebase lean.
+
+## Supported Languages
+
+| Language | Status | Parser | Features |
+|----------|--------|--------|----------|
+| **Python** (`.py`) | Built-in | `ast` (stdlib) | Decorators, type annotations, dynamic imports, framework-aware entry detection |
+| **Rust** (`.rs`) | Built-in (opt-in deps) | `tree-sitter` | Attribute macros, traits, `pub` visibility, `macro_rules!` |
+
+Install with Rust support: `pip install graphlint[rust]` (adds `tree-sitter` and `tree-sitter-rust`).
 
 ## Features
 
 - **Dead code detection** — finds components unreachable from any entry point via graph traversal
-- **AST parsing** — extracts classes, functions, methods, variables, and fields; aware of type annotations and unpacked variables (e.g., loop bindings)
+- **Multi-language support** — Python and Rust backends via a language adapter abstraction; Python uses stdlib `ast`, Rust uses `tree-sitter`
+- **Language-specific awareness** — Python decorators, Rust attribute macros (`#[tokio::main]`, `#[test]`), trait implementations, `pub` visibility, and more
+- **AST/CST parsing** — extracts functions, methods, structs, enums, traits, impls, macros, variables, and fields; aware of type annotations and unpacked variables
 - **Dependency graph** — builds directed edges: `read`, `write`, `call`, `inherit`, `decorate`
-- **Entry point detection** — 10 built-in rules (main, FastAPI, Flask, Django, Click, Typer, Celery, pytest, plus package and test entries) and custom rules
-- **Multi-language architecture** — language adapter abstraction layer, laying the foundation for future multi-language support
+- **Entry point detection** — 17 built-in rules covering Python frameworks (FastAPI, Flask, Django, Click, Typer, Celery, pytest) and Rust conventions (main, async runtimes, WASM, proc macros, FFI, tests, pub API) plus custom rules
+- **Configurable entry templates** — add custom entry rules via `ast_pattern` prefixes including `function_call:`, `function_def:`, `decorator:`, `file_match:`, `visibility:pub` (Rust), `trait_impl:` (Rust), `macro_def:` (Rust), and more
+- **`--public-as-entry` flag** — treat all public items (Rust `pub`) as entry points for library-crate analysis
 - **Warning detection** — 11 warning types including circular references, unused imports, write-only variables, and more
 - **Python API + CLI** — integrate into any Tool, CI pipeline, or let agents self-analyze and self-clean
 
@@ -29,6 +40,12 @@ pip install graphlint
 
 **Requirements:** Python >= 3.9
 
+For Rust support (`.rs` files), install the optional `tree-sitter` dependencies:
+
+```bash
+pip install graphlint[rust]
+```
+
 ## Quick Start
 
 ### Agent Integration
@@ -65,6 +82,9 @@ graphlint query -g 1 --detail full
 # Exit non-zero when dead code or circular refs found (for CI)
 graphlint query --json --fail-on dead_code,circular_ref
 
+# Treat all public items as entry points (library-crate mode)
+graphlint query --public-as-entry
+
 # Rebuild index
 graphlint build --force
 
@@ -162,7 +182,10 @@ Full documentation is available in the [docs/](docs/) directory:
 
 ## Limitations
 
-- **Static analysis only** — graphlint performs static analysis and cannot detect runtime linkage such as `getattr`, `importlib`, or dynamic dispatch patterns, which may result in false positives. **Mitigation:** add custom entry rules matching your codebase's conventions. For example, graphlint's own codebase uses `function_def:_detect_*` and `function_def:visit_*` patterns to prevent functions discovered via `getattr` from being flagged as dead.
+- **Static analysis only** — graphlint performs static analysis and cannot detect runtime linkage such as `getattr`, `importlib`, or dynamic dispatch patterns, which may result in false positives. This primarily affects Python; Rust's static dispatch model produces fewer false positives. **Mitigation:** add custom entry rules matching your codebase's conventions. For example, graphlint's own codebase uses `function_def:_detect_*` and `function_def:visit_*` patterns to prevent functions discovered via `getattr` from being flagged as dead.
+- **Python dynamic imports** — due to Python's dynamic import mechanisms (`importlib`, `getattr`, metaclasses, etc.), the default entry templates may produce false positives in codebases that rely heavily on runtime dispatch. Users should tune the `entry_rules` configuration to match their project's conventions.
+- **Rust macro expansion** — tree-sitter parses unexpanded source; procedural macros and `macro_rules!` bodies appear as opaque token trees. Some macro-generated call paths may be missed. `#[derive]` attributes are partially recognized via implicit `inherit` edges.
+- **`--public-as-entry` scope** — this flag only applies to languages with `public` visibility declarations (Rust `pub`). It has no effect on Python files. Toggling this flag triggers a full re-index. For long-term library-crate analysis, prefer enabling the `rust_pub_api` entry rule via `graphlint config` to persist the setting.
 - **Large codebase build time** — on a large codebase with 700+ `.py` files, 1,000+ classes, and 14,000+ functions, a full rebuild takes approximately 200 seconds (actual performance depends on hardware). Small projects (~60 files) complete in ~1 second. **Best practice:** run `query` before making changes to plan your work, and avoid invoking `query` during refactoring to prevent unnecessary index rebuilds.
 
 ## License

{graphlint-0.2.0 → graphlint-0.3.0}/README_PYPI.md

@@ -4,20 +4,31 @@
 [![Python](https://img.shields.io/pypi/pyversions/graphlint)](https://pypi.org/project/graphlint/)
 [![License](https://img.shields.io/pypi/l/graphlint)](https://github.com/AngelosZou/graphlint/blob/main/LICENSE)
 
-[![en](https://img.shields.io/badge/lang-en-red.svg)](https://github.com/AngelosZou/graphlint/blob/main/README.md)
-[![zh](https://img.shields.io/badge/lang-zh--CN-blue.svg)](https://github.com/AngelosZou/graphlint/blob/main/docs/zh/README.md)
+[English](https://github.com/AngelosZou/graphlint/blob/main/README.md) | [简体中文](https://github.com/AngelosZou/graphlint/blob/main/docs/zh/README.md)
 
-**Dead code detection for AI-generated Python codebases.**
+**Dead code detection for AI-generated codebases.**
 
-AI agents generate code rapidly, leaving behind dead and redundant code that pollutes the LLM's context window and dilutes attention. Graphlint analyzes your Python codebase's dependency graph to identify entry points and **detect dead code** — components unreachable from any entry point — so agents can self-clean and keep the codebase lean.
+AI agents generate code rapidly, leaving behind dead and redundant code that pollutes the LLM's context window and dilutes attention. Graphlint analyzes your codebase's dependency graph to identify entry points and **detect dead code** — components unreachable from any entry point — so agents can self-clean and keep the codebase lean.
+
+## Supported Languages
+
+| Language | Status | Parser | Features |
+|----------|--------|--------|----------|
+| **Python** (`.py`) | Built-in | `ast` (stdlib) | Decorators, type annotations, dynamic imports, framework-aware entry detection |
+| **Rust** (`.rs`) | Built-in (opt-in deps) | `tree-sitter` | Attribute macros, traits, `pub` visibility, `macro_rules!` |
+
+Install with Rust support: `pip install graphlint[rust]` (adds `tree-sitter` and `tree-sitter-rust`).
 
 ## Features
 
 - **Dead code detection** — finds components unreachable from any entry point via graph traversal
-- **AST parsing** — extracts classes, functions, methods, variables, and fields; aware of type annotations and unpacked variables (e.g., loop bindings)
+- **Multi-language support** — Python and Rust backends via a language adapter abstraction; Python uses stdlib `ast`, Rust uses `tree-sitter`
+- **Language-specific awareness** — Python decorators, Rust attribute macros (`#[tokio::main]`, `#[test]`), trait implementations, `pub` visibility, and more
+- **AST/CST parsing** — extracts functions, methods, structs, enums, traits, impls, macros, variables, and fields; aware of type annotations and unpacked variables
 - **Dependency graph** — builds directed edges: `read`, `write`, `call`, `inherit`, `decorate`
-- **Entry point detection** — 10 built-in rules (main, FastAPI, Flask, Django, Click, Typer, Celery, pytest, plus package and test entries) and custom rules
-- **Multi-language architecture** — language adapter abstraction layer, laying the foundation for future multi-language support
+- **Entry point detection** — 17 built-in rules covering Python frameworks (FastAPI, Flask, Django, Click, Typer, Celery, pytest) and Rust conventions (main, async runtimes, WASM, proc macros, FFI, tests, pub API) plus custom rules
+- **Configurable entry templates** — add custom entry rules via `ast_pattern` prefixes including `function_call:`, `function_def:`, `decorator:`, `file_match:`, `visibility:pub` (Rust), `trait_impl:` (Rust), `macro_def:` (Rust), and more
+- **`--public-as-entry` flag** — treat all public items (Rust `pub`) as entry points for library-crate analysis
 - **Warning detection** — 11 warning types including circular references, unused imports, write-only variables, and more
 - **Python API + CLI** — integrate into any Tool, CI pipeline, or let agents self-analyze and self-clean
 
@@ -29,6 +40,12 @@ pip install graphlint
 
 **Requirements:** Python >= 3.9
 
+For Rust support (`.rs` files), install the optional `tree-sitter` dependencies:
+
+```bash
+pip install graphlint[rust]
+```
+
 ## Quick Start
 
 ### Agent Integration
@@ -65,6 +82,9 @@ graphlint query -g 1 --detail full
 # Exit non-zero when dead code or circular refs found (for CI)
 graphlint query --json --fail-on dead_code,circular_ref
 
+# Treat all public items as entry points (library-crate mode)
+graphlint query --public-as-entry
+
 # Rebuild index
 graphlint build --force
 
@@ -162,7 +182,10 @@ Full documentation is available in the [docs/](https://github.com/AngelosZou/gra
 
 ## Limitations
 
-- **Static analysis only** — graphlint performs static analysis and cannot detect runtime linkage such as `getattr`, `importlib`, or dynamic dispatch patterns, which may result in false positives. **Mitigation:** add custom entry rules matching your codebase's conventions. For example, graphlint's own codebase uses `function_def:_detect_*` and `function_def:visit_*` patterns to prevent functions discovered via `getattr` from being flagged as dead.
+- **Static analysis only** — graphlint performs static analysis and cannot detect runtime linkage such as `getattr`, `importlib`, or dynamic dispatch patterns, which may result in false positives. This primarily affects Python; Rust's static dispatch model produces fewer false positives. **Mitigation:** add custom entry rules matching your codebase's conventions. For example, graphlint's own codebase uses `function_def:_detect_*` and `function_def:visit_*` patterns to prevent functions discovered via `getattr` from being flagged as dead.
+- **Python dynamic imports** — due to Python's dynamic import mechanisms (`importlib`, `getattr`, metaclasses, etc.), the default entry templates may produce false positives in codebases that rely heavily on runtime dispatch. Users should tune the `entry_rules` configuration to match their project's conventions.
+- **Rust macro expansion** — tree-sitter parses unexpanded source; procedural macros and `macro_rules!` bodies appear as opaque token trees. Some macro-generated call paths may be missed. `#[derive]` attributes are partially recognized via implicit `inherit` edges.
+- **`--public-as-entry` scope** — this flag only applies to languages with `public` visibility declarations (Rust `pub`). It has no effect on Python files. Toggling this flag triggers a full re-index. For long-term library-crate analysis, prefer enabling the `rust_pub_api` entry rule via `graphlint config` to persist the setting.
 - **Large codebase build time** — on a large codebase with 700+ `.py` files, 1,000+ classes, and 14,000+ functions, a full rebuild takes approximately 200 seconds (actual performance depends on hardware). Small projects (~60 files) complete in ~1 second. **Best practice:** run `query` before making changes to plan your work, and avoid invoking `query` during refactoring to prevent unnecessary index rebuilds.
 
 ## License

{graphlint-0.2.0 → graphlint-0.3.0}/docs/en/architecture/overview.md

@@ -1,6 +1,6 @@
 # Architecture Overview
 
-graphlint is positioned as a dead code detection tool for AI-generated codebases. It analyzes the dependency graph to find components unreachable from all entry points (dead code), helping agents clean redundant code and reduce context pollution and attention dilution.
+graphlint is positioned as a dead code detection tool for AI-generated codebases (Python, Rust, and more in the future). It analyzes the dependency graph to find components unreachable from all entry points (dead code), helping agents clean redundant code and reduce context pollution and attention dilution.
 
 ## Overall Architecture
 
@@ -97,8 +97,8 @@ AST Parse (ast.parse / other language parser)
     │
     ▼
 ASTVisitor Traversal (single pass)
-    ├── Extract nodes (classes/functions/methods/variables/fields)
-    ├── Parse import statements
+    ├── Extract nodes (classes/functions/methods/structs/enums/traits/impls/variables/fields)
+    ├── Parse import statements (Python) / use declarations (Rust)
     ├── Collect name usage
     └── Collect structured references (ReferenceInfo — read/write/call/inherit/decorate)
     │

{graphlint-0.2.0 → graphlint-0.3.0}/docs/en/cli/usage.md

@@ -45,6 +45,7 @@ graphlint query -j                 # JSON format output
 | `--file-limit` | — | int | `10` | Max files shown in graph detail (0=unlimited) |
 | `--node-limit` | — | int | `30` | Max nodes shown in graph detail (0=unlimited) |
 | `--no-scan` | — | flag | `false` | Skip auto-scan/build, query existing index only |
+| `--public-as-entry` | — | flag | `false` | Treat public methods (Rust `pub`) as execution entry points — see [Entry Detection](../guide/entry-detection.md#-public-as-entry-flag) |
 | `--fail-on` | — | string | — | Exit non-zero if matching warning types found (comma-separated) |
 
 ### Examples

{graphlint-0.2.0 → graphlint-0.3.0}/docs/en/guide/configuration.md

@@ -16,10 +16,17 @@ graphlint's configuration file is located at `.graphlint/config.json` in the pro
     {"name": "typer_app",        "ast_pattern": "class_instantiation:typer.Typer | decorator:*.command", "file_pattern": "**/*.py", "enabled": true},
     {"name": "celery_app",       "ast_pattern": "class_instantiation:Celery | class_instantiation:celery.Celery", "file_pattern": "**/*.py", "enabled": true},
     {"name": "pytest_plugin",    "ast_pattern": "function_def:pytest_addoption | decorator:pytest.fixture", "file_pattern": "**/conftest.py", "enabled": true},
-    {"name": "pytest_test",      "ast_pattern": "test_file",                         "file_pattern": "**/*.py",         "enabled": true, "no_propagate": true}
+    {"name": "pytest_test",      "ast_pattern": "test_file",                         "file_pattern": "**/*.py",         "enabled": true, "no_propagate": true},
+    {"name": "rust_main",        "ast_pattern": "function_def:main",                 "file_pattern": "**/*.rs",         "enabled": true},
+    {"name": "rust_async_main",  "ast_pattern": "decorator:tokio::main | decorator:actix_rt::main | decorator:actix_web::main | decorator:async_std::main | decorator:rocket::main | decorator:rocket::launch | decorator:main", "file_pattern": "**/*.rs", "enabled": true},
+    {"name": "rust_wasm_entry",  "ast_pattern": "decorator:wasm_bindgen",            "file_pattern": "**/*.rs",         "enabled": true},
+    {"name": "rust_proc_macro",  "ast_pattern": "decorator:proc_macro | decorator:proc_macro_derive | decorator:proc_macro_attribute", "file_pattern": "**/*.rs", "enabled": true},
+    {"name": "rust_ffi_export",  "ast_pattern": "decorator:no_mangle | decorator:export_name", "file_pattern": "**/*.rs", "enabled": true},
+    {"name": "rust_test",        "ast_pattern": "test_file",                         "file_pattern": "**/*.rs",         "enabled": true, "no_propagate": true},
+    {"name": "rust_pub_api",     "ast_pattern": "visibility:pub",                    "file_pattern": "**/*.rs",         "enabled": false}
   ],
   "exclude_patterns": {
-    "always_exclude": ["__pycache__/", ".mypy_cache/", ".pytest_cache/", ".tox/", ".venv/", "venv/", "env/", "virtualenv/", ".env/", "node_modules/", ".git/", ".svn/", ".hg/", ".idea/", ".vscode/", ".vs/", ".graphlint/", "build/", "dist/", "*.egg-info/", "*.pyc", "*.pyo"],
+    "always_exclude": ["__pycache__/", ".mypy_cache/", ".pytest_cache/", ".tox/", ".venv/", "venv/", "env/", "virtualenv/", ".env/", "node_modules/", ".git/", ".svn/", ".hg/", ".idea/", ".vscode/", ".vs/", ".graphlint/", "build/", "dist/", "target/", ".cargo/", "*.egg-info/", "*.pyc", "*.pyo"],
     "user_exclude": []
   },
   "lang": "system",
@@ -36,7 +43,7 @@ graphlint's configuration file is located at `.graphlint/config.json` in the pro
   "test_patterns": {
     "config_files": ["conftest.py"],
     "dir_patterns": ["tests/", "test/", "__tests__/"],
-    "file_patterns": ["test_*.py", "*_test.py"],
+    "file_patterns": ["test_*.py", "*_test.py", "test_*.rs", "*_test.rs"],
     "function_patterns": ["test_*"]
   },
   "version": 1
@@ -58,19 +65,36 @@ Defines how code entry points are auto-detected. Each rule contains:
 | `enabled` | `boolean` | Whether the rule is enabled |
 | `no_propagate` | `boolean` | Entry does not propagate reachability (default `false`, e.g. pytest test rules set to `true`) |
 
+**Note:** The `rust_pub_api` rule (pattern `visibility:pub`, Rust only) is **disabled by default** (`"enabled": false`). Use `--public-as-entry` at query time, or manually set `"enabled": true` in the config for persistent library-crate analysis.
+
+### --public-as-entry Flag
+
+The `--public-as-entry` CLI flag (or `public_as_entry=True` API parameter) treats all public items as execution entry points:
+
+```bash
+graphlint query --public-as-entry
+```
+
+- **Scope:** Only affects languages with `public` visibility declarations (Rust `pub`). Has no effect on Python files.
+- **Re-indexing:** Toggling the flag triggers a full rebuild (the flag value is stored in the scan stamp). For long-term use, prefer enabling the `rust_pub_api` config rule or adding custom `visibility:pub` entry rules to avoid repeated rebuilds.
+- **Config interaction:** Independent of the `rust_pub_api` config rule — the two mechanisms are orthogonal and do not interfere.
+
 #### AST Pattern Prefixes
 
 All rules use the same prefix pattern syntax, supporting OR combinations with ` | `:
 
-| Prefix | Match Target | Example |
-|--------|-------------|---------|
-| `function_call:` | Function call | `"function_call:my_entry"` |
-| `function_def:` | Function definition name (supports glob) | `"function_def:run_*"` |
-| `decorator:` | Decorator | `"decorator:app.route"` |
-| `class_instantiation:` | Class instantiation | `"class_instantiation:MyApp"` |
-| `file_match:` | Filename match | `"file_match:**/main.py"` |
-| `if_name_main` | `if __name__ == '__main__'` check | `"if_name_main"` |
-| `test_file` | Test file detection (uses `test_patterns` config) | `"test_file"` |
+| Prefix | Match Target | Example | Languages |
+|--------|-------------|---------|-----------|
+| `function_call:` | Function call | `"function_call:my_entry"` | Python |
+| `function_def:` | Function definition name (supports glob) | `"function_def:run_*"` | Python, Rust |
+| `decorator:` | Decorator or attribute macro (`#[...]`) | `"decorator:app.route"` / `"decorator:tokio::main"` | Python, Rust |
+| `class_instantiation:` | Class instantiation | `"class_instantiation:MyApp"` | Python |
+| `file_match:` | Filename match | `"file_match:**/main.py"` | Python, Rust |
+| `if_name_main` | `if __name__ == '__main__'` check | `"if_name_main"` | Python |
+| `test_file` | Test file detection (uses `test_patterns` config) | `"test_file"` | Python, Rust |
+| `visibility:pub` | Items with `pub` visibility modifier | `"visibility:pub"` | Rust |
+| `trait_impl:` | Trait implementation block | `"trait_impl:Default"` | Rust |
+| `macro_def:` | `macro_rules!` definition | `"macro_def:my_macro"` | Rust |
 
 ### exclude_patterns — Exclude Patterns
 

{graphlint-0.2.0 → graphlint-0.3.0}/docs/en/guide/entry-detection.md

@@ -1,9 +1,11 @@
 # Entry Point Detection Reference
 
-graphlint has 10 built-in entry point detection rules and supports custom rule extension. On first `graphlint build`, these rules are written as a template into `.graphlint/config.json`; thereafter the config file is the single source of truth — you may add, remove, or modify rules via `graphlint config` or by editing the file directly.
+graphlint has 17 built-in entry point detection rules (10 for Python, 7 for Rust) and supports custom rule extension. On first `graphlint build`, these rules are written as a template into `.graphlint/config.json`; thereafter the config file is the single source of truth — you may add, remove, or modify rules via `graphlint config` or by editing the file directly.
 
 ## Built-in Rules
 
+### Python Rules
+
 ### 1. python_main
 
 Detects the standard Python entry point `if __name__ == '__main__':`.
@@ -167,6 +169,117 @@ Detects Pytest test cases as entry points.
           pass
   ```
 
+### Rust Rules
+
+### 11. rust_main
+
+Detects the Rust binary crate entry point `fn main()`.
+
+- **Match Pattern**: `function_def:main`
+- **Match Files**: `**/*.rs`
+- **Example**:
+  ```rust
+  fn main() {
+      println!("Hello, world!");
+  }
+  ```
+
+### 12. rust_async_main
+
+Detects async runtime `#[...]` attributes that decorate `main`.
+
+- **Match Pattern**: `decorator:tokio::main | decorator:actix_rt::main | decorator:actix_web::main | decorator:async_std::main | decorator:rocket::main | decorator:rocket::launch | decorator:main`
+- **Match Files**: `**/*.rs`
+- **Note**: Rust attribute macros (`#[...]`) are compile-time and do **not** create `decorate` edges in the dependency graph (unlike Python decorators).
+- **Example**:
+  ```rust
+  #[tokio::main]
+  async fn main() {
+      // ...
+  }
+  ```
+
+### 13. rust_wasm_entry
+
+Detects WebAssembly exports.
+
+- **Match Pattern**: `decorator:wasm_bindgen`
+- **Match Files**: `**/*.rs`
+- **Example**:
+  ```rust
+  use wasm_bindgen::prelude::*;
+
+  #[wasm_bindgen]
+  pub fn greet(name: &str) {
+      // ...
+  }
+  ```
+
+### 14. rust_proc_macro
+
+Detects Rust procedural macro entry points called by the compiler.
+
+- **Match Pattern**: `decorator:proc_macro | decorator:proc_macro_derive | decorator:proc_macro_attribute`
+- **Match Files**: `**/*.rs`
+- **Example**:
+  ```rust
+  #[proc_macro]
+  pub fn my_macro(input: TokenStream) -> TokenStream {
+      // ...
+  }
+  ```
+
+### 15. rust_ffi_export
+
+Detects FFI exports via `#[no_mangle]` or `#[export_name]`.
+
+- **Match Pattern**: `decorator:no_mangle | decorator:export_name`
+- **Match Files**: `**/*.rs`
+- **Example**:
+  ```rust
+  #[no_mangle]
+  pub extern "C" fn my_export() {
+      // ...
+  }
+  ```
+
+### 16. rust_test
+
+Detects Rust test files and `#[test]` functions.
+
+- **Match Pattern**: `test_file`
+- **Match Files**: `**/*.rs`
+- **Note**: Test entry points do not propagate reachability to non-test code under test.
+- **Example**:
+  ```rust
+  #[test]
+  fn test_addition() {
+      assert_eq!(2 + 2, 4);
+  }
+  ```
+
+### 17. rust_pub_api
+
+Treats all `pub` items in Rust library crates as entry points.
+
+- **Match Pattern**: `visibility:pub`
+- **Match Files**: `**/*.rs`
+- **Note**: Disabled by default (`"enabled": false`). Use `--public-as-entry` to activate it at query time, or enable the rule in config for persistent library-crate analysis.
+
+## `--public-as-entry` Flag
+
+The `--public-as-entry` flag provides an alternative way to treat public items as entry points without modifying the config:
+
+```bash
+graphlint query --public-as-entry
+```
+
+This flag:
+- Only applies to languages with `public` visibility declarations (Rust `pub`); has no effect on Python files.
+- Toggles independently from the `rust_pub_api` config entry rule — the two are orthogonal mechanisms.
+- **Triggers a full re-index** when switched on or off (detected via the scan stamp).
+- For long-term library-crate analysis, prefer enabling `rust_pub_api` in `.graphlint/config.json` to persist the setting and avoid repeated rebuilds.
+
 ## Custom Rules
 
 Add custom entry detection rules via the `entry_rules` configuration.
@@ -175,15 +288,18 @@ Add custom entry detection rules via the `entry_rules` configuration.
 
 All rules (built-in and custom) use the same prefix syntax, supporting OR combinations with ` | `.
 
-| Prefix | Description | Example |
-|--------|-------------|---------|
-| `function_call:<name>` | Match a function call by name | `"function_call:start_app"` |
-| `function_def:<pattern>` | Match a function definition by name (supports glob) | `"function_def:run_*"` |
-| `decorator:<name>` | Match a decorator by name | `"decorator:app.route"` |
-| `class_instantiation:<name>` | Match a class instantiation by name | `"class_instantiation:MyApp"` |
-| `file_match:<pattern>` | Match a filename pattern | `"file_match:**/startup.py"` |
-| `if_name_main` | Match `if __name__ == '__main__'` | `"if_name_main"` |
-| `test_file` | Match test files (uses `test_patterns` config) | `"test_file"` |
+| Prefix | Description | Example | Applicable |
+|--------|-------------|---------|------------|
+| `function_call:<name>` | Match a function call by name | `"function_call:start_app"` | Python |
+| `function_def:<pattern>` | Match a function definition by name (supports glob) | `"function_def:run_*"` | Python, Rust |
+| `decorator:<name>` | Match a decorator (Python) or attribute macro (Rust `#[...]`) by name | `"decorator:app.route"` / `"decorator:tokio::main"` | Python, Rust |
+| `class_instantiation:<name>` | Match a class instantiation by name | `"class_instantiation:MyApp"` | Python |
+| `file_match:<pattern>` | Match a filename pattern | `"file_match:**/startup.py"` | Python, Rust |
+| `if_name_main` | Match `if __name__ == '__main__'` | `"if_name_main"` | Python |
+| `test_file` | Match test files (uses `test_patterns` config) | `"test_file"` | Python, Rust |
+| `visibility:pub` | Match items with `pub` visibility modifier | `"visibility:pub"` | Rust |
+| `trait_impl:<pattern>` | Match `impl Trait for Type` blocks | `"trait_impl:Default"` | Rust |
+| `macro_def:<pattern>` | Match `macro_rules!` definitions | `"macro_def:my_macro"` | Rust |
 
 ### Custom Rule Examples
 

{graphlint-0.2.0 → graphlint-0.3.0}/docs/en/guide/getting-started.md

@@ -10,7 +10,13 @@ graphlint provides a **Python API** (for integration into any Tool development)
 pip install graphlint
 ```
 
-Requirements: Python >= 3.9, zero third-party dependencies.
+Requirements: Python >= 3.9
+
+For Rust support (`.rs` files), install the optional `tree-sitter` dependencies:
+
+```bash
+pip install graphlint[rust]
+```
 
 ## Agent Integration
 

{graphlint-0.2.0 → graphlint-0.3.0}/docs/zh/README.md

@@ -4,20 +4,31 @@
 [![Python](https://img.shields.io/pypi/pyversions/graphlint)](https://pypi.org/project/graphlint/)
 [![License](https://img.shields.io/pypi/l/graphlint)](https://github.com/AngelosZou/graphlint/blob/main/LICENSE)
 
-[![en](https://img.shields.io/badge/lang-en-red.svg)](../../README.md)
-[![zh](https://img.shields.io/badge/lang-zh--CN-blue.svg)](README.md)
+[English](../../README.md) | [简体中文](README.md)
 
-**面向 AI 生成 Python 代码库的死代码检测工具。**
+**面向 AI 生成代码库的死代码检测工具。**
 
 AI Agent 在快速生成代码的同时，也会留下大量冗余和死代码。这些代码污染了 LLM 的上下文窗口，稀释了注意力。Graphlint 通过分析代码库的依赖关系图，识别入口点并**检测死代码**（从任何入口点均不可达的组件），让 Agent 能够自行清理，保持代码库的简洁高效。
 
+## 支持的语言
+
+| 语言 | 状态 | 解析器 | 特性 |
+|------|------|--------|------|
+| **Python** (`.py`) | 内置 | `ast`（标准库） | 装饰器、类型注解、动态导入、框架感知入口检测 |
+| **Rust** (`.rs`) | 内置（可选依赖） | `tree-sitter` | 属性宏、Trait、`pub` 可见性、`macro_rules!` |
+
+安装含 Rust 支持的版本：`pip install graphlint[rust]`（额外引入 `tree-sitter` 和 `tree-sitter-rust`）。
+
 ## 特性
 
 - **死代码检测** — 通过图遍历找出所有入口点不可达的组件
-- **AST 解析** — 提取类、函数、方法、变量、字段；感知类型声明，自动处理循环解包等变量绑定
+- **多语言支持** — Python 和 Rust 后端，通过语言适配器抽象层实现；Python 使用标准库 `ast`，Rust 使用 `tree-sitter`
+- **语言专有特性感知** — Python 装饰器、Rust 属性宏（`#[tokio::main]`、`#[test]`）、Trait 实现、`pub` 可见性等
+- **AST/CST 解析** — 提取函数、方法、结构体、枚举、Trait、实现块、宏、变量、字段；感知类型声明，自动处理循环解包等变量绑定
 - **依赖图构建** — 有向边：`read`、`write`、`call`、`inherit`、`decorate`
-- **入口点检测** — 10 种内置规则（main、FastAPI、Flask、Django、Click、Typer、Celery、pytest、包入口和测试入口）及自定义规则
-- **多语言架构** — 语言适配器抽象层，为未来多语言支持提供基础
+- **入口点检测** — 17 种内置规则，覆盖 Python 框架（FastAPI、Flask、Django、Click、Typer、Celery、pytest）和 Rust 惯例（main、异步运行时、WASM、proc 宏、FFI、测试、pub API）及自定义规则
+- **可配置入口模板** — 通过 `ast_pattern` 前缀添加自定义入口规则，包括 `function_call:`、`function_def:`、`decorator:`、`file_match:`、`visibility:pub`（Rust）、`trait_impl:`（Rust）、`macro_def:`（Rust）等
+- **`--public-as-entry` 标志** — 将所有公开项（Rust `pub`）视为入口点，用于库代码分析
 - **警告检测** — 11 种警告类型：循环引用、未使用 import、只写变量、死代码等
 - **Python API + CLI** — 可集成到任何 Tool 开发、CI 流程，或直接供 Agent 自行分析和清理
 
@@ -29,6 +40,12 @@ pip install graphlint
 
 **要求：** Python >= 3.9
 
+如需支持 Rust（`.rs` 文件），安装可选的 `tree-sitter` 依赖：
+
+```bash
+pip install graphlint[rust]
+```
+
 ## 快速开始
 
 ### Agent 集成
@@ -65,6 +82,9 @@ graphlint query -g 1 --detail full
 # 检测到死代码或循环引用时返回非零退出码（用于 CI）
 graphlint query --json --fail-on dead_code,circular_ref
 
+# 将所有公开项视为入口点（库模式分析）
+graphlint query --public-as-entry
+
 # 重建索引
 graphlint build --force
 
@@ -162,7 +182,10 @@ Graphlint 将配置存储在分析目录下的 `.graphlint/config.json` 中。
 
 ## 局限性
 
-- **纯静态分析** — graphlint 基于静态分析执行，无法检测 `getattr`、`importlib` 等运行时动态链接或动态分发模式，这可能会导致假阳性。**缓解方案：** 根据代码库的实际约定添加自定义入口规则。例如，graphlint 自身的代码库使用了 `function_def:_detect_*` 和 `function_def:visit_*` 两种 ast_pattern，防止通过 `getattr` 发现的函数被误报为死代码。
+- **纯静态分析** — graphlint 基于静态分析执行，无法检测 `getattr`、`importlib` 等运行时动态链接或动态分发模式，这可能会导致假阳性。此问题主要影响 Python；Rust 的静态分发模型产生的假阳性较少。**缓解方案：** 根据代码库的实际约定添加自定义入口规则。例如，graphlint 自身的代码库使用了 `function_def:_detect_*` 和 `function_def:visit_*` 两种 ast_pattern，防止通过 `getattr` 发现的函数被误报为死代码。
+- **Python 动态导入** — 由于 Python 的动态导入机制（`importlib`、`getattr`、元类等），默认入口模板在重度依赖运行时调度的代码库中可能产生假阳性。用户应根据项目约定调整 `entry_rules` 配置。
+- **Rust 宏展开** — tree-sitter 解析未展开的源代码；过程宏和 `macro_rules!` 体显示为不透明标记树。部分宏生成的调用路径可能遗漏。`#[derive]` 属性通过隐式 `inherit` 边部分识别。
+- **`--public-as-entry` 适用范围** — 此标志仅适用于具有 `public` 可见性声明的语言（Rust `pub`），对 Python 文件无效。开关此标志会触发全量重新索引。对于长期库代码分析，建议通过 `graphlint config` 启用 `rust_pub_api` 入口规则以持久化设置。
 - **大规模代码库构建耗时** — 在包含 700+ 个 Python 文件、1,000+ 个类定义和 14,000+ 个函数的大规模代码库上，完整重构需要约 200 秒（实际时间与设备性能有关）。小型项目（~60 个文件）约 1 秒完成。**最佳实践：** 在改动前运行 `query` 了解现状并规划方案，改动期间避免执行 `query` 以防止不必要地触发索引重构。
 
 ## 许可证