elixir-lsp/elixir-ls

This system is the Elixir Language Server, a tool that provides IDE-like code intelligence for Elixir projects. It implements the Language Server Protocol to offer features such as code completion, navigation, diagnostics, and formatting, while also supporting debugging via the Debug Adapter Protocol. Additionally, it includes an embedded Model Context Protocol server to expose code analysis capabilities to large language models.

21 changes.

The project underwent a major architectural overhaul, migrating the language server to the gen\_lsp library and restructuring the codebase into a new umbrella layout. This period involved removing legacy components like the debugger and io\_handler, rewriting the server's startup logic, and introducing new features such as incremental Dialyzer analysis and call hierarchy providers.

22 changes.

This period focused on significantly expanding the language server's capabilities by implementing LSP features such as folding ranges, location protocols, and code lenses for test execution and type spec suggestions. It also introduced custom commands for LLM integration and code manipulation, while simultaneously building comprehensive test suites and fixtures to validate these new functionalities and ensure cross-platform compatibility.

28 changes.

This period focused on restructuring the project into a standalone Debug Adapter application with full DAP support and refactoring the language server's provider architecture into modular, testable components. Significant work included implementing context-aware completion plugins for Ecto and Phoenix, enhancing navigation accuracy for complex Elixir syntax, and expanding the test suite to cover these new features and infrastructure changes.

9 changes.

This period focused on establishing foundational protocol schemas for the Language Server Protocol (LSP) and Debug Adapter Protocol (DAP), alongside implementing core navigation features like declaration and call hierarchy providers. The work also introduced an embedded Model Context Protocol (MCP) server to expose language server capabilities to AI tools, supported by comprehensive test coverage for these new components.

Introduces a new \ElixirLS.LanguageServer.Protocol.Location\ module that implements the LSP Location interface. This module provides a \to\_gen\_lsp\ function to convert internal ElixirLS location data into the GenLSP structure, handling URI resolution relative to the project directory and converting Elixir positions to LSP-compliant line and column coordinates.

_apps/language\_server/lib/language\server/protocol · high confidence

The language server now supports call hierarchy, allowing users to navigate to callers (incoming calls) and callees (outgoing calls) of a function. This feature is implemented via a new \CallHierarchy\ provider and its associated \Locator\ module, which parses function names and arities to identify call relationships within the current file and across traced remote files. The implementation routes through the \SurroundContext.Toxic\ seam to determine the context at the cursor position, handling cases such as function definitions and local variable contexts to build accurate hierarchy items.

_apps/language\_server/lib/language\_server/providers/call\hierarchy · high confidence

The debug adapter's protocol layer now includes generated schema definitions for Debug Adapter Protocol (DAP) events and requests. This adds validation structures for all standard DAP events (such as breakpoint, capabilities, continued, exited, initialized, invalidated, loadedSource, memory, module, output, process, progress, stopped, terminated, and thread) and requests (including attach, breakpointLocations, cancel, completions, configurationDone, continue, dataBreakpointInfo, disassemble, disconnect, evaluate, exceptionInfo, goto, gotoTargets, initialize, launch, loadedSources, locations, modules, next, pause, readMemory, restart, restartFrame, reverseContinue, runInTerminal, scopes, setBreakpoints, setDataBreakpoints, setExceptionBreakpoints, setExpression, setFunctionBreakpoints, setInstructionBreakpoints, setVariable, source, stackTrace, startDebugging, stepBack, stepIn, stepInTargets, stepOut, terminate, terminateThreads, threads, variables, and writeMemory). Additionally, it introduces enumerations for breakpoint mode applicability, checksum algorithms, completion item types, data breakpoint access types, exception break modes, invalidated areas, and stepping granularity to support these interactions.

_apps/debug\adapter/lib/protocol · high confidence

A new declaration provider has been introduced in the language server, allowing users to navigate from an implementation of a callback or protocol function directly to its definition in the behaviour or protocol module. This feature, implemented in the new \Locator\ module, effectively serves as the reverse of 'go to implementations' by resolving the source of the contract being fulfilled.

_apps/language\_server/lib/language\server/providers/declaration · high confidence

The language server now includes an embedded Model Context Protocol (MCP) server, exposing tools such as LLM documentation aggregation, type information, definition lookup, implementation finding, module dependencies, and environment details. This new component introduces a dedicated TCP server and request handler that support the MCP protocol version 2024-11-05, handle initialization and tool calls, and emit telemetry events for request timing and errors.

_apps/language\_server/lib/language\server/mcp · high confidence

The language server now includes the foundational type definitions and enumerations for the Language Server Protocol (LSP) via the new \GenLSP\ module. This change adds generated schema files for base types, error codes, and various LSP enumerations (such as \CodeActionKind\, \CompletionItemKind\, \DiagnosticSeverity\, and \SymbolKind\), alongside the core notification structures (e.g., \textDocument/didChange\, \initialized\). These files provide the structural basis for the server's LSP communication layer.

_apps/language\_server/lib/language\server/lsp · high confidence

The language server now provides code lenses for running tests directly from the editor, supporting execution of individual test blocks, describe blocks, and entire test modules via the 'elixir.lens.test.run' command. Additionally, it offers inline @spec suggestions inferred by Dialyzer, translating success typings into Elixir syntax to help developers add type specifications to their functions.

_apps/language\_server/lib/language\_server/providers/code\lens · high confidence

The \debugger\ application has been renamed to \debug\_adapter\ and restructured into a standalone OTP application (\apps/debug\_adapter\) that fully implements the Debug Adapter Protocol (DAP). This change introduces a new server architecture (\ElixirLS.DebugAdapter.Server\) that manages breakpoints, thread/variable registries, and stack traces, replacing the previous \IEx.Broker\-based debugging mechanism with a GenServer-driven model. The new adapter supports advanced debugging features including conditional breakpoints, hit counts, log points, and remote node attachment. It also provides detailed test execution events via a custom ExUnit formatter and generates per-file code coverage reports (lines, functions, and branches) from \:cover\ analysis. Additionally, the implementation includes robust error handling with a dedicated error dictionary, safe UTF-16 cursor position parsing to prevent crashes on surrogate pairs, and improved shutdown behavior using \System.halt\.

_apps/debug\_adapter/lib/debug\adapter · high confidence

The language server now includes dedicated plugins to provide context-aware completions for Ecto and Phoenix code. The new Ecto plugin offers suggestions for schema fields, associations, and query bindings, while the Phoenix plugin suggests controllers and route actions within the router scope. These plugins rely on a new ModuleStore that caches loaded modules by behavior, replacing the previous \Code.ensure\_compiled\ approach with \Code.ensure\_loaded?\ to avoid locking issues during concurrent compilation.

_apps/language\_server/lib/language\server/providers/plugins · high confidence

This change introduces the \elixir\_ls\_utils\ application, providing foundational components for the language server. It includes a new completion engine that delegates cursor parsing to the host compiler (supporting Elixir 1.18+ block keywords and OTP 28 nominal types), a fuzzy module matcher, and a field type resolver. It also adds a launch module to manage Mix startup and environment configuration, a wire protocol handler for JSON-RPC packet streaming, and an IO output interceptor to forward logs to the IDE.

_apps/elixir\_ls\utils/lib · high confidence

The language server now provides two new quick-fix code actions. The 'Replace Remote Function' action suggests renaming undefined function calls to similar existing functions within the same module, correctly handling Erlang module aliases, \\_\MODULE\\_\ self-references, and diagnostic messages formatted as \MarkupContent\. The 'Replace with Underscore' action automatically prefixes unused variables with an underscore to suppress compiler warnings. Both actions rely on new helper modules for AST manipulation and text editing.

_apps/language\_server/lib/language\_server/providers/code\action · high confidence

Added a new provider module under \apps/language\_server/lib/language\_server/providers/code\_mod\ that enables the language server to generate precise text edits for code modifications. This includes AST parsing utilities to convert source code to and from abstract syntax trees, a Myers diff algorithm implementation to calculate differences between source versions, and helper functions to extract leading indentation and trailing comments while correctly handling \\#\ characters inside string literals.

_apps/language\_server/lib/language\_server/providers/code\mod · high confidence

The language server now exposes several new custom commands to enhance developer workflows, particularly for AI-assisted coding and code refactoring. A suite of LLM-optimized commands has been added to provide structured data for large language models: \llmDefinition\ retrieves source code for symbols, \llmDocsAggregator\ fetches comprehensive documentation for modules and functions, \llmEnvironment\ provides context-aware environment details (aliases, imports, variables) at a specific cursor position, \llmImplementationFinder\ locates behavior and protocol implementations, \llmModuleDependencies\ maps direct and transitive module dependencies, and \llmTypeInfo\ extracts type specs and dialyzer contracts. Additionally, new commands allow users to expand macros (\expandMacro\), insert dialyzer-suggested function specs (\applySpec\), retrieve ExUnit tests within a file (\getExUnitTestsInFile\), and convert between pipe operators and function calls (\manipulatePipes\).

_apps/language\_server/lib/language\_server/providers/execute\command · high confidence

The language server now includes dedicated providers for call hierarchy (incoming and outgoing function calls), code actions (specifically replacing remote functions and using underscores), and on-type formatting (smart insertion of 'end' after 'do' or '-\>'). These new modules in the providers directory expand the server's capabilities for navigating code structure, applying quick fixes, and maintaining formatting during typing.

_apps/language\_server/lib/language\server/providers · high confidence

The language server now implements the textDocument/foldingRange capability, allowing editors to collapse sections of code. This is achieved through new providers that identify folding regions based on indentation levels (e.g., function bodies, modules) and contiguous comment blocks. The implementation includes helper modules for parsing line metadata and grouping comments, enabling users to navigate large files more efficiently by hiding irrelevant code sections.

_apps/language\_server/lib/language\_server/providers/folding\range · high confidence

The \ElixirLS.Debugger\ application module, which previously defined the OTP application behavior and supervised child processes (including the output device and server), has been deleted from the codebase. This change removes the explicit application start/stop logic and supervisor tree definition for the debugger component.

apps/debugger/lib · high confidence

The core debugger implementation files in \apps/debugger/lib/debugger\ have been deleted. This includes the main server logic (\server.ex\), output handling (\output.ex\, \output\_device.ex\), protocol definitions (\protocol.basic.ex\), stacktrace retrieval (\stacktrace.ex\), and variable inspection (\variables.ex\).

apps/debugger/lib/debugger · high confidence

The io\_handler application, which previously managed reading and writing packets via the Language Server Protocol's wire protocol, has been removed from the codebase. This deletion eliminates the ElixirLS.IOHandler module and its PacketStream implementation, meaning the system no longer uses this specific component for stdin/stdout packet processing.

_apps/io\handler · high confidence

Path manipulation utilities previously embedded within the SourceFile module have been moved to a new dedicated module, SourceFile.Path. This change centralizes logic for converting between file system paths and URIs, handling Windows-specific path separators and drive letters, and validating whether a file resides within a specific directory, improving code organization and maintainability.

_apps/language\_server/lib/language\_server/source\file · high confidence

The language server has been re-architected to use the gen\_lsp library, introducing a new application supervision tree and dedicated modules for handling client capabilities, build processes, diagnostics, and incremental dialyzer analysis. This change replaces the previous implementation with a more robust foundation, including a new JSON-RPC logger backend for improved log visibility and a restructured ExUnit test tracer, fundamentally changing how the server initializes and manages its internal state.

_apps/language\_server/lib/language\server · high confidence

The elixir\_ls\_utils app now includes a .formatter.exs file that configures code formatting for source files in lib, config, and test directories. Additionally, the .gitignore file has been moved from the io\_handler app to this location.

_apps/elixir\_ls\utils · high confidence

The completion subsystem has been restructured from a monolithic implementation into a pipeline of specialized reducers located in the \completion/reducers\ directory. This change introduces distinct modules for handling specific completion types—such as \Callbacks\, \CompleteEngine\, \DocsSnippets\, \Overridable\, \Params\, \Protocol\, \Record\, \Returns\, and \TypeSpecs\—allowing the language server to generate suggestions for callbacks, record fields, protocol functions, and type specs through a more organized and maintainable architecture.

_apps/language\_server/lib/language\server/providers/completion/reducers · high confidence

The completion subsystem has been restructured to use a new \GenericReducer\ behavior, allowing completion suggestions to be customized based on the cursor's position within function calls. This change introduces a more robust error-handling mechanism that prevents the language server from crashing if internal error reporting (specifically \Exception.blame\) fails during suggestion generation. Additionally, the provider now supports plugin-based reducers via the \ModuleStore\, enabling external plugins to inject or decorate completion suggestions, while maintaining a core set of built-in reducers for variables, modules, functions, and structs.

_apps/language\_server/lib/language\server/providers/completion · high confidence

The debug adapter application now explicitly checks the running Elixir and OTP versions against supported minimums at startup. If the environment does not meet the required versions, the adapter displays an important warning and halts execution, preventing operation on unsupported configurations. This change also renames the application from 'debugger' to 'debug\_adapter' and ensures the OTP debugger modules are available in the code path without starting the app.

_apps/debug\adapter/lib · high confidence

The Ecto provider in the language server has been updated to support ElixirLS 1.20, introducing new modules for query, schema, and type completion. Users now receive intelligent code completion for Ecto query clauses (such as joins and filters), schema field options (like \:default\, \:source\, and association behaviors), and both built-in and custom Ecto data types. This enhancement improves the developer experience by providing context-aware suggestions and documentation directly within the editor when writing Ecto queries and schemas.

_apps/language\_server/lib/language\server/providers/plugins/ecto · high confidence

This release updates the language server to version 0.31.1, adding official support for Elixir 1.20 and OTP 29 while dropping support for Elixir 1.15 and OTP versions below 26. A key breaking change is the removal of legacy dialyzer support, making OTP's incremental Dialyzer the only engine and removing the \elixirLS.incrementalDialyzer\ configuration setting. The update also ports the completion subsystem to the 1.20 engine for more accurate block keyword completions, improves go-to-definition resolution for functions inside \\_\using\\_\ macros, and eradicates \Code.ensure\_compiled\ calls to reduce compilation-related hangs. Additionally, the project now includes a MkDocs-based documentation website, a Code of Conduct, and standardized configuration files (\.editorconfig\, \.formatter.exs\, \.dialyzer\_ignore.exs\) to improve development consistency.

(repo-wide) · high confidence

The configuration now enables ElixirSense's native Module.Types backend (set-theoretic type inference) by default, which powers improved inlay hints, hover information, and code completion. This feature requires Elixir 1.19+ and will automatically fall back to the custom engine on older versions. Users can disable this behavior by setting the environment variable ELIXIR\_LS\_TYPE\_INFERENCE to false or 0, which is useful for A/B testing or troubleshooting. The configuration also notes that log-flood issues on Elixir 1.18/1.19 are handled via test-level logger adjustments rather than global config changes.

config · high confidence

The hover provider in the language server has been updated to provide richer context for users. It now returns hover information for function specs and callbacks, which were previously omitted. Additionally, the provider correctly handles multialias syntax (e.g., \Module.{}Function\), allowing users to get documentation for functions accessed via this shorthand. The implementation has been moved from the external \elixir\_sense\ library into the \ElixirLS.LanguageServer.Providers.Hover.Docs\ module, integrating with the new \SurroundContext.Toxic\ seam for better context resolution.

_apps/language\_server/lib/language\server/providers/hover · high confidence

The implementation provider has been refactored to return precise location ranges for symbol implementations rather than just module or function names. This change, part of the migration from elixir\_sense, improves the accuracy of navigation features by providing exact line and column information for where behaviors, protocols, and delegates are implemented.

_apps/language\_server/lib/language\server/providers/implementation · high confidence

The definition provider in the language server has been updated to handle more complex navigation scenarios. It now supports resolving definitions for multialias syntax (e.g., \Module.{}Function\) by correctly expanding outer aliases and \\_\MODULE\\_\ contexts. Additionally, the provider can now return definitions when the cursor is positioned on a function spec or callback, and it includes fixes for crashes related to invalid multialias usage. These changes improve the accuracy of 'Go to Definition' for advanced Elixir patterns.

_apps/language\_server/lib/language\server/providers/definition · high confidence

The Phoenix language server provider now includes a new \Scope\ module that correctly resolves module aliases within Phoenix router \scope\ blocks. This change ensures that code completion and navigation accurately reflect the nested module structure defined by router scopes, handling various alias configurations and versioned variables.

_apps/language\_server/lib/language\server/providers/plugins/phoenix · high confidence

The language server now provides more accurate type spec suggestions for \defprotocol\ and \defimpl\ definitions. This change extracts the contract translation logic into a dedicated module (\ContractTranslator\) and adds specific handling to correctly infer types for protocol callbacks (e.g., ensuring the first argument is typed as \t\) and implementations, while avoiding incorrect modifications to \\_\deriving\\_\ macros and handling default arguments gracefully.

_apps/language\_server/lib/language\_server/providers/code\_lens/type\spec · high confidence

The language server app has undergone structural changes, including the removal of the legacy README and the introduction of a new .formatter.exs that configures code formatting with specific exclusions for test fixtures and protocol DSL definitions. Additionally, a .dialyzer\_ignore.exs file was added to suppress dialyzer warnings for the new restart command implementation, reflecting internal refactoring of the server's provider and state management components.

_apps/language\server · medium confidence

The language server's entry point has been completely rewritten from a standard OTP Application behavior to a new \main\ function that manages its own lifecycle. This change replaces the previous supervisor-based startup with explicit initialization steps, including intercepting standard output/error streams to send them via JSON-RPC, replacing the default console logger with a JSON-RPC backend, and dynamically applying runtime configuration (such as type inference toggles) that was previously only possible at build time. The new flow also includes detailed version reporting, environment checks for OTP documentation chunks and source availability, and specific error handling for incomplete Erlang installations, providing users with clearer feedback during startup failures.

_apps/language\server/lib · high confidence

The configuration file for the elixir\_ls\_utils application has been updated to use the modern \import Config\ syntax instead of the deprecated \use Mix.Config\. This change, which also includes renaming the application context from \io\_handler\ to \elixir\_ls\_utils\ in comments and examples, ensures compatibility with current Elixir standards and resolves associated compiler warnings.

_apps/elixir\_ls\utils/config · high confidence

The language server now uses a new incremental Dialyzer backend (DialyzerIncremental) instead of the legacy one, supporting OTP 26 through 28 with corresponding warning options. This change introduces a new feature that suggests function specifications based on Dialyzer's success typings via code lenses, and improves warning handling by defaulting to the dialyxir\_long format while properly managing PLT transfers and manifest race conditions.

_apps/language\_server/lib/language\server/dialyzer · high confidence

The language server's formatting task now avoids triggering accidental compilation and code path modifications. This change ensures that formatting operations remain lightweight and do not have side effects on the project's build state, addressing issues where the formatter might inadvertently compile code or alter the environment.

_apps/language\_server/lib/language\_server/mix\tasks · high confidence

The scripts directory has been restructured to improve reliability and shell compatibility. A new POSIX launcher (launch.sh) now detects the user's preferred shell (bash, zsh, or fish) and relaunches itself using the appropriate shell-specific script (exec.bash, exec.zsh, or launch.fish) to ensure correct environment handling and signal propagation. Shell-specific exec scripts (exec.bash, exec.zsh) are introduced to properly parse ELS\_ELIXIR\_OPTS into arrays before launching the Elixir runtime. The installer logic has been refactored into a dedicated installer.exs module and a quiet\_install.exs wrapper that suppresses stdout noise to prevent LSP protocol corruption. Additionally, new helper scripts (debug\_adapter.sh, elixir\_check.sh, language\_server.sh) standardize the launch modes, and a new tcp\_to\_stdio\_bridge.exs provides an MCP bridge for LLM integration.

scripts · high confidence

The references provider has been refactored to utilize the new SurroundContext API, replacing the previous method of determining the cursor's semantic context. This change improves the accuracy of reference lookups by better handling variable scopes and module environments, ensuring that references are resolved correctly even in complex nested structures or when dealing with versioned variables.

_apps/language\_server/lib/language\server/providers/references · high confidence

The custom configuration for the Elixir Language Server's logging backend has been removed. Users will no longer have the \ElixirLS.LanguageServer.LoggerBackend\ configured via \config :logger\ in this file, meaning the specific LSP logging behavior previously enabled here is no longer applied by default.

_apps/language\server/config · high confidence

The signature help provider has been refactored to integrate with updated ElixirSense APIs, specifically adopting the \actual\_mod\_fun\ interface for more accurate function resolution. This change enables the display of additional metadata in signature hints and introduces specific handling for protocol callbacks, ensuring that documentation and specs from behavior implementations are correctly merged and presented to the user.

_apps/language\_server/lib/language\_server/providers/signature\help · high confidence

Added Ecto test support stubs for the language server plugin; Added benchmark for document line retrieval performance; Added comprehensive test suite for the debug adapter; Added comprehensive test suites for language server providers; Added dialyzer test fixtures for type analysis; Added fixture tests for custom test path and pattern support; Added test coverage for LLM-focused execute commands and pipe manipulation; Added test coverage for describe and test block parsing logic; Added test fixtures for Phoenix plugin and Elixir string analysis; Added test fixtures for language server capabilities; Added test fixtures for mix clean custom command; Added test fixtures for protocol definitions and implementations; Added test fixtures for the debug adapter; Added test fixtures for umbrella Dialyzer warnings; Added test fixtures for umbrella app code lens prefix handling; Added test fixtures for wire protocol message validation; Added test suite for ElixirLS Utils; Added test support macros for Debug Adapter Protocol requests; Added test support modules and refactored packet capture for reliability; Added tests for CodeLens test provider; Added tests for CodeMod diff logic; Added tests for Ecto and Phoenix plugin completions; Added tests for Ecto query binding extraction with join associations; Added tests for MCP request handler and tool integration; Added tests for Phoenix scope parsing logic; Added tests for SourceFile path conversion functions; Added tests for code action providers; Added tests for completion suggestion filtering; Added tests for hover documentation retrieval; Added tests for signature help provider; Added tests for the Call Hierarchy Locator; Added tests for the ContractTranslator module; Added tests for the references locator provider; Added workspace symbols fixture module; Expanded test coverage for language server core components; Expanded test fixtures for language server analysis; Removed debugger integration tests and fixtures; Updated build error test fixture module name.

The project has been restructured into a new umbrella layout, introducing dedicated apps for the language server, utilities, and a renamed debug adapter (replacing the old debugger and io\_handler apps). This change raises the minimum supported Elixir version to 1.16.0 and modernizes the dependency graph by vendoring core libraries—including Jason, Dialyxir, Schematic, and PathGlob—while switching the primary code-analysis dependency to the elixir-lsp fork of elixir\_sense.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 62 → 67 (+4.4)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 83 → 87 (+4.5)
• Architecture 99 → 99 (+0.4)
• Maturity 52 → 52 (+0.2)
• Readiness 83 → 83 (+0.0)
• Security 59 → 74 (+15.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 2) (apps/debug_adapter/lib/debug_adapter/exunit_formatter.ex)
• Duplicated block (10 lines × 2) (apps/debug_adapter/lib/protocol/dap/requests/set_expression.ex)
• Duplicated block (10 lines × 2) (apps/language_server/lib/language_server/build.ex)
• Duplicated block (10 lines × 2) (apps/language_server/lib/language_server/location.ex)
• Duplicated block (10 lines × 3) (apps/language_server/lib/language_server/providers/definition/locator.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/lsp/protocol/structures/notebook_document_sync_options.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/lsp/protocol/structures/related_full_document_diagnostic_report.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/call_hierarchy/locator.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/call_hierarchy/locator.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/completion.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/declaration/locator.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/implementation/locator.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/inlay_hints.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/references/locator.ex)
• Duplicated block (13 lines × 2) (apps/debug_adapter/lib/debug_adapter/server.ex)
• Duplicated block (13 lines × 2) (apps/language_server/lib/language_server/providers/declaration/locator.ex)
• Duplicated block (14 lines × 2) (apps/language_server/lib/language_server/providers/execute_command/llm_module_dependencies.ex)
• Duplicated block (14 lines × 2) (apps/language_server/lib/language_server/providers/execute_command/manipulate_pipes.ex)
• …and 79 more

• Change coupling: test.ex ↔ server.ex (apps/language_server/lib/language_server/providers/code_lens/test.ex)
• Dependency hygiene PARTLY measured — Mix pinning read, dependency currency not (Hex registry unreachable)
• Documentation: no installation or build instructions (README.md)
• Documentation: written for insiders (docs/getting-started/emacs.md)
• Duplicated block (10 lines × 2) (apps/language_server/lib/language_server/build.ex)
• Duplicated block (10 lines × 2) (apps/language_server/lib/language_server/providers/call_hierarchy/locator.ex)
• Duplicated block (10 lines × 2) (apps/language_server/lib/language_server/providers/execute_command/llm_docs_aggregator.ex)
• Duplicated block (10 lines × 2) (apps/language_server/lib/language_server/providers/hover/docs.ex)
• Duplicated block (10–14 lines × 2) (apps/language_server/lib/language_server/providers/call_hierarchy/locator.ex)
• Duplicated block (11 lines × 2) (apps/language_server/lib/language_server/providers/references/locator.ex)
• Duplicated block (11–17 lines × 2) (apps/language_server/lib/language_server/providers/call_hierarchy/locator.ex)
• Duplicated block (12 lines × 2) (apps/debug_adapter/lib/debug_adapter/server.ex)
• Duplicated block (12 lines × 3) (apps/language_server/lib/language_server/server.ex)
• Duplicated block (13 lines × 2) (apps/language_server/lib/language_server/providers/declaration/locator.ex)
• Duplicated block (13 lines × 3) (apps/language_server/lib/language_server/providers/completion.ex)
• Duplicated block (14 lines × 2) (apps/language_server/lib/language_server/providers/call_hierarchy.ex)
• Duplicated block (14 lines × 2) (apps/language_server/lib/language_server/providers/execute_command/manipulate_pipes.ex)
• Duplicated block (16 lines × 2) (apps/language_server/lib/language_server/providers/completion.ex)
• Duplicated block (17 lines × 3) (apps/language_server/lib/language_server/providers/definition/locator.ex)
• Duplicated block (17 lines × 4) (apps/language_server/lib/language_server/providers/execute_command/llm_module_dependencies.ex)
• …and 146 more

• 6 commits — 4 feature/other, 2 fixes

• (repo) — 2 commits
• apps/language_server — 2 commits
• apps/debug_adapter — 1 commit
• apps/elixir_ls_utils — 1 commit

• fix: Merge pull request #1274 from elixir-lsp/fix-evaluator-registry-wiped-on-continue
• fix: fix(dap): keep evaluator registry when continuing all processes
• change: Don't crash on unrecognized cursor contexts
• change: Drop redundant is_struct/1 check in parser rescue
• change: Merge pull request #1273 from elixir-lsp/completion-engine-unknown-cursor-context
• change: add new liveview error to known

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

elixir-lsp/elixir-ls was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.