{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-johnhuang316-code-index-mcp","slug":"mcp-johnhuang316-code-index-mcp","name":"code-index-mcp","type":"mcp","url":"https://github.com/johnhuang316/code-index-mcp","page_url":"https://unfragile.ai/mcp-johnhuang316-code-index-mcp","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-johnhuang316-code-index-mcp__cap_0","uri":"capability://memory.knowledge.dual.strategy.codebase.indexing.with.shallow.and.deep.modes","name":"dual-strategy codebase indexing with shallow and deep modes","description":"Implements a two-tier indexing strategy where shallow indexing rapidly builds file lists via filesystem traversal, while deep indexing extracts symbol-level structure (functions, classes, variables) using tree-sitter AST parsing for 50+ file types with fallback regex strategies. The indexing system uses SQLite for symbol storage and JSON for file metadata, enabling LLMs to understand codebase structure without full source transmission. Supports incremental updates and file watching for auto-refresh on changes.","intents":["I need to give Claude access to my entire codebase structure without uploading gigabytes of source code","I want to index a large monorepo and search for specific functions or classes across multiple files","I need the index to stay fresh as my code changes without manual re-indexing"],"best_for":["developers using Claude Desktop or MCP-compatible IDEs who want codebase-aware AI assistance","teams managing large monorepos (100+ files) needing efficient symbol extraction","solo developers building LLM agents that need to reason about code structure"],"limitations":["Tree-sitter parsing adds ~500ms-2s overhead per large file depending on language complexity","SQLite symbol storage requires local disk access; no cloud-based index sharing","Fallback regex strategies for unsupported languages may miss nested or complex symbol definitions","File watching uses polling on some systems, consuming CPU on very large repos (10k+ files)"],"requires":["Python 3.9+","tree-sitter library with language bindings for target languages","Local filesystem read access to codebase","MCP client compatible with stdio transport (Claude Desktop, Codex CLI, or custom)"],"input_types":["local filesystem paths","file type filters (e.g., '.py', '.js', '.ts')","configuration JSON for indexing strategies"],"output_types":["SQLite database with symbol tables","JSON file lists with metadata","structured symbol objects (name, type, line number, scope)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_1","uri":"capability://search.retrieval.multi.strategy.code.search.with.regex.fuzzy.matching.and.semantic.filtering","name":"multi-strategy code search with regex, fuzzy matching, and semantic filtering","description":"Exposes search_code_advanced tool that combines regex pattern matching, fuzzy string matching, and file type filtering to locate code across indexed repositories. Searches operate against both the symbol database (for function/class names) and file contents (for code patterns). Supports complex queries like 'find all async functions in TypeScript files' through composable filter chains. Results include file paths, line numbers, and context snippets.","intents":["I need to find all usages of a deprecated function across my codebase","I want to search for code patterns matching a regex without loading the entire repo into context","I need to locate all test files or configuration files matching specific naming conventions"],"best_for":["developers refactoring large codebases and needing precise code location","LLM agents performing code analysis tasks that require targeted symbol discovery","teams auditing code for security patterns or compliance violations"],"limitations":["Regex search performance degrades on very large files (>10MB); no streaming results","Fuzzy matching may return false positives for short search terms (< 3 characters)","Search operates on indexed snapshot; real-time file changes require index refresh","No semantic/AST-aware search (e.g., cannot distinguish function calls from definitions without post-processing)"],"requires":["Completed deep index (build_deep_index must be run first)","Valid regex patterns or fuzzy search strings","File type filters must match indexed file extensions"],"input_types":["regex pattern strings","fuzzy search keywords","file type filters (e.g., '.py', '.js')","scope filters (function, class, variable)"],"output_types":["list of matched file paths with line numbers","code context snippets (surrounding lines)","symbol metadata (type, scope, definition location)"],"categories":["search-retrieval","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_10","uri":"capability://data.processing.analysis.language.specific.parsing.strategy.selection.with.fallback.chains","name":"language-specific parsing strategy selection with fallback chains","description":"Implements an intelligent parser selection system that chooses the best parsing strategy for each language based on availability and accuracy. For languages with tree-sitter bindings (Python, JavaScript, TypeScript, Go, Rust, Java, C++, etc.), uses AST parsing. For unsupported languages, falls back to regex-based heuristics. Fallback strategies are language-specific (e.g., Bash uses different patterns than SQL). Parsing results are cached to avoid re-parsing identical files.","intents":["I have a polyglot codebase with 10+ languages and need consistent symbol extraction","I want to index languages that don't have tree-sitter support using best-effort regex","I need fast parsing without installing language-specific compilers or tools"],"best_for":["teams managing polyglot monorepos (microservices, multi-language projects)","developers who want to index code without language-specific tooling","LLM agents that need to handle arbitrary code files"],"limitations":["Regex fallback is less accurate than AST parsing; may miss nested or complex definitions","Fallback strategies are heuristic-based and may produce false positives/negatives","Adding new language support requires implementing regex patterns or tree-sitter bindings","Performance varies significantly by language; some regex patterns are slow on large files"],"requires":["tree-sitter library for supported languages","Python regex engine for fallback strategies","Language identification (file extension or content-based)"],"input_types":["source code text","language identifier (auto-detected from file extension)"],"output_types":["list of extracted symbols with type and location","parsing strategy used (tree-sitter or regex)","confidence score for regex-based results"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_11","uri":"capability://search.retrieval.context.aware.symbol.search.with.scope.and.type.filtering","name":"context-aware symbol search with scope and type filtering","description":"Extends basic search with semantic awareness by filtering results by symbol type (function, class, variable, import) and scope (global, module-level, nested). Allows queries like 'find all async functions' or 'find all class methods named init'. Leverages symbol metadata extracted during indexing (type, scope, decorators) to filter results without post-processing. Results include full symbol context (definition location, signature, scope chain).","intents":["I need to find all async functions in my codebase to understand concurrency patterns","I want to locate all class constructors (__init__, constructor) across multiple languages","I need to find all global variables to identify potential state management issues"],"best_for":["code auditors looking for specific patterns (async functions, global state, etc.)","LLM agents performing code analysis tasks that require semantic understanding","developers refactoring code and needing to understand symbol relationships"],"limitations":["Type and scope filtering depends on accurate parsing; regex fallback may miss metadata","Scope detection is limited to syntactic scope; does not understand runtime scope changes","Decorator and annotation filtering is language-specific; not all languages supported equally","No semantic understanding of inheritance or polymorphism; cannot find overridden methods"],"requires":["Completed deep index with symbol metadata","Valid symbol type and scope filters"],"input_types":["search pattern (regex or fuzzy)","symbol type filter (function, class, variable, import, etc.)","scope filter (global, module, nested, etc.)","optional: language filter"],"output_types":["filtered list of matching symbols","symbol metadata (type, scope, signature, location)","context snippets showing symbol definition"],"categories":["search-retrieval","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_12","uri":"capability://data.processing.analysis.project.statistics.and.code.metrics.generation","name":"project statistics and code metrics generation","description":"Provides get_project_stats tool that analyzes the indexed codebase to generate aggregate metrics: total files, lines of code per language, symbol counts (functions, classes, variables), file size distribution, and complexity estimates. Metrics are computed from the index without re-parsing. Supports filtering by language, file type, or directory. Useful for understanding codebase scale and composition.","intents":["I need to understand the size and composition of my codebase (how many lines of code, how many functions)","I want to compare code metrics across languages in my monorepo","I need to identify which parts of my codebase are largest or most complex"],"best_for":["engineering managers assessing codebase health and scale","developers planning refactoring efforts and understanding scope","LLM agents gathering context about project size before analysis"],"limitations":["Metrics are based on indexed snapshot; real-time changes require index refresh","Complexity estimates are heuristic-based (e.g., function count, nesting depth) not true cyclomatic complexity","Line-of-code counts may include comments and blank lines depending on parser","No support for excluding generated code or third-party libraries"],"requires":["Completed index (shallow or deep)","Valid language or file type filters"],"input_types":["optional: language filter","optional: file type filter","optional: directory filter"],"output_types":["JSON object with aggregate metrics","per-language breakdowns","file size and complexity distributions","symbol count statistics"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_13","uri":"capability://data.processing.analysis.dependency.graph.extraction.and.relationship.analysis","name":"dependency graph extraction and relationship analysis","description":"Analyzes import statements and symbol references to build a dependency graph showing relationships between files and modules. Extracts import/require statements from indexed code to identify direct dependencies. Supports language-specific import syntax (Python import/from, JavaScript import/require, Go import, etc.). Can compute transitive dependencies and identify circular dependencies. Results are returned as graph data structure suitable for visualization or further analysis.","intents":["I need to understand the dependency structure of my codebase to plan refactoring","I want to detect circular dependencies that might indicate architectural issues","I need to trace how changes in one module affect other modules"],"best_for":["architects analyzing codebase structure and dependencies","developers planning modularization or microservices migration","LLM agents understanding code relationships before refactoring"],"limitations":["Dependency extraction is limited to static imports; misses dynamic requires or lazy loading","External dependencies (npm packages, PyPI modules) are identified but not resolved","Transitive dependency computation can be expensive for large graphs (O(n²) in worst case)","Circular dependency detection may have false positives if imports are conditional"],"requires":["Completed deep index with import statements extracted","Language support for import statement parsing"],"input_types":["optional: starting file or module for dependency trace","optional: depth limit for transitive dependencies","optional: language filter"],"output_types":["graph data structure (nodes=files, edges=imports)","list of circular dependencies","dependency statistics (average degree, depth)","JSON representation suitable for visualization"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_2","uri":"capability://code.generation.editing.file.level.code.summarization.and.structural.analysis","name":"file-level code summarization and structural analysis","description":"The get_file_summary tool generates concise summaries of individual source files by analyzing their AST structure to extract top-level definitions (functions, classes, imports, exports). Summaries include symbol lists with signatures, dependency information, and file-level documentation. Uses tree-sitter parsing to understand code structure without executing or compiling, producing machine-readable output suitable for LLM context windows.","intents":["I need a quick overview of what functions and classes are defined in a file without reading the entire source","I want to understand a file's dependencies and public API surface","I need to generate context for an LLM to understand a file's purpose before asking it to modify the code"],"best_for":["LLM agents preparing context before code generation or refactoring tasks","developers navigating unfamiliar codebases quickly","documentation generation pipelines that need automated file summaries"],"limitations":["Summaries are structural only; do not include docstring content or inline comments","Complex nested structures (closures, decorators) may be simplified or omitted","Performance scales with file size; very large files (>50KB) may timeout","Language-specific features (e.g., Python decorators, TypeScript generics) may not be fully represented"],"requires":["File must be in indexed codebase","Language must have tree-sitter parser or fallback regex strategy","File must be readable (not binary)"],"input_types":["file path (relative to project root)","optional: summary detail level (basic, detailed)"],"output_types":["JSON object with file metadata","list of top-level symbols with types and signatures","import/export statements","file-level statistics (lines of code, complexity estimate)"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_3","uri":"capability://tool.use.integration.mcp.protocol.server.with.stdio.transport.and.tool.registration","name":"mcp protocol server with stdio transport and tool registration","description":"Implements a FastMCP server that exposes 15+ code intelligence tools through the Model Context Protocol, communicating with MCP clients (Claude Desktop, Codex CLI) via stdio transport. All tools are decorated with @mcp.tool() and wrapped with @handle_mcp_tool_errors for consistent error handling. The server manages a CodeIndexerContext object that provides shared state (index managers, services, configuration) across all tool invocations, enabling stateful operations like maintaining an active project path.","intents":["I want to integrate code intelligence into Claude Desktop without building a custom API","I need to expose my indexing and search tools to any MCP-compatible client","I want consistent error handling and tool discovery across all code analysis operations"],"best_for":["developers using Claude Desktop or other MCP-compatible IDEs","teams building custom MCP clients that need code intelligence","organizations standardizing on MCP for LLM tool integration"],"limitations":["Stdio transport is single-threaded; concurrent tool calls are serialized","No built-in authentication; relies on OS-level process isolation","Tool discovery requires MCP client to parse tool definitions; no dynamic capability negotiation","Error responses are converted to MCPToolError format; custom error types are flattened to strings"],"requires":["Python 3.9+","FastMCP library","MCP-compatible client application","Stdio transport support (available on all major OSes)"],"input_types":["MCP tool call requests (JSON-RPC format)","tool arguments as JSON objects"],"output_types":["MCP tool responses (JSON-RPC format)","structured tool results or error objects","MCPToolError for exceptions"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_4","uri":"capability://automation.workflow.project.path.management.with.context.persistence","name":"project path management with context persistence","description":"Provides set_project_path and get_project_path tools that manage the active codebase context across tool invocations. The project path is stored in CodeIndexerContext and persists for the lifetime of the MCP server process, allowing subsequent search and indexing operations to operate on the correct codebase without re-specifying the path. Validates paths exist and are readable before accepting them.","intents":["I want to set a working directory once and have all subsequent tools operate on that codebase","I need to switch between multiple projects in a single MCP session","I want to verify that my project path is correctly configured before running indexing operations"],"best_for":["LLM agents managing multi-step code analysis workflows","developers switching between projects in Claude Desktop","automation scripts that need to operate on different codebases sequentially"],"limitations":["Project path is session-scoped; lost when MCP server restarts","No project configuration file support; path must be set programmatically","Changing project path does not automatically invalidate existing indexes; must call refresh_index","No validation of project structure (e.g., does not check for package.json or pyproject.toml)"],"requires":["Valid filesystem path","Read permissions on target directory","MCP server running and accessible"],"input_types":["absolute or relative filesystem path","optional: validation flags"],"output_types":["confirmation of set path","current project path string","path validation status"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_5","uri":"capability://automation.workflow.incremental.index.refresh.with.file.change.detection","name":"incremental index refresh with file change detection","description":"The refresh_index tool rebuilds the symbol index for changed files only, using file modification timestamps to detect changes since last index. Implements file watching via watchdog library (or polling fallback) to automatically trigger refreshes when files change. Supports both manual refresh (on-demand) and automatic refresh (background monitoring). Preserves unchanged file entries in the index, reducing reprocessing overhead.","intents":["I want my code index to stay current as I edit files without manually re-indexing","I need to refresh the index after pulling changes from git","I want to detect which files have changed since the last index build"],"best_for":["developers using code-index-mcp in long-running IDE sessions","CI/CD pipelines that need to index code after checkout or merge","LLM agents that need to maintain accurate codebase state across multiple interactions"],"limitations":["File watching uses polling on some systems (macOS, Windows), consuming CPU on large repos","Timestamp-based detection misses changes that don't update mtime (e.g., git checkout with --no-touch)","Refresh is blocking; large file changes may pause tool responses for seconds","No support for .gitignore or other exclusion patterns; must be configured separately"],"requires":["Existing index (build_deep_index must be run first)","Filesystem that supports modification timestamps","watchdog library for file monitoring (optional; falls back to polling)"],"input_types":["optional: file paths to refresh (if not provided, scans all indexed files)","optional: refresh mode (manual, auto, background)"],"output_types":["list of refreshed files","count of added/modified/deleted files","index statistics (total symbols, file count)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_6","uri":"capability://data.processing.analysis.tree.sitter.ast.parsing.with.language.specific.symbol.extraction","name":"tree-sitter ast parsing with language-specific symbol extraction","description":"Implements a pluggable parsing system using tree-sitter library to extract symbols (functions, classes, variables, imports) from source code by traversing the Abstract Syntax Tree. Supports 50+ languages with language-specific parsers (Python, JavaScript, TypeScript, Go, Rust, Java, C++, etc.). For unsupported languages, falls back to regex-based heuristics. Parsing results are cached and stored in SQLite for fast retrieval. Each parser extracts language-specific metadata (e.g., async/await markers, decorators, type annotations).","intents":["I need to extract all function definitions from a Python file with their signatures and decorators","I want to find all class definitions across multiple languages in a monorepo","I need to understand import dependencies to trace code relationships"],"best_for":["developers working with polyglot codebases (multiple languages)","LLM agents that need accurate symbol extraction without language-specific compilers","code analysis tools that require structural understanding of source code"],"limitations":["Tree-sitter parsing adds 500ms-2s latency per large file depending on language complexity","Language bindings must be installed separately; missing bindings fall back to regex (less accurate)","Regex fallback misses nested or complex definitions (e.g., closures, decorators in Python)","Parsing does not execute code; cannot extract runtime-generated symbols or dynamic imports"],"requires":["tree-sitter Python library","Language-specific tree-sitter bindings (e.g., tree-sitter-python, tree-sitter-javascript)","Source files must be readable text (not binary)"],"input_types":["source code text","language identifier (e.g., 'python', 'javascript')","optional: parsing options (include comments, include docstrings)"],"output_types":["list of symbol objects with type, name, line number, scope","AST node references for further analysis","language-specific metadata (decorators, type annotations, async markers)"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_7","uri":"capability://search.retrieval.file.discovery.and.listing.with.type.based.filtering","name":"file discovery and listing with type-based filtering","description":"The find_files tool performs filesystem traversal to locate files matching specified criteria (name patterns, file types, size constraints). Supports glob patterns, regex matching, and file type filters (e.g., 'all Python files', 'all test files'). Results include file paths, sizes, and modification times. Operates on the indexed file list for fast retrieval without filesystem I/O. Supports exclusion patterns to skip directories like node_modules, .git, __pycache__.","intents":["I need to find all test files in my codebase to understand test coverage","I want to locate all configuration files (package.json, pyproject.toml, etc.) across a monorepo","I need to find large files that might be performance bottlenecks"],"best_for":["developers auditing codebase structure and file organization","LLM agents gathering context about project layout before analysis","build systems and CI/CD pipelines that need to discover files matching patterns"],"limitations":["File discovery operates on indexed snapshot; real-time filesystem changes require index refresh","Glob patterns are limited to standard syntax; no advanced regex features","No support for symlinks or hard links; treats them as regular files","Exclusion patterns must be configured upfront; cannot be specified per-query"],"requires":["Completed shallow index (set_project_path must be called first)","Valid glob or regex pattern"],"input_types":["glob pattern (e.g., '*.py', 'src/**/*.ts')","file type filter (e.g., 'python', 'javascript')","optional: size constraints (min/max bytes)","optional: exclusion patterns"],"output_types":["list of matching file paths","file metadata (size, modification time, type)","match count and statistics"],"categories":["search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_8","uri":"capability://automation.workflow.configuration.management.and.tool.discovery","name":"configuration management and tool discovery","description":"Manages MCP server configuration through JSON files (.well-known/mcp.json, fastmcp.json) that define tool schemas, transport settings, and discovery metadata. Supports environment variable substitution for API keys and paths. Exposes get_config and set_config tools for runtime configuration updates. Configuration is validated against JSON schema to ensure tool definitions are correct. Enables MCP clients to discover available tools and their parameters without hardcoding.","intents":["I need to configure which languages to parse and which file types to index","I want to set up environment-specific settings (dev vs. production indexing strategies)","I need to discover what tools are available in the MCP server and their parameters"],"best_for":["MCP client developers integrating code-index-mcp into their applications","DevOps teams deploying code-index-mcp with environment-specific settings","developers customizing indexing behavior for their specific codebase"],"limitations":["Configuration changes require server restart to take effect (no hot-reload)","Environment variable substitution is limited to simple ${VAR} syntax","No validation of configuration values; invalid settings may cause silent failures","Configuration files must be manually edited; no UI for configuration management"],"requires":["JSON configuration files in project root or .well-known directory","Write permissions to configuration files","Valid JSON syntax"],"input_types":["JSON configuration objects","environment variable names","configuration keys and values"],"output_types":["current configuration as JSON","tool schema definitions","validation status and errors"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-johnhuang316-code-index-mcp__cap_9","uri":"capability://safety.moderation.error.handling.and.tool.response.normalization","name":"error handling and tool response normalization","description":"Implements @handle_mcp_tool_errors decorator that wraps all MCP tool functions to catch exceptions and convert them to MCPToolError responses with consistent formatting. Provides detailed error messages including stack traces (in debug mode) and user-friendly summaries. Normalizes error responses across all tools so MCP clients receive consistent error format regardless of which tool fails. Logs errors for debugging and monitoring.","intents":["I need consistent error handling across all code intelligence tools","I want detailed error messages when tools fail so I can debug issues","I need to ensure MCP clients receive properly formatted error responses"],"best_for":["MCP client developers building robust integrations","DevOps teams monitoring code-index-mcp in production","developers debugging tool failures and understanding root causes"],"limitations":["Error details are limited to exception messages; no structured error codes","Stack traces are only included in debug mode; production errors are summarized","No error recovery or retry logic; failed tools return errors immediately","Error logging is local only; no integration with external monitoring systems"],"requires":["Python logging configuration","MCP client that can handle MCPToolError responses"],"input_types":["exceptions raised by tool functions","debug mode flag"],"output_types":["MCPToolError response with message and optional stack trace","log entries for error tracking"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":44,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","tree-sitter library with language bindings for target languages","Local filesystem read access to codebase","MCP client compatible with stdio transport (Claude Desktop, Codex CLI, or custom)","Completed deep index (build_deep_index must be run first)","Valid regex patterns or fuzzy search strings","File type filters must match indexed file extensions","tree-sitter library for supported languages","Python regex engine for fallback strategies","Language identification (file extension or content-based)"],"failure_modes":["Tree-sitter parsing adds ~500ms-2s overhead per large file depending on language complexity","SQLite symbol storage requires local disk access; no cloud-based index sharing","Fallback regex strategies for unsupported languages may miss nested or complex symbol definitions","File watching uses polling on some systems, consuming CPU on very large repos (10k+ files)","Regex search performance degrades on very large files (>10MB); no streaming results","Fuzzy matching may return false positives for short search terms (< 3 characters)","Search operates on indexed snapshot; real-time file changes require index refresh","No semantic/AST-aware search (e.g., cannot distinguish function calls from definitions without post-processing)","Regex fallback is less accurate than AST parsing; may miss nested or complex definitions","Fallback strategies are heuristic-based and may produce false positives/negatives","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.42193210507224155,"quality":0.5,"ecosystem":0.39999999999999997,"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:22.065Z","last_scraped_at":"2026-05-03T14:23:34.856Z","last_commit":"2026-04-24T07:23:15Z"},"community":{"stars":930,"forks":113,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-johnhuang316-code-index-mcp","compare_url":"https://unfragile.ai/compare?artifact=mcp-johnhuang316-code-index-mcp"}},"signature":"J+Rt5hBjnT16lxzjr3mvnOEf+MHNkO1DhaujRlppNqLn/D/zjC6FH72FVvqe1lAznh6WSzCKh5ktgrip0sM5CQ==","signedAt":"2026-06-21T14:29:21.295Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-johnhuang316-code-index-mcp","artifact":"https://unfragile.ai/mcp-johnhuang316-code-index-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-johnhuang316-code-index-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"}}