{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-deusdata--codebase-memory-mcp","slug":"deusdata--codebase-memory-mcp","name":"codebase-memory-mcp","type":"mcp","url":"https://deusdata.github.io/codebase-memory-mcp/","page_url":"https://unfragile.ai/deusdata--codebase-memory-mcp","categories":["mcp-servers"],"tags":["aider","c","claude-code","code-analysis","code-intelligence","codex","cursor","developer-tools","gemini-cli","graph-visualization","kilocode","knowledge-graph","mcp","mcp-server","model-context-protocol","opencode","performance","sqlite","tree-sitter","windsurf"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-deusdata--codebase-memory-mcp__cap_0","uri":"capability://data.processing.analysis.multi.language.ast.parsing.and.entity.extraction.with.tree.sitter","name":"multi-language ast parsing and entity extraction with tree-sitter","description":"Parses source code in 66 languages using tree-sitter grammar bindings (vendored C components) to extract structural entities: function/method definitions, class hierarchies, variable declarations, imports, and type annotations. The parsing engine operates as the first pass in a 7-pass indexing pipeline, converting raw source text into an intermediate AST representation that feeds downstream semantic analysis. Uses tree-sitter's incremental parsing to avoid re-parsing unchanged file regions during incremental reindexing.","intents":["I need to understand what functions and classes exist in a codebase across multiple languages","I want to extract all definitions and their signatures without manually reading files","I need to identify all imports and dependencies declared in source code"],"best_for":["AI agents analyzing polyglot codebases (Python + Go + TypeScript stacks)","Teams using Claude Code, Cursor, or Windsurf that need language-agnostic code intelligence","Developers building code analysis tools that require structural understanding across 66+ languages"],"limitations":["Tree-sitter grammars may have edge cases with non-standard or legacy syntax variants","Parsing latency scales with file size; very large files (>100KB) may add milliseconds per file","Type inference is best-effort and language-dependent — dynamically typed languages (Python, JavaScript) have less precise type information than statically typed ones"],"requires":["Source code files in one of 66 supported languages (Python, Go, TypeScript, Rust, Java, C++, C#, Kotlin, Lua, Haskell, OCaml, Swift, Dart, MATLAB, Lean 4, Wolfram, etc.)","Filesystem read access to codebase directory"],"input_types":["source code files (any of 66 supported languages)"],"output_types":["structured AST nodes (definitions, calls, imports, type annotations)"],"categories":["data-processing-analysis","code-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_1","uri":"capability://memory.knowledge.persistent.sqlite.knowledge.graph.with.cypher.query.engine","name":"persistent sqlite knowledge graph with cypher query engine","description":"Builds and maintains a queryable knowledge graph stored in SQLite WAL mode at ~/.cache/codebase-memory-mcp/codebase-memory.db. The graph schema models code entities (functions, classes, modules) as nodes and relationships (calls, inheritance, imports, type references) as edges. Exposes a Cypher query engine (src/store/store.c) for graph traversal, enabling sub-millisecond queries for structural patterns like 'find all callers of function X' or 'trace inheritance chain for class Y'. Supports incremental updates via content-hash-based change detection — only modified files trigger re-parsing and graph updates.","intents":["I want to query the codebase structure without re-parsing files every time","I need to find all callers of a function or all subclasses of a type in milliseconds","I want to understand call graphs and dependency chains across the entire codebase"],"best_for":["AI agents that need repeated structural queries on the same codebase","Teams using Claude Code or Cursor that want sub-millisecond response times for code intelligence","Developers building impact analysis tools (what breaks if I change this function?)"],"limitations":["Graph schema is optimized for structural queries; semantic queries (what does this code do?) still require LLM analysis","SQLite WAL mode adds ~5-10MB overhead per indexed codebase; very large graphs (>1GB) may experience slower traversal","Cypher query engine is read-only; no mutation support for dynamic graph updates during agent execution"],"requires":["SQLite 3.8+ (included in most systems)","Filesystem write access to ~/.cache/codebase-memory-mcp/ for graph persistence","Initial indexing pass (one-time, ~milliseconds for average repo)"],"input_types":["Cypher query strings (e.g., 'MATCH (f:Function)-[:CALLS]->(g:Function) WHERE f.name = \"foo\" RETURN g')","graph traversal parameters (start node, depth, relationship type)"],"output_types":["structured graph results (node lists, relationship paths, aggregated counts)"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_10","uri":"capability://planning.reasoning.community.detection.and.architectural.clustering","name":"community detection and architectural clustering","description":"Performs community detection on the code graph to identify clusters of related entities (functions, classes, modules) that form logical architectural components. The indexing pipeline (Pass 6) uses graph clustering algorithms to group entities based on call frequency, shared dependencies, and module boundaries. Results are stored in the graph as 'BELONGS_TO_COMMUNITY' relationships, queryable via tools like 'find_communities' and 'find_community_members'. Useful for understanding codebase architecture, identifying tightly coupled components, and visualizing system structure.","intents":["I want to understand the architectural structure of my codebase without reading documentation","I need to identify tightly coupled components that should be refactored","I want to visualize logical groupings of related functions and classes"],"best_for":["Architects and tech leads understanding codebase organization","Teams performing large-scale refactoring and needing to understand component boundaries","AI agents generating architectural recommendations"],"limitations":["Community detection is heuristic-based; results may not align with intended architectural boundaries","Clustering quality depends on call graph density; sparse graphs may produce poor clusters","Results are sensitive to algorithm parameters (edge weight thresholds, cluster size); tuning required for different codebases","Module boundaries and package structure are not automatically respected; may split modules across communities"],"requires":["Indexed codebase with call graph (automatic via indexing pipeline)","Sufficient call graph density for meaningful clustering (sparse graphs produce poor results)"],"input_types":["optional filters (module, file path)"],"output_types":["list of communities with member functions/classes, inter-community call frequencies"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_11","uri":"capability://search.retrieval.test.coverage.mapping.and.test.to.code.linking","name":"test coverage mapping and test-to-code linking","description":"Identifies test functions and links them to the code they test by analyzing test file naming conventions, test decorators, and assertion patterns. The indexing pipeline (Pass 7) detects test functions (e.g., functions starting with 'test_', methods in classes ending with 'Test', functions decorated with @test or @pytest.mark) and attempts to link them to the functions they test based on naming patterns and call graph analysis. Results are stored in the graph as 'TESTS' relationships, queryable via tools like 'find_tests_for_function' and 'find_tested_functions'.","intents":["I want to find all tests for a specific function to understand test coverage","I need to identify functions with no test coverage","I want to understand which tests exercise a specific code path"],"best_for":["QA teams understanding test coverage and identifying gaps","Developers refactoring code and needing to update related tests","AI agents generating test cases for untested functions"],"limitations":["Test linking is heuristic-based (naming patterns, call graph analysis); complex test setups may not be detected","Test coverage is not measured (line coverage, branch coverage); only test-to-function linking is provided","Parameterized tests and test fixtures are not fully resolved; may undercount test coverage","Integration tests that exercise multiple functions are linked to all called functions, inflating coverage metrics"],"requires":["Indexed codebase with test detection pass completed (automatic via indexing pipeline)","Test files following standard naming conventions (test_*.py, *_test.go, *.test.ts, etc.)"],"input_types":["function name (string)"],"output_types":["list of test functions with locations, test-to-function relationships"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_12","uri":"capability://code.generation.editing.file.content.access.and.code.snippet.retrieval","name":"file content access and code snippet retrieval","description":"Provides direct access to source code files and code snippets via tools like 'get_file_content' and 'get_code_snippet'. Supports retrieving entire files or specific line ranges, with optional syntax highlighting and context expansion. Useful for AI agents that need to read actual code after identifying relevant functions via graph queries. Integrates with graph queries to provide seamless navigation from structural queries (find_callers) to actual code inspection.","intents":["I want to read the implementation of a function after finding it via call graph query","I need to get a specific line range from a file for context","I want to retrieve code snippets for multiple functions to understand their implementations"],"best_for":["AI agents that need to read code after structural queries","Developers navigating codebases and needing quick access to file contents","Tools integrating code intelligence with code reading capabilities"],"limitations":["File access is read-only; no write or edit capabilities","Large files (>1MB) may be slow to retrieve; pagination recommended","Binary files are not supported; only text files","Symlinks and relative paths may not resolve correctly across different systems"],"requires":["Filesystem read access to codebase directory","File path or function location from graph query"],"input_types":["file path (string), optional line range (start_line, end_line)"],"output_types":["file content (string), syntax-highlighted code (optional)"],"categories":["code-generation-editing","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_13","uri":"capability://search.retrieval.configuration.file.and.dependency.link.detection","name":"configuration file and dependency link detection","description":"Detects references to configuration files, environment variables, and external dependencies by analyzing code patterns, imports, and config file references. The indexing pipeline (Pass 5) identifies config file paths (e.g., 'config.yaml', 'settings.json'), environment variable references (e.g., 'os.getenv(\"DATABASE_URL\")'), and external dependencies (e.g., 'import requests', 'require(\"express\")') and links them to the code that references them. Results are stored in the graph as 'REFERENCES_CONFIG', 'USES_ENV_VAR', and 'DEPENDS_ON' relationships.","intents":["I want to find all code that references a specific configuration file","I need to identify all environment variables used in my codebase","I want to understand all external dependencies and where they are used"],"best_for":["DevOps and infrastructure teams understanding configuration dependencies","Developers performing security audits on environment variable usage","Teams managing dependency upgrades and understanding impact"],"limitations":["Config file detection is pattern-based; non-standard config file names may be missed","Environment variable detection uses regex patterns; dynamic variable names (e.g., 'os.getenv(var_name)') are not resolved","Dependency detection is based on import statements; transitive dependencies are not resolved","Config file content is not analyzed; only references are detected"],"requires":["Indexed codebase with config link detection pass completed (automatic via indexing pipeline)"],"input_types":["config file name (string), environment variable name (string), or dependency name (string)"],"output_types":["list of code locations that reference the config/env var/dependency"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_14","uri":"capability://data.processing.analysis.polyglot.codebase.indexing.with.language.specific.semantics","name":"polyglot codebase indexing with language-specific semantics","description":"Indexes codebases containing multiple programming languages (Python, Go, TypeScript, Rust, Java, C++, C#, Kotlin, Lua, Haskell, OCaml, Swift, Dart, MATLAB, Lean 4, Wolfram, and 48 more) in a single unified indexing pass. Each language is parsed using language-specific tree-sitter grammars, and semantic analysis (call resolution, type inference, HTTP route detection) is adapted to each language's semantics. Results are stored in a unified graph that enables cross-language queries (e.g., 'find all Python functions that call Go functions').","intents":["I want to understand the structure of my polyglot codebase (Python + Go + TypeScript) in a single view","I need to find cross-language dependencies (Python calling Go, TypeScript calling Rust)","I want to perform impact analysis across language boundaries"],"best_for":["Teams with polyglot codebases (microservices, multi-language projects)","Developers understanding cross-language dependencies and integration points","AI agents analyzing complex systems with multiple languages"],"limitations":["Cross-language type inference is limited; type information is not shared across language boundaries","Call resolution across languages requires explicit integration points (FFI, gRPC, HTTP); implicit calls are not resolved","Language-specific idioms and patterns may not be recognized in other languages","Semantic analysis quality varies by language; dynamically typed languages have less precise information"],"requires":["Codebase with files in one or more of 66 supported languages","Explicit integration points between languages (imports, FFI, HTTP calls) for cross-language queries"],"input_types":["codebase directory with mixed-language files"],"output_types":["unified graph with language-specific entities and cross-language relationships"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_2","uri":"capability://data.processing.analysis.7.pass.semantic.indexing.pipeline.with.call.resolution.and.type.inference","name":"7-pass semantic indexing pipeline with call resolution and type inference","description":"Executes a multi-stage indexing pipeline (src/pipeline/pipeline.c) that progressively enriches the graph: Pass 1 extracts structure (definitions, imports), Pass 2 resolves calls to their definitions, Pass 3 infers types and inheritance, Pass 4 detects HTTP links and routes, Pass 5 identifies config file references, Pass 6 performs community detection (clustering related entities), Pass 7 indexes test coverage. Each pass operates on the graph built by previous passes, enabling sophisticated analyses like 'find all functions that handle HTTP POST requests' or 'identify dead code by tracing reachability from entry points'. Type inference uses language-specific heuristics (e.g., Python type hints, Go explicit types, TypeScript annotations) to build a best-effort type map.","intents":["I want to understand which functions are called by which other functions across the entire codebase","I need to identify which HTTP routes are handled by which handlers","I want to find dead code by tracing reachability from entry points","I need to understand type relationships and inheritance hierarchies"],"best_for":["AI agents performing impact analysis (what breaks if I change this?)","Teams using Claude Code or Cursor that need to understand call graphs and dependencies","Developers building refactoring tools that require precise call resolution across languages"],"limitations":["Call resolution is best-effort; dynamic calls (reflection, eval, function pointers) are not resolved","Type inference is incomplete for dynamically typed languages (Python, JavaScript) without explicit annotations","Community detection uses heuristic clustering; results may not align with actual architectural boundaries","HTTP link detection is pattern-based (regex on route strings); complex routing logic (middleware, decorators) may be missed"],"requires":["Completed AST parsing pass (automatic prerequisite)","Codebase with identifiable entry points or root functions for reachability analysis"],"input_types":["parsed AST from tree-sitter (automatic input from parsing pass)"],"output_types":["enriched graph with call relationships, type information, HTTP routes, communities, test coverage"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_3","uri":"capability://automation.workflow.incremental.reindexing.with.content.hash.change.detection","name":"incremental reindexing with content-hash change detection","description":"Detects file changes using content hashing (comparing SHA-256 hashes of file contents) and re-parses only modified files during incremental reindexing. The file watcher (src/pipeline/pipeline_incremental.c) polls the filesystem with adaptive intervals (5-60 seconds) and triggers incremental re-indexing when changes are detected. This approach avoids full-codebase re-parsing on every change, achieving ~4× faster reindexing than scanning all files. The graph is updated in-place, preserving query performance for unchanged portions of the codebase.","intents":["I want the codebase graph to stay in sync with my editor without full re-indexing on every keystroke","I need fast reindexing when I make changes to a few files in a large codebase","I want background indexing that doesn't block my AI agent from querying the graph"],"best_for":["Developers using Claude Code, Cursor, or Windsurf with large codebases (>10K files)","Teams with continuous development workflows that need graph freshness without re-indexing latency","AI agents that need to query the graph while files are being edited"],"limitations":["File watcher polling interval is adaptive (5-60s); changes may not be reflected immediately in the graph","Content-hash comparison adds ~1-5ms per file; very large codebases (>100K files) may experience noticeable polling overhead","Concurrent file modifications during indexing may result in stale graph state; no locking mechanism for multi-process access","Deleted files are not automatically removed from the graph; manual cleanup required for large-scale refactoring"],"requires":["Filesystem read access to codebase directory","Background process with CPU and I/O resources for polling and re-parsing"],"input_types":["filesystem events (file modifications detected via content hashing)"],"output_types":["updated SQLite graph with changes from modified files"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_4","uri":"capability://tool.use.integration.mcp.tool.exposure.with.stdio.transport.and.cli.fallback","name":"mcp tool exposure with stdio transport and cli fallback","description":"Exposes 14 code intelligence tools via the Model Context Protocol (MCP) specification, communicating with MCP clients (Claude Code, Cursor, Windsurf, Gemini CLI, VS Code, Zed) over stdio transport. The MCP server (src/mcp/mcp.c) implements a single-threaded event loop that parses incoming JSON-RPC requests, routes them to tool handlers, and returns structured results. Each tool maps to a specific graph query or code access operation (e.g., 'find_callers', 'find_callees', 'get_file_content'). Additionally, exposes all tools via CLI mode (codebase-memory-mcp cli <tool_name>) for scripting and testing without an MCP client.","intents":["I want to integrate code intelligence into Claude Code, Cursor, or Windsurf without custom plugins","I need to call code intelligence tools from scripts or CI/CD pipelines","I want to test and debug code intelligence queries without an MCP client"],"best_for":["AI agents using Claude Code, Cursor, Windsurf, or other MCP-compatible clients","Teams building custom AI workflows that need code intelligence as a tool","Developers scripting code analysis tasks in CI/CD pipelines"],"limitations":["Single-threaded event loop means concurrent tool calls are serialized; high-concurrency workloads may experience queueing","Stdio transport has no built-in authentication; assumes trusted local execution","MCP specification is relatively new; some clients may have incomplete tool support or schema validation issues","CLI mode requires manual JSON formatting for complex queries; not suitable for interactive use"],"requires":["MCP-compatible client (Claude Code, Cursor, Windsurf, Gemini CLI, VS Code, Zed) OR shell access for CLI mode","Indexed codebase (automatic via initial indexing pass)"],"input_types":["JSON-RPC requests (MCP mode) or CLI arguments (CLI mode)"],"output_types":["JSON-structured tool results (function definitions, call graphs, file contents)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_5","uri":"capability://search.retrieval.graph.visualization.and.interactive.exploration.ui","name":"graph visualization and interactive exploration ui","description":"Provides a web-based graph visualization UI (docs/index.html) that renders the indexed knowledge graph as an interactive node-link diagram. Users can click nodes to expand relationships, search for entities by name, and explore call graphs, inheritance hierarchies, and dependency chains visually. The UI queries the SQLite graph via the MCP tools, enabling real-time exploration without re-indexing. Useful for understanding codebase structure, identifying architectural patterns, and communicating code organization to team members.","intents":["I want to visualize the call graph for a function to understand its dependencies","I need to explore the inheritance hierarchy for a class visually","I want to show my team the architecture of our codebase in an interactive diagram"],"best_for":["Teams onboarding new developers who need to understand codebase structure","Architects and tech leads communicating code organization to stakeholders","Developers debugging complex dependency chains or circular dependencies"],"limitations":["Graph visualization can become cluttered for large codebases (>10K nodes); filtering and clustering are essential","Interactive exploration is slower than programmatic queries; suitable for exploration, not real-time analysis","Web UI requires browser access; not suitable for headless or remote-only environments","Rendering performance degrades with graph size; very large graphs (>50K nodes) may experience lag"],"requires":["Web browser with JavaScript support","Indexed codebase (automatic via initial indexing pass)","HTTP server or local file access to serve UI HTML"],"input_types":["user interactions (node clicks, search queries, filter selections)"],"output_types":["interactive graph visualization (SVG or canvas rendering)"],"categories":["search-retrieval","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_6","uri":"capability://search.retrieval.project.level.code.intelligence.queries.find.callers.find.callees.trace.calls","name":"project-level code intelligence queries (find_callers, find_callees, trace_calls)","description":"Exposes graph query tools that answer project-level structural questions by traversing the knowledge graph. 'find_callers' returns all functions/methods that call a given function; 'find_callees' returns all functions called by a given function; 'trace_calls' returns the full call path from a source function to a target function. These queries operate on the pre-built graph, returning results in milliseconds without re-parsing. Supports filtering by language, module, or file path to narrow results in large codebases.","intents":["I need to find all callers of a function to understand its impact","I want to trace the call path from a user-facing endpoint to a database query","I need to identify all functions called by a specific handler to understand its dependencies"],"best_for":["AI agents performing impact analysis (what breaks if I change this function?)","Developers refactoring code and needing to understand call dependencies","Teams debugging issues by tracing execution paths from entry points"],"limitations":["Call resolution is best-effort; dynamic calls (reflection, eval, function pointers) are not resolved","Results may include false positives if multiple functions share the same name (name collisions)","Filtering by module or file path requires exact matches; partial matching not supported","Very deep call chains (>100 levels) may return large result sets; pagination recommended"],"requires":["Indexed codebase with resolved call graph (automatic via indexing pipeline)","Function/method name to query (exact match or regex pattern)"],"input_types":["function name (string), optional filters (language, module, file path)"],"output_types":["list of function definitions with locations, call paths with intermediate functions"],"categories":["search-retrieval","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_7","uri":"capability://search.retrieval.http.route.and.handler.mapping.with.pattern.detection","name":"http route and handler mapping with pattern detection","description":"Detects HTTP routes and their handler functions by analyzing route definitions (decorators, function calls, config files) across frameworks (Express, FastAPI, Django, Spring, etc.). The indexing pipeline (Pass 4) uses pattern matching and AST analysis to identify route declarations (e.g., @app.route('/api/users'), router.get('/users/:id')) and link them to their handler functions. Supports extracting route parameters, HTTP methods, and middleware chains. Results are stored in the graph and queryable via tools like 'find_routes' and 'find_route_handlers'.","intents":["I want to find which handler function handles a specific HTTP route","I need to understand the full middleware chain for an endpoint","I want to identify all API routes in my codebase and their handlers"],"best_for":["Backend developers understanding API structure and request handling","AI agents generating API documentation or test cases","Teams performing security audits on API endpoints"],"limitations":["Route detection is pattern-based; complex routing logic (middleware, conditional routes, dynamic route generation) may be missed","Framework-specific decorators and conventions are supported for popular frameworks (Express, FastAPI, Django, Spring); custom frameworks may not be detected","Route parameters and middleware chains are extracted as strings; semantic understanding requires LLM analysis","Regex-based route patterns are not fully resolved; exact path matching not supported"],"requires":["Indexed codebase with HTTP link detection pass completed (automatic via indexing pipeline)","Web framework using standard route declaration patterns (decorators, function calls, config files)"],"input_types":["route path (string), optional HTTP method filter"],"output_types":["handler function definitions, middleware chain, route parameters"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_8","uri":"capability://search.retrieval.type.hierarchy.and.inheritance.chain.resolution","name":"type hierarchy and inheritance chain resolution","description":"Resolves type relationships and inheritance hierarchies by analyzing class definitions, interface implementations, and type annotations. The indexing pipeline (Pass 3) uses language-specific heuristics to identify parent classes, implemented interfaces, and type parameters. Results are stored in the graph as 'INHERITS_FROM' and 'IMPLEMENTS' relationships, queryable via tools like 'find_subclasses', 'find_implementations', and 'trace_inheritance'. Supports both single and multiple inheritance, generic types, and mixins (where applicable).","intents":["I want to find all subclasses of a base class to understand the inheritance hierarchy","I need to identify all implementations of an interface","I want to trace the type hierarchy for a generic class with type parameters"],"best_for":["Developers refactoring class hierarchies and needing to understand all subclasses","Teams performing impact analysis on interface changes","AI agents generating code that respects type hierarchies"],"limitations":["Type inference is best-effort; dynamically typed languages (Python, JavaScript) without explicit type annotations have incomplete hierarchies","Generic types and type parameters are partially resolved; complex type algebra (union types, intersection types) may be incomplete","Mixins and trait-based inheritance (Rust, Scala) are partially supported; exact semantics depend on language","Dynamic class creation (reflection, metaclasses) is not resolved"],"requires":["Indexed codebase with type inference pass completed (automatic via indexing pipeline)","Class or interface name to query (exact match or regex pattern)"],"input_types":["class/interface name (string), optional language filter"],"output_types":["list of subclasses/implementations with locations, inheritance chains, type parameters"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-deusdata--codebase-memory-mcp__cap_9","uri":"capability://planning.reasoning.dead.code.and.reachability.analysis","name":"dead code and reachability analysis","description":"Identifies unreachable code by performing reachability analysis from entry points (main functions, exported APIs, test entry points). The indexing pipeline uses graph traversal to mark all functions reachable from entry points, identifying functions with no incoming edges as potentially dead code. Supports filtering by module, file path, or function type (private vs. public) to reduce false positives. Results are queryable via tools like 'find_dead_code' and 'find_unreachable_functions'.","intents":["I want to identify unused functions in my codebase to clean up dead code","I need to find functions that are never called from any entry point","I want to understand which functions are reachable from a specific entry point"],"best_for":["Teams performing code cleanup and refactoring","Developers optimizing codebase size and complexity","AI agents generating code removal suggestions"],"limitations":["Reachability analysis is based on static call graph; dynamic calls (reflection, eval, function pointers) are not resolved, leading to false positives","Exported APIs (public functions) are assumed reachable; may miss unused public functions","Test functions and fixtures are often marked as reachable even if not called from main code","Framework-specific entry points (middleware, decorators, event handlers) may not be recognized as entry points"],"requires":["Indexed codebase with call graph and entry point detection (automatic via indexing pipeline)","Identifiable entry points (main functions, exported APIs, test entry points)"],"input_types":["optional filters (module, file path, function type)"],"output_types":["list of unreachable functions with locations, reachability paths from entry points"],"categories":["planning-reasoning","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":49,"verified":false,"data_access_risk":"high","permissions":["Source code files in one of 66 supported languages (Python, Go, TypeScript, Rust, Java, C++, C#, Kotlin, Lua, Haskell, OCaml, Swift, Dart, MATLAB, Lean 4, Wolfram, etc.)","Filesystem read access to codebase directory","SQLite 3.8+ (included in most systems)","Filesystem write access to ~/.cache/codebase-memory-mcp/ for graph persistence","Initial indexing pass (one-time, ~milliseconds for average repo)","Indexed codebase with call graph (automatic via indexing pipeline)","Sufficient call graph density for meaningful clustering (sparse graphs produce poor results)","Indexed codebase with test detection pass completed (automatic via indexing pipeline)","Test files following standard naming conventions (test_*.py, *_test.go, *.test.ts, etc.)","File path or function location from graph query"],"failure_modes":["Tree-sitter grammars may have edge cases with non-standard or legacy syntax variants","Parsing latency scales with file size; very large files (>100KB) may add milliseconds per file","Type inference is best-effort and language-dependent — dynamically typed languages (Python, JavaScript) have less precise type information than statically typed ones","Graph schema is optimized for structural queries; semantic queries (what does this code do?) still require LLM analysis","SQLite WAL mode adds ~5-10MB overhead per indexed codebase; very large graphs (>1GB) may experience slower traversal","Cypher query engine is read-only; no mutation support for dynamic graph updates during agent execution","Community detection is heuristic-based; results may not align with intended architectural boundaries","Clustering quality depends on call graph density; sparse graphs may produce poor clusters","Results are sensitive to algorithm parameters (edge weight thresholds, cluster size); tuning required for different codebases","Module boundaries and package structure are not automatically respected; may split modules across communities","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5003638110016269,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"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:21.550Z","last_scraped_at":"2026-05-03T13:56:59.049Z","last_commit":"2026-04-25T05:42:53Z"},"community":{"stars":2021,"forks":233,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=deusdata--codebase-memory-mcp","compare_url":"https://unfragile.ai/compare?artifact=deusdata--codebase-memory-mcp"}},"signature":"OyIODQKPLNFPaw1Jibrkwyd8VNnU+7yBuA1qkuzYYpavy9k4ODAuduXf15OPvRVbPu2AjzeSDHY+pt9onjamBw==","signedAt":"2026-06-21T03:27:55.775Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/deusdata--codebase-memory-mcp","artifact":"https://unfragile.ai/deusdata--codebase-memory-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=deusdata--codebase-memory-mcp","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"}}