core

Implements Model Context Protocol (MCP) client functionality that connects to MCP servers, discovers available tools via the MCP specification, and orchestrates tool invocation through a schema-based registry. The framework handles bidirectional message passing between the IDE and MCP servers, manages tool schemas, and routes function calls from the editor context to remote MCP-compliant services with automatic serialization/deserialization of arguments and results.

Provides a bidirectional RPC (Remote Procedure Call) communication layer that separates browser-side UI logic from Node.js backend services. The architecture uses the connection package to handle message serialization, routing, and lifecycle management between frontend and backend, enabling developers to define services once and expose them across process boundaries. Supports both request-response patterns and event-based subscriptions with automatic type marshaling.

Provides a menu system where menu items, keybindings, and commands are registered via the contribution system. Commands are first-class objects that can be invoked from menus, keybindings, or the command palette. The menu-bar package renders the menu UI, and the keybinding-service handles keyboard input and command dispatch. Supports context-based menu visibility (e.g., show 'Debug' menu only when debugging) and custom keybinding overrides.

Manages workspace state including open folders, file trees, and workspace settings. The workspace-service package handles multi-root workspaces (multiple folders open simultaneously) and maintains the file tree structure. Supports workspace-level settings that override user settings and folder-level settings that override workspace settings. Workspace state is persisted to enable restoration across IDE sessions.

Provides AI-native capabilities through the ai-native package, including inline code suggestions, error explanations, and context-aware completions. The system integrates with language models via MCP or direct API calls, passing editor context (file content, cursor position, diagnostics) to the model. Suggestions are displayed inline in the editor and can be accepted or rejected by the user. The framework handles prompt engineering, context window management, and result formatting.

Provides a translation system that enables the IDE to support multiple languages. The i18n package manages translation strings, language detection, and dynamic language switching without requiring IDE restart. Translations are stored in JSON files organized by language code. The system supports pluralization, variable interpolation, and context-specific translations. Language preference is persisted and restored across sessions.

Provides debugging capabilities including breakpoint management, step-through execution, and variable inspection. The debugging system communicates with debug adapters (via the Debug Adapter Protocol) running on the backend, which interface with language-specific debuggers (GDB, LLDB, Python debugger, etc.). The frontend displays the call stack, variables, and watches, and allows users to set breakpoints and control execution. Debug state is managed per debug session.

Implements a plugin/extension system built on dependency injection (DI) containers that allows developers to register modules, services, and contributions at runtime. Modules can declare dependencies, lifecycle hooks (startup, shutdown), and contributions to extension points (menu items, keybindings, views). The framework uses a contribution registry pattern where modules register implementations of interfaces, enabling loose coupling and dynamic composition of IDE features.

Wraps Microsoft's Monaco Editor (the editor component from VSCode) with IDE-specific enhancements including language server protocol (LSP) support, syntax highlighting, code completion, diagnostics, and refactoring. The editor package provides a service layer that manages editor instances, handles file-to-editor mapping, and coordinates with language services running on the backend. Supports multiple editor instances with independent state and synchronized file content.

Provides a unified file system API that abstracts away differences between local file systems (Node.js fs), browser-based storage (IndexedDB, LocalStorage), and remote file systems (SSH, cloud storage). The file-service package implements a FileSystemProvider interface that allows different backends to be plugged in. The framework handles file watching, caching, and synchronization across the client-server boundary, enabling the same IDE code to work with different storage backends.

Implements a constraint-based layout system (main-layout package) that manages IDE panels (editor, explorer, terminal, output) with resizable sections, collapsible sidebars, and customizable arrangements. The layout engine uses a tree-based data structure to represent panel hierarchy and supports drag-and-drop reorganization. Panels are registered via the contribution system, enabling modules to add new panels without modifying core layout code. State is persisted to enable layout restoration across sessions.

Provides a terminal emulator integrated into the IDE that can spawn and manage multiple terminal instances, each running arbitrary shell commands or scripts. The terminal uses a PTY (pseudo-terminal) on the backend to provide full terminal emulation including color support, cursor control, and signal handling. Terminal output is streamed to the frontend via the RPC layer, and user input is sent back to the backend. Supports custom shell configuration and environment variables.

Implements a search system that indexes workspace files and provides fast full-text search with regex support, case sensitivity options, and whole-word matching. The search-service package handles indexing on the backend and communicates results to the frontend via RPC. Supports incremental search (results update as you type) and replace operations with preview before applying changes. Search results are displayed in a dedicated panel with file and line number context.

Provides a centralized preferences system that stores IDE settings (editor font size, theme, keybindings) with schema validation and type safety. Settings are defined via JSON schemas that specify allowed values, defaults, and descriptions. The preferences-service package handles persistence (to disk or cloud), merging of user and workspace settings, and broadcasting changes to all components. Components can subscribe to preference changes and react automatically.

Implements a theming system that allows users to customize IDE colors, fonts, and visual styles. Themes are defined as JSON objects with color tokens (e.g., 'editor.background', 'button.foreground') that map to CSS variables. The theme-service package handles theme loading, validation, and application to all UI components. Supports both light and dark themes with automatic switching based on system preferences. Custom themes can be created by users or installed from extensions.