{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-tirth8205--code-review-graph","slug":"tirth8205--code-review-graph","name":"code-review-graph","type":"product","url":"https://code-review-graph.com","page_url":"https://unfragile.ai/tirth8205--code-review-graph","categories":["code-review-security"],"tags":["ai-coding","claude","claude-code","code-review","graphrag","incremental","knowledge-graph","llm","mcp","python","static-analysis","tree-sitter"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-tirth8205--code-review-graph__cap_0","uri":"capability://data.processing.analysis.tree.sitter.based.incremental.codebase.parsing.with.sha.256.change.tracking","name":"tree-sitter-based incremental codebase parsing with sha-256 change tracking","description":"Parses source code using Tree-sitter AST parsing across 40+ languages, extracting structural entities (functions, classes, types, imports) and storing them in a persistent knowledge graph. Tracks file changes via SHA-256 hashing to enable incremental updates—only re-parsing modified files rather than rescanning the entire codebase on each invocation. The parser system maintains a directed graph of code entities and their relationships (CALLS, IMPORTS_FROM, INHERITS, CONTAINS, TESTED_BY, DEPENDS_ON) without requiring full re-indexing.","intents":["Build a persistent structural index of my codebase that survives across sessions","Detect which files have actually changed since the last analysis to avoid redundant parsing","Extract function signatures, class hierarchies, and import dependencies from source code","Support multiple programming languages in a single unified graph representation"],"best_for":["teams maintaining large codebases (10k+ files) where full re-parsing is prohibitively expensive","developers using Claude Code or similar LLM assistants who need persistent context across sessions","monorepo maintainers needing language-agnostic structural analysis"],"limitations":["Tree-sitter parsing accuracy varies by language maturity; less mature grammars may miss edge cases in dynamic or metaprogramming-heavy code","SHA-256 change detection is file-level only—moving or renaming files without content changes may trigger unnecessary re-parsing","Graph construction time scales linearly with codebase size; initial indexing of 100k+ file monorepos may take minutes","No built-in support for generated code or transpiled outputs; requires manual configuration to exclude build artifacts"],"requires":["Python 3.9+","Tree-sitter library and language-specific grammar bindings (auto-installed via pyproject.toml)","Writable filesystem for graph storage (SQLite or similar backend)","Source code files accessible locally (no remote repository streaming)"],"input_types":["source code files (Python, JavaScript, TypeScript, Go, Rust, Java, C++, etc.)","file paths and directory structures","git diff or file modification timestamps"],"output_types":["directed graph nodes (File, Class, Function, Type, Test entities)","graph edges (relationship tuples with metadata)","structured entity metadata (signatures, line numbers, docstrings)"],"categories":["data-processing-analysis","static-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_1","uri":"capability://planning.reasoning.blast.radius.impact.analysis.with.dependency.graph.traversal","name":"blast-radius impact analysis with dependency graph traversal","description":"When a file changes, the system traces the directed graph to identify all potentially affected code entities—callers, dependents, inheritors, and tests. This 'blast radius' computation uses graph traversal algorithms (BFS/DFS) to walk the CALLS, IMPORTS_FROM, INHERITS, DEPENDS_ON, and TESTED_BY edges, producing a minimal set of files and functions that Claude must review. The system excludes irrelevant files from context, reducing token consumption by 6.8x to 49x depending on repository structure and change scope.","intents":["Determine which parts of my codebase could be affected by a specific code change","Exclude irrelevant files from code review context to reduce LLM token consumption","Identify all tests that exercise a modified function or class","Understand the full dependency chain for a file change in a monorepo"],"best_for":["code review workflows where context window is limited (e.g., Claude Code with 200k token limit)","large monorepos (Next.js, Kubernetes, etc.) where naive full-file inclusion would exceed token budgets","teams needing to understand change impact before merging pull requests","developers optimizing LLM API costs by minimizing token consumption per review"],"limitations":["Blast radius is conservative—it may include false positives if the graph contains indirect or transitive dependencies that don't actually affect behavior","Dynamic imports, reflection, or metaprogramming patterns may not be captured in the static graph, leading to incomplete blast radius computation","Graph traversal time scales with the number of edges; highly interconnected codebases may require seconds to compute blast radius for a single change","No support for runtime-only dependencies (e.g., configuration files, environment variables) that affect behavior but aren't represented in the code graph"],"requires":["Pre-built knowledge graph from the incremental parsing capability","Graph database or in-memory representation with edge traversal support","File change information (git diff, file paths, or modification timestamps)"],"input_types":["changed file paths or git diff output","graph node identifiers (file, function, class names)"],"output_types":["set of affected file paths","set of affected function/class identifiers","graph subsets (nodes and edges relevant to the change)","impact metrics (number of affected entities, estimated token reduction)"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_10","uri":"capability://data.processing.analysis.evaluation.framework.with.benchmark.metrics.and.token.reduction.reporting","name":"evaluation framework with benchmark metrics and token reduction reporting","description":"Includes an automated evaluation framework (`code-review-graph eval --all`) that benchmarks the tool against real open-source repositories, measuring token reduction, impact analysis accuracy, and query performance. The framework compares naive full-file context inclusion against graph-optimized context, reporting metrics like average token reduction (8.2x across tested repos, up to 49x on monorepos), precision/recall of blast radius analysis, and query latency. Results are aggregated and visualized in benchmark reports, enabling teams to understand the expected token savings for their codebase.","intents":["Measure token reduction achieved by code-review-graph on my codebase","Benchmark graph query performance and impact analysis accuracy","Understand expected cost savings from using graph-optimized context","Validate that the tool is working correctly on my code"],"best_for":["teams evaluating code-review-graph before adoption","organizations tracking LLM API cost savings","developers validating tool performance on their specific codebase","researchers studying code analysis and token optimization"],"limitations":["Evaluation framework requires running against real repositories; results may not generalize to other codebases with different structures","Token reduction metrics are specific to Claude and may vary for other LLM assistants","Evaluation requires API calls to embedding services (if semantic search is enabled), adding cost and latency","Benchmark results are historical; they don't predict future performance as the codebase evolves"],"requires":["Python 3.9+ with code-review-graph installed","Real codebase or test repositories for evaluation","Optional: API keys for embedding services if semantic search is enabled"],"input_types":["codebase paths or repository URLs","evaluation configuration (which metrics to measure)"],"output_types":["benchmark reports with token reduction metrics","impact analysis accuracy metrics (precision, recall)","query performance statistics","visualized benchmark results"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_11","uri":"capability://data.processing.analysis.graph.storage.and.persistence.with.sqlite.backend","name":"graph storage and persistence with sqlite backend","description":"Persists the knowledge graph to a local SQLite database, enabling the graph to survive across sessions and be queried without re-parsing the entire codebase. The storage layer maintains tables for nodes (entities), edges (relationships), and metadata, with indexes optimized for common query patterns (entity lookup, relationship traversal, impact analysis). The SQLite backend is lightweight, requires no external services, and supports concurrent read access, making it suitable for local development workflows and CI/CD integration.","intents":["Store the knowledge graph persistently so it survives across sessions","Query the graph without re-parsing the entire codebase","Enable fast graph access for code review and analysis tasks","Support concurrent read access from multiple tools (CLI, MCP server, VS Code extension)"],"best_for":["local development workflows where the graph must persist across sessions","teams without access to external database services","developers who want a lightweight, zero-configuration storage solution","CI/CD pipelines that need fast graph access without external dependencies"],"limitations":["SQLite is single-writer, multiple-reader; concurrent write access may cause locking issues","SQLite performance degrades with very large graphs (100k+ nodes); query latency may increase","No built-in replication or backup; graph loss requires manual recovery","SQLite database file is stored locally; no cloud synchronization or sharing between machines"],"requires":["Python 3.9+ with code-review-graph installed","Writable filesystem for SQLite database file","Sufficient disk space for graph storage (typically 10-100MB per 10k files)"],"input_types":["graph nodes and edges from the parser system","query parameters (entity names, relationship types)"],"output_types":["persisted graph data in SQLite format","query results from graph traversal"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_2","uri":"capability://tool.use.integration.mcp.server.integration.with.claude.code.and.llm.assistants","name":"mcp server integration with claude code and llm assistants","description":"Exposes the knowledge graph as an MCP (Model Context Protocol) server that Claude Code and other LLM assistants can query via standardized tool calls. The MCP server implements a set of tools (graph management, query, impact analysis, review context, semantic search, utility, and advanced analysis tools) that allow Claude to request only the relevant code context for a task instead of re-reading entire files. Integration is bidirectional: Claude sends queries (e.g., 'what functions call this one?'), and the MCP server returns structured graph results that fit within token budgets.","intents":["Enable Claude Code to query my codebase structure without re-reading entire files","Provide Claude with precise function signatures, class hierarchies, and dependency information","Allow Claude to understand code impact before suggesting changes","Integrate code-review-graph seamlessly into Claude's existing workflow without manual context pasting"],"best_for":["Claude Code users who want to reduce token consumption on code reviews and refactoring tasks","teams using Claude as their primary LLM assistant for development","developers who want to maintain a persistent codebase index that Claude can query across sessions"],"limitations":["MCP server must be running locally or accessible over the network; no cloud-hosted version reduces latency","Claude's tool-calling latency adds ~100-200ms per query; rapid iterative queries may feel slower than direct file reading","MCP tool results are limited by Claude's context window; very large blast radius results may still exceed token budgets","Requires Claude Code or another MCP-compatible LLM client; not compatible with standard Claude API or web interface"],"requires":["Python 3.9+ with code-review-graph installed","Claude Code or another MCP-compatible LLM client","Pre-built knowledge graph from the incremental parsing capability","Network connectivity between Claude client and MCP server (local or remote)"],"input_types":["MCP tool calls with structured parameters (file paths, function names, query types)","natural language queries from Claude (translated to tool calls by Claude's reasoning)"],"output_types":["structured JSON responses with graph entities and relationships","code snippets and summaries","impact analysis results","semantic search results"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_3","uri":"capability://search.retrieval.semantic.search.and.embedding.based.code.retrieval","name":"semantic search and embedding-based code retrieval","description":"Generates embeddings for code entities (functions, classes, documentation) and stores them in a vector index, enabling semantic search queries like 'find functions that handle authentication' or 'locate all database connection logic'. The system uses embedding models (likely OpenAI or similar) to convert code and natural language queries into vector space, then performs similarity search to retrieve relevant code entities without requiring exact keyword matches. Results are ranked by semantic relevance and integrated into the MCP tool suite for Claude to query.","intents":["Find related code by semantic meaning rather than exact keyword matching","Locate all authentication-related functions across a large codebase","Discover similar patterns or implementations for reference","Augment code review context with semantically relevant code snippets"],"best_for":["large codebases (10k+ files) where keyword search is insufficient","teams with diverse code patterns and naming conventions","developers exploring unfamiliar codebases and needing semantic guidance","code review workflows where related code patterns should be considered"],"limitations":["Embedding generation requires API calls to external services (OpenAI, etc.), adding latency and cost per indexed entity","Semantic search quality depends on embedding model quality; poor embeddings lead to irrelevant results","Vector index must be updated when code changes; incremental embedding updates may lag behind code changes","Semantic search results are probabilistic; no guarantee that all relevant code will be retrieved (recall < 100%)","Embedding models have context length limits; very large functions may be truncated before embedding"],"requires":["Pre-built knowledge graph with code entities","Embedding model API key (OpenAI, Anthropic, or local embedding service)","Vector database or index (e.g., Pinecone, Weaviate, or local FAISS)","Sufficient API quota for embedding generation (scales with codebase size)"],"input_types":["natural language queries (e.g., 'authentication logic')","code snippets for similarity search","entity identifiers (function names, class names)"],"output_types":["ranked list of semantically similar code entities","relevance scores (0-1)","code snippets and metadata for retrieved entities"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_4","uri":"capability://automation.workflow.watch.mode.with.auto.update.hooks.for.continuous.graph.synchronization","name":"watch mode with auto-update hooks for continuous graph synchronization","description":"Monitors the filesystem for code changes (via file watchers or git hooks) and automatically triggers incremental graph updates without manual intervention. When files are modified, the system detects changes via SHA-256 hashing, re-parses only affected files, and updates the knowledge graph in real-time. Auto-update hooks integrate with git workflows (pre-commit, post-commit) to keep the graph synchronized with the working directory, ensuring Claude always has current structural information.","intents":["Keep the knowledge graph synchronized with my codebase as I make changes","Avoid manual graph rebuild commands during active development","Ensure Claude has current code structure information for real-time code review","Integrate graph updates into my git workflow automatically"],"best_for":["developers working in active development cycles who need real-time graph updates","teams using git-based workflows with pre-commit or post-commit hooks","continuous integration pipelines where graph updates should happen automatically","developers who want to avoid manual 'rebuild graph' commands"],"limitations":["File watchers add background process overhead; may impact system performance on very large codebases","Watch mode requires the process to remain running; stopping the process halts graph synchronization","Git hooks add latency to commit operations; very large commits may trigger slow graph updates","Race conditions possible if multiple processes modify the graph simultaneously; requires locking mechanism","Watch mode may miss changes if files are modified outside the watched directory (e.g., via symlinks or network mounts)"],"requires":["Python 3.9+ with code-review-graph installed","File watcher library (watchdog or similar, auto-installed)","Writable filesystem for graph storage","Optional: git repository with hook support for auto-update integration"],"input_types":["filesystem events (file creation, modification, deletion)","git hook triggers (pre-commit, post-commit)"],"output_types":["updated knowledge graph","log messages indicating which files were re-parsed","graph synchronization status"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_5","uri":"capability://text.generation.language.code.review.context.generation.with.token.optimized.summaries","name":"code review context generation with token-optimized summaries","description":"Generates concise, token-optimized summaries of code changes and their context by combining blast radius analysis with semantic search. Instead of sending entire files to Claude, the system produces structured summaries that include: changed code snippets, affected functions/classes, test coverage, and related code patterns. The summaries are designed to fit within Claude's context window while providing sufficient information for accurate code review, achieving 6.8x to 49x token reduction compared to naive full-file inclusion.","intents":["Generate code review context that fits within Claude's token budget","Summarize code changes with their impact and related code patterns","Provide Claude with just enough context to understand a change without overwhelming detail","Optimize token consumption for cost-sensitive code review workflows"],"best_for":["teams using Claude Code for code reviews with limited token budgets","large monorepos where full-file context would exceed token limits","cost-conscious teams optimizing LLM API spending","developers who want to understand change impact before detailed review"],"limitations":["Summary generation may omit important context if the blast radius is conservative or semantic search misses related code","Token reduction is variable (6.8x to 49x) depending on repository structure and change scope; small changes in tightly-coupled code may not benefit as much","Summaries are optimized for Claude; other LLM assistants may require different formatting or context structure","No guarantee that summaries contain all necessary context; developers may need to request additional context for complex changes"],"requires":["Pre-built knowledge graph with blast radius and semantic search capabilities","Code change information (git diff, file paths, or modification timestamps)","Claude Code or another MCP-compatible LLM client"],"input_types":["git diff or file change information","file paths of modified code","optional: natural language context or review guidelines"],"output_types":["structured code review context (changed code, affected entities, related patterns)","token count estimates","impact analysis summary","test coverage information"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_6","uri":"capability://tool.use.integration.vs.code.extension.with.graph.visualization.and.interactive.exploration","name":"vs code extension with graph visualization and interactive exploration","description":"Provides a VS Code extension that visualizes the knowledge graph as an interactive diagram, allowing developers to explore code structure, dependencies, and impact analysis results directly in the editor. The extension displays nodes (files, functions, classes) and edges (relationships) in a visual format, supports filtering and search, and integrates with VS Code's code navigation (go-to-definition, find-references). Developers can click on entities to view details, trace dependencies, and understand code structure without leaving the editor.","intents":["Visualize my codebase structure as an interactive graph in VS Code","Explore code dependencies and relationships visually","Understand blast radius impact by seeing affected code highlighted","Navigate code structure more intuitively than text-based search"],"best_for":["developers who prefer visual exploration of code structure","teams onboarding new developers who need to understand codebase architecture","developers debugging complex dependency chains","teams using VS Code as their primary editor"],"limitations":["Graph visualization performance degrades with very large graphs (10k+ nodes); rendering may be slow or unresponsive","VS Code extension API limitations may prevent full-featured graph visualization (e.g., real-time layout updates)","Graph filtering and search features may be limited compared to dedicated graph visualization tools","Extension requires VS Code 1.80+ and may not work with older versions or alternative editors"],"requires":["VS Code 1.80+","code-review-graph extension installed from VS Code marketplace","Pre-built knowledge graph from the incremental parsing capability"],"input_types":["graph node and edge data from the knowledge graph","user interactions (clicks, filters, search queries)"],"output_types":["interactive graph visualization","node details and metadata","navigation links to code locations","filtered subgraphs based on search or filter criteria"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_7","uri":"capability://data.processing.analysis.multi.language.support.with.language.agnostic.graph.schema","name":"multi-language support with language-agnostic graph schema","description":"Supports parsing and indexing code in 40+ programming languages (Python, JavaScript, TypeScript, Go, Rust, Java, C++, etc.) using language-specific Tree-sitter grammars, while maintaining a unified, language-agnostic graph schema. All languages are represented with the same node types (File, Class, Function, Type, Test) and edge types (CALLS, IMPORTS_FROM, INHERITS, CONTAINS, TESTED_BY, DEPENDS_ON), enabling cross-language dependency analysis in monorepos. The parser system automatically detects language based on file extension and applies the appropriate grammar.","intents":["Index and analyze code in multiple programming languages in a single graph","Understand dependencies across language boundaries in polyglot monorepos","Perform cross-language impact analysis for changes that affect multiple languages","Maintain a unified codebase index regardless of language diversity"],"best_for":["polyglot monorepos with code in multiple languages (e.g., backend in Go, frontend in TypeScript, scripts in Python)","teams migrating between languages who need to understand cross-language dependencies","organizations with diverse technology stacks","large enterprises with legacy code in multiple languages"],"limitations":["Language support quality varies; mature languages (Python, JavaScript) have better Tree-sitter grammars than newer languages","Cross-language dependency analysis is limited to explicit imports/calls; implicit dependencies (e.g., REST API contracts) are not captured","Language-specific features (e.g., Python decorators, TypeScript generics) may not be fully represented in the unified schema","Adding support for new languages requires Tree-sitter grammar availability and may require custom parsing logic"],"requires":["Python 3.9+ with code-review-graph installed","Tree-sitter language grammars for each language (auto-installed via pyproject.toml)","Source code files in supported languages"],"input_types":["source code files in any of 40+ supported languages","file paths with language-specific extensions"],"output_types":["unified graph with language-agnostic node and edge types","language-specific metadata (e.g., function signatures, type annotations)"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_8","uri":"capability://data.processing.analysis.incremental.graph.update.system.with.delta.computation","name":"incremental graph update system with delta computation","description":"Implements an incremental update mechanism that computes the delta between the current codebase state and the previous indexed state, then applies only the necessary graph updates. The system uses SHA-256 file hashing to detect changes, identifies which entities (functions, classes, imports) were added, modified, or deleted, and updates only the affected graph nodes and edges. This delta-based approach reduces update time from O(n) to O(delta), where delta is the number of changed entities, enabling fast graph synchronization even in large codebases.","intents":["Update the knowledge graph quickly after code changes without full re-indexing","Minimize graph update latency during active development","Reduce computational overhead of keeping the graph synchronized","Support real-time graph updates in watch mode"],"best_for":["developers in active development cycles who need fast graph updates","large codebases where full re-indexing would be prohibitively slow","continuous integration pipelines where graph updates must complete quickly","watch mode workflows where real-time synchronization is critical"],"limitations":["Delta computation assumes file-level change detection; moving or renaming files without content changes may trigger unnecessary updates","Incremental updates may miss indirect effects of changes (e.g., if a function signature changes, all callers may need re-analysis but may not be detected as 'changed')","Graph consistency must be maintained during incremental updates; concurrent updates may cause inconsistencies","Rollback of incremental updates is not supported; errors during update may corrupt the graph"],"requires":["Pre-built knowledge graph with entity tracking","File change detection mechanism (SHA-256 hashing or file modification timestamps)","Graph database with support for selective node/edge updates"],"input_types":["file change information (paths, modification timestamps, or git diff)","previous graph state"],"output_types":["updated knowledge graph","delta summary (added/modified/deleted entities)","update timing information"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tirth8205--code-review-graph__cap_9","uri":"capability://automation.workflow.cli.command.suite.for.graph.management.and.analysis","name":"cli command suite for graph management and analysis","description":"Provides a comprehensive command-line interface for building, querying, and analyzing the knowledge graph. Commands include: `build` (initial graph construction), `update` (incremental updates), `query` (graph traversal and entity lookup), `impact` (blast radius analysis), `review` (code review context generation), `watch` (continuous synchronization), `visualize` (graph export for visualization), and `eval` (evaluation and benchmarking). The CLI is designed for both interactive use and integration into CI/CD pipelines, with structured output formats (JSON, YAML) for programmatic consumption.","intents":["Build and maintain the knowledge graph from the command line","Query the graph for specific entities or relationships","Analyze code impact and dependencies programmatically","Integrate graph operations into CI/CD pipelines and automation scripts","Evaluate graph quality and token reduction metrics"],"best_for":["developers who prefer command-line tools over GUI interfaces","CI/CD pipelines that need to build and update graphs automatically","teams integrating code-review-graph into custom workflows","developers scripting graph operations or analysis"],"limitations":["CLI output is text-based; complex graph visualization requires additional tools or export to external formats","Some advanced features may be easier to use through the VS Code extension or MCP interface than CLI","CLI requires Python environment setup; less accessible to non-technical team members","Error messages may be verbose or unclear for users unfamiliar with the tool"],"requires":["Python 3.9+ with code-review-graph installed","Command-line shell (bash, zsh, PowerShell, etc.)","Optional: jq or other JSON processing tools for output parsing"],"input_types":["command-line arguments and flags","file paths and directory structures","query parameters (entity names, relationship types)"],"output_types":["structured output (JSON, YAML, or plain text)","graph statistics and metrics","query results (entity lists, relationship data)","impact analysis summaries"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":40,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Tree-sitter library and language-specific grammar bindings (auto-installed via pyproject.toml)","Writable filesystem for graph storage (SQLite or similar backend)","Source code files accessible locally (no remote repository streaming)","Pre-built knowledge graph from the incremental parsing capability","Graph database or in-memory representation with edge traversal support","File change information (git diff, file paths, or modification timestamps)","Python 3.9+ with code-review-graph installed","Real codebase or test repositories for evaluation","Optional: API keys for embedding services if semantic search is enabled"],"failure_modes":["Tree-sitter parsing accuracy varies by language maturity; less mature grammars may miss edge cases in dynamic or metaprogramming-heavy code","SHA-256 change detection is file-level only—moving or renaming files without content changes may trigger unnecessary re-parsing","Graph construction time scales linearly with codebase size; initial indexing of 100k+ file monorepos may take minutes","No built-in support for generated code or transpiled outputs; requires manual configuration to exclude build artifacts","Blast radius is conservative—it may include false positives if the graph contains indirect or transitive dependencies that don't actually affect behavior","Dynamic imports, reflection, or metaprogramming patterns may not be captured in the static graph, leading to incomplete blast radius computation","Graph traversal time scales with the number of edges; highly interconnected codebases may require seconds to compute blast radius for a single change","No support for runtime-only dependencies (e.g., configuration files, environment variables) that affect behavior but aren't represented in the code graph","Evaluation framework requires running against real repositories; results may not generalize to other codebases with different structures","Token reduction metrics are specific to Claude and may vary for other LLM assistants","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.36921103025918506,"quality":0.49,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.35,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.064Z","last_scraped_at":"2026-05-03T13:58:34.540Z","last_commit":"2026-04-21T16:48:20Z"},"community":{"stars":14996,"forks":1652,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=tirth8205--code-review-graph","compare_url":"https://unfragile.ai/compare?artifact=tirth8205--code-review-graph"}},"signature":"Rt4ulX0cYJ0Qki6HFWQCjBQKcQ0PkNsJ5y3Szua0YsI9jbbYeTzLEYjLjOTOUhpb2MWcWqGlDN74+k0fZPG6AQ==","signedAt":"2026-06-20T21:43:09.743Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/tirth8205--code-review-graph","artifact":"https://unfragile.ai/tirth8205--code-review-graph","verify":"https://unfragile.ai/api/v1/verify?slug=tirth8205--code-review-graph","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}