Skip to content
CAI
Software that uses CAICheck a score

expert-lsp/expert

74.9

Strong · 13 November 2026

50.9k

lines of production code

Elixir

with Erlang

8

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

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

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.