{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-elisp-dev-mcp","slug":"elisp-dev-mcp","name":"elisp-dev-mcp","type":"mcp","url":"https://github.com/laurynas-biveinis/elisp-dev-mcp","page_url":"https://unfragile.ai/elisp-dev-mcp","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-elisp-dev-mcp__cap_0","uri":"capability://code.generation.editing.elisp.code.completion.with.context.awareness","name":"elisp-code-completion-with-context-awareness","description":"Provides intelligent code completion for Emacs Lisp by analyzing the current buffer context, function signatures, and variable bindings. Works by parsing the elisp AST to understand scope and available symbols, then filtering completion candidates based on semantic relevance rather than simple prefix matching. Integrates with Emacs' native completion UI to deliver suggestions inline.","intents":["Complete function names and variable references while writing elisp code","Discover available functions and their signatures in the current scope","Reduce typos and syntax errors when writing elisp interactively"],"best_for":["Emacs Lisp developers building extensions and configurations","Emacs package maintainers working on complex elisp codebases","Users customizing their Emacs environment with elisp"],"limitations":["Completion accuracy depends on proper elisp syntax in the buffer — malformed code may reduce suggestion quality","No cross-file symbol resolution — only completes symbols visible in current buffer and loaded packages","Performance degrades on very large buffers (>10k lines) due to full AST re-parsing on each keystroke"],"requires":["Emacs 27.0 or later","elisp-dev-mcp server running as an MCP process","MCP client integration in Emacs (e.g., via emacs-mcp or similar bridge)"],"input_types":["elisp source code (buffer content)","cursor position (line and column)","partial symbol prefix"],"output_types":["completion candidates (list of strings)","completion metadata (function signatures, docstrings)"],"categories":["code-generation-editing","emacs-development"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_1","uri":"capability://code.generation.editing.elisp.function.signature.extraction.and.documentation","name":"elisp-function-signature-extraction-and-documentation","description":"Extracts function signatures, argument lists, and docstrings from elisp code by introspecting function objects at runtime or parsing function definitions statically. Returns structured metadata including parameter names, optional/rest arguments, and documentation, enabling IDE-like hover hints and signature help. Integrates with MCP to deliver this metadata to client tools.","intents":["View function signatures and parameter documentation while editing","Generate accurate function stubs with correct argument lists","Build documentation or API references from live function definitions"],"best_for":["Emacs Lisp developers needing inline documentation and type hints","Tool builders creating IDE features for Emacs (linters, formatters, documentation generators)","Package maintainers documenting elisp APIs programmatically"],"limitations":["Docstring extraction only works for functions that have been loaded into Emacs — unloaded code requires static parsing which may miss runtime-generated functions","Anonymous functions and lambdas have no docstrings by design — only named functions are documented","Macro expansion and generated code may not have source locations, making signature extraction unreliable"],"requires":["Emacs 27.0 or later","Target function must be defined or loaded in the Emacs session","MCP server with introspection capabilities"],"input_types":["function name (symbol)","elisp source code (for static parsing)"],"output_types":["structured function metadata (JSON with signature, docstring, argument types)","formatted documentation string"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_10","uri":"capability://tool.use.integration.elisp.buffer.and.file.operations.via.mcp","name":"elisp-buffer-and-file-operations-via-mcp","description":"Provides MCP-based access to Emacs buffer and file operations, allowing external tools to read, write, and manipulate buffers and files within the Emacs session. Supports operations like opening files, creating buffers, reading buffer content, and saving changes. Integrates with Emacs' buffer management to ensure consistency.","intents":["Read and write Emacs buffers from external tools","Perform file operations (create, delete, rename) through Emacs","Synchronize external editor state with Emacs buffers"],"best_for":["Tool builders creating IDE features that need to interact with Emacs buffers","External tools that need to manipulate Emacs files and buffers","Integration scenarios where external systems need to coordinate with Emacs"],"limitations":["Buffer operations are synchronous — large file operations may block the Emacs process","File encoding and line ending handling depends on Emacs configuration — may differ from external tools","Concurrent modifications from multiple sources may cause conflicts — no built-in conflict resolution","Buffer-local variables and modes are not preserved when buffers are accessed externally"],"requires":["Emacs 27.0 or later","MCP server running in Emacs with buffer access capabilities","File system access for file operations"],"input_types":["buffer name or file path","content (for write operations)","operation type (read, write, create, delete)"],"output_types":["buffer content (text)","file metadata (size, modification time, encoding)","operation status (success/failure)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_2","uri":"capability://code.generation.editing.elisp.code.navigation.and.definition.lookup","name":"elisp-code-navigation-and-definition-lookup","description":"Enables jumping to function and variable definitions by resolving symbols to their source locations in the Emacs codebase or loaded packages. Uses Emacs' native find-function and find-variable mechanisms combined with source file indexing to map symbols to file paths and line numbers. Exposes this via MCP to support IDE-style 'go to definition' workflows.","intents":["Jump to the definition of a function or variable under the cursor","Find all usages of a symbol across the codebase","Navigate between related functions and their dependencies"],"best_for":["Emacs Lisp developers working on large packages or Emacs core modifications","Tool builders implementing IDE navigation features for elisp","Users exploring unfamiliar elisp codebases"],"limitations":["Only resolves symbols that are loaded in Emacs or have source files on disk — dynamically generated symbols have no source location","Cross-file navigation requires source files to be accessible on the filesystem — works poorly with remote or archived code","Aliased functions may resolve to the alias target rather than the original definition, requiring manual disambiguation"],"requires":["Emacs 27.0 or later","Source files for target functions must be on disk or loaded in Emacs","MCP server with file system access"],"input_types":["symbol name (function or variable)","current buffer context (for resolving local bindings)"],"output_types":["file path and line number","source code snippet (surrounding context)"],"categories":["code-generation-editing","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_3","uri":"capability://code.generation.editing.elisp.syntax.checking.and.error.detection","name":"elisp-syntax-checking-and-error-detection","description":"Performs static analysis and runtime validation of elisp code to detect syntax errors, undefined variables, and common mistakes. Combines byte-compilation (via Emacs' native byte-compiler) with custom linting rules to catch issues like unused variables, incorrect function calls, and type mismatches. Reports diagnostics via MCP in LSP-compatible format for integration with editor linters.","intents":["Catch syntax errors and undefined references before running code","Identify unused variables and dead code","Validate function calls against their actual signatures"],"best_for":["Emacs Lisp developers writing production packages or complex configurations","CI/CD pipelines linting elisp code before deployment","Tool builders implementing linting features for Emacs"],"limitations":["Byte-compilation may fail on code with intentional dynamic behavior (e.g., eval, symbol-function manipulation) — false positives are common","Linting rules are static and cannot detect runtime errors that depend on actual data or execution flow","Macro-generated code is difficult to analyze — macros that generate functions dynamically may produce false warnings"],"requires":["Emacs 27.0 or later","Byte-compiler available in Emacs installation","MCP server with code analysis capabilities"],"input_types":["elisp source code (buffer or file)","compilation context (loaded packages, variable bindings)"],"output_types":["diagnostic list (errors, warnings, info)","structured diagnostic data (file, line, column, message, severity)"],"categories":["code-generation-editing","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_4","uri":"capability://code.generation.editing.elisp.refactoring.rename.and.extract","name":"elisp-refactoring-rename-and-extract","description":"Supports automated refactoring operations like renaming functions and variables across multiple files, and extracting code into new functions. Works by analyzing the symbol table to find all references to a symbol, then applying transformations while respecting scope and shadowing rules. Uses buffer manipulation and file I/O to apply changes atomically.","intents":["Rename a function or variable throughout a codebase safely","Extract repeated code into a new helper function","Refactor code structure without manual search-and-replace"],"best_for":["Emacs Lisp developers refactoring large packages","Teams maintaining shared elisp codebases","Developers modernizing legacy Emacs configurations"],"limitations":["Refactoring accuracy depends on proper symbol resolution — dynamically generated symbols or eval'd code may be missed","String-based references (e.g., symbol-name in strings) are not detected — only code-level references are transformed","Macro-generated code is difficult to refactor — macros that create functions dynamically may require manual intervention","No built-in undo for multi-file refactorings — requires external version control to revert changes"],"requires":["Emacs 27.0 or later","Write access to all files being refactored","MCP server with file manipulation capabilities","Version control system (git, etc.) for safety"],"input_types":["symbol name to rename","new name or extracted function definition","scope (single file or entire project)"],"output_types":["list of modified files","diff of changes","refactoring status (success/failure per file)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_5","uri":"capability://code.generation.editing.elisp.interactive.evaluation.and.repl.integration","name":"elisp-interactive-evaluation-and-repl-integration","description":"Enables executing elisp code snippets directly within the Emacs session via MCP, with results returned to the client. Supports evaluating expressions, loading files, and inspecting the state of the running Emacs instance. Integrates with Emacs' eval function and provides access to the current environment (variables, functions, buffers).","intents":["Execute elisp code and see results immediately without switching to Emacs","Test code changes in a live Emacs session","Inspect Emacs state (variables, buffers, functions) programmatically"],"best_for":["Emacs Lisp developers testing code interactively","Tool builders creating IDE features that need live evaluation","Users prototyping Emacs extensions and configurations"],"limitations":["Evaluation happens in the Emacs process — side effects (buffer modifications, file writes) affect the live session and cannot be easily undone","Long-running or infinite-loop code will block the Emacs process, making the editor unresponsive","Evaluation context is the global Emacs environment — local variables and buffer-local bindings may not be available","Results are serialized to JSON for MCP transport — complex objects (buffers, processes) may not serialize cleanly"],"requires":["Emacs 27.0 or later","MCP server running in the Emacs process","Network connectivity between client and Emacs (for remote evaluation)"],"input_types":["elisp code string","evaluation context (optional: buffer, point, local variables)"],"output_types":["evaluation result (any elisp value, serialized to JSON)","error message (if evaluation fails)","side effects (buffer modifications, output)"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_6","uri":"capability://data.processing.analysis.elisp.package.and.dependency.management","name":"elisp-package-and-dependency-management","description":"Analyzes elisp code to extract package dependencies, version requirements, and load-path configuration. Parses require and use-package declarations to build a dependency graph, then validates that all dependencies are available and compatible. Integrates with Emacs' package management system (package.el) to check installed versions.","intents":["Identify all dependencies of an elisp package","Validate that required packages are installed and compatible","Generate package metadata (Package-Requires header) from code analysis"],"best_for":["Emacs package developers publishing to MELPA or other repositories","Teams managing Emacs configurations with many dependencies","Tool builders creating package management features for Emacs"],"limitations":["Dependency detection is static — dynamic requires (e.g., require with computed names) are not detected","Version compatibility checking is basic — only checks if a package is installed, not if it meets version constraints","Transitive dependencies are not automatically resolved — only direct dependencies are analyzed","Package metadata from package.el may be incomplete or outdated if packages are not installed"],"requires":["Emacs 27.0 or later","package.el available in Emacs installation","MCP server with package analysis capabilities"],"input_types":["elisp source code (file or buffer)","package metadata (optional: Package-Requires header)"],"output_types":["dependency list (package names and versions)","dependency graph (JSON or structured format)","validation report (missing packages, version conflicts)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_7","uri":"capability://automation.workflow.elisp.test.discovery.and.execution","name":"elisp-test-discovery-and-execution","description":"Discovers and executes elisp unit tests by scanning for test functions (typically named test-* or *-test) and test frameworks (ert, buttercup, etc.). Parses test definitions to extract test names and metadata, then runs tests via the framework's API and collects results. Returns test results in a structured format compatible with IDE test runners.","intents":["Discover all tests in an elisp project","Run tests and view results without leaving the editor","Integrate elisp tests into CI/CD pipelines"],"best_for":["Emacs Lisp developers writing and maintaining test suites","CI/CD systems running elisp tests as part of build pipelines","Tool builders creating test runner features for Emacs"],"limitations":["Test discovery only finds tests that follow naming conventions — tests with non-standard names are missed","Test execution happens in the Emacs process — tests that modify global state may interfere with each other","Test frameworks must be installed and loaded — tests for missing frameworks cannot be discovered","Test results are serialized to JSON — complex assertion failures may lose detail in serialization"],"requires":["Emacs 27.0 or later","Test framework (ert, buttercup, etc.) installed and loaded","MCP server with test discovery and execution capabilities"],"input_types":["project path or file path","test filter (optional: pattern to select specific tests)"],"output_types":["test list (test names and metadata)","test results (pass/fail, execution time, error messages)","coverage report (optional, if framework supports it)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_8","uri":"capability://text.generation.language.elisp.documentation.generation.from.code","name":"elisp-documentation-generation-from-code","description":"Generates documentation (markdown, HTML, or plain text) from elisp source code by extracting docstrings, function signatures, and variable definitions. Parses code structure to build a documentation outline, then formats it for human consumption. Supports custom templates and styling for different output formats.","intents":["Generate API documentation from elisp source code","Create README or reference documentation automatically","Export function signatures and docstrings in multiple formats"],"best_for":["Emacs package developers documenting their packages","Teams maintaining shared elisp libraries","Tool builders creating documentation generation features"],"limitations":["Documentation quality depends on docstring quality — poorly documented code produces poor documentation","Complex code structures (macros, generated functions) may not be documented accurately","Custom templates require manual creation — no built-in templates for all documentation styles","Generated documentation may require manual editing for clarity and completeness"],"requires":["Emacs 27.0 or later","MCP server with documentation generation capabilities"],"input_types":["elisp source code (file or directory)","documentation template (optional)","output format (markdown, html, text)"],"output_types":["formatted documentation (markdown, HTML, or plain text)","structured documentation data (JSON with sections, functions, variables)"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-elisp-dev-mcp__cap_9","uri":"capability://code.generation.editing.elisp.macro.expansion.and.analysis","name":"elisp-macro-expansion-and-analysis","description":"Expands elisp macros to show their generated code, enabling developers to understand what code a macro produces. Uses Emacs' macroexpand and macroexpand-all functions to recursively expand macros, then formats the result for readability. Supports stepping through macro expansion to see intermediate steps.","intents":["Understand what code a macro generates","Debug macro-related errors by inspecting expanded code","Learn how macros work by seeing their expansion"],"best_for":["Emacs Lisp developers working with complex macros","Users learning elisp macro system","Tool builders creating macro debugging features"],"limitations":["Macro expansion requires the macro to be defined and loaded — undefined macros cannot be expanded","Expansion may fail if the macro has side effects or depends on runtime state","Expanded code may be large and difficult to read — no built-in pretty-printing or simplification","Recursive macro expansion can be slow for deeply nested macros"],"requires":["Emacs 27.0 or later","Target macro must be defined and loaded in Emacs","MCP server with macro expansion capabilities"],"input_types":["macro call (elisp s-expression)","expansion depth (optional: how many levels to expand)"],"output_types":["expanded code (elisp s-expression)","formatted expansion (pretty-printed)","expansion steps (intermediate expansions)"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":27,"verified":false,"data_access_risk":"high","permissions":["Emacs 27.0 or later","elisp-dev-mcp server running as an MCP process","MCP client integration in Emacs (e.g., via emacs-mcp or similar bridge)","Target function must be defined or loaded in the Emacs session","MCP server with introspection capabilities","MCP server running in Emacs with buffer access capabilities","File system access for file operations","Source files for target functions must be on disk or loaded in Emacs","MCP server with file system access","Byte-compiler available in Emacs installation"],"failure_modes":["Completion accuracy depends on proper elisp syntax in the buffer — malformed code may reduce suggestion quality","No cross-file symbol resolution — only completes symbols visible in current buffer and loaded packages","Performance degrades on very large buffers (>10k lines) due to full AST re-parsing on each keystroke","Docstring extraction only works for functions that have been loaded into Emacs — unloaded code requires static parsing which may miss runtime-generated functions","Anonymous functions and lambdas have no docstrings by design — only named functions are documented","Macro expansion and generated code may not have source locations, making signature extraction unreliable","Buffer operations are synchronous — large file operations may block the Emacs process","File encoding and line ending handling depends on Emacs configuration — may differ from external tools","Concurrent modifications from multiple sources may cause conflicts — no built-in conflict resolution","Buffer-local variables and modes are not preserved when buffers are accessed externally","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.32,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"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-06-17T09:51:03.039Z","last_scraped_at":"2026-05-03T14:00:15.503Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=elisp-dev-mcp","compare_url":"https://unfragile.ai/compare?artifact=elisp-dev-mcp"}},"signature":"byG/wdL68+s6SF/udZf1Ly3RLrBS7EM8bOuS+9wvaTg1/oD565qfZBPpM1e1S2+KHd35On+KlYW+2Ri2b6AtCQ==","signedAt":"2026-06-21T07:11:58.644Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/elisp-dev-mcp","artifact":"https://unfragile.ai/elisp-dev-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=elisp-dev-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"}}