expert-lsp/expert
74.9
Strong · 13 November 2026
50.9k
lines of production code
Elixir
with Erlang
8
measurements over time
What this system is
Features
Add AST analysis and version matching benchmarks
Added benchmark scripts to the engine to measure the performance of AST analysis and version matching logic. The new \ast\_analyze.exs\ script uses Benchee to benchmark the \Ast.analyze\ function against a sample Elixir file, while \versions\_bench.exs\ benchmarks the \Forge.VM.Versions\ module's current version checks. Supporting test data, including a large ETS index file and a copy of the Elixir standard library's \Enum\ protocol, has also been added to support these performance tests.
apps/engine/benchmarks · high confidence
Add Elixir version-aware feature detection
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. Also in this area: Simplified dependency compilation by removing legacy Elixir version checks.
apps/forge/lib/elixir · high confidence
Added VM version compatibility checking for build artifacts
The \Forge.VM.Versions\ module has been added to manage and verify Elixir and Erlang runtime versions. This allows the system to tag build directories with the specific VM versions used during compilation and provides a \check\_erlang\_compatibility\ function to ensure that existing beam files are compatible with the currently running VM, preventing runtime errors caused by version mismatches.
apps/forge/lib/forge/vm · high confidence
Added engine build script and remote shell utilities
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
Added internal Elixir compiler components to support future Elixir integration
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
Added pre-commit hook for code formatting and linting
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
Engine core components and bootstrap logic introduced
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
Expert language server initial release
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
Hex package intelligence for mix.exs completions
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. Also in this area: 1 commit (0 fixes) modifying apps/expert; Expert app modules migrated from Forge; New code intelligence and search indexing infrastructure in the Expert app.
_apps/expert/lib/expert/code\intelligence · medium confidence · unverified
Initial configuration for the Expert application
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
Introduce Forge core library with LSP document, AST, and refactoring capabilities
This change introduces the \Forge\ library, providing the foundational components for the Expert language server. It adds a \Forge.Document\ module to manage LSP text documents, a \Forge.Ast\ module for parsing and analyzing Elixir syntax trees (including partial analysis for code with errors), and a \Forge.CodeAction\ module to support deferred code actions. The library also includes \Forge.Refactor\ with a suite of built-in refactorings (such as extracting or inlining functions and variables), utilities for UTF-8/UTF-16 position conversion in \Forge.CodeUnit\, and infrastructure for EPMD-less clustering via \Forge.EPMD\ and \Forge.NodePortMapper\. Additionally, it provides path handling with Windows compatibility in \Forge.Path\ and project management logic in \Forge.Project\.
apps/forge/lib/forge · high confidence
Introduce Nix build definition for the Expert application
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
Introduce Spitfire-based AST parser with crash handling
The AST parser now uses the Spitfire library to parse Elixir code, providing document symbols even for files with syntax errors. The new \Forge.Ast.Parser.Spitfire\ module wraps Spitfire's parsing functions and includes specific error handling for crashes, returning a \{:error, :crashed, ...}\ tuple when the parser fails unexpectedly, ensuring the system remains stable during parsing operations.
apps/forge/lib/forge/ast/parser · high confidence
Introduce code modification engine for managing aliases, requires, and formatting
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
Introduce new AST analysis and context detection modules
This change adds a new set of modules under \apps/forge/lib/forge/ast\ to power code analysis and context awareness. \Forge.Ast.Analysis\ handles parsing and scope traversal, including support for documents with syntax errors. \Forge.Ast.Env\ provides a representation of the environment at a cursor position, detecting contexts like aliases, structs, and function captures. Supporting modules include \Forge.Ast.Detection\ for context recognition behaviors, \Forge.Ast.Tokens\ for tokenizing code prefixes, and utilities in \Forge.Ast.Module\ and \Forge.Ast.Range\ for module name handling and AST range extraction.
apps/forge/lib/forge/ast · high confidence
Introduce protocol for LSP-native data conversion
Added a new \Forge.Protocol.Convertible\ protocol and helper utilities to centralize the conversion of internal data structures (such as positions and ranges) into Language Server Protocol (LSP) formats and vice versa. This change implements automatic conversion logic for Maps, Lists, and generic structs, ensuring that UTF-8 based Elixir data structures are correctly translated to UTF-16 based LSP specifications without requiring manual conversion code throughout the codebase.
apps/forge/lib/forge/protocol · high confidence
Introduce search indexer data structures for code entries and blocks
The search indexer now includes dedicated structs to represent source code elements: \Forge.Search.Indexer.Entry\ models individual code symbols (such as functions, modules, or tests) with metadata like location and type, while \Forge.Search.Indexer.Source.Block\ represents hierarchical code blocks. These structures provide the foundational data model for indexing and querying code content. Also in this area: 1 commit (1 fix) fixing apps/forge.
apps/forge/lib/forge/search · medium confidence · unverified
Introduces formatter caching and resolution logic
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
Introduction of SQLite as a search index backend
A new SQLite-based search index backend has been added to the Expert application, implementing the standard search store backend interface. This change introduces a new file storage mechanism using a local SQLite database file, complete with schema management, connection handling via GenServer, and optimized batch operations for indexing. Users can now utilize this backend for search functionality, which provides an alternative to existing storage methods.
apps/expert/lib/expert/search/store/backends · high confidence
New AST analysis modules for tracking aliases, imports, requires, and uses
Added new modules in the AST analysis layer to model and track Elixir language constructs: \Alias\, \Import\, \Require\, \Use\, \Scope\, and \State\. These modules provide structured representations of code elements (such as aliasing, importing functions/macros, requiring modules, and using behaviors) along with scope management logic to resolve them correctly within nested contexts. This enables more accurate static analysis features like find-references and code actions that depend on understanding module dependencies and namespace resolution.
apps/forge/lib/forge/ast/analysis · high confidence
New AST context detection modules for struct references and string interpolation
This change introduces a suite of new detection modules in the AST analysis layer, specifically \Forge.Ast.Detection.StructReference\ and \Forge.Ast.Detection.String\, alongside supporting modules for aliases, bitstrings, comments, directives, function captures, imports, module attributes, pipes, requires, specs, struct fields, and types. The \StructReference\ module now robustly identifies struct references (e.g., \%Foo\) by analyzing cursor context and token prefixes, including handling edge cases like \%\_\MODULE\\_\ in function heads. The \String\ module enhances context detection to distinguish between string literals, interpolated strings, and string sigils (\\~s\, \\~S\), correctly identifying cursor positions within interpolations versus the string content itself. These additions improve the precision of code analysis features like completion and highlighting by accurately determining the syntactic context of the cursor.
apps/forge/lib/forge/ast/detection · high confidence
New Mix tasks for Git hooks and release namespacing
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
New code actions for aliases, undefined functions, and refactoring
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
New code intelligence capabilities: declarations, implementations, and signature help
The code intelligence engine now supports Go-to-Declaration, Find Implementations, and Signature Help. Go-to-Declaration resolves the definition of variables, functions, and module attributes, including callback declarations in behaviours. Find Implementations lists all modules implementing a given behaviour or protocol. Signature Help displays the function signature and argument details for the call at the cursor. These features complement existing Go-to-Definition and Hover capabilities, providing a more complete IDE experience for navigating and understanding Elixir code.
_apps/engine/lib/engine/code\intelligence · high confidence
New configuration modules for LSP client capabilities and workspace symbols
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
New diagnostic and documentation data structures for code intelligence
This change introduces new internal data structures to support code analysis capabilities. In the code action module, a \Diagnostic\ struct is added to represent code issues with specific ranges, messages, and sources. In the code intelligence module, \Docs\ and \Docs.Entry\ structs are introduced to model module documentation, including functions, macros, callbacks, and types, along with metadata like deprecation status and guard clauses. These structures provide the foundation for parsing and representing code documentation and diagnostics within the application.
_apps/forge/lib/forge/code\_action, apps/forge/lib/forge/code\intelligence · high confidence
New in-memory fuzzy search and persistent store for code indexing
The search subsystem now includes a new \Expert.Search.Fuzzy\ module that performs in-memory fuzzy matching of search entries, allowing for more resilient and faster partial-name lookups. This is paired with a new \Expert.Search.Store\ GenServer that acts as a persistent, manager-node store for search entries, supporting configurable backends (defaulting to SQLite) to handle indexing, updates, and queries like exact, prefix, and caller-based searches. The \Expert.Search.Indexer\ has been updated to work with this new store, managing the creation and incremental updating of the search index by streaming entries and coordinating with the fuzzy matcher. Also in this area: 1 commit (0 fixes) modifying apps/expert; 4 commits (2 fixes) modifying apps/expert; Expert app modules migrated from Forge.
apps/expert/lib/expert/search · medium confidence · unverified
New internal modules for engine API messages and progress tracking
The engine API layer now includes a new \Forge.EngineApi.Messages\ module that defines the specific record structures and type specifications for internal events (such as compile requests, diagnostics, and file changes) and a new \Forge.Progress.Tracker\ GenServer that manages concurrent progress reporting to the LSP client. These additions establish the data contracts and state management mechanisms required for the engine's communication and progress feedback loops.
_apps/forge/lib/forge/engine\api · high confidence
New isolated build engine with robust error handling and dependency management
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
New namespacing engine for transforming Erlang/Elixir artifacts
The Forge namespace module now includes a comprehensive set of transformers that apply a configurable prefix (defaulting to 'XP') to modules, applications, and file paths. This capability covers rewriting Erlang abstract syntax in .beam files, updating .app and .rel configuration files, modifying runtime configuration scripts, and synchronizing file structures to reflect the new namespaced layout.
apps/forge/lib/forge/namespace · high confidence
Port refactoring capabilities from Refactorex into Forge
This change introduces a comprehensive suite of code refactoring tools to Forge, ported from the open-source Refactorex project. Users can now perform various structural changes on their Elixir code, including extracting and inlining functions, constants, variables, and guards; managing aliases by extracting, merging, inlining, or expanding them; and rewriting code style by converting between keyword and regular syntax for functions and if/else blocks. Additional features include collapsing and expanding anonymous functions, introducing IO.inspect calls in pipelines, and sorting nested aliases.
apps/forge/lib/forge/refactor · high confidence
Support for epmd-less clustering and improved startup stability
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
Removals
Removal of Protocol App and Formatter Configuration
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
Removal of core Lexical library modules
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
Removal of legacy SourceFile modules
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
Removal of legacy StdIO transport module
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
Removal of legacy code-mod utility modules
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
Removed code action, formatting, and find-references handlers
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
Removed legacy protocol encoding and conversion modules
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
Removed legacy protocol macro and conversion infrastructure
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
Removed legacy provider queue and environment modules
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
Removed legacy remote control build and messaging subsystem
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
Removed legacy server infrastructure modules
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
Removed the legacy remote control module
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
Removed unused variable underscore prefix code action
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
Architecture
Engine and Forge apps restructured with Nix build support and code formatting
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
Behavioural changes
20 commits (5 fixes) modifying apps/expert/lib/expert/search/indexer
A change to existing behaviour in apps/expert/lib/expert/search/indexer — 20 commits (5 fixs), 27 files: “fix(expert): index BEAM files without creating atoms (\#968)”; “perf(indexer): reduce index file size (\#954)”; “perf(expert): reduce wait time when writing index entries (\#980)”; and 17 more (refs \#968, \#954, \#980, \#1004, \#937, …).
apps/expert/lib/expert/search/indexer · medium confidence · unverified
3 commits (1 fix) modifying apps/expert/lib/expert/integrations
A change to existing behaviour in apps/expert/lib/expert/integrations — 3 commits (1 fix), 7 files: “fix(expert): index BEAM files without creating atoms (\#968)”; “feat: add Spark integration (\#835)”; “perf: warmup index before the engine starts (\#908)” (refs \#968, \#835, \#908).
apps/expert/lib/expert/integrations · medium confidence · unverified
4 commits (2 fixes) modifying apps/expert
A change to existing behaviour in apps/expert — 4 commits (2 fixs), 40 files: “fix(expert): index BEAM files without creating atoms (\#968)”; “perf(expert): reduce wait time when writing index entries (\#980)”; “fix(expert): persist module registry (\#969)”; and 1 more (refs \#968, \#980, \#969, \#977). Also in this area: 1 commit (0 fixes) modifying apps/expert.
apps/expert/test/expert/integrations · medium confidence · unverified
Add conversion implementations for LSP structures and Forge types
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
Compiler tracers now index macro-generated definitions
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
Diagnostics handling moved to a plugin architecture
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
Engine initialization and AST indexing infrastructure
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
Expert LSP provider restructured with new handler architecture and enhanced code intelligence
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
Expert LSP server core implementation
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
Improved handling of multiple compilation diagnostics
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
Improved module loading performance via caching
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
Introduce dedicated project lifecycle and diagnostics management
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
Introduce diagnostics state management for Expert
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
Introduces Future.Code and related modules for Elixir 1.20/OTP 29 compatibility
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
New document-level compiler architecture for Elixir, EEx, and HEEx
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
New fuzzy scoring algorithm for search relevance
A new \Expert.Search.Fuzzy.Scorer\ module has been introduced to handle fuzzy matching logic. This component implements a heuristic-based scoring system that evaluates search queries against subjects by calculating scores based on consecutive character matches, tail matches, and camel-case patterns, while applying penalties for mismatches and incompleteness. This change replaces or augments previous fuzzy matching behavior with a more granular, configurable scoring mechanism to improve search result relevance.
apps/expert/lib/expert/search/fuzzy · high confidence
New translation layer for code completion items
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
Project renamed to Expert with initial release configuration
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
Project renamed to Expert with updated tooling and configuration
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
Refactored code completion to use GenLSP structures and improved sorting logic
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
Refactored document model and path handling for Forge
The document subsystem has been restructured into a dedicated Forge module, introducing new types for positions, ranges, edits, and a hyper-optimized line-based backing store. This change improves how the language server handles text edits and cursor positions by providing efficient, generic access to document context. Additionally, path handling has been updated to support Windows drive letters and untitled file URIs, ensuring correct path resolution across different operating systems.
apps/forge/lib/forge/document · high confidence
Removal of legacy Lexical server and dialyzer modules
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
Removal of legacy error-to-diagnostic conversion module
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
Removed outdated local development configuration files
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
Removed umbrella-wide default configuration file
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
Fixes
Engine build process now captures and displays error output
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
Fixes LSP position handling and protocol conversion robustness
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
Fixes to alias resolution and import/require/usage analysis in the engine analyzer
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
Test coverage
12 commits adding/updating tests in apps/expert/test/expert/search/indexer; 3 commits adding/updating tests in apps/engine/test/engine/compilation; Added RefactorCase test helper for validating code refactoring; Added benchmark for Forge.Identifier; Added benchmark scripts for expert search and code folding performance; 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 document lines, paths, positions, ranges, and store; Added test coverage for the analyzer's alias, import, require, and use resolution; 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 LSP structure conversions; Added tests for SQLite search backend; 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 intelligence completion, dependency parsing, and Hex package search; Added tests for code intelligence definition resolution; Added tests for code intelligence features; 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 scorer 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 Forge Document module; Added tests for the RefactorEx code action suite; Added tests for the code formatting cache; Added tests for the search indexer and SQLite-backed store; Added tests for the search store state module; 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.
Dependencies
Engine and Forge apps adopt Elixir 1.15 and updated dependencies
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 73 → 75 (+1.7)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 91 → 87 (-3.7)
- Architecture 83 → 85 (+2.0)
- Maturity 62 → 67 (+4.8)
- Readiness 79 → 79 (+0.0)
- Security 87 → 81 (-5.9)
- Performance 95 → 95 (+0.0)
Resolved (23)
- Change coupling: function_reference.ex ↔ module.ex (apps/expert/lib/expert/search/indexer/extractors/function_reference.ex)
- Change coupling: port.ex ↔ build_engine.exs (apps/expert/lib/expert/port.ex)
- Duplicated block (10 lines × 2) (apps/expert/lib/expert/search/store.ex)
- Duplicated block (11 lines × 2) (apps/expert/lib/expert/search/indexer/beams.ex)
- Duplicated block (13 lines × 3) (apps/expert/lib/expert/search/indexer/extractors/module.ex)
- Duplicated block (16 lines × 2) (apps/expert/lib/expert/search/indexer/extractors/module.ex)
- Duplicated block (17 lines × 2) (apps/engine/lib/engine/analyzer/aliases.ex)
- Duplicated block (20–22 lines × 2) (apps/engine/lib/engine/analyzer/imports.ex)
- Duplicated block (5 lines × 2) (apps/engine/lib/engine/analyzer/imports.ex)
- Duplicated block (6 lines × 2) (apps/expert/lib/expert/code_intelligence/definition.ex)
- Duplicated block (6 lines × 2) (apps/expert/lib/expert/code_intelligence/definition.ex)
- Duplicated block (7 lines × 2) (apps/engine/lib/engine/analyzer.ex)
- Duplicated block (7 lines × 2) (apps/expert/lib/expert/code_intelligence/definition.ex)
- Duplicated block (7 lines × 2) (apps/expert/lib/expert/code_intelligence/definition.ex)
- Duplicated block (8 lines × 2) (apps/expert/lib/expert/search/indexer/beams.ex)
- Duplicated block (8–32 lines × 2) (apps/expert/lib/expert/search/store/backends/sqlite.ex)
- Duplicated block (9 lines × 2) (apps/engine/lib/engine/analyzer.ex)
- Hotspot: apps/expert/lib/expert.ex (apps/expert/lib/expert.ex)
- Medium CVE: EEF-[CVE redacted] (apps/engine/mix.lock)
- No ADRs found
- …and 3 more
New (85)
- Change coupling: builder.ex ↔ build_engine.exs (apps/expert/lib/expert/engine_node/builder.ex)
- Completion.complete (cognitive 17) (apps/expert/lib/expert/integrations/spark/completion.ex)
- Completion.dsl_call_candidates (cognitive 16) (apps/expert/lib/expert/integrations/spark/completion.ex)
- Duplicated block (10 lines × 2) (apps/expert/lib/expert/search/store.ex)
- Duplicated block (18 lines × 2) (apps/expert/lib/expert/search/indexer/extractors/module.ex)
- Duplicated block (5 lines × 2) (apps/expert/lib/expert/search/store/backends/sqlite.ex)
- Duplicated block (7 lines × 2) (apps/engine/lib/engine/analyzer.ex)
- Duplicated block (8 lines × 2) (apps/expert/lib/expert/integrations/spark/indexer.ex)
- Duplicated block (9 lines × 2) (apps/expert/lib/expert/search/indexer/beams.ex)
- Duplicated block (9–10 lines × 2) (apps/expert/lib/expert/search/store/backends/sqlite.ex)
- Edited copies of one member (3 members, 13+ corresponding lines) (apps/expert/lib/expert/search/store/backends/sqlite.ex)
- Edited copies of one member (3 members, 3+ corresponding lines) (apps/forge/lib/forge/refactor/constant/extract_constant.ex)
- Edited copies of one member (3 members, 7+ corresponding lines) (apps/expert/lib/expert/search/store.ex)
- Edited copies of one member (3 members, 7+ corresponding lines) (apps/forge/src/future_elixir_tokenizer.erl)
- Edited copies of one member (4 members, 12+ corresponding lines) (apps/forge/lib/forge/ast.ex)
- Edited copies of one member (4 members, 7+ corresponding lines) (apps/expert/lib/expert/search/store/state.ex)
- Edited copies of one member (5 members, 10+ corresponding lines) (apps/expert/lib/expert/code_intelligence/hex/api.ex)
- Edited copy of a member (1 corresponding lines) (apps/engine/lib/engine/code_action/handlers/add_alias.ex)
- Edited copy of a member (1 corresponding lines) (apps/engine/lib/engine/modules.ex)
- Edited copy of a member (1 corresponding lines) (apps/forge/lib/forge/refactor/function/collapse_anonymous_function.ex)
- …and 65 more
Changes since last survey
- 33 commits — 24 feature/other, 9 fixes
By area
- apps/expert — 20 commits
- .github/workflows — 10 commits
- apps/engine — 2 commits
- apps/forge — 1 commit
Notable commits
- fix: fix(ci): let backports update workflow files (#990)
- fix: fix(engine): keep the module table from filling up on large projects (#948)
- fix: fix(expert): don't force a recompile on an empty index (#951)
- fix: fix(expert): index BEAM files without creating atoms (#968)
- fix: fix(expert): persist module registry (#969)
- fix: fix(expert): resolve MODULE at its own position (#1004)
- fix: fix(expert): resolve imported calls from the compiler's trace (#971)
- fix: fix: correct Forge.Document and Entry specs (#946)
- fix: fix: mix and hex isolation (#975)
- change: chore(ci): pin Just version (#1005)
- change: chore(deps): bump actions/create-github-app-token from 3.2.0 to 3.3.0 (#956)
- change: chore(deps): bump amannn/action-semantic-pull-request from 6.1.1 to 6.1.2 (#1011)
- change: chore(deps): bump cachix/install-nix-action from 31.11.2 to 31.11.3 (#985)
- change: chore(deps): bump korthout/backport-action from 4.7.0 to 4.7.1 (#1010)
- change: chore(deps): bump sourceror and deps with security advisories (#978)
- change: chore(deps): bump zizmorcore/zizmor-action from 0.6.4 to 0.7.1 (#957)
- change: chore(deps): bump zizmorcore/zizmor-action from 0.7.1 to 0.8.0 (#986)
- change: chore(deps): bump zizmorcore/zizmor-action from 0.8.0 to 0.8.1 (#1012)
- change: chore: increase startup timeout to cover both environment discovery phases (#972)
- change: chore: remove dead code in Analysis.Aliases (#974)
- …and 13 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 254310edd7da0690d6a368a66271f282e4c21e21 — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.57+preprod-8ebfb01cf4c0.