continuedev/continue

This release delivers a comprehensive overhaul of the autocomplete engine, introducing a modular architecture with dedicated services for context retrieval, ranking, and filtering, alongside a new 'Next Edit' feature for predictive code changes. The CLI is significantly enhanced with a modern React-based UI, a robust permissions system, and support for subagents and hooks. Under the hood, the codebase has been cleaned up by removing legacy LLM providers, old React apps, and deprecated scripts, while introducing a new SDK for programmatic access to Hub APIs.

A new Jira Issues context provider has been added, allowing users to reference Jira issues directly in the editor. The provider fetches issue details (summary, description, and comments) and displays them as context items. It supports configuration for domain, credentials, issue query, API version, and max results, and includes a deprecation notice suggesting migration to the Atlassian MCP server.

core/context/providers/JiraIssuesContextProvider · high confidence

New Tree-sitter query files have been added to the VS Code extension to extract static context for TypeScript. The changes introduce queries to capture function signatures (including parameters, return types, and import statements) and type declarations (including type aliases, interfaces, and enums). These additions enable the extension to better understand and navigate TypeScript code by providing structured data about function and type definitions.

extensions/vscode/tree-sitter/static-context-queries · high confidence

Added new helper functions in core/nextEdit/diff/diff.ts to support the Next Edit feature. These include getOffsetPositionAtLastNewLine and getRenderableDiffWithGutterAnnotations for calculating cursor offsets and generating renderable diffs with gutter annotations, as well as checkFim to detect purely additive (FIM) changes. A corresponding test file (diff.vitest.ts) was added to verify the FIM detection logic.

core/nextEdit/diff · high confidence

The CLI now includes a new \apiClient\ module that provides a typed, authenticated HTTP client for making GET, POST, PUT, and DELETE requests to the Continue API, along with an \apiKeyValidation\ module that validates Anthropic API key formats. Additionally, a \clipboard\ module was added to detect and retrieve image data from the system clipboard across macOS, Windows, and Linux, and a \fileWatcher\ module was introduced to monitor directory changes while respecting ignore patterns for common non-essential files. These utilities support the CLI's headless and interactive modes by handling external interactions and network communication.

extensions/cli/src/util · high confidence

The @xenova/transformers library has been added to the vendor modules, providing a full suite of machine learning capabilities including model loading, tokenization, and pipeline execution. This includes support for ONNX runtime backends (Web and Node), configuration management, and various utility functions for audio, image, and text processing. The integration enables the application to run transformer-based models directly in the browser or Node.js environments.

core/vendor/modules/@xenova/transformers/src · high confidence

Added chat and edit prompt templates for multiple LLMs, including Llama 2/3, Anthropic, DeepSeek, Phi-2, Zephyr, and others, with corresponding unit tests to ensure correct prompt generation.

core/llm/templates · high confidence

A new constant file, AutocompleteLanguageInfo.ts, was added to the core/autocomplete/constants directory. This file defines a standardized interface and configuration objects for various programming languages (including TypeScript, JavaScript, Python, Java, C++, C\#, Scala, Go, Rust, Haskell, PHP, Ruby, Swift, Kotlin, Clojure, and Julia). Each language entry specifies properties such as top-level keywords, single-line comment characters, and end-of-line indicators, which are used by the autocomplete system to apply language-specific filtering and formatting rules.

core/autocomplete/constants · high confidence

Added the \all-MiniLM-L6-v2\ model files (README, config, tokenizer, and vocabulary) to the VS Code extension. These files provide the necessary assets for the extension to locally generate codebase embeddings using the \transformers.js\ library, enabling local semantic search and code understanding features without requiring external API calls.

extensions/vscode/models · high confidence

Added a new manual-testing-sandbox directory containing a variety of sample files for testing purposes, including a React component (AdvancedPage.tsx), Java classes (Calculator.java, Main.java), a Dockerfile, a Claude Desktop configuration, a CloudFormation template, JSON data, a Jupyter notebook, Python scripts, and multiple TypeScript files for code editing exercises (next-edit).

manual-testing-sandbox · high confidence

The CLI now includes a new utility to determine if a model is recommended for use with the \cn\ command. This change introduces a \isModelCapable\ function that checks if a model's name or model property matches a set of supported patterns (including GPT, Claude, Gemini, Llama, Mistral, Qwen, Kimi, Nemotron, and Grok). Tests confirm that models from providers like OpenAI, Anthropic, Google, and others are correctly identified as capable, while unsupported models (like Falcon or StarCoder) are marked as not capable. This allows the CLI to provide better guidance on which models are supported.

extensions/cli/src/utils · high confidence

A new pre-commit hook has been added to the .husky directory, which runs 'npx lint-staged' before each commit. This ensures that staged files are automatically linted and formatted according to the project's standards, helping to maintain code quality and consistency.

.husky · high confidence

New tree-sitter tag query files have been added for C, C\#, C++, Emacs Lisp, Elixir, Elm, Go, Java, JavaScript, OCaml, PHP, Python, QL, Ruby, Rust, and TypeScript. These files define how the editor identifies and references code elements like classes, functions, and modules, enabling improved code navigation and symbol indexing for these languages.

extensions/vscode/tag-qry · high confidence

The extension now includes new tree-sitter query files for C, C\#, C++, Elisp, Elixir, Go, Java, JavaScript, OCaml, PHP, Python, Rust, TypeScript, and QL. These additions enable the IDE to recognize and navigate definitions and references for these languages, improving code navigation and autocomplete features for users working in these languages.

extensions/vscode/tree-sitter/code-snippet-queries · high confidence

New tree-sitter query files were added to the root-path-context-queries directory for C++, Go, Java, PHP, Python, and TypeScript. These queries define how to extract function parameters, return types, class inheritance, and interface implementations from the source code AST. This enables the editor to better understand and provide context for these language constructs.

extensions/vscode/tree-sitter/root-path-context-queries · high confidence

New utility functions \rifWithContentsToContextItem\ and \ctxItemToRifWithContents\ were added to \core/commands/util.ts\ to facilitate the conversion between \ContextItemWithId\ and \RangeInFileWithContents\ objects. The implementation includes parsing line numbers from item names and handling edge cases such as missing URIs or invalid line formats. Corresponding unit tests were added in \core/commands/util.vitest.ts\ to verify the correct behavior of these conversion utilities.

core/commands · high confidence

A new module, workspaceBlocks.ts, has been introduced to handle the creation and naming of configuration files for different block types (models, context, rules, docs, prompts, and MCP servers). This includes logic for generating default content for each block type and ensuring unique filenames with automatic counter suffixes. Corresponding unit tests have been added to verify the filename generation and content creation logic.

core/config/workspace · high confidence

The core/llm/utils directory introduces several new utility modules: calculateRequestCost.ts provides a comprehensive cost calculation engine for Anthropic and OpenAI models, supporting token, cache write, and cache read pricing; extractContentFromCodeBlocks.ts and extractPathsFromCodeBlocks.ts add regex-based parsers to extract file paths and content from markdown code blocks; getSecureID.ts generates a persistent UUID for LLM prompts; and retry.ts implements a robust retry mechanism with exponential backoff, jitter, and specific handling for HTTP 429/5xx errors and embedded rate limits. Each of these new files is accompanied by corresponding test files (.test.ts or .vitest.ts) to verify their behavior.

core/llm/utils · high confidence

The CLI extension now includes a complete build and testing infrastructure. A new \build.mjs\ script uses esbuild to bundle the CLI into a single distributable file, including local packages like \@continuedev/config-yaml\ and \@continuedev/openai-adapters\. A \smoke-test.mjs\ script verifies the build output, checking for bundle existence, executable wrapper scripts, version/help commands, bundle size, and metadata. Configuration files for TypeScript (\tsconfig.json\, \tsconfig.build.json\), ESLint (\eslint.config.js\), and Vitest (\vitest.config.ts\, \vitest.e2e.config.ts\, \vitest.smoke-api.config.ts\) are added to support development and testing workflows. Additional files include \.env.example\ for environment variables, \.gitignore\ and \.npmignore\ for build artifacts, \.releaserc.json\ for semantic release configuration, and \validate-aliases.mjs\ to ensure all local package aliases are correctly defined in the build script.

extensions/cli · high confidence

The CLI commands have been reorganized into a modular structure with a new \BaseCommandOptions\ interface that standardizes shared flags like \--config\, \--org\, \--rule\, \--mcp\, \--model\, \--prompt\, \--allow\, \--ask\, \--exclude\, and \--agent\ across all commands. The \chat\ command now supports forking and resuming sessions, while the \ls\ command provides JSON and TUI modes for listing sessions. A new \review\ command (previously \checks\) analyzes code diffs and applies patches. The \commands\ module centralizes slash command registration, supporting system, assistant, and skill-based commands, with remote mode filtering. Tests have been added for \ls\, \serve\ initial prompt logic, and command registration.

extensions/cli/src/commands · high confidence

The LLM core now supports a wider range of providers and models, including GPT-5, GPT-5.1, GPT-5.1, and GPT-5.1.1, as well as new providers such as CometAPI, ClawRouter, DeepInfra, DeepSeek, Flowise, InceptionLabs, LlamaStack, Mercury, MiniMax, Moonshot AI, Nebius, Novita, Scaleway, Sambanova Cloud, SiliconFlow, Tensorix, and Venice. Additionally, the system now handles reasoning content and redacted thinking for models like Anthropic's Claude and Google's Gemini, and supports prompt caching for Anthropic and Google. The update also includes fixes for various providers including Ollama, vLLM, and Azure OpenAI, and improves error handling and streaming for multiple LLMs.

core/llm/llms · high confidence

The custom fetch implementation, proxy handling, and certificate management have been extracted from the main codebase into a standalone \packages/fetch\ package. This new package includes a patched version of \node-fetch\ to resolve premature close errors, along with dedicated modules for SSL certificate caching (\certs.ts\), agent options (\getAgentOptions.ts\), and streaming utilities (\stream.ts\). The extraction is accompanied by comprehensive test coverage for certificate handling, agent configuration, and stream parsing.

packages/fetch · high confidence

The edit and apply workflows now support infinite streaming, allowing the system to handle very large files or ranges that exceed the standard token limits. This is achieved through a new \recursiveStream\ mechanism that automatically continues generating content when the initial token budget is reached, ensuring that large edits are not silently truncated. The implementation includes an \ApplyAbortManager\ to handle cancellation of these long-running streams and adds specific handling for the Inception LLM's Mercury model.

core/edit · high confidence

Added new utility functions and a state tracker in core/utils to correctly identify and process nested markdown code blocks. The \MarkdownBlockStateTracker\ and \headerIsMarkdown\ helpers now support detecting various markdown header identifiers (md, markdown, gfm, github-markdown) and file extensions, enabling the \stopAtLinesWithMarkdownSupport\ stream to properly handle complex nested structures in markdown files. This ensures that markdown content is processed correctly when it contains other code blocks or nested markdown syntax.

core/utils · high confidence

The @continuedev/llm-info package has been introduced to centralize information about Large Language Models, including embedding, reranking, and other models. This package provides a structured way to manage model metadata such as context length, maximum completion tokens, supported use cases (chat, autocomplete, rerank, embed), and provider-specific configurations. The package includes type definitions for LlmInfo and ModelProvider, along with provider-specific files for OpenAI, Anthropic, Gemini, Cohere, and others, enabling consistent model information across the application.

packages/llm-info · high confidence

The OpenAI adapters package now supports configurable prompt caching for Anthropic models, allowing users to select from multiple caching strategies (none, system-only, system-and-tools, or optimized) to reduce latency and cost. Additionally, the adapters now include an implementation using the Vercel AI SDK, which provides an alternative, feature-rich path for supported providers (OpenAI, Anthropic, Google, xAI, DeepSeek, OpenRouter, and ClawRouter) alongside the existing native implementations.

packages/openai-adapters · high confidence

A new abstract base class, BaseContextProvider, is introduced in core/context/index.ts to standardize context provider implementations. This class enforces a consistent interface by requiring subclasses to implement the getContextItems method and providing default implementations for loadSubmenuItems and deprecationMessage, simplifying the creation of new context providers.

core/context · high confidence

Added a new CodeRenderer class that uses the Shiki library to perform syntax highlighting on code strings and return them as SVG representations. This new component supports theme switching, handles diff line annotations, and provides a singleton instance for rendering code in the application.

core/codeRenderer · high confidence

Added LocalPlatformClient to handle secret resolution from local environment files (.env) and process.env, enabling the YAML config system to access local secrets. The implementation includes new files: LocalPlatformClient.ts for secret resolution logic, loadLocalYamlBlocks.ts for unrolling local YAML blocks, default.ts for default configurations, models.ts for LLM model configuration, and yamlToContinueConfig.ts for converting YAML to internal config. Tests are added in LocalPlatformClient.vitest.ts, loadYaml.vitest.ts, and models.vitest.ts to verify secret resolution and model configuration.

core/config/yaml · high confidence

The core/nextEdit directory now contains the foundational components for the Next Edit feature. This includes a singleton DocumentHistoryTracker to manage document AST and content history, a NextEditProvider to handle completion logic and state, and a PrefetchQueue for background inference results. Supporting infrastructure includes a NextEditLoggingService for tracking outcomes, a NextEditEditableRegionCalculator with multiple strategies (naive, sliding, static), and model-specific providers (Instinct, Mercury Coder) managed by a factory. The change also adds type definitions, constants, and utility functions to support this new capability.

core/nextEdit · high confidence

Added a new RootPathContextService that provides code snippets for autocomplete by traversing the AST, querying language-specific Tree-sitter files, and fetching definitions from the IDE. This service caches results using an LRU cache and filters out ignored paths, enabling the autocomplete system to pull in relevant code context from the root path of the project.

core/autocomplete/context/root-path-context · high confidence

Added a new Rust library in the sync directory that implements codebase indexing and synchronization. This includes a Merkle tree implementation for tracking file changes, a SQLite-based database for storing code chunks and tags, and logic to compute, add, and retrieve indexed content. The module exposes functions to sync results, add chunks, and retrieve data, facilitating efficient codebase indexing and synchronization.

sync · high confidence

The binary's core entry point now supports a TCP-based messenger for debugging. When the \CONTINUE\_DEVELOPMENT\ environment variable is set to \true\, the binary starts a TCP server on \127.0.0.1:3000\ to handle IPC messages, allowing developers to connect to the core for debugging purposes. Otherwise, it defaults to the standard IPC messenger.

binary/src · high confidence

The CLI now includes a new \cn review\ command that automatically discovers and runs code review checks. The command scans for local review definitions in \.continue/agents/\ and \.continue/checks/\ directories, providing a fallback when no hub-based checks are configured. The implementation introduces a new \review\ command directory containing components for progress tracking (\ReviewProgress.tsx\), diff context computation (\diffContext.ts\), report rendering (\renderReport.ts\), review resolution (\resolveReviews.ts\), and a worker process (\reviewWorker.ts\) that executes agents in isolated git worktrees. Tests are added to verify local discovery logic.

extensions/cli/src/commands/review · high confidence

The CLI now includes a new permissions system that controls which tools the AI can use and how. Users can configure permissions via a \permissions.yaml\ file or CLI flags, with three states: 'allow' (auto-execute), 'ask' (prompt for confirmation), and 'exclude' (hide from the model). By default, read-only tools are allowed, while write operations and terminal commands require confirmation in TUI mode but are allowed in headless mode. The system supports wildcard patterns and argument-based matching for granular control.

extensions/cli/src/permissions · high confidence

Added the abstract \BaseNextEditModelProvider\ class and concrete implementations for \Instinct\ and \MercuryCoder\ models in the \core/nextEdit/providers\ directory. This establishes the internal architecture for the new Next Edit capability, defining how prompts are constructed and how completions are extracted for specific model types.

core/nextEdit/providers · high confidence

The codebase retrieval feature now uses a repo map to identify relevant files for a given query. This new capability allows the system to understand the project structure and select the most appropriate files, improving the relevance of context provided to the model. The implementation includes a new \repoMapRequest.ts\ file that handles the logic for generating and using the repo map, and a \retrieval.ts\ file that orchestrates the retrieval pipeline. Additionally, a \util.ts\ file provides a utility for deduplicating chunks, and corresponding tests in \utils.vitest.ts\ ensure the deduplication logic works correctly.

core/context/retrieval · high confidence

Added new modules in core/nextEdit/context to support edit history and context generation. EditAggregator implements a singleton pattern to cluster small edits based on time, line distance, and edit count, while diffFormatting provides utilities to generate unified diffs and extract metadata. AutocompleteContextFetching introduces a function to retrieve formatted autocomplete context for a given position, and processNextEditData handles logging edit data to the dev data logger. These changes enable the system to track, cluster, and log user edits for downstream features like telemetry and autocomplete context.

core/nextEdit/context · high confidence

The \core/edit/lazy\ directory now contains a new 'lazy edit' system that enables faster, deterministic code block application. The \applyCodeBlock\ function now attempts to apply changes instantly using a deterministic algorithm (\deterministicApplyLazyEdit\) or a unified diff, falling back to a streaming LLM-based approach (\streamLazyApply\) if needed. This includes new helper files for AST traversal (\findInAst\), replacement logic (\replace.ts\), and model-specific prompts (\prompts.ts\). Comprehensive unit tests have been added for the deterministic logic and stream processing.

core/edit/lazy · high confidence

Added new modules for codebase indexing: a \ChunkCodebaseIndex\ implementation that manages SQLite storage for chunks and tags, alongside dedicated chunkers for Markdown (\markdown.ts\) and code (\code.ts\, \basic.ts\). The code chunker leverages tree-sitter to extract and collapse function/class definitions, while the markdown chunker recursively splits documentation by headers. Tests were added to verify chunking behavior, size limits, and index updates.

core/indexing/chunk · high confidence

The core/protocol/messenger directory now contains the new messaging infrastructure for the application. The diff introduces a generic InProcessMessenger class that handles synchronous and asynchronous message passing between the core and the IDE, along with specific MessageIde and ReverseMessageIde classes that implement the IDE interface by routing calls to and from the protocol. This replaces the previous mechanism for handling IDE interactions, providing a more structured and type-safe way to manage messages between the core application logic and the IDE environment.

core/protocol/messenger · high confidence

Added a new \systemMessageTools\ module that enables pluggable frameworks for generating system messages and intercepting tool calls. The \buildToolsSystemMessage.ts\ file introduces logic to generate structured system messages for tools, distinguishing between predefined and dynamic tools. The \interceptSystemToolCalls.ts\ file adds a streaming interceptor that detects and parses tool calls from markdown code blocks, converting them into proper tool call deltas. The \convertSystemTools.ts\ file provides utilities for converting tool call states into system tool calls and outputs. The \types.ts\ file defines the \SystemMessageToolsFramework\ interface, which allows different models or providers to implement their own parsing and formatting logic. This change supports a more flexible and extensible approach to handling tool calls in the system message.

core/tools/systemMessageTools · high confidence

Added new TypeScript interfaces and a client implementation for communicating with the Continue server. The \IContinueServerClient\ interface and its \ContinueServerClient\ implementation provide methods to fetch remote configuration (\getConfig\) and retrieve cached embeddings or chunks from the server's indexing cache (\getFromIndexCache\). Additionally, a \getHeaders\ utility was added to generate standard request headers including extension version, OS, and unique ID.

core/continueServer · high confidence

The \binary\ directory now contains a complete, self-contained build system for the Continue core engine, enabling it to be packaged and run from any IDE or platform. This includes a new \build.js\ script that bundles TypeScript with esbuild, copies necessary assets (like tree-sitter WASM files), and prepares the environment for packaging with pkg. The setup also adds a \core-dev-server.js\ for debugging the binary in IntelliJ, a \prompt-logs.js\ utility for cross-platform log watching, and updated \tsconfig.json\ to support the new structure. This change provides a unified, cross-platform binary that can be integrated into different host applications.

binary · high confidence

Added a new StaticContextService that provides static code context to the autocomplete engine. The service extracts relevant types and headers from the codebase using Tree-sitter AST analysis, allowing the autocomplete to suggest more accurate completions based on the current file's type information and header declarations.

core/autocomplete/context/static-context · high confidence

Added new diff utilities in core/diff to handle code changes more effectively. This includes a streaming diff implementation (streamDiff) that processes line-by-line updates, a Myers diff algorithm (myers.ts) for efficient line and character-level diffing, and supporting utilities (util.ts) for line matching and stream processing. Comprehensive test coverage (vitest files) validates the new diff logic, including edge cases like trailing whitespace, indentation, and empty lines.

core/diff · high confidence

The \packages/config-types\ package now provides a formalized, Zod-based schema for validating the application's configuration. This introduces a \ModelDescription\ type that supports a wider range of AI providers (including Ollama, AWS SageMaker, OVHcloud, Nebius, Scaleway, Watsonx, and MiniMax) and allows configuration of completion options such as temperature, topP, and context length. The schema also defines types for embeddings providers, UI options (including a new \showChatScrollbar\ setting), tab autocomplete options, slash commands, custom commands, context providers, and rerankers, ensuring that the configuration file adheres to the expected structure.

packages/config-types · high confidence

Added a new subagent execution framework in the CLI extension, including an executor that manages child sessions, retrieves configured agents, and handles tool permissions and system message overrides. The implementation introduces a 'Subagent' tool that allows the main agent to delegate specialized tasks to configured subagents, with support for dynamic agent discovery and output streaming.

extensions/cli/src/subagent · high confidence

The Continue SDK is introduced as a new package providing programmatic access to Continue's Hub APIs and functionality. This includes a TypeScript implementation (in the \/typescript\ directory) and a Python implementation (in the \/python\ directory), both designed as drop-in replacements for OpenAI's client libraries. The SDK exposes a \Continue.from()\ method to initialize and use Continue assistants with an OpenAI-compatible interface. The Python SDK is auto-generated from an OpenAPI specification (\openapi.yaml\) using OpenAPI Generator, and includes generated client code, models, and documentation. End users can install the published packages via \npm install @continuedev/sdk\ or \pip install continuedev\.

packages/continue-sdk · high confidence

Added a new GitHub Action at actions/general-review that automates code review for pull requests and PR comments. The action validates user permissions and repository context before executing the review, and includes helper scripts to generate review prompts and handle error states. This enables automated AI-assisted code review workflows within the repository.

actions/general-review · high confidence

Added new slash commands to the built-in legacy set: 'cmd' to generate and run shell commands, 'commit' to generate commit messages, 'http' to call external HTTP endpoints, 'onboard' to provide a project overview, 'review' to analyze code quality, and 'share' to export chat sessions as Markdown. These commands are now available via the 'built-in-legacy' source, each implementing the standard SlashCommand interface with specific functionality for their respective tasks.

core/commands/slash/built-in-legacy · high confidence

Added a new DataLogger class in core/data/log.ts that captures local development data events (such as tokens generated and chat interactions) and writes them to local JSONL files. Additionally, a new SQLite database implementation (core/data/devdataSqlite.ts) was introduced to store and aggregate token generation metrics by day and by model. The changes also include corresponding unit tests in core/data/log.vitest.ts to verify the logging behavior.

core/data · high confidence

Added a new CompletionProvider class in core/autocomplete that manages autocomplete requests, caching, and error handling, alongside new type definitions for autocomplete inputs and outputs.

core/autocomplete · high confidence

The \core/protocol\ directory has been restructured to define a strict, typed interface between the IDE, webview, and core logic. This change introduces new TypeScript files (\core.ts\, \ide.ts\, \webview.ts\, etc.) that explicitly map out every message type and payload for internal communication. For users, this ensures more reliable message passing between the editor and the Continue interface, reducing the likelihood of communication errors or lost commands. The new protocol also introduces specific message types for features like 'nextEdit' predictions and 'MCP' server management, supporting the platform's evolving capabilities.

core/protocol · high confidence

The \core/context/mcp\ directory now contains the core implementation for Model Context Protocol (MCP) connections, including \MCPConnection\ for handling transport logic (stdio, SSE, WebSocket, Streamable HTTP), \MCPManagerSingleton\ for managing multiple server connections, and \MCPOauth\ for handling OAuth authentication flows. This includes support for custom headers, environment variable resolution, working directory (cwd) configuration, and status tracking. Tests have been added for all three modules.

core/context/mcp · high confidence

Added several new React components for the CLI interface: AppRoot as the main entry point wrapping TUIChat with NavigationProvider; ColoredDiff and DiffViewer for displaying git diffs with syntax highlighting and word-level diffing; ConfigSelector for choosing local or assistant configurations; EditMessageSelector for editing past user messages in chat history; FileSearchUI for fuzzy-matching file searches; IntroMessage for displaying ASCII art, model info, and tips; JobsSelector for managing background jobs; and LoadingAnimation for visual feedback. Tests were added for ColoredDiff, EditMessageSelector, IntroMessage, and ImagePaste functionality.

extensions/cli/src/ui · high confidence

The CLI now includes a suite of new UI components for the terminal interface. A bottom status bar displays the current mode, context usage percentage, and verbose cost information. The chat screen content area renders user input, quiz prompts, and tool permission selectors. Additional components include a checklist display for task lists, a mode indicator for non-normal modes, and a resource debug bar for monitoring memory, CPU, and event loop lag. The chat history is rendered using a static component that splits large messages to reduce flickering, and session selectors now include loading states.

extensions/cli/src/ui/components · high confidence

Added new utility functions in core/util/handlebars to support advanced template rendering. handlebarUtils.ts introduces helpers for registering asynchronous Handlebars helpers and preparing templated filepaths by replacing file paths with unique letter keys to avoid escaping issues. renderTemplatedString.ts provides a high-level function that compiles a Handlebars template, processes file content, and resolves all helper promises, enabling more robust and secure template rendering for user inputs.

core/util/handlebars · high confidence

The codebase indexing system has been refactored to support multiple, distinct indexing strategies. A new \CodebaseIndexer\ orchestrates the indexing process, while specific index implementations like \CodeSnippetsCodebaseIndex\ (for code snippets), \FullTextSearchCodebaseIndex\ (for SQLite-based full-text search), and \LanceDbIndex\ (for vector embeddings) are now separate, testable units. This change introduces a more modular and extensible approach to codebase indexing, allowing for different indexing backends and improved test coverage for each index type.

core/indexing · high confidence

Added several new tools for the agent: a \codebase\ tool for semantic codebase search, a \readFileRange\ tool to read specific line ranges from files, a \createRuleBlock\ tool to generate markdown rule files, and a \createNewFile\ tool to create new files. Also introduced \readSkill\ to load markdown skills, \requestRule\ to fetch rule content by name, and \fetchUrlContent\ to retrieve and truncate web page content. These tools expand the agent's ability to interact with the codebase, manage rules, and access external content.

core/tools/implementations · high confidence

A new \SystemMessageToolCodeblocksFramework\ implementation has been added to \core/tools/systemMessageTools/toolCodeblocks\. This introduces a structured codeblock format (using \\\tool and \\\tool\definition) for defining and calling tools in the system message, replacing or supplementing previous formats. The implementation includes parsers (\parseSystemToolCall.ts\) and interceptors (\interceptSystemToolCalls.ts\) to handle this new syntax, along with comprehensive unit tests (\\.vitest.ts\) verifying the generation and parsing of these codeblocks.

core/tools/systemMessageTools/toolCodeblocks · medium confidence

A new ContextRetrievalService has been introduced to centralize and manage the retrieval of context snippets for autocomplete. This service coordinates multiple context sources, including import definitions, root-path context, and static context, allowing the autocomplete system to gather relevant code snippets from various parts of the codebase to improve suggestion quality.

core/autocomplete/context · high confidence

Added several new scripts to the \scripts\ directory to improve the development workflow. \build-packages.js\ enables parallel building of internal packages (config-types, terminal-security, fetch, config-yaml, openai-adapters, continue-sdk) with dependency-aware phases. \install-dependencies.sh\ and \install-dependencies.ps1\ automate the full dependency installation and build process for Unix and Windows respectively, including Node.js version checks. \oneper\ is a new utility for installing the VS Code extension from PR builds or the latest pre-release, supporting automatic cron-based updates. \analyze-file-hotspots.js\ provides a new way to analyze git history to find the most frequently edited files. \uninstall.js\ and \scripts/util/index.js\ provide cleanup and shared utility functions for the new scripts.

scripts · high confidence

The \extensions/vscode/e2e/actions\ directory now contains a set of new end-to-end test helper classes that encapsulate common user interactions. \EditActions\ provides methods to invoke edit shortcuts and accept/reject edits in both the GUI and code lens. \AutocompleteActions\ includes helpers to test completions and force autocomplete triggers. \NextEditActions\ supports testing the Next Edit feature, including forcing suggestions and verifying decorations. \GUIActions\ offers utilities for managing the Continue GUI, switching between iframes, selecting models and modes, sending messages, and toggling tool policies. \GlobalActions\ handles workspace setup, file creation, and status bar interactions. \KeyboardShortcutsActions\ provides utilities for simulating keyboard input. These changes introduce new capabilities for testing the editor's editing, autocomplete, and GUI features.

extensions/vscode/e2e/actions · high confidence

The CLI now supports a hooks system that allows external tools to intercept and modify the behavior of the CLI. This includes a new \HookService\ that loads configuration from settings files (supporting both \.continue\ and \.claude\ directories), a \hookRunner\ that executes command or HTTP-based hooks, and convenience functions in \fireHook.ts\ to trigger events like \PreToolUse\, \PostToolUse\, \UserPromptSubmit\, and more. The system is compatible with Claude Code's hook format, allowing users to write hooks that work across both tools.

extensions/cli/src/hooks · high confidence

Added new installation scripts for the Continue CLI: a PowerShell script (install.ps1) for Windows and a Bash script (install.sh) for Unix-like systems (macOS, Linux, WSL, Git Bash). These scripts automate the installation of Node.js (via fnm) and the @continuedev/cli package, ensuring the required Node.js version (20.20.1) is present before proceeding.

extensions/cli/scripts · high confidence

A new postprocessing module has been introduced for autocomplete completions, featuring a \postprocessCompletion\ function that applies several cleaning and formatting rules. It removes markdown code block delimiters (backticks) from the start and end of completions, filters out empty or whitespace-only results, and prevents duplicate line repetitions. Additionally, it applies model-specific adjustments: trimming leading spaces for Codestral, stripping Qwen3 thinking markers, removing repeated prefixes for Granite, handling indentation for Mercury, and stripping trailing file separators for Gemini/Gemma models.

core/autocomplete/postprocessing · high confidence

The \core/promptFiles\ directory now contains the implementation for a new prompt file system. This includes \createNewPromptFile.ts\ to generate new \.prompt\ files with default templates, \getPromptFiles.ts\ to scan and read prompt and rule files from workspace and global directories, \parsePromptFile.ts\ to handle YAML frontmatter and system message extraction, and \initPrompt.ts\ which provides a slash command to automatically generate a \CONTINUE.md\ project guide. These changes introduce a structured way to define, parse, and initialize prompts and rules, replacing or augmenting previous ad-hoc handling.

core/promptFiles · high confidence

Added four new prompt templates in the .continue/prompts directory: core-unit-test.prompt for generating Jest-based unit tests for core utilities, update-llm-info.prompt for updating provider information in the llm-info package, and sub-agent-background.md and sub-agent-foreground.md for invoking the Continue CLI in background and foreground modes respectively.

.continue/prompts · high confidence

A new \packages/terminal-security\ package has been introduced to handle terminal command evaluation. It provides an \evaluateTerminalCommandSecurity\ function that parses shell commands and applies security policies (disabled, allowedWithPermission, allowedWithoutPermission) to prevent dangerous operations like system destruction, privilege escalation, and permission modification. The package includes type definitions, a test suite, and configuration files, effectively extracting terminal security logic into a dedicated, reusable component.

packages/terminal-security · high confidence

The core/tools area introduces a new \applyToolOverrides\ function that allows configuration to modify tool descriptions, display titles, action phrases, and system message content, or disable tools entirely. This is supported by a new \parseArgs\ module that provides robust argument parsing, including a \coerceArgsToSchema\ function that ensures string-typed parameters are correctly serialized from JSON objects. Additionally, \mcpToolName\ standardizes MCP tool naming by prefixing them with the server name, and \builtIn.ts\ defines the registry of built-in tool names.

core/tools · high confidence

The documentation site has been rebuilt as a static Next.js application, introducing a complete visual and structural overhaul. Users will see a modernized layout featuring a persistent sidebar for navigation, a table of contents for each page, and a client-side search powered by Orama. The new design includes a 'Copy page' button, improved code block styling with copy-to-clipboard functionality, and a dark mode toggle. The site now supports redirects, handles 404s gracefully, and renders MDX content with custom components like accordions, tabs, and callouts.

docs-site · high confidence

The context provider system has been refactored to support a modular, pluggable architecture. Each provider (e.g., Clipboard, Code, Database, DebugLocals, Diff, Discord, Docs, File, FileTree) is now a distinct, standalone class that implements the \IContextProvider\ interface. This change allows for easier extension, better separation of concerns, and more flexible configuration. Users will see a more consistent and extensible way to add and manage context providers, with each provider handling its own logic for fetching and formatting context items.

core/context/providers · high confidence

The repository now enforces consistent code style and quality through new configuration files. A \.prettierrc\ file defines formatting rules (2-space tabs, semicolons, etc.), and a \.prettierignore\ file excludes generated or build artifacts from formatting. Additionally, a new \.eslintrc.shared.json\ file introduces shared ESLint rules, including checks for floating promises, misused promises, and import ordering. A \.continueignore\ file is also added to exclude IDE-specific files (\.idea/\, \.vscode/\) and other non-essential files from version control.

(repo-wide) · high confidence

The application now loads and processes MCP server configurations from JSON files located in the \.continue/mcpServers\ directory (both global and per-workspace). This change introduces a new loader (\loadJsonMcpConfigs\) that parses JSON files supporting both the 'Claude Code' and 'Claude Desktop' configuration formats, converting them into a standard internal representation. Users can now define their MCP servers using JSON files, which are then validated, deduplicated, and converted for use by the system.

core/context/mcp/json · high confidence

The system now loads rules and skills from markdown files located within the codebase. Rules can be defined in \rules.md\ files placed alongside code, with automatic scope inference based on the file's directory. Additionally, the system loads agent configuration files (AGENTS.md, AGENT.md, CLAUDE.md) and supports skills defined in \.claude/skills\ directories. This enables developers to keep configuration close to the relevant code, improving maintainability and discoverability of project-specific instructions.

core/config/markdown · high confidence

The \packages/config-yaml\ directory was created, introducing a new \config-yaml\ package that manages the configuration schema and loading logic. This includes a \.gitignore\ and \.npmignore\ for build artifacts, a comprehensive \CHANGELOG.md\ tracking the package's history, and the foundational files for the configuration system.

packages/config-yaml · high confidence

The \extension/scripts\ directory has been cleared of several Python and JavaScript files that were previously used for codebase indexing and TypeScript type generation. Specifically, \chroma.py\, \index.py\, \query.py\, \replace.py\, \run\_continue\_server.py\, \typegen.js\, and \update.py\ have been deleted, along with the \.gitignore\ and \README.md\ files in that folder. This removes the legacy mechanism for maintaining a local vector index of the codebase and generating types from JSON schemas, indicating a shift away from these specific client-side Python/JS scripts for these tasks.

extension/scripts · high confidence

The legacy LLM abstraction and its specific provider implementations have been removed from the codebase. This includes the base \LLM\ class, the \OpenAI\ and \HuggingFace\ provider classes, and associated utilities like \prompters.py\, \prompt\_utils.py\, and \utils.py\. This change eliminates the old synchronous and early asynchronous OpenAI integration patterns, as well as local model serving via Hugging Face transformers, in favor of a newer, unified LLM configuration system.

continuedev/src/continuedev/libs/llm · high confidence

The \extension/react-app\ directory, which contained the old React-based UI implementation (including components, Redux slices, and styles), has been completely removed. This cleanup eliminates the legacy codebase in favor of the current UI architecture.

extension/react-app · high confidence

The \activate.ts\ and \environmentSetup.ts\ files in the extension's activation directory have been removed. This eliminates the previous logic responsible for setting up the Python environment, managing the Continue server process, and handling initial extension activation tasks, indicating a shift away from this specific activation flow.

extension/src/activation · high confidence

The extension's legacy codebase has been removed, including the old bridge, commands, debug panel, decorations, and language libraries. Additionally, Segment telemetry has been removed from the extension, meaning the extension no longer sends usage data to Segment.

extension/src · high confidence

The \continuedev/models\ package had its core model classes and file system abstractions removed. Specifically, the \main.py\ (containing \Position\, \Range\, \AbstractModel\, \Traceback\), \filesystem.py\ (containing \RangeInFile\, \RangeInFileWithContents\, and the \FileSystem\ abstract base), \filesystem\_edit.py\ (containing \FileSystemEdit\, \FileEdit\, \EditDiff\, and related edit types), and \generate\_json\_schema.py\ were all deleted. This removes the previous implementation of file system operations, range tracking, and edit diffing from the models layer.

continuedev/src/continuedev/models · high confidence

The \policy\ and \step\ plugin directories have been removed from the codebase. This includes the pluggy-based hook specifications and implementations for policy and step execution, such as the \AlternatingPolicy\ and \HelloWorldStep\ examples. Users relying on these specific legacy plugin structures will need to migrate to the current plugin architecture.

continuedev/src/continuedev/plugins/policy, continuedev/src/continuedev/plugins/step · high confidence

Deleted the old server-side implementation of the notebook and IDE protocol, including \core.py\, \observation.py\, \policy.py\, \ide.py\, \ide\_protocol.py\, \main.py\, and \notebook.py\. This removes the previous architecture that managed sessions, agents, and websockets directly on the server, likely as part of a larger refactoring to move this logic elsewhere.

continuedev/src/continuedev/server · high confidence

Deleted the \copy\_codebase.py\, \map\_path.py\, \queue.py\, and \traceback\_parsers.py\ files from the \continuedev/libs/util\ directory. These modules, which previously handled codebase copying, path mapping, asynchronous message queuing, and Python traceback parsing, have been removed from the codebase.

continuedev/src/continuedev/libs/util · high confidence

The \extension/src/terminal\ directory no longer contains the \snoopers.ts\ and \terminalEmulator.ts\ files. This removes the custom terminal emulator and the associated \CommandCaptureSnooper\ and \PythonTracebackSnooper\ classes that previously intercepted terminal output to capture command lines and Python tracebacks. Users will no longer see terminal content processed by these specific snooping mechanisms.

extension/src/terminal · high confidence

The logic for determining whether an autocomplete suggestion should be multiline has been extracted into a new \shouldCompleteMultiline\ module. This module encapsulates the decision tree for multiline completions, including checks for single-line comments and language-specific rules, making the autocomplete classification more modular.

core/autocomplete/classification · high confidence

The CLI's internal architecture has been refactored to use a new service-based pattern. A generic BaseService class now provides lifecycle management (initialize, reload, cleanup) and state handling for all CLI services. New services have been introduced to manage specific concerns: ConfigService handles loading and merging configuration from files or hub slugs; ChatHistoryService manages conversation history and session state; BackgroundJobService tracks and controls concurrent background processes; and AuthService, ApiClientService, and AgentFileService manage their respective domains. Each service is now tested with comprehensive unit tests covering initialization, state changes, and error handling.

extensions/cli/src/services · high confidence

The autocomplete filtering logic has been restructured into a new \StreamTransformPipeline\ that chains character and line-level filters. This refactoring introduces dedicated modules for character streams (\charStream.ts\), line streams (\lineStream.ts\), and code block filtering (\filterCodeBlock.ts\), each with corresponding unit tests (\.vitest.ts\). The pipeline applies stop tokens, handles suffix matching, filters empty comments and path lines, and manages markdown block nesting, providing a more maintainable and testable foundation for autocomplete generation.

core/autocomplete/filtering/streamTransforms · high confidence

The codebase retrieval logic has been refactored into a modular pipeline system. A new \BaseRetrievalPipeline\ class now encapsulates shared retrieval logic, including full-text search, embeddings, and recently edited files. This is extended by two concrete implementations: \NoRerankerRetrievalPipeline\, which returns raw chunks without scoring, and \RerankerRetrievalPipeline\, which applies a reranker model to sort and filter results. This change introduces a more flexible and testable structure for how the AI retrieves relevant code context.

core/context/retrieval/pipelines · high confidence

A new file, core/deploy/constants.ts, was added to the project. This file defines a constants object containing a timestamp string and a secret key, alongside a getTimestamp() function that generates a modified timestamp string based on the current date and time.

core/deploy · high confidence

A .gitignore file was added to the core/vendor directory to exclude node\_modules from version control, alongside a README explaining that the directory contains vendored node\_modules (specifically transformers.js) to avoid sharp dependencies with native components.

core/vendor · high confidence

New Tree-sitter query files (cpp.scm, java.scm, python.scm, typescript.scm) were added to the import-queries directory. These files define how the extension extracts import statements and symbols from these specific languages, enabling the autocomplete feature to access and cache imports for these languages.

extensions/vscode/tree-sitter/import-queries · high confidence

A new stub file for react-devtools-core has been added to the CLI extensions. This prevents errors when the package is not installed, ensuring the production bundle runs without issues by providing a no-op implementation for devtools.

extensions/cli/stubs · high confidence

Autocomplete will no longer trigger in empty, untitled files, preventing spurious suggestions in new, unsaved documents. Additionally, autocomplete is disabled for files matching patterns in the \disableInFiles\ configuration, as well as for \.prompt\ files and files listed in the global or workspace \.continueignore\ files. This ensures that autocomplete respects user-defined exclusions and avoids generating completions in contexts where it is not useful.

core/autocomplete/prefiltering · high confidence

The autocomplete system now prevents the generation of code that would leave brackets (such as (), {}, or \[\]) unbalanced. A new \BracketMatchingService\ is introduced to track opening brackets from the previous completion and the current line context. When generating a completion, the system will stop the stream if it encounters a closing bracket that does not match the expected opening bracket, ensuring that autocomplete suggestions are syntactically balanced.

core/autocomplete/filtering · high confidence

A new shared release configuration has been introduced for packages, standardizing how version bumps are determined. The new \shared-release.config.js\ file defines rules where fixes and changes within a specific package scope result in a patch release, while breaking changes trigger a major release. This centralizes the logic previously scattered across individual package configurations, ensuring consistent versioning behavior across the monorepo.

packages · high confidence

The config loading process in core/config has been refactored to use a class-based \ConfigHandler\ that manages cascading configuration from multiple sources (e.g., \\~/.continue/assistants\, \config.yaml\, \config.json\). The system now validates tab-autocomplete models and other config entries, ensuring that invalid configurations do not crash the application. Additionally, error handling has been improved to catch and log config loading failures gracefully, preventing uncaught exceptions during startup or reload.

core/config · high confidence

The core module has undergone significant refactoring, including the migration of tests from Jest to Vitest, the removal of the \EmbeddingsProvider\ class in favor of a new \EmbeddingsProvider\ concept, and the introduction of \model roles\ to replace \model types\. The configuration system has been updated to support YAML, and various fixes were applied to autocomplete, indexing, and tool usage.

core · high confidence

The VS Code extension now supports a 'Next Edit' feature that predicts and applies code changes, offering users the ability to accept or reject suggested edits via keyboard shortcuts or UI buttons. This includes a new window manager to handle edit ranges and a ghost text preview of the predicted changes. Additionally, the extension's tab-autocomplete has been improved with better context handling, support for more models, and the ability to disable completions in specific files or contexts like commit messages. The update also introduces a global selection change manager to handle text selection events more efficiently.

extensions/vscode · medium confidence

The core LLM module has been updated to support a wide range of new and existing model providers, including Amazon Bedrock, Cloudflare AI Gateway, Cohere, Function Network, Inception Labs, LlamaStack, MiniMax, Moonshot AI, Nebius, Novita, OVHcloud AI Endpoints, Scaleway, Sambanova, Tensorix, and Watsonx. Additionally, tool calling support has been added or improved for numerous models from providers such as DeepSeek, Gemini, Grok, LM Studio, Mistral, Ollama, OpenAI, OpenRouter, and others, enabling more robust agent and function-calling workflows.

core/llm · high confidence

The CLI's streaming response handling was refactored to improve tool call processing and chat history management. Tool call errors are now stored in the assistant message's \toolCallStates\ rather than as separate history items, preventing duplicate \tool\_result\ messages when converting history to API format. A new \MessageQueue\ class was added to manage queued messages, and auto-compaction logic was extracted into dedicated modules (\streamChatResponse.autoCompaction.ts\, \streamChatResponse.compactionHelpers.ts\) to handle context length validation and automatic compaction. Additionally, tool filtering now respects the current permission mode (plan, normal, auto), ensuring write tools are correctly excluded in plan mode.

extensions/cli/src/stream · high confidence

The autocomplete generation logic has been refactored to introduce a \CompletionStreamer\ that manages the streaming of completion tokens. A new \GeneratorReuseManager\ is now used to reuse pending completion requests when the user's typed prefix matches the start of an ongoing completion, reducing redundant API calls. Additionally, a \stopAfterMaxProcessingTime\ utility enforces a timeout on the generation stream, ensuring that stale or slow requests are cancelled. These changes are accompanied by comprehensive unit tests for the new components.

core/autocomplete/generation · high confidence

The system message generation for LLM rules has been refactored to provide more granular control over when rules are applied. A new \alwaysApply\ property allows rules to be applied globally regardless of file context, while rules without \alwaysApply\ are now scoped to their directory or matched by explicit glob patterns. This ensures that colocated rules in nested directories only apply to files within that directory structure, and root-level rules without globs act as global defaults. The implementation includes comprehensive tests for these behaviors, including handling of rule policies (on/off) and file protocol matching.

core/llm/rules · high confidence

The search and replace feature now uses a multi-strategy matching system (exact, trimmed, case-insensitive, and whitespace-ignored) to find text more robustly, and introduces a new \validateSingleEdit\ utility to enforce that old and new strings are present, distinct, and properly typed. The \executeFindAndReplace\ function now supports a \replaceAll\ flag to replace all occurrences, and the multi-edit pipeline validates each edit individually, ensuring that only the first edit may have an empty \old\_string\ for insertion. Additionally, replacement text is automatically indented to match the matched region's context, and file path validation ensures the target file exists before editing.

core/edit/searchAndReplace · high confidence

The Next Edit feature now uses distinct prompt templates for the 'mercury-coder' and 'instinct' models. The \NextEditPromptEngine\ module defines these templates, which structure the context, user edits, and file content using model-specific tokens. A \PromptTemplateRenderer\ class compiles and renders these templates, while utility functions handle inserting cursor and editable region markers. Comprehensive tests verify the template rendering and utility functions.

core/nextEdit/templating · high confidence

The system now uses newly defined prompt templates for code editing operations with Claude, Codestral, and GPT models. These templates structure how the LLM receives context about the file prefix, suffix, and the specific code segment to be rewritten or inserted, ensuring the model outputs only the relevant code changes without natural language explanations. Additionally, a default apply prompt template is introduced to guide the model in applying suggested edits to original code.

core/llm/templates/edit · high confidence

The autocomplete context ranking module has been refactored to include a new \index.ts\ file that implements Jaccard similarity-based scoring for code snippets. This change introduces logic to rank snippets by relevance to the cursor context, deduplicate overlapping ranges within the same file, and trim the final set of snippets to fit within token limits. This affects how relevant code is selected and ordered for the autocomplete prompt.

core/autocomplete/context/ranking · medium confidence

The CLI now includes a new telemetry service (telemetryService.ts) that initializes OpenTelemetry metrics and tracks session metadata. Specifically, the service detects whether the CLI is running in headless mode (via -p or --print flags) and whether it is running in a GitHub Actions CI environment, adding corresponding boolean labels (is\_headless, is\_github\_actions) to telemetry data. Helper utilities (headerUtils.ts, utils.ts) support this by parsing OTEL headers and detecting terminal types. This change modifies the existing telemetry behavior by introducing new environment variable checks (CONTINUE\_METRICS\_ENABLED, OTEL\_EXPORTER\_OTLP\_HEADERS) and adding new metrics for headless and CI contexts.

extensions/cli/src/telemetry · high confidence

The CLI's tool execution pipeline has been refactored to support dynamic tool overrides via the \.continuerc.json\ configuration file. Users can now customize tool descriptions or disable specific built-in tools (like Edit, Fetch, or Bash) through a new \applyToolOverrides\ mechanism. The tool registry has been restructured into \allBuiltIns.ts\ and \builtInToolNames.ts\ to resolve circular dependencies, and the main execution flow in \index.tsx\ now applies these overrides before making tools available to the agent. Additionally, a new \ToolCallTitle\ component and \formatters.ts\ helper improve how tool calls are displayed in the CLI output.

extensions/cli/src/tools · high confidence

The TabBar component now manages tabs using the Redux store (tabsSlice) instead of local state, enabling consistent session management across the application.

gui · high confidence

The config loading logic has been refactored into a profile-based architecture, introducing an \IProfileLoader\ interface and a \LocalProfileLoader\ implementation that encapsulates the loading of the primary local configuration. This change separates the concerns of profile management from the core config loading logic, which is now handled by the new \doLoadConfig\ function. The \doLoadConfig\ function now accepts a \PackageIdentifier\ that can include pre-read file content, allowing the system to bypass filesystem reads for remote URIs (such as those in WSL environments). Additionally, the default title for the main configuration is now dynamically updated from the loaded config's \configName\ if available, rather than using a static name.

core/config/profile · high confidence

The build and packaging process for the VS Code extension has been refactored into a modular set of scripts. The main \prepackage.js\ script now orchestrates a series of specialized scripts: \npm-install.js\ handles parallel installation of dependencies for the VS Code extension and GUI; \generate-copy-config.js\ generates and copies configuration schemas; \download-copy-sqlite.js\ and \install-copy-nodemodule.js\ manage native binaries and node modules; and \esbuild.js\ handles the extension bundling. This structure replaces the previous monolithic \prepackage.js\ with a more maintainable, cross-platform compatible build system.

extensions/vscode/scripts · high confidence

The autocomplete snippet collection logic has been refactored into a new \getAllSnippets.ts\ module that consolidates how code, diff, clipboard, and recently opened file snippets are gathered. A new \GitDiffCache\ singleton class has been introduced to cache git diff results, preventing redundant file system reads and race conditions. The \getAllSnippets\ function now orchestrates these sources, including a timeout mechanism (\racePromise\) to prevent slow snippet providers from blocking the autocomplete response. Tests have been added for the new caching logic.

core/autocomplete/snippets · high confidence

The autocomplete system's templating and snippet logic has been refactored into a new \core/autocomplete/templating\ module. This introduces a modular pipeline for generating autocomplete prompts, including dedicated files for template definitions (e.g., Qwen, Granite, Codestral), snippet filtering and prioritization, context formatting, and stop-token management. The change consolidates how snippets (clipboard, recently edited, diff, etc.) are validated, ranked by recency and size, and formatted into the final prompt, improving maintainability and enabling better control over context inclusion.

core/autocomplete/templating · high confidence

The autocomplete utility layer has been restructured into distinct, modular components to improve maintainability and testing. A new \AutocompleteDebouncer\ manages request debouncing, while \AutocompleteLoggingService\ handles completion outcome tracking and telemetry. A persistent \AutocompleteLruCache\ with SQLite storage and an \openedFilesLruCache\ manage caching logic. Additionally, \HelperVars\ centralizes file content and AST parsing, and \processSingleLineCompletion\ with its test suite handles completion application logic. These changes provide a more robust and testable foundation for autocomplete features.

core/autocomplete/util · high confidence

The binary build process has been refactored to improve modularity and reliability. The monolithic \bundle-binary.js\ script was split into separate modules for downloading \ripgrep\ and \node-sqlite3\, allowing for parallel downloads and better error handling. Additionally, the script was renamed from \download-copy-sqlite-esbuild\ to \download-copy-sqlite.js\ to better reflect its purpose, and a new \targets.js\ file was introduced to centralize platform and architecture mappings for both \ripgrep\ and \@lancedb\ dependencies.

binary/utils · high confidence

All example projects and sample code have been removed from the repository. This includes the 'MyProject' TypeScript/TypeORM example, Python utility scripts (calculator, sum, filesystem implementations), and their associated unit tests. Users will no longer have access to these reference implementations within the extension's examples directory.

extension/examples, extension/examples/MyProject · high confidence

The \continuedev/libs/steps\ module has removed several experimental and draft step implementations, including \chroma.py\, \draft/abstract\_method.py\, \draft/dlt.py\, \draft/redux.py\, \draft/typeorm.py\, \migration.py\, \nate.py\, \pytest.py\, and \ty.py\. These files contained various step classes such as \AnswerQuestionChroma\, \SetupPipelineStep\, \EditReduxStateStep\, and \WritePytestsStep\. This change eliminates these specific automated workflows from the codebase.

continuedev/src/continuedev/libs/steps · high confidence

The \chroma\ library directory has been cleared of its previous implementation files, including \query.py\, \replace.py\, and \update.py\, along with the \.gitignore\ file. This removes the old codebase indexing and querying logic that relied on \llama\_index\ and direct file system operations, indicating a shift away from this specific implementation within the \continuedev/libs/chroma\ path.

continuedev/src/continuedev/libs/chroma · medium confidence

The extension/src/lang-server/codeLens.ts file, which registered CodeLens providers for accepting/rejecting suggestions and debugging Python tests, has been removed. This eliminates the inline 'Accept' and 'Reject' buttons in the editor gutter for suggestions, as well as the 'Debug This Test' code lens for Python test functions.

extension/src/lang-server · high confidence

The \\_\init\\_.py\ and \load.py\ files within the \continuedev/plugins\ directory have been deleted. This removes the previous plugin loading mechanisms, including the \get\_plugin\_manager\ function that handled plugin discovery and filtering, as well as the \load\_validator\_plugin\, \load\_llm\_plugin\, and \load\_policy\_plugin\ functions that instantiated specific plugin types like \PythonTracebackValidator\, \PytestValidator\, \OpenAI\, \RandomPolicy\, and \DFSPolicy\.

continuedev/src/continuedev/plugins · medium confidence

The file extension/src/util/util.ts has been removed, eliminating several utility functions including JSON quote conversion, file range reading, and debouncing. This cleanup removes legacy code that was likely superseded by newer implementations or VS Code APIs.

extension/src/util · medium confidence

The CLI's authentication module has been stripped of all Hub and WorkOS integration. The \workos.ts\ file now provides no-op stubs for all auth-related functions, ensuring that calls to login, logout, or config loading do not crash but return null or false. The \authEnv.ts\ file defines the path for \AUTH\_CONFIG\_PATH\, and \uriUtils.ts\ provides utilities for converting between file paths and URIs, supporting the new simplified auth state. This change removes the previous requirement for Hub authentication, simplifying the CLI's security model.

extensions/cli/src/auth · high confidence

The AccountDropdown component in the account configuration page has been replaced with a null implementation, effectively removing the account dropdown UI element. This change eliminates the free trial query that was previously displayed in the account dropdown, as the component now returns null, indicating the feature is no longer needed without Hub authentication.

gui/src/pages/config/features/account · high confidence

The \core/tools/definitions\ directory has been completely restructured. All built-in tools (e.g., \codebaseTool\, \createNewFileTool\, \editFileTool\, \grepSearchTool\, etc.) are now defined as individual modules with explicit \Tool\ interfaces, including \defaultToolPolicy\ (e.g., \allowedWithPermission\, \disabled\), \systemMessageDescription\ for LLM guidance, and \preprocessArgs\/\evaluateToolCallPolicy\ for security and path resolution. The \index.ts\ file now exports all tool definitions. A new \requestRule\ tool and its test suite (\requestRule.test.ts\) have been added. The \createRuleBlock\ tool now supports \globs\ and \regex\ parameters for rule scoping. The \editFile\ and \multiEdit\ tools include instructions to prevent parallel calls. The \runTerminalCommand\ tool now detects the user's preferred shell and platform for command suggestions.

core/tools/definitions · high confidence

The system now converts prompt files, custom commands, and rule blocks into a unified slash command format. This change ensures that all prompt sources (YAML, JSON, and rule blocks) are consistently represented as slash commands with a common interface, improving how users interact with and manage these features.

core/commands/slash · high confidence

The Gradle wrapper configuration has been updated to use Gradle 8.14.3. This ensures the IntelliJ extension builds with the specified Gradle distribution, aligning the build environment with the latest stable release for improved stability and compatibility.

extensions/intellij/gradle · high confidence

The \@xenova/transformers\ package's TypeScript definitions have been updated, adding or refreshing type declarations for core modules including \backends/onnx\, \configs\, \env\, \models\, \pipelines\, and \processors\. This update ensures that the library's public API—covering model loading, configuration, environment settings, and pipeline interfaces—is correctly typed for TypeScript users.

core/vendor/modules/@xenova/transformers/types · high confidence

The JetBrains extension now properly disposes of the plugin service when the plugin is unloaded, preventing memory leaks. This addresses a long-standing issue where the plugin service was not being cleaned up correctly, which could lead to increased memory usage and potential instability over time.

extensions/intellij · high confidence

Add OpenAI-compatible LLM test utilities; Add smoke tests for CLI API connectivity; Add unit tests for autocomplete filtering; Add unit tests for the CLI navigation context; Added E2E test infrastructure and utilities; Added binary integration tests; Added comprehensive test coverage for CLI platform client and compaction logic; Added comprehensive tests for CLI TUI components; Added diff algorithm test suite; Added e2e selector classes for VS Code extension tests; Added end-to-end tests for CLI headless mode and utility features; Added end-to-end tests for VS Code extension features; Added indexing test utilities; Added integration tests for model persistence and rule handling; Added mock implementations for CLI testing; Added mock implementations for testing CLI UI components; Added mock service implementations for CLI testing; Added test cases for Python and TypeScript function/class definitions; Added test coverage for autocomplete templating; Added test environment setup and fixtures for core tests; Added test fixtures for Python, Go, PHP, and TypeScript; Added test helper utilities for the CLI; Added tests for CLI process signal handling; Added tests for GlobalContext to verify persistence and corruption handling; Added tests for LLM FIM support detection; Added unit tests for CLI test-helpers; Added unit tests for RootPathContextService; Refactored CLI chat hooks into modular, testable components; Removed obsolete test files from the extension test suite; Removed obsolete test runner script.

The project's dependencies have been updated across 63 manifests, including security fixes for packages like handlebars, form-data, and axios, alongside routine version bumps for the VS Code extension, JetBrains plugin, and core packages.

(dependencies) · high confidence

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

• CAI 38 → 47 (+9.3)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 68 → 75 (+6.6)
• Architecture 34 → 45 (+10.9)
• Maturity 55 → 60 (+4.4)
• Readiness 33 → 59 (+26.4)
• Security 43 → 54 (+11.3)
• Accessibility 42 (new)
• Performance 60 (new)

• (anonymous) (cognitive 50) (packages/fetch/src/node-fetch-patch.js)
• (anonymous) (cyclomatic 33) (packages/fetch/src/node-fetch-patch.js)
• Boundary-crossing change coupling: mcpUtils.ts ↔ agentFiles.ts (extensions/cli/src/services/mcpUtils.ts)
• Boundary-crossing change coupling: metadata.ts ↔ providers.ts (extensions/cli/src/util/metadata.ts)
• Change coupling: Anthropic.ts ↔ url.ts (core/llm/llms/Anthropic.ts)
• Change coupling: Bedrock.ts ↔ url.ts (core/llm/llms/Bedrock.ts)
• Change coupling: Gemini.ts ↔ url.ts (core/llm/llms/Gemini.ts)
• Change coupling: Ollama.ts ↔ url.ts (core/llm/llms/Ollama.ts)
• Change coupling: exit.ts ↔ metadata.ts (extensions/cli/src/util/exit.ts)
• Change coupling: serve.ts ↔ metadata.ts (extensions/cli/src/commands/serve.ts)
• Change coupling: streamChatResponse.compactionHelpers.ts ↔ streamChatResponse.ts (extensions/cli/src/stream/streamChatResponse.compactionHelpers.ts)
• Change coupling: url.ts ↔ Anthropic.ts (core/util/url.ts)
• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (binary/package-lock.json)
• Critical CVE: [GHSA redacted] (extensions/cli/package-lock.json)
• Critical CVE: [GHSA redacted] (manual-testing-sandbox/requirements.txt)
• Critical CVE: [GHSA redacted] (manual-testing-sandbox/requirements.txt)
• Critical CVE: [GHSA redacted] (extensions/vscode/package-lock.json)
• Critical CVE: [GHSA redacted] (extensions/cli/package-lock.json)
• Critical CVE: [GHSA redacted] (manual-testing-sandbox/requirements.txt)
• …and 107 more

• (anonymous) (cognitive 17) (binary/build.js)
• AddModelForm.AddModelForm (cognitive 36) (gui/src/forms/AddModelForm.tsx)
• AddModelForm.AddModelForm (cyclomatic 44) (gui/src/forms/AddModelForm.tsx)
• Anthropic.convertMessageContentToBlocks (cognitive 19) (core/llm/llms/Anthropic.ts)
• Anthropic.getContentBlocksFromChatMessage (cognitive 16) (core/llm/llms/Anthropic.ts)
• Anthropic.handleResponse (cognitive 29) (core/llm/llms/Anthropic.ts)
• Anthropic.handleResponse (cyclomatic 22) (core/llm/llms/Anthropic.ts)
• AnthropicApi.convertMessageContentToBlocks (cognitive 29) (packages/openai-adapters/src/apis/Anthropic.ts)
• AnthropicCachingStrategies.optimizedStrategy (cyclomatic 22) (packages/openai-adapters/src/apis/AnthropicCachingStrategies.ts)
• AnthropicUtils.addCacheControlToLastTwoUserMessages (cognitive 16) (packages/openai-adapters/src/apis/AnthropicUtils.ts)
• AskSageApi.chatCompletionStream (cyclomatic 16) (packages/openai-adapters/src/apis/AskSage.ts)
• AskSageApi.convertMessages (cognitive 30) (packages/openai-adapters/src/apis/AskSage.ts)
• AutocompleteTemplate.getTemplateForModel (cognitive 16) (core/autocomplete/templating/AutocompleteTemplate.ts)
• AutocompleteTemplate.getTemplateForModel (cyclomatic 25) (core/autocomplete/templating/AutocompleteTemplate.ts)
• BaseLLM.fetch (cognitive 29) (core/llm/index.ts)
• BaseLLM.parseError (cognitive 17) (core/llm/index.ts)
• BaseLLM.streamChat (cognitive 56) (core/llm/index.ts)
• BaseLLM.streamChat (cyclomatic 29) (core/llm/index.ts)
• BaseLLM.streamComplete (cognitive 23) (core/llm/index.ts)
• BaseLLM.streamFim (cognitive 20) (core/llm/index.ts)
• …and 1270 more

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

continuedev/continue 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.