expert-lsp/expert

Expert is an Elixir Language Server Protocol (LSP) server that provides code intelligence, including completions, hover documentation, and go-to-definition, for Elixir projects. It features a dedicated engine for AST analysis, incremental indexing, and fuzzy search, alongside a robust build system that isolates compilation tasks to prevent crashes. The system supports modern Elixir features, Hex package intelligence, and various code actions such as refactoring and alias management.

103 changes.

The project was rebranded from Lexical to Expert, involving a complete architectural rewrite of the language server to use the GenLSP library and a new modular provider system. This period saw the introduction of a dedicated Engine for AST analysis, indexing, and isolated compilation, alongside a Forge library to support Elixir 1.20 and OTP 29 compatibility. The work focused on replacing legacy protocol handling and remote control mechanisms with a robust, plugin-based diagnostic and code intelligence system.

16 changes.

This period focused on expanding code intelligence capabilities by introducing fuzzy search, Hex.pm package metadata, and formatter caching to improve performance and usability. Significant effort was also dedicated to stabilizing the codebase through comprehensive test coverage for the engine, refactoring tools, and logging subsystems.

A new \Elixir.Features\ module has been added to detect specific Elixir and Erlang capabilities based on the running version. This enables the application to safely use features like \Code.with\_diagnostics/1\, compile-time directory retention, post-verify compilation, diagnostic spans, set-theoretic types, lazy loading, and formatter plugins only when supported by the current Elixir version (ranging from 1.14.0 to 1.19.0). It also includes a check to avoid a segfault in Erlang/OTP 27.0.0–27.0.1 when using the \:compressed\ ETS table option, ensuring compatibility with Erlang versions outside that vulnerable range.

apps/forge/lib/elixir · high confidence

Added benchmark scripts to the engine to measure performance of AST analysis, source indexing, and SQLite-based search operations. The suite includes benchmarks for the \Ast.analyze\ function, the \Indexer.Source\ indexing pipeline, and various SQLite search queries (such as \find\_by\_subject\ and \find\_by\_references\) using a large Elixir standard library file as test data.

apps/engine/benchmarks · high confidence

Added \build\_engine.exs\ to handle offline, isolated Elixir engine builds using a custom SCM module that bypasses Hex/Rebar downloads, ensuring builds work without network access. Added \port\_wrapper.sh\ to prevent zombie processes when spawning external build tasks. Added \remote\_shell.sh\ and \remote\_shell.bat\ to enable remote shell connections to the expert node with configurable cookies and EPMD settings.

apps/expert/priv · high confidence

The \apps/forge/src\ directory now includes a set of new Erlang source files (\future\_elixir.erl\, \future\_elixir.hrl\, \future\_elixir\_errors.erl\, \future\_elixir\_interpolation.erl\, \future\_elixir\_parser.yrl\, \future\_elixir\_tokenizer.erl\, and \future\_elixir\_tokenizer.hrl\) that are copied from the Elixir language repository. These files provide the foundational tokenizer, parser, error handling, and interpolation logic required to compile and run Elixir code within the Forge environment, effectively adding the Elixir compiler backend as a dependency of this application.

apps/forge/src · high confidence

A new pre-commit hook has been introduced to automatically check code formatting and run Credo linting before commits are finalized. This ensures that all code changes adhere to the project's style guidelines and quality standards before being merged.

hooks · high confidence

The engine now includes its foundational runtime components, starting with \Engine.Bootstrap\ which handles project initialization, Mix environment setup, and build path configuration. Core services like \Engine.Build\ (managing compilation and dependency fetching), \Engine.ModuleStore\ (caching module metadata for completions), and \Engine.Analyzer\ (resolving aliases and imports) are defined and wired into the \Engine.Supervisor\. Additionally, \Engine.CodeAction\ and \Engine.Completion\ provide the logic for user-facing code actions and intelligent suggestions, while \Engine.Deps\ and \Engine.ModuleMappings\ manage dependency metadata and file-to-module associations.

apps/engine/lib/engine · high confidence

The Expert language server for Elixir is now available, providing core LSP capabilities including code intelligence, completion, hover, and code actions. The server supports both stdio and TCP transport modes, manages isolated engine builds for project toolchains, and integrates with the LSP client via window/logMessage notifications. It includes configuration options for log levels, auto-fetching dependencies, and compile-on-type, along with CLI subcommands for managing engine builds.

apps/expert/lib/expert · high confidence

The Expert code intelligence engine now provides context-aware completions for Hex package dependencies within mix.exs files. This feature detects when a user is editing a dependency tuple and offers suggestions for package names, versions, and configuration options (such as :git, :github, :ref, :branch, :tag, :path, :in\_umbrella, and others) by querying the Hex.pm registry. It also includes logic to exclude Expert's own internal dependencies from general code completions to reduce noise, and ensures that completions for definitions in test files are correctly surfaced.

_apps/expert/lib/expert/code\intelligence · high confidence

The Expert app now provides code intelligence for Elixir Hex.pm packages. It detects dependency slots in \mix.exs\ files, fetches package metadata from the Hex.pm registry (including descriptions, versions, and download counts), and displays this information in hover tooltips. A persistent DETS-backed cache ensures these lookups remain fast and resilient to network issues.

_apps/expert/lib/expert/code\intelligence/hex · high confidence

This change introduces the configuration files for the new Expert application. It sets up logging to include instance ID and project metadata, configures the argument parser to use Burrito when running in release mode, and adjusts the test environment to prevent ExUnit from exiting prematurely and to set an edit window for the engine.

apps/expert/config · high confidence

A new Nix package definition (nix/expert.nix) is introduced to build the Expert application. This build configuration addresses a specific runtime issue with the elixir\_sense dependency by pre-generating its yecc grammar parser during the build phase, ensuring compatibility with Nix's read-only store. The resulting binary is named 'expert' and is configured to start as a non-halting node with the xp\_expert application pre-started, enabling immediate interactive use.

nix · high confidence

This change introduces the \Engine.CodeMod\ module, which provides the core logic for automatically managing \alias\ and \require\ directives and applying code formatting. It includes specific components for calculating insertion positions, sorting directives, generating document edits, and computing line-based diffs to apply formatting changes efficiently.

_apps/engine/lib/engine/code\mod · high confidence

The search subsystem now supports fuzzy matching for code definitions, allowing users to find symbols even with typos or partial input. This change introduces an in-memory fuzzy matcher (\Expert.Search.Fuzzy\) and a scoring engine (\Expert.Search.Fuzzy.Scorer\) that apply heuristics like consecutive character bonuses and camel-case awareness to rank results. The \Expert.Search.Store\ has been updated to integrate this fuzzy logic, exposing a new \fuzzy/3\ query method alongside existing exact, prefix, and structural queries, while the SQLite backend provides the underlying data for building the fuzzy index.

apps/expert/lib/expert/search · high confidence

The code intelligence subsystem has been replaced with a new implementation located in \apps/engine/lib/engine/code\_intelligence\. This new engine provides core language features including go-to-definition, hover documentation, find-references, and workspace/document symbols. It integrates ElixirSense for resolution and documentation, adds specific support for HEEx templates (normalizing shorthand component syntax in \\~H\ sigils and Phoenix components), and implements an arity fallback mechanism to resolve function definitions when multiple arities exist. The module also includes utilities for autodetecting the Elixir standard library source path and resolving entities within the AST.

_apps/engine/lib/engine/code\intelligence · high confidence

This change adds three new modules to the search subsystem: \Engine.Search.Fuzzy\ for performing fuzzy matching on indexed entries, \Engine.Search.Indexer\ for managing the creation, updating, and committing of search indexes (including handling beam file siblings and manifest planning), and \Engine.Search.Subject\ for converting project elements into search subject strings. These files establish the core data structures and logic for the new indexing backend.

apps/engine/lib/engine/search · high confidence

Adds a new caching layer (\Engine.CodeMod.Format.Cache\) and resolver (\Engine.CodeMod.Format.Resolver\) to the code formatting system. The cache uses ETS tables to store formatter configurations keyed by file path and options, reducing redundant resolution calls. The resolver handles finding the appropriate \.formatter.exs\ configuration for a given file, including walking up the directory tree to find the nearest config file, and integrates with Mix's formatter tasks when running within a project node. This change aims to improve performance by avoiding repeated file system and configuration lookups during formatting operations.

_apps/engine/lib/engine/code\mod/format · high confidence

The Forge library introduces a dedicated AST analysis and context detection layer to improve code understanding and editor features. This includes a new \Forge.Ast\ module for parsing and analyzing Elixir documents (supporting both the Spitfire and standard Elixir parsers), which tracks scopes, aliases, imports, requires, and uses. A comprehensive context detection system (\Forge.Ast.Detection\) has been added to identify specific code contexts at the cursor position, such as aliases, bitstrings, comments, function captures, pipes, structs, and module attributes. This enables more accurate completions, hover information, and other IDE features by understanding the syntactic and semantic context of the code being edited.

apps/forge/lib/forge · high confidence

The \forge\ library now includes two new Mix tasks: \Mix.Tasks.Hooks\ copies local hook scripts into the \.git/hooks\ directory to enable pre-commit or similar hooks, and \Mix.Tasks.Namespace\ applies incremental namespacing transformations to an assembled release. The namespace task analyzes engine dependencies, identifies root modules, and applies transformers to beam files, scripts, and configurations to isolate the application's namespace, supporting both full and incremental builds.

apps/forge/lib/mix · high confidence

The engine now provides several new code actions to help developers fix common issues and refactor code. You can now automatically add missing aliases, organize existing aliases, and remove unused aliases. If you call a function that does not exist, the engine offers a quick fix to create the undefined function with the correct signature. Additionally, a new handler integrates Refactorex, allowing you to apply refactorings directly from the editor, with support for deferred execution to improve performance for complex changes.

_apps/engine/lib/engine/code\action · high confidence

Added two new configuration modules to the Expert application: \Expert.Configuration.Support\ and \Expert.Configuration.WorkspaceSymbols\. The support module maps GenLSP client capabilities (such as code action dynamic registration, hierarchical symbols, snippets, and signature help) to the application's internal struct, allowing the server to adapt its behavior based on client support. The workspace symbols module introduces a configurable \min\_query\_length\ setting (defaulting to 2) for workspace symbol queries, enabling users to control the minimum input required to trigger symbol searches.

apps/expert/lib/expert/configuration · high confidence

Added Engine.Search.Fuzzy.Scorer, a new module that implements a heuristic-based scoring system for fuzzy string matching. This component pre-processes subjects to extract metadata and scores pattern matches based on factors such as consecutive character matches, position within the subject, and case sensitivity, allowing for more relevant search results.

apps/engine/lib/engine/search/fuzzy · high confidence

The search indexer now includes dedicated extractors to recognize and index Ecto schemas and embedded schemas, ExUnit test blocks (setup, test, describe), and standard Elixir language elements including function definitions (def, defp, defmacro, defmacrop), function references (including dynamic calls and captures), module definitions and references, module attributes, and struct definitions and references. This expands the indexer's ability to provide accurate navigation and search results for these common patterns in Elixir codebases.

apps/engine/lib/engine/search/indexer/extractors · high confidence

The build system has been replaced with a new engine located in \apps/engine/lib/engine/build\ that isolates compilation tasks in monitored processes to prevent crashes from affecting the main server. This engine introduces structured error handling via \Engine.Build.Error\, which normalizes and refines compiler diagnostics for better readability, and manages project dependencies by ensuring \hex\ and \rebar\ are available and fetching them when out of sync. It also includes a new \Engine.Build.Isolation\ module to safely execute compilation code, and moves build-related utilities like \CaptureIO\ and \CaptureServer\ from the remote control app to the engine to support this new architecture.

apps/engine/lib/engine/build · high confidence

The Expert release now supports deployment without the Erlang Port Mapper Daemon (epmd) by configuring the VM to use a custom EPMD module (\Elixir.XPForge.EPMD\) and disabling the default epmd process via \vm.args.eex\ and \remote.vm.args.eex\. Additionally, the release includes a custom \start\_expert\ script (for both Unix and Windows) that ensures the application starts without halting, and enforces UTF-8 encoding on standard I/O to prevent crashes when handling non-ASCII characters in LSP messages or other IO operations.

apps/expert/rel · high confidence

The protocol application has been removed from the codebase, evidenced by the deletion of its formatter configuration file (.formatter.exs) which previously defined custom DSL macros for protocol definitions. This change eliminates the local formatting rules and associated tooling for this specific app.

apps/protocol · high confidence

The \apps/common/lib\ directory has removed several core modules: \Lexical.CodeUnit\ (UTF-8/UTF-16 offset conversions), \Lexical\ (URI type definition), \Lexical.Project\ (project state and configuration management), and \Lexical.SourceFile\ (source file representation and content change application). This deletion eliminates the underlying data structures and conversion logic used for handling LSP positions, project metadata, and document content within this common library.

apps/common/lib · high confidence

The \Lexical.SourceFile\ module and its associated sub-modules (\Conversions\, \Line\, \Position\, \Range\, and \Store\) have been removed from the codebase. This change eliminates the previous implementation for managing source file state, URI/path conversions, and LSP position handling, indicating a shift in how source files are processed within the application.

_apps/common/lib/source\file · high confidence

The \Lexical.Transport.StdIO\ module has been removed from the server. This change eliminates the previous implementation that delegated I/O operations and error logging to \Lexical.Server.IOServer\, indicating a shift in how the server handles standard input/output transport for the lexical protocol.

apps/server/lib/lexical/server/transport · high confidence

The \Lexical.CodeMod\ namespace has removed four internal utility modules: \Ast\ (AST parsing), \Diff\ (text edit generation via Myers algorithm), \Format\ (code formatting logic), and \ReplaceWithUnderscore\ (variable renaming). These files are deleted from \apps/server/lib/lexical/server/code\_mod/\, indicating that the server-side code modification capabilities previously handled by these specific components are no longer present in this location.

_apps/server/lib/lexical/server/code\mod · high confidence

The server no longer provides code actions, document formatting, or find-references capabilities. The handler modules for these features (\code\_action.ex\, \formatting.ex\, and \find\_references.ex\) have been deleted from the codebase, meaning these LSP features are no longer available to users.

apps/server/lib/lexical/provider/handlers · high confidence

The \conversions.ex\, \json\_rpc.ex\, \notifications.ex\, \proto.ex\, \requests.ex\, \responses.ex\, and \types.ex\ files in \apps/protocol/lib/lexical/protocol\ have been deleted. This removes the previous manual implementation of LSP message encoding, decoding, and position conversion logic (including UTF-8/UTF-16 handling), indicating a shift to a different protocol handling mechanism elsewhere in the codebase.

apps/protocol/lib/lexical/protocol · high confidence

The \apps/protocol/lib/lexical/protocol/proto\ directory has been completely removed, deleting the legacy macro-based protocol definition system. This includes the removal of \CompileMetadata\ (which tracked protocol modules), \Convert\ (which handled LSP-to-Elixir struct conversion), and the \Macros\ suite (\Struct\, \Parse\, \Json\, \Meta\, etc.) used to generate protocol types. The deletion of \alias.ex\, \enum.ex\, \field.ex\, and \type\_functions.ex\ eliminates the previous DSL for defining protocol types, fields, and enums, indicating a migration away from this specific implementation approach.

apps/protocol/lib/lexical/protocol/proto · high confidence

The \Lexical.Provider.Env\, \Lexical.Provider.Queue\, and \Lexical.Provider.Queue.Supervisor\ modules have been deleted from the server. This removes the previous implementation that managed provider request tasks via a dedicated GenServer queue and a specific task supervisor, simplifying the provider architecture by eliminating these internal components.

apps/server/lib/lexical/provider · high confidence

The \Lexical.RemoteControl\ module has removed its internal build orchestration and communication layer, specifically deleting the \Api\, \Application\, \Build\, \CompileTracer\, and \Messages\ modules. This eliminates the previous mechanism where the remote control process directly managed project compilation, handled compile-time tracing, and emitted structured messages (such as \project\_compiled\ and \module\_updated\) to listeners. Users will no longer interact with this specific internal build pipeline, as the responsibility for compilation and notification has been moved or refactored elsewhere in the system.

_apps/remote\_control/lib/lexical/remote\control · high confidence

Deleted the \application.ex\, \configuration.ex\, \configuration/support.ex\, \io\_server.ex\, \json\_rpc\_backend.ex\, \output\_device.ex\, \state.ex\, and \transport.ex\ files from the \apps/server/lib/lexical/server\ directory. This removes the previous OTP application entry point, the manual JSON-RPC I/O handling, the custom logger backend, the output device interception logic, and the legacy server state management, effectively stripping out the old server implementation components from this location.

apps/server/lib/lexical/server · high confidence

The \Lexical.RemoteControl\ module, which previously managed the lifecycle of a separate Erlang VM node for executing tasks in the context of a remote project, has been deleted. This change removes the underlying implementation for booting and communicating with that isolated node, indicating that the remote control capability has been refactored or replaced by a different mechanism elsewhere in the application.

_apps/remote\control/lib/lexical · high confidence

The code action that automatically prefixed unused variables with an underscore has been removed from the Lexical server. This change eliminates the 'Rename to \_\<variable\>' quick-fix option, meaning users will no longer see this specific suggestion when diagnostics detect unused variables.

_apps/server/lib/lexical/provider/code\action · high confidence

The Engine and Forge applications have been reorganized to support independent Nix-based builds and standardized code formatting. New \deps.nix\ files define build overrides for native dependencies (such as RustlerPrecompiled and portCompiler), while \.formatter.exs\ and \.credo.exs\ files integrate the Quokka formatter and linting rules. Configuration directories have been established for the Engine app, and \.gitignore\ files have been renamed to reflect the new app names, ensuring proper build artifact exclusion.

apps/engine · high confidence

The \apps/expert/lib/convertibles\ directory now includes new implementation modules that bridge the internal \Forge\ domain models (such as \Diagnostic\, \Document.Changes\, \Document.Edit\, \Document.Location\, \Position\, and \Range\) with the \GenLSP\ protocol structures. These additions enable the system to correctly serialize internal diagnostic and document change data into standard LSP formats and deserialize incoming LSP messages back into native Elixir structures, supporting the migration to the \genlsp\ architecture.

apps/expert/lib/convertibles · high confidence

The engine now uses compiler tracers to capture and index definitions generated by macros. A new TraceBuffer GenServer records module binaries and their macro-generated definitions during compilation, while the Tracer module intercepts module load events to extract and store this metadata. This ensures that definitions created by macros are properly indexed for search and navigation, addressing previous gaps where macro-generated code was not fully discoverable.

apps/engine/lib/engine/compilation · high confidence

The internal \Lexical.Server.Project.Diagnostics\ GenServer and its associated \Index\ and \Supervisor\ modules have been removed from the core project structure. This change eliminates the previous mechanism where the project directly managed and published diagnostics via internal dispatch messages, aligning with the shift to a plugin-based diagnostic system (specifically \Lexical.Plugin.Diagnostics\).

apps/server/lib/lexical/server/project · high confidence

The engine now explicitly manages the startup of required Elixir applications and preloads all engine modules to prevent code-path pruning issues during dependency compilation, ensuring stable runtime availability. Additionally, a new source reducer has been introduced to traverse Elixir AST, tracking block hierarchies and applying extractors to generate structured indexing entries for modules, functions, and structs.

apps/engine/lib · high confidence

The Expert LSP provider has been reorganized into a modular handler system, introducing a \Handler\ behavior and dedicated modules for features like code folding, code actions, and workspace symbols. Code folding now supports anonymous functions, consecutive comments, and multi-line strings without requiring the engine to be initialized. Workspace symbol search can now return all symbols when the query is empty, controlled by a new \min\_query\_length\ configuration. Code actions support deferred execution, computing edits on resolve to handle stale documents gracefully. Hover resolution now integrates ElixirSense as a fallback and supports module attributes. Project discovery logic has been refined to correctly handle workspace folders, umbrella projects, and dependency directories.

apps/expert/lib/expert/provider · high confidence

The Expert LSP server is now implemented using the GenLSP library, replacing the previous protocol layer. This change introduces a new request handling pipeline that converts incoming LSP messages to native structures via \Expert.Protocol.Convert\, processes them through specific handlers, and converts responses back to LSP format. It establishes workspace folder support by resolving projects from normalized folders during initialization and manages engine initialization states to prevent requests from being sent before the backend engine is ready.

apps/expert/lib · high confidence

The engine now correctly preserves multiple diagnostics from both file and project compilation stages instead of discarding them. This change introduces new modules for parsing error details and managing diagnostic locations, ensuring that users see all relevant error and warning messages during the build process rather than having some silently dropped.

apps/engine/lib/engine/build/error · high confidence

The engine now uses a new module loader that caches loaded modules to avoid slow round-trips to the code server, which significantly improves startup time and indexing performance, especially for large projects. This change also includes specific handling for Windows to account for potential timing issues during module loading.

apps/engine/lib/engine/module · high confidence

The reindexing command now uses a GenServer to prevent multiple reindexing jobs from running simultaneously, ensuring that only one reindex operation can execute at a time. Additionally, individual URI reindex requests are debounced with a 1-second interval, batching multiple rapid changes into a single update cycle to reduce overhead. This change improves responsiveness during heavy editing sessions and prevents resource contention from concurrent reindex attempts.

apps/engine/lib/engine/commands · high confidence

The Expert application now manages each project through a dedicated supervision tree that includes a diagnostics handler, an indexer, an intelligence tracker, a search listener, and a node manager. This structure ensures that diagnostics are cleared and updated in real-time as you type, that stale diagnostics are removed when files change, and that the search index is refreshed automatically after successful compiles. The system also provides user-friendly error messages for filesystem issues (such as read-only directories or insufficient permissions) and tracks project readiness to prevent operations on blocked or incomplete projects.

apps/expert/lib/expert/project · high confidence

The Expert project now includes a dedicated diagnostics state module that manages how build and file-level errors are tracked and displayed. This implementation introduces logic to clear stale diagnostics as the user types, ensuring that outdated errors are removed from the view. It also prevents the loss of multiple diagnostics by properly handling both file and project compilation results, and adds safeguards to prevent crashes when encountering typespec errors. This change establishes the core state handling required for accurate, real-time feedback in the Expert environment.

apps/expert/lib/expert/project/diagnostics · high confidence

The \apps/forge/lib/future\ directory now contains a forked copy of Elixir's standard library modules (\Future.Code\, \Future.Code.Fragment\, \Future.Code.Identifier\, \Future.Code.Typespec\, \Future.Macro\, and \Mix.Tasks.Future.Format\). These modules are adapted to use \:future\_elixir\ for string-to-quoted conversion, enabling the application to support the syntax and compiler changes introduced in Elixir 1.20 and OTP 29.

apps/forge/lib/future · high confidence

A new bimodal buffering proxy has been added to the engine API. This component intercepts API calls, forwarding them normally in its default state, but can switch to a buffering mode where requests are collected and processed according to specific deduplication and ordering rules (e.g., dropping time-sensitive format requests, keeping only the latest reindex). This architecture supports the LSP semantics improvements by allowing the engine to manage concurrent operations more effectively, particularly during dependency fetching and compilation phases.

apps/engine/lib/engine/api · high confidence

The engine now uses a new \Engine.Build.Document.Compiler\ behavior to handle document compilation, replacing the previous plugin architecture. This change introduces specific compilers for Elixir (\.ex\/\.exs\), EEx (\.eex\), HEEx (\.heex\), and Elixir configuration files (\.exs\ in config directories), all of which provide diagnostic feedback via the \Forge.Diagnostic\ interface. The implementation leverages Elixir's \Code.compile\_quoted\ and \EEx.compile\_string\ to parse and evaluate code, ensuring that syntax errors and runtime exceptions are surfaced as structured diagnostics to the user. A fallback \NoOp\ compiler is included to handle unsupported file types gracefully.

apps/engine/lib/engine/build/document · high confidence

The search indexer now uses a persistent manifest to track indexed files and their modification times, enabling incremental updates that only re-index files that have actually changed. This new system introduces a manifest store to persist indexing state, a manifest entry structure to record file metadata, and updated indexing logic for both source files and compiled beam files that leverages this manifest to determine what needs re-indexing.

apps/engine/lib/engine/search/indexer · high confidence

The Expert app introduces a new set of translation modules in the \completion/translations\ directory to convert internal completion candidates into LSP completion items. This change adds dedicated handlers for various Elixir constructs, including bitstring options, callables (functions, macros, callbacks, typespecs), Hex package metadata (packages, versions, and options), module attributes (such as \@moduledoc\, \@doc\, and \@spec\), modules, structs, struct fields, and variables. These modules implement the \Translatable\ protocol to define how each candidate type is rendered, including snippet insertion, sorting scopes, and label details, effectively replacing or augmenting the previous completion generation logic.

_apps/expert/lib/expert/code\intelligence/completion/translations · high confidence

The project has been renamed from Lexical to Expert, reflected in the updated README, the new Apache 2.0 LICENSE file, and the initial version set to 0.1.0 in version.txt and release-please-config.json. The development environment has been updated to use Elixir 1.20 and Erlang 29.0.1, and the IEx helper configuration now uses the Expert namespace.

(repo-wide) · high confidence

The application has been renamed from 'Server' to 'Expert', reflected in the directory structure and the new README. Configuration files have been added or updated to support this change, including a new \.credo.exs\ for code linting and a \.formatter.exs\ that integrates the 'Quokka' formatter plugin. The Nix build configuration (\deps.nix\) has been introduced to manage dependencies and native builds. Additionally, the interactive Elixir shell configuration (\.iex.exs\) has been updated to alias \Forge.Project\ instead of the previous \Lexical.Project\.

apps/expert · high confidence

The dispatch mechanism in the engine has been restructured to support a more modular and extensible event handling architecture. A new \Engine.Dispatch.Handler\ behavior allows developers to define custom handlers that selectively receive events (such as \file\_compile\_requested\ or \filesystem\_event\) via a declarative \use Handler, \[...\]\ macro, simplifying the implementation of event-driven logic. The previous \Lexical.Server.Project.Dispatch\ GenServer has been replaced by \Engine.Dispatch.PubSub\, which now implements the \:gen\_event\ behavior to manage listener registrations and message routing more efficiently. Additionally, a new \Engine.Dispatch.Handlers.Indexing\ handler has been introduced to automatically trigger re-indexing on file compilation requests and clear search stores on file deletions, centralizing indexing-related side effects within the dispatch layer.

apps/engine/lib/engine/dispatch · high confidence

The code completion engine has been rewritten to generate completion items using GenLSP structures, ensuring broader compatibility and allowing for more precise control over text edits and replacement ranges. A new sorting system has been introduced via the \SortScope\ module, which categorizes completions (e.g., modules, variables, local/remote declarations) to prioritize results more effectively for the user. Additionally, the \Translatable\ protocol was added to standardize how completion items are processed and translated within the completion builder.

_apps/expert/lib/expert/code\intelligence/completion · high confidence

The \Lexical.Dialyzer\ and \Lexical.Server\ modules have been removed from the codebase. This eliminates the previous GenServer-based implementation that handled protocol messages, state initialization, and configuration defaults, indicating a structural shift in how the language server processes requests and manages state.

apps/server/lib/lexical · high confidence

The \Lexical.RemoteControl.Build.Error\ module, which previously handled the conversion of Elixir compiler errors (such as \SyntaxError\, \TokenMissingError\, and \CompileError\) into LSP diagnostics, has been removed. This change indicates a shift in how build errors are processed within the remote control build system, likely consolidating error handling logic elsewhere or adopting a different mechanism for generating diagnostics from compilation output.

_apps/remote\_control/lib/lexical/remote\control/build · high confidence

The local development environment setup for the remote control app has been cleaned up by deleting the \.iex.exs\ and \.tool-versions\ files. The removed \.iex.exs\ contained hardcoded paths to an external project (\eakins\) and automatic remote control initialization that were preventing the application from starting correctly, while the \.tool-versions\ file specified specific Erlang and Elixir versions that are no longer managed at this location.

_apps/remote\control · high confidence

The global \config/config.exs\ file, which previously applied shared configuration and dependencies to all applications in the umbrella project, has been deleted. Users must now manage configuration settings individually within their specific application contexts rather than relying on a centralized umbrella configuration.

config · high confidence

The engine node builder now captures the most recent 50 non-empty output lines from the build subprocess. If the build fails, this captured output is forwarded to the user, ensuring that the actual error message is visible instead of just a generic stacktrace or exit status.

_apps/expert/lib/expert/engine\node · high confidence

This change introduces a new conversion module to correctly handle UTF-8 to UTF-16 character position mapping, ensuring that document edits involving non-ASCII characters are processed accurately without clamping received character indices. It also adds robust handling for native-to-LSP conversions, specifically preventing crashes when receiving shutdown requests with nil parameters and ensuring the document from the request is used as a fallback when it is missing from the store.

apps/expert/lib/expert/protocol · high confidence

The engine analyzer now correctly resolves local calls and module aliases by introducing a dedicated alias resolution module that handles unquoted aliases, prevents recursive alias generation for nested modules, and stops double-applying alias suffixes when prefixes are aliased. Additionally, the analyzer's import, require, and use detection logic has been refined to accurately scope these declarations to specific positions, ensuring that imported functions, required modules, and used behaviors are resolved correctly within the context of the current line and scope.

apps/engine/lib/engine/analyzer · high confidence

Added RefactorCase test helper for validating code refactoring; Added benchmark for Forge.Identifier; Added comprehensive test coverage for the engine core; Added test coverage for Expert clustering, configuration, engine builds, and progress tracking; Added test coverage for Expert project diagnostics, indexing, and intelligence; Added test coverage for Expert protocol conversions, document lookup, and engine initialization; Added test coverage for Forge core utilities; Added test coverage for document compilers; Added test coverage for the analyzer's alias, import, require, and use resolution; Added test coverage for the search indexer subsystem; Added test fixtures for umbrella app search and custom apps path; Added test helper initialization for Forge.Identifier; Added test suite for Engine build, module, and clustering behavior; Added test support modules for completion, configuration, and protocol conversion; Added tests for AST detection of various Elixir syntax elements; Added tests for Erlang version normalization and compatibility checks; Added tests for Expert provider LSP handlers; Added tests for Forge AST environment, module, and token handling; Added tests for Forge Document components; Added tests for LSP structure conversions; Added tests for Spitfire parser crash handling; Added tests for arity fallback logic in go-to-definition; Added tests for build error handling, compilation state, and compiler tracing; Added tests for code action handlers; Added tests for code completion translations; Added tests for code indexer extractors; Added tests for code intelligence completion, dependency parsing, and Hex package search; Added tests for code intelligence definition resolution; Added tests for code modification utilities; Added tests for completion builder sorting and edge cases; Added tests for diagnostics state management; Added tests for fuzzy search and indexer logic; Added tests for namespace file synchronization and beam rewriting; Added tests for project log file and window log handler; Added tests for stdio adapter and user process behavior; Added tests for the Engine Node Builder; Added tests for the Engine dispatch system and indexing handlers; Added tests for the Expert search indexer and SQLite store; Added tests for the Forge Document module; Added tests for the RefactorEx code action suite; Added tests for the Reindex command; Added tests for the code formatting cache; Expanded test fixtures for compilation, navigation, and workspace scenarios; Initialize test environment for Engine app; New test infrastructure and utilities for the Forge application; Removal of ExUnit test helper file; Removed common\_test.exs test file; Removed diagnostics state unit tests; Removed legacy test helper file; Removed obsolete protocol test files; Removed obsolete test files for build and remote control modules; Removed test fixture helper; Updated test fixtures for Engine isolation.

The \engine\ and \forge\ applications now require Elixir 1.15 and have updated their dependency specifications to align with the new version. Key dependency updates include \gen\_lsp\ to 0.11.3, \sourceror\ to 1.12.2, and \spitfire\ to 0.4.1. The \engine\ app also introduces \elixir\_sense\ (from a specific git ref), \logger\_backends\, and \path\_glob\, while \forge\ adds \spitfire\ and \benchee\. Test fixtures have been migrated from \remote\_control\ to \forge\ and updated to use Elixir 1.15 or 1.17.

(dependencies) · high confidence

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

• CAI 73 → 76 (+2.4)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 96 → 88 (-8.7)
• Architecture 99 → 93 (-6.0)
• Maturity 66 → 66 (-0.0)
• Readiness 71 → 82 (+11.4)
• Security 81 → 84 (+2.6)

• 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/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (12 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (13 lines × 2) (apps/engine/lib/engine/modules.ex)
• Duplicated block (13 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (13 lines × 3) (apps/engine/lib/engine/search/indexer/extractors/module.ex)
• Duplicated block (15 lines × 2) (apps/engine/lib/engine/search/indexer/extractors/module.ex)
• Duplicated block (17 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (17 lines × 2) (apps/expert/lib/expert/code_intelligence/completion/translations/module_attribute.ex)
• Duplicated block (8 lines × 2) (apps/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (9 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (9 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (9 lines × 2) (apps/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (9 lines × 2) (apps/expert/lib/expert/code_intelligence/completion/builder.ex)
• FileTooLong: forge/ast.ex (apps/forge/lib/forge/ast.ex)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Test reliability not included
• …and 4 more

• Documentation: no architecture or design documentation (pages/architecture.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (10–13 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (11 lines × 2) (apps/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (11 lines × 2) (apps/engine/lib/engine/search/indexer/beams.ex)
• Duplicated block (12 lines × 2) (apps/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (13 lines × 2) (apps/engine/lib/engine/modules.ex)
• Duplicated block (13 lines × 2) (apps/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (13 lines × 2) (apps/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (13 lines × 3) (apps/engine/lib/engine/search/indexer/extractors/module.ex)
• Duplicated block (13–17 lines × 2) (apps/engine/lib/engine/search/fuzzy/scorer.ex)
• Duplicated block (15 lines × 2) (apps/engine/lib/engine/search/indexer/extractors/module.ex)
• Duplicated block (25 lines × 2) (apps/expert/lib/expert/code_intelligence/completion/translations/module_attribute.ex)
• Duplicated block (27–29 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (28–30 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (38–40 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (5 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (6 lines × 2) (apps/engine/lib/engine/search/fuzzy.ex)
• Duplicated block (6 lines × 3) (apps/forge/lib/forge/namespace/transform/apps.ex)
• …and 81 more

• 36 commits — 14 feature/other, 22 fixes

• apps/engine — 15 commits
• apps/expert — 9 commits
• .github/workflows — 7 commits
• apps/forge — 4 commits
• pages/installation.md — 1 commit

• fix: chore(revert): prevent formatter cache from forgetting the formatter for a path (#831) (#875)
• fix: fix(engine): drop edit window to 100ms (#872)
• fix: fix(engine): keep ModuleStore alive across builds (#889)
• fix: fix(engine): resolve formatter against project mix config (#834)
• fix: fix(expert): force unicode encoding on IO (#852)
• fix: fix(forge): handle bitstrings in interpolation (#865)
• fix: fix: clear stale diagnostics as you type (#878)
• fix: fix: diagnostics take a long time to update (#871)
• fix: fix: don't discard multiple diagnostics from file and project compilation (#841)
• fix: fix: don't load deps before the project is compiled (#839)
• fix: fix: don't reverse text document params (#884)
• fix: fix: don't use token_metadata option when compiling (#845)
• fix: fix: index macro-generated definitions from compiler traces (#856)
• fix: fix: prevent formatter cache from forgetting the formatter for a path (#831)
• fix: fix: properly calculate callback completion line range (#846)
• fix: fix: properly handle typespec errors; prevent diagnostics crash (#879)
• fix: fix: record module binary if module metata read fails (#874)
• fix: fix: relax Hex connectivity timeout (#858)
• fix: fix: stop calls to IO and other writes to stdout from crashing Expert. (#824)
• fix: fix: stop checking dependency beam mtime (#890)
• …and 16 more

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

expert-lsp/expert 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.