Skip to content
CAI
Software that uses CAICheck a score

intitni/CopilotForXcode

32.7

Weak · 14 November 2026

56.9k

lines of production code

Swift

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Copilot for Xcode is a macOS application that integrates AI-powered code suggestions and chat directly into the Xcode development environment. It supports multiple backend providers, including GitHub Copilot, Codeium, and various OpenAI-compatible services, while offering features like real-time inline completions, context-aware chat with web search, and shell command execution. The system manages workspace state, handles code modifications, and provides a customizable interface for managing models, plugins, and user preferences.

How it got here

2022–2023 — Initial release and architectural modernization

104 changes.

This period marks the initial release of Copilot for Xcode, establishing the core project structure and host application. The work focused on a comprehensive architectural overhaul, migrating the codebase to the Composable Architecture and introducing a modular service layer with pluggable AI providers. It also integrated a robust LangChain framework for context-aware chat, vector search, and agent-based workflows, alongside a complete UI redesign for settings and suggestion widgets.

2024 — Multi-provider AI integration and plugin architecture

40 changes.

The project established a unified, multi-provider AI service layer supporting OpenAI, Claude, Google, Ollama, and GitHub Copilot, while introducing a modular plugin architecture for chat and suggestion capabilities. Significant work focused on integrating Codeium and GitHub Copilot as builtin extensions with dedicated language server management, alongside new features like RAG chat agents, code modification agents, and precise context collection. The period also saw the introduction of robust infrastructure for asynchronous event streaming, file system abstraction, and comprehensive test coverage for these new core components.

2025 — Web search and overlay enhancements

8 changes.

This period focused on expanding the WebSearchService with multiple new providers and headless browser capabilities, alongside the introduction of a new JoinJSON utility for data merging. Significant work also went into implementing overlay window management for Xcode workspaces and adding comprehensive test coverage for these new features and existing parsers.

Features

API key storage now supports UserDefaults fallback

The Keychain module in the Tool package now allows API keys to be stored in UserDefaults instead of the system Keychain, controlled by the \useUserDefaultsBaseAPIKeychain\ preference. This change introduces a \UserDefaultsBaseAPIKeychain\ implementation that persists keys as a dictionary in user defaults, providing an alternative storage mechanism alongside the existing Keychain-based approach.

Tool/Sources/Keychain · high confidence

Add Codeium Chat tab

A new Codeium Chat tab has been added to the tool, providing a dedicated interface for interacting with the Codeium service. This feature integrates a WKWebView-based browser view that loads the Codeium chat URL, observes title and loading progress changes, and displays error overlays when the workspace cannot be found or the service fails to start. Users can access this tab via the context menu or open chat command, with options to reload the view or manually load the current workspace.

Tool/Sources/CodeiumService/ChatTab · high confidence

Add Git ignore checking capability

A new Git ignore checker has been added to the tool, allowing users to determine if specific files are ignored by Git. This feature is disabled by default and can be enabled via the \disableGitIgnoreCheck\ preference. The implementation uses a dependency injection pattern (\GitIgnoredChecker\) to allow for testable and swappable implementations, and it safely passes file paths to the \git check-ignore\ command via environment variables to prevent command injection.

Tool/Sources/GitIgnoreCheck · high confidence

Add Objective-C exception handling utility

Introduces the \ObjcExceptionHandler\ class, which provides a \catchException:error:\ method to safely execute Objective-C blocks and convert thrown \NSException\ objects into \NSError\ instances for structured error handling.

Tool/Sources/ObjectiveCExceptionHandling · high confidence

Add Objective-C focused code finder

Introduces a new \ObjectiveCFocusedCodeFinder\ implementation that parses Objective-C source files to extract focused code ranges, including class interfaces, implementations, categories, protocols, methods, functions, and type definitions. The feature also correctly identifies and includes \\#include\, \\#import\, and \@import\ statements in the context information, and handles super class references and protocol conformance for accurate signature generation.

Tool/Sources/FocusedCodeFinder/ObjectiveC · high confidence

Add OpenAI embedding support with safe long-text handling

Introduces a new \Embeddings\ protocol and an \OpenAIEmbedding\ implementation in the LangChain tooling. Users can now generate vector embeddings for documents and queries via the OpenAI API. The implementation includes a \safe\ mode that handles inputs exceeding token limits by chunking text, with an optional \shouldAverageLongEmbeddings\ flag to control how long-text embeddings are aggregated.

Tool/Sources/LangChain/Embedding · high confidence

Add SandboxedClientTester app for verifying XPC service connectivity

A new macOS application, SandboxedClientTester, has been added to provide a user-facing interface for testing the CommunicationBridge XPC service. The app features a simple UI with a 'Test' button that, when tapped, attempts to connect to the XPC service and retrieve its version and build information, displaying the result or any errors on screen. The application is configured with App Sandbox entitlements, specifically granting read-only access to user-selected files and a temporary exception to look up the CommunicationBridge service by name, ensuring it can interact with the service while maintaining security constraints.

SandboxedClientTester · high confidence

Add async debounce and throttle utilities

The Tool/Sources/DebounceFunction module now provides \DebounceFunction\, \DebounceRunner\, \ThrottleFunction\, and \ThrottleRunner\ actors to manage asynchronous execution timing. These utilities allow users to delay execution until a specified duration has passed without further calls (debounce) or to ensure a block runs at most once per duration interval (throttle), with support for cancelling pending tasks.

Tool/Sources/DebounceFunction · high confidence

Add headless browser-based web scraping capability

The WebScrapper tool now uses a headless WKWebView to fetch web content, enabling it to handle JavaScript-rendered pages that static HTTP requests cannot. This implementation blocks non-essential resources like images and fonts to improve performance, scrolls to the bottom of the page to ensure full content loading, and includes retry logic with validation to robustly extract HTML.

Tool/Sources/WebScrapper · high confidence

Add local FileSystem abstraction and supporting utilities

The Tool/Sources/FileSystem module now includes a local implementation of the file system API, introducing the \FileSystem\ protocol and concrete types like \AbsolutePath\ and \RelativePath\ for cross-platform path handling. This change adds core utilities for working with byte sequences (\ByteString\), file metadata (\FileInfo\), and process synchronization (\FileLock\), along with helper functions for directory traversal (\walk\) and symbolic link resolution (\resolveSymlinks\), enabling the tool to perform file system operations independently of the underlying platform.

Tool/Sources/FileSystem · high confidence

Add system prompt with current time to chat context

A new SystemInfoChatContextCollector has been introduced to inject the current date and time into the chat's system prompt. This allows the AI model to reference the current time for timezone calculations or temporal context during conversations.

Core/Sources/ChatContextCollectors/SystemInfoChatContextCollector · high confidence

Add token counting strategies for OpenAI and Google Gemini models

The memory strategy layer now includes specific implementations for counting tokens in chat messages and function calls. The OpenAI strategy uses the Tiktoken encoder to calculate token usage for message content, names, tool calls, and images, while the Google Gemini strategy provides a placeholder implementation that adds a fixed offset to the OpenAI count. This enables the system to more accurately track context window usage for both providers.

Tool/Sources/OpenAIService/Memory/AutoManagedChatGPTMemoryStrategy · high confidence

Added CLI helper to reload launch agents

A new command-line helper tool has been added to manage macOS launch agents. Users can now reload a specific launch agent service by providing its service identifier, which triggers an unload and subsequent load of the corresponding plist file in the user's Library/LaunchAgents directory.

Helper · high confidence

Added Playground with RetrievalQAChain and WebScrapper pages

A new Xcode playground file has been added to the project, configured to target macOS. It includes two specific pages: 'RetrievalQAChain' and 'WebScrapper', allowing users to interact with these components directly within the Xcode environment.

Playground.playground · high confidence

Added Swift wrapper for USearch index operations

Introduced a new \USearchIndex\ actor in the Tool module that provides a simplified, thread-safe interface for managing vector search indexes. This wrapper exposes methods to initialize, load, view, save, clear, add vectors, set multiple items, and search within a USearch index, while handling Objective-C exceptions and enforcing state-based restrictions (e.g., preventing mutations on viewing indexes).

Tool/Sources/USearchIndex · high confidence

Added Xcode project schemes and workspace configuration

The project now includes a set of shared Xcode schemes (CommunicationBridge, Copilot for Xcode Debug, Copilot for Xcode, EditorExtension, ExtensionService, and SandboxedClientTester) along with the workspace data file. These schemes define how the various targets are built, tested, and launched, including specific configurations for debugging (such as command-line arguments for the main app and extension service) and launching the editor extension alongside the main application.

Copilot for Xcode.xcodeproj/xcshareddata · high confidence

Added Xcode scheme for SuggestionModel target

An Xcode scheme file (SuggestionModel.xcscheme) has been added to the Tool/.swiftpm directory, configuring build, test, launch, profile, analyze, and archive actions for the SuggestionModel target. This enables the SuggestionModel target to be run and tested directly within Xcode.

Tool/.swiftpm · high confidence

Added debug logging for chat request lifecycle events

A new debug utility has been added to the OpenAIService module that posts notifications via the default notification center for key stages of a chat request, including when the request body is sent, when function calls and results are received, when the final response content arrives, and when the request finishes. These notifications are only active in DEBUG builds and include a task-local ID along with the relevant payload data, allowing developers to monitor and debug the service's interaction flow in real-time.

Tool/Sources/OpenAIService/Debug · high confidence

Added timedDebounce operator for AsyncSequence

A new \timedDebounce\ method has been added to \AsyncSequence\, allowing users to debounce incoming values with a specific time duration and a custom reducer function. This operator buffers and reduces values received within the time window, yielding the final reduced value only after the duration has elapsed or when the sequence completes, providing a specialized asynchronous control flow tool for handling rapid updates.

Tool/Sources/CustomAsyncAlgorithms · high confidence

GitHub Copilot integration converted to a builtin extension with chat support

The GitHub Copilot service is now implemented as a builtin extension (GitHubCopilotExtension) that manages both suggestion and chat capabilities. This change introduces a dedicated chat service (GitHubCopilotChatService) alongside the existing suggestion service, allowing users to access Copilot chat features directly. The extension handles document lifecycle events (open, save, close, update) and synchronizes file content with the language server, including a fix to reopen documents if they are not found in the language server during updates. It also ensures the language server is properly terminated when the workspace closes and automatically updates the language server if it is outdated.

Tool/Sources/GitHubCopilotService · high confidence

Initial release of Copilot for Xcode

This entry marks the initial release of the Copilot for Xcode application (version 0.38.0). The diff establishes the complete project structure, including the host app, editor extension, and background services, alongside configuration files for versioning and Sparkle auto-updates. It introduces comprehensive documentation (README, DEVELOPMENT.md) detailing installation, permissions, and setup for GitHub Copilot, Codeium, and Chat features, while also adding the MIT license and a test plan for the codebase.

(repo-wide) · high confidence

Integrate Sparkle for automatic and manual application updates

The application now uses the Sparkle framework to handle software updates, enabling both automatic background checks and manual user-triggered checks via the new UpdateChecker component. This integration supports beta channel updates based on user preferences and includes logging for update scheduling events, ensuring users are notified of and can install new versions seamlessly.

Core/Sources/UpdateChecker · high confidence

Introduce API key management in account settings

Users can now view, add, and delete API keys directly from the Account Settings. The new APIKeyManagement view lists existing keys (sorted alphabetically) and allows removal via a context menu or trash icon. A new APIKeySubmission form enables creating keys with a name and secure value, while the APIKeyPicker component in other settings screens lets users select from their stored keys or navigate to this management interface.

Core/Sources/HostApp/AccountSettings/APIKeyManagement · high confidence

Introduce ActiveApplicationMonitor for tracking active macOS applications

A new ActiveApplicationMonitor singleton has been added to the Tool module to track the currently active application on macOS. It exposes the active app and specifically identifies when Xcode is active via the activeXcode property. Consumers can subscribe to real-time updates using the createInfoStream() method, which yields RunningApplicationInfo structs containing details such as the app's name, bundle identifier, and whether it is hidden or active.

Tool/Sources/ActiveApplicationMonitor · high confidence

Introduce AsyncPassthroughSubject for async event streaming

A new \AsyncPassthroughSubject\ actor is added to the \Tool\ module, providing a mechanism to stream elements asynchronously. This component allows subscribers to receive updates via \AsyncStream\ and supports sending and finishing streams, replacing previous implementations that relied on \NSWorkspace\ notifications.

Tool/Sources/AsyncPassthroughSubject · high confidence

Introduce BuiltinExtension framework for managing built-in AI services

A new BuiltinExtension module has been added to centralize the management of built-in AI capabilities. It defines a BuiltinExtension protocol for registering extensions with identifiers and chat tab types, a BuiltinExtensionManager to handle lifecycle and configuration checks (such as determining which suggestion provider is active), a BuiltinExtensionSuggestionServiceProvider to bridge suggestion requests to specific providers like GitHub Copilot or Codeium, and a BuiltinExtensionWorkspacePlugin to notify extensions of file open, save, and update events.

Tool/Sources/BuiltinExtension · high confidence

Introduce ChatBasic library with new chat models and plugin architecture

The ChatBasic module has been introduced, providing the foundational types and protocols for the chat system. This includes the ChatAgent protocol and ChatAgentRequest/Response types, which support streaming responses, status updates, and reasoning content. The ChatMessage model has been expanded to support tool calls, references, images, and caching, while the ChatPlugin protocol allows for both simple text responses and complex, structured interactions. Additionally, JSONSchema support has been added to facilitate function argument validation.

Tool/Sources/ChatBasic · high confidence

Introduce ChatContextCollector for scoped context generation

The ChatContextCollector module now provides a new protocol and implementation for generating chat context based on specific scopes (file, code, sense, project, web). This includes a MessageScopeParser that extracts scope tags from user input and a ChatContext structure that aggregates system prompts, retrieved content, and available functions. The generateContext method is now asynchronous, allowing for more flexible context assembly.

Tool/Sources/ChatContextCollector · high confidence

Introduce ChatModel protocol and OpenAIChat implementation

Added a new ChatModel protocol and an OpenAIChat struct that implements it, enabling users to generate chat responses via OpenAI's API with support for streaming, conversation memory, and function providers. The implementation wraps the existing LegacyChatGPTService and exposes configuration options through ChatGPTConfiguration, allowing for extensible chat interactions within the LangChain Swift tool.

Tool/Sources/LangChain/ChatModel · high confidence

Introduce ChatPlugins with Terminal and Shortcut capabilities

A new ChatPlugins module has been added, providing two distinct plugins for interacting with the host environment. The TerminalChatPlugin (command: /shell) allows users to execute shell commands directly from the chat, automatically injecting the current file path and project root as environment variables ($FILE\_PATH, $PROJECT\_ROOT) via XcodeInspector integration. The ShortcutChatPlugin (command: /shortcut) enables running macOS Shortcuts, accepting input from the chat message or previous history and writing output to temporary files. Both plugins implement the ChatPlugin interface to support streaming text responses and complex action-based interactions.

ChatPlugins · high confidence

Introduce CodeDiff library for structured code snippet comparison

Added the CodeDiff module, which provides a public API for computing and representing differences between code snippets. The library exposes a \CodeDiff\ struct with methods to calculate line-level diffs (\diff(text:from:)\) and structured snippet diffs (\diff(snippet:from:)\) that return \SnippetDiff\ objects. These objects contain sections detailing unchanged, added, and removed lines with specific offsets, enabling users to programmatically access granular change data rather than just raw text output.

Tool/Sources/CodeDiff · high confidence

Introduce Codeium extension integration with workspace lifecycle management

This change adds the CodeiumExtension and CodeiumWorkspacePlugin to the tool, enabling the Codeium language server to be managed as a builtin extension. The extension registers a CodeiumChatTab and a suggestion service, while the workspace plugin handles the lifecycle of the Codeium service, including launching it when workspaces open and terminating it when they close. It also implements logic to prevent unused language servers from loading by tracking usage via a life keeper, and filters out large files (\>15MB) from being sent to the service to optimize performance.

Tool/Sources/CodeiumService · high confidence

Introduce CommandHandler abstraction for IDE interactions

A new CommandHandler protocol and its UniversalCommandHandler implementation have been added to centralize and abstract interactions with the IDE. This change introduces a dependency-injected interface for managing code suggestions (presenting, accepting, rejecting, and navigating), chat functionality (opening chat, sending messages), and code modifications (accepting and presenting modifications). It also provides a mechanism for handling custom commands, displaying toasts, and opening specific files in the editor, allowing these behaviors to be mocked in tests or overridden in production.

Tool/Sources/CommandHandler · high confidence

Introduce CommunicationBridge service for extension lifecycle management

A new XPC-based CommunicationBridge service has been added to manage the lifecycle of the CopilotForXcode extension service. This service allows the host application to launch, update the endpoint for, and quit the extension service app, while automatically terminating the bridge itself after a period of inactivity (30 minutes in release builds).

CommunicationBridge · high confidence

Introduce Composable Architecture-based Suggestion Widget with Chat and Prompt-to-Code Panels

The SuggestionWidget has been migrated to the Composable Architecture (TCA), introducing a new \SuggestionWidgetController\ and \WidgetWindowsController\ to manage the circular indicator, suggestion panels, and a new detachable Chat Panel. This change adds a dedicated \ChatPanelWindow\ with tabbed navigation, a \PromptToCodePanelGroupView\ for code generation tasks, and a \SharedPanelView\ to unify suggestion display modes. The widget now uses a \SuggestionWidgetDataSource\ protocol for decoupled suggestion retrieval and a \TextCursorTracker\ for passive editor observation, while \WidgetPositionStrategy\ handles precise window placement and alignment relative to the Xcode editor.

Core/Sources/SuggestionWidget · high confidence

Introduce DocumentLoader framework with Text and Web loading capabilities

Added a new DocumentLoader module that defines a Document model and a DocumentLoader protocol for loading content into structured documents. This includes a TextLoader for reading local text files with metadata (filename, path, modification date) and a WebLoader that uses WKWebView to scrape web pages, supporting configurable content extraction strategies and parsing via SwiftSoup.

Tool/Sources/LangChain/DocumentLoader · high confidence

Introduce FocusedCodeFinder to extract structured code context

The FocusedCodeFinder tool now provides structured code context for the active document, including focused code ranges, surrounding scope signatures, and relevant imports/includes. It supports Swift, Objective-C, and C via language-specific finders, and falls back to a generic line-based search for unknown languages. The system automatically adjusts the focused range based on selection and line count limits, ensuring concise yet complete context for code suggestions.

Tool/Sources/FocusedCodeFinder · high confidence

Introduce GitHub Copilot chat and suggestion services

This change adds the core service implementations for GitHub Copilot integration within the tool. It introduces GitHubCopilotChatService, which handles chat interactions by sending messages and history to the Copilot language server, managing conversation turns, and streaming responses with timeout and error handling. It also adds GitHubCopilotSuggestionService, which provides code completion suggestions by querying the Copilot service for completions based on the current file content and cursor position, and handles feedback for accepted or rejected suggestions.

Tool/Sources/GitHubCopilotService/Services · high confidence

Introduce RAGChatAgent for configurable AI chat interactions

Added a new RAGChatAgent component that enables users to configure and execute chat sessions with specific model parameters (such as temperature, max tokens, and system prompts) and conversation settings (like isolation and language). The agent supports a pluggable capability system, allowing external features to inject context, references, and functions into the chat flow, while managing the underlying OpenAI service integration and history.

Tool/Sources/RAGChatAgent · high confidence

Introduce SuggestionBasic module with code suggestion models and editor utilities

This change introduces the new SuggestionBasic module, which provides the foundational data structures and utilities for code suggestions. It adds the CodeSuggestion model to represent suggested code blocks, including their text, position, and associated descriptions. It also introduces EditorInformation to manage editor state, such as cursor position, selection ranges, and line annotations, along with helper methods to extract code snippets from ranges. Additionally, the module includes CursorPosition and CursorRange types for precise location tracking, Modification types for applying text changes, and utilities for handling string line endings and identifying programming languages from file paths.

Tool/Sources/SuggestionBasic · high confidence

Introduce Swift LangChain agent and chain execution framework

This change introduces the core LangChain infrastructure for Swift, enabling the construction and execution of AI agent workflows. It adds the \Agent\ protocol and \AgentExecutor\ actor, which manage iterative tool usage, handle cancellation, and enforce execution limits. The update also provides a \Chain\ protocol with composable chain types (connected, paired, mapped) and a \CallbackManager\ system to allow users to observe and react to events during chain and agent execution.

Tool/Sources/LangChain · high confidence

Introduce Swift-focused code context extraction

The Swift-focused code finder now extracts context for Swift source files by parsing the syntax tree and identifying the scope hierarchy (such as structs, classes, functions, and closures) that contain the cursor position. This implementation generates signatures for various Swift declarations and collects import statements, enabling the tool to provide relevant code context for Swift documents.

Tool/Sources/FocusedCodeFinder/Swift · high confidence

Introduce VectorStore protocol and TemporaryUSearch implementation

Added a new \VectorStore\ protocol and a \TemporaryUSearch\ actor implementation to support local vector storage for small, temporary documents. The \TemporaryUSearch\ class manages an in-memory and on-disk USearch index, storing index and document data in the user's cache directory, and conforms to the new protocol to provide add, set, clear, and search capabilities.

Tool/Sources/LangChain/VectorStore · high confidence

Introduce Workspace, Filespace, and WorkspacePool architecture

This change introduces the core workspace management infrastructure in the Tool/Workspace module. It adds a WorkspacePool to manage multiple project workspaces, a Workspace class to handle file opening/closing and plugin hooks, and a Filespace class to represent individual open files with metadata, suggestion state, and gitignore awareness. It also includes supporting components like a FileSaveWatcher for detecting file changes, an OpenedFileRecoverableStorage to persist recently opened files across sessions, and a UserDefaultsObserver to monitor preference changes. This forms the foundation for workspace-aware features like code suggestions and file tracking.

Tool/Sources/Workspace · high confidence

Introduce basic code modification agent with streaming explanation and code parsing

This change introduces the core components for a new code modification feature. It adds a stream parser that distinguishes between explanatory text and code blocks in AI responses, a state manager to track modification history and snippets, and an agent protocol to handle requests for code changes. Users can now initiate code modifications that provide both an explanation of the changes and the resulting code, with the system maintaining a history of these interactions.

Tool/Sources/ModificationBasic · high confidence

Introduce extensible Prompt-to-Code customization framework

Adds a new customization layer for the Prompt-to-Code feature, allowing external modules to inject custom UI elements (such as extra menu items, buttons, and context input fields) and provide alternative context resolution logic. This is achieved through the \PromptToCodeCustomizedUI\ protocol and \PromptToCodeContextInputController\ protocol, which replace the previous hardcoded behavior with configurable factories and delegates, enabling third-party tools to extend the prompt-to-code experience without modifying the core implementation.

Tool/Sources/PromptToCodeCustomization · high confidence

Introduce overlay window management for Xcode workspaces

Added new source files to manage overlay windows within Xcode workspaces. The implementation includes an OverlayPanel class that handles window appearance, frame synchronization, and debug visibility, alongside an OverlayWindowController that observes Xcode window changes and manages the lifecycle of overlay instances. A new IDEWorkspaceWindowOverlayWindowController coordinates content providers and handles accessibility notifications to keep overlays aligned with workspace windows, including support for window miniaturization and space changes.

OverlayWindow/Sources · high confidence

Introduce unified ChatGPTService and EmbeddingService with multi-provider support

The OpenAIService module has been restructured to provide a new, unified ChatGPTService and EmbeddingService that support multiple model providers (OpenAI, Ollama, GitHub Copilot, Azure, and others) via a pluggable configuration system. ChatGPTService now handles streaming chat responses, including tool calls and usage tracking, while the EmbeddingService abstracts embedding requests across different backends. A legacy wrapper (LegacyChatGPTService) is provided for backward compatibility, and a HeaderValueParser enables dynamic header configuration with placeholder substitution.

Tool/Sources/OpenAIService · high confidence

Introduces PlusFeatureFlag module for feature gating

A new PlusFeatureFlag module has been added to the core sources, providing a unified interface for checking and executing code based on feature flags. The module defines a PlusFeatureFlags struct and helper functions (withFeatureEnabled, isFeatureAvailable) that delegate to the LicenseManagement module when available, or return default values (0/false) in its absence, allowing the application to conditionally enable features based on license status.

Core/Sources/PlusFeatureFlag · high confidence

Introduces configurable chat and embedding model settings with override support

Users can now configure specific chat and embedding models via user preferences, with the ability to override settings such as model ID, temperature, max tokens, and dimensions for specific contexts. The new configuration system supports GitHub Copilot as a chat model option and allows disabling automatic function calling. Embedding configurations now include dimension settings, defaulting to 1536 if not specified by the model info.

Tool/Sources/OpenAIService/Configuration · high confidence

Introduces context-aware chat with dynamic scopes and plugin support

The chat service now automatically gathers contextual information (such as file, code, project, web, or sense data) based on configurable scopes, allowing the system to inject relevant context and switch models per scope. It also supports a plugin architecture where commands prefixed with / are routed to specific plugins (e.g., Terminal, Shortcut) for specialized handling, while legacy plugins are wrapped for compatibility.

Core/Sources/ChatService · high confidence

Introduces function call provider protocol for OpenAI service

A new \ChatGPTFunctionProvider\ protocol and a default \NoChatGPTFunctionProvider\ implementation have been added to the OpenAI service layer. This change allows users to register custom functions and define a function call strategy, enabling the service to support tool-use capabilities when interacting with OpenAI models.

Tool/Sources/OpenAIService/FucntionCall · high confidence

Introduction of LegacyChatPlugin module with terminal execution and translation capabilities

A new LegacyChatPlugin module has been added to the codebase, introducing a plugin architecture for legacy chat interactions. This includes a TerminalChatPlugin that allows users to execute shell commands directly from the chat interface, leveraging XcodeInspector to pass context like the active file and project root. The module also provides utility functions for asking ChatGPT general questions, calling AI functions via code generation, and translating text with caching support. These changes establish the foundational components for legacy-style plugin-based AI interactions within the application.

Core/Sources/LegacyChatPlugin · high confidence

Introduction of structured logging and performance signpost support

The application now uses a new centralized Logger class that wraps Apple's os\_log framework, providing structured logging with specific categories for different subsystems (such as Service, UI, Client, GitHubCopilot, and LangChain). This change also introduces OSSignpost integration via the signpostBegin method, allowing developers to track and measure performance intervals within the app.

Tool/Sources/Logger · high confidence

Native Swift text splitting and document transformation

The LangChain tool now includes a native Swift implementation for splitting and transforming documents. This adds a \DocumentTransformer\ protocol and a \RecursiveCharacterTextSplitter\ that breaks text into chunks using configurable separators and overlap, with built-in support for common programming languages like Swift, C++, Java, and JavaScript via \TextSplitterSeparatorSet\. The system manages chunk metadata (UTF-16 offsets) to allow for precise merging and joining of split documents back together.

Tool/Sources/LangChain/DocumentTransformer · high confidence

New 'Get Code at Line' function for active document context

A new function named 'getCodeAtLine' has been added to the ActiveDocumentChatContextCollector, allowing the AI to retrieve code snippets surrounding a specific line number in the currently active document. When invoked, the function navigates to the specified line, extracts the surrounding code block, and returns it with a marker indicating the target line, enabling more precise code analysis and context gathering within the chat interface.

Tool/Sources/ChatContextCollectors/ActiveDocumentChatContextCollector/Functions · high confidence

New AI model management interface with base URL selection

Users can now manage chat and embedding models through a new settings view that displays a list of available models, allows selection, duplication, removal, and reordering, and enforces a limit of two models for non-Plus users (with an 'Add Model (Plus)' button when the limit is reached). The interface includes a base URL picker that lets users choose from available URLs or enter a custom value, and the system automatically populates the list of available base URLs by scanning existing chat and embedding model configurations.

Core/Sources/HostApp/AccountSettings/SharedModelManagement · high confidence

New AXUIElement extensions for accessibility data and window management

Added new Swift extensions for AXUIElement that expose convenience properties for reading accessibility attributes (such as identifier, title, role, label, and value types including Int and Double), retrieve element geometry (position, size, rect), and manage window relationships (focused element, windows, full-screen state, and frontmost status). The implementation also includes a private API binding for \_AXUIElementGetWindow to retrieve the underlying CGWindowID, enabling more precise window identification and interaction.

Tool/Sources/AXExtension · high confidence

New ChatAgent with structured tool-use and language support

A new ChatAgent implementation is introduced that enables agents to interact with tools via structured JSON actions (action/action\_input) and parse final answers based on the 'Final Answer:' marker. The agent now supports specifying a preferred language for responses, which is passed into the system prompt to influence the output format. This change adds a new agent type capable of handling multi-step reasoning loops with tool execution, distinct from previous agent implementations.

Tool/Sources/LangChain/Agents · high confidence

New Host App Settings Interface with Debug and Toast Support

The Host App now includes a comprehensive settings interface built with the Composable Architecture (TCA). Users can manage general app configuration, including launch agent installation and accessibility permissions, via the General tab. A new Service tab allows configuration of suggestion providers (GitHub Copilot, Codeium) and model settings (Chat, Embedding, Web Search). A dedicated Advanced tab exposes numerous debug toggles for fine-tuning behavior, such as disabling function calling, controlling accessibility API interactions, and managing API key storage. Additionally, a new toast notification system has been implemented to provide user feedback for actions like launch agent setup.

Core/Sources/HostApp · high confidence

New JoinJSON utility for merging JSON data

A new \JoinJSON\ tool has been added to the codebase, providing a public API to merge two JSON objects. Users can pass strings or \Data\ objects representing JSON, and the utility will combine them into a single JSON \Data\ object, with keys from the second object overwriting those in the first.

Tool/Sources/JoinJSON · high confidence

New LangChain chains for document retrieval, refinement, and structured output

The tool now includes several new LangChain chain implementations to enhance how it processes information. QAInformationRetrievalChain retrieves relevant documents from vector stores and extracts key information using RelevantInformationExtractionChain, which leverages function calling to identify and summarize relevant content. RefineDocumentChain iteratively refines answers across multiple documents, providing intermediate feedback via callbacks. CombineAnswersChain merges multiple answers into a single response, while StructuredOutputChatModelChain enables the generation of typed, structured outputs (such as Int, Double, or custom Decodable types) through function calling. These chains are built on the new ChatModelChain base class, which standardizes prompt templating and output parsing for chat models.

Tool/Sources/LangChain/Chains · high confidence

New Terminal abstraction for streaming and running shell commands

A new \Terminal\ component has been introduced in the Tool module, providing a \TerminalType\ protocol and implementation for executing shell commands. This change adds support for streaming command output via \streamCommand\ and \streamLineForCommand\, as well as synchronous execution via \runCommand\, all utilizing \URL\ for the current directory instead of a string path. Users can now interact with the terminal asynchronously, handling output chunks or lines as they arrive, with proper error handling for process termination.

Tool/Sources/Terminal · high confidence

New XPC communication infrastructure for editor extension services

This change introduces a new shared XPC communication layer in Tool/Sources/XPCShared, establishing the protocol and client-side bridge that allows the host application to interact with the extension service. It defines the CommunicationBridgeXPCServiceProtocol for managing service lifecycle (launching, quitting, endpoint updates) and the XPCServiceProtocol for sending editor content and receiving code suggestions, chat responses, and custom command results. The new EditorContent model supports multiple selections and cursor offsets, enabling the extension to process complex editor states and return updated code with new selections.

Tool/Sources/XPCShared · high confidence

New chat model management interface with multi-provider support

Users can now configure and manage chat models directly within the Account Settings. This new management view supports a wide range of providers including OpenAI, Azure OpenAI, Google AI, Ollama, Claude, and GitHub Copilot, as well as generic OpenAI-compatible endpoints. The interface allows users to customize model names, base URLs, API keys, and specific settings such as max tokens, function calling toggles, custom headers, and custom request bodies. A built-in test feature lets users validate their configuration before saving, and models can be created, duplicated, or removed from the list.

Core/Sources/HostApp/AccountSettings/ChatModelManagement · high confidence

New chat settings interface with model and open-mode configuration

A new Chat Settings view has been added, providing users with controls for chat behavior and appearance. Users can now select the default chat model and a separate utility chat model, configure language, temperature, and message limits, and adjust UI preferences like font size and code wrapping. The settings also allow configuring how the chat panel opens (panel, browser, or extension tab), including a URL field for browser mode and an option to open web pages in an in-app browser. Additionally, users can control the chat panel's 'always on top' behavior, including options to keep it on top when overlapping Xcode or disable it when detached.

Core/Sources/HostApp/FeatureSettings/Chat · high confidence

New custom command settings interface with export/import and type renaming

The Custom Command settings panel has been rebuilt using the Composable Architecture, introducing a dedicated UI for managing custom commands. Users can now create, edit, delete, and reorder commands, with support for exporting individual commands to JSON files and importing them via drag-and-drop or file picker. The interface enforces a 10-command limit for non-Plus users, prompting an upgrade when the limit is reached. Additionally, the 'Prompt to Code' command type has been renamed to 'Modification' in the UI and underlying state to better reflect its function.

Core/Sources/HostApp/CustomCommandSettings · high confidence

New embedding model management interface in Account Settings

Users can now configure and manage embedding models directly within the Account Settings. This change introduces a new management view and edit sheet that supports multiple model formats, including OpenAI, Azure OpenAI, Ollama, GitHub Copilot, and various OpenAI-compatible providers. The interface allows users to specify API keys, base URLs, and custom headers, while also exposing model-specific settings such as max tokens and embedding dimensions. A built-in test feature validates connectivity and dimension accuracy, providing immediate feedback via toast notifications.

Core/Sources/HostApp/AccountSettings/EmbeddingModelManagement · high confidence

New playground pages for QA and Web Scraper interactions

Added two new interactive playground pages: RetrievalQAChain and WebScrapper. The RetrievalQAChain page provides a UI for asking questions against web content, utilizing a QAInformationRetrievalChain to extract relevant information and documents, while the WebScrapper page allows users to input a URL and view the extracted web content directly.

Playground.playground/Pages · high confidence

New preference types for model providers, custom commands, and UI settings

The preferences system now includes dedicated type definitions for configuring AI model providers (OpenAI, Azure, GitHub Copilot, Codeium, and Google Gemini), embedding models, and custom commands with attachment support. It also introduces settings for open chat modes (panel, browser, or extensions), suggestion widget positioning and color schemes, and storable font and color preferences, enabling users to customize the tool's behavior and appearance through the preferences UI.

Tool/Sources/Preferences/Types · high confidence

New settings views for Codeium, GitHub Copilot, web search, and custom headers

The AccountSettings area now includes dedicated configuration screens for several services. Users can manage Codeium sign-in, installation status, and enterprise settings via CodeiumView. GitHub Copilot configuration is handled by GitHubCopilotView, which exposes node path and runner options, while GitHubCopilotModelPicker allows selection of specific LLM models. Web search capabilities are configured in WebSearchView, supporting Serp API and headless browser providers with a built-in test function. Additionally, CustomHeaderSettingsView enables users to add or remove custom HTTP headers for OpenAI-compatible models, and OtherSuggestionServicesView provides a link to external suggestion services.

Core/Sources/HostApp/AccountSettings · high confidence

New settings views for Prompt to Code, Terminal, and Xcode features

Added dedicated settings views for the Prompt to Code feature (allowing users to select chat/embedding models, toggle code wrapping, hide preceding spaces, and choose fonts/themes), the Terminal (font selection), and Xcode (idle tab closing in Pro builds). These new SwiftUI views integrate with the existing preferences system to expose granular control over these specific functionalities.

Core/Sources/HostApp/FeatureSettings · high confidence

New shared UI components for code display, editing, and settings

The SharedUIComponents module now includes a suite of reusable SwiftUI views to enhance the user interface. Users can now see code blocks with syntax highlighting, line numbers, and optional diff visualization (added/removed lines) via AsyncCodeBlock and AsyncDiffCodeBlock, which support features like dropping leading spaces and dimming typed content. A new DraggableCopyButton allows copying or dragging code content, while AutoresizingCustomTextEditor provides a text input field with dynamic height adjustment and completion support. The settings experience is improved with a FontPicker for selecting code fonts, SubSection for grouping settings with titles and descriptions, and SettingsDivider for visual separation. Additionally, CustomScrollView and DynamicHeightTextInFormWorkaround address layout issues, and XcodeStyleFrame applies a native Xcode-like aesthetic to panels.

Tool/Sources/SharedUIComponents · high confidence

New suggestion and modification UI components for the Suggestion Widget

The Suggestion Widget now includes dedicated SwiftUI views for displaying code suggestions, prompt-to-code modifications, errors, and toast notifications. Users will see a new CodeBlockSuggestionPanelView for navigating and accepting code suggestions, a PromptToCodePanelView for interacting with AI-generated code modifications, an ErrorPanelView for displaying errors, and a ToastPanelView for non-intrusive status messages with actionable buttons.

Core/Sources/SuggestionWidget/SuggestionPanelContent · high confidence

New web search providers: Apple Documentation, Bing API, SerpAPI, and headless browser engines

Users can now search Apple Developer Documentation directly, in addition to existing options. The service also introduces Bing Search via the official Bing Web Search API (requiring a subscription key), SerpAPI integration for Google, Baidu, Bing, and DuckDuckGo results, and a headless browser-based search supporting Google, Baidu, Bing, and DuckDuckGo. This entry covers the implementation of these specific search services and their configuration within the WebSearchService module.

Tool/Sources/WebSearchService · high confidence

Support for accepting code suggestions via Tab key

Users can now accept the first line of a code suggestion by pressing the Tab key in Xcode, provided the 'Accept Suggestion with Tab' preference is enabled. This feature monitors key events in the active Xcode editor and triggers the acceptance command when the Tab key is pressed, optionally requiring specific modifier keys (Shift, Control, Option, or Command) based on user settings. The behavior is context-aware, ensuring it only activates when a suggestion is currently presented in the editor.

Core/Sources/KeyBindingManager · high confidence

Support for accepting multiple code suggestions simultaneously

The SuggestionInjector now includes an acceptSuggestions method that allows users to apply multiple code completions in a single operation. The implementation automatically sorts the suggestions by their position in the document and dynamically adjusts the ranges of subsequent suggestions to account for line count changes caused by previously accepted insertions or deletions, ensuring that cursor positions and text modifications remain accurate throughout the batch process.

Tool/Sources/SuggestionInjector · high confidence

Sync Xcode color themes to code highlighting

The app now automatically mirrors your Xcode editor color scheme (both light and dark modes) into the code highlighting engine used for suggestions, prompt-to-code, and chat responses. This is achieved by a new \XcodeThemeController\ that reads Xcode's \.xccolortheme\ files, converts them to Highlight.js CSS, and applies them via a \HighlightrThemeManager\. Users can control this behavior using new preference keys (\syncSuggestionHighlightTheme\, \syncPromptToCodeHighlightTheme\, \syncChatCodeHighlightTheme\), and the theme syncs automatically when Xcode is activated or when the underlying Xcode theme file changes.

Core/Sources/XcodeThemeController · high confidence

Unified chat and embedding API services for multiple providers

The chat and embedding integrations have been restructured into a unified service layer that supports OpenAI, Claude, Google Generative AI, Ollama, and GitHub Copilot. A new \ChatCompletionsAPIBuilder\ routes requests to the appropriate provider-specific service (e.g., \ClaudeChatCompletionsService\, \GoogleAIChatCompletionsService\, \OllamaChatCompletionsService\, \GitHubCopilotChatCompletionsService\) based on the model format, while a \BuiltinExtensionChatCompletionsService\ handles Xcode extension-based chat. Embedding capabilities are similarly abstracted via \OpenAIEmbeddingService\, \OllamaEmbeddingService\, and \GitHubCopilotEmbeddingService\. The request body definitions now support tool calls, images, and custom headers, and streaming responses are standardized across all providers.

Tool/Sources/OpenAIService/APIs · high confidence

Web context collection with search and website querying

The chat assistant can now gather context from the web. When the 'web' scope is active, the system scans conversation history and current input for URLs. It provides two capabilities: a general web search (via the user's preferred provider) to find recent information, and a specific 'query website' function that fetches, embeds, and searches the content of provided URLs to answer questions based on that page's text.

Core/Sources/ChatContextCollectors/WebChatContextCollector · high confidence

Removals

Removal of SuggestionInjector component

The SuggestionInjector class, which previously handled the insertion, acceptance, and rejection of code suggestions (including managing comment markers and cursor positioning), has been removed from the codebase.

Core/Sources/SuggestionInjector · high confidence

XPC service implementation removed

The XPCService target and all its source files (including Environment, Helpers, Workspace, and protocol definitions) have been deleted from the codebase.

XPCService · high confidence

Architecture

Copilot service architecture refactored

The CopilotService module has been restructured by removing the legacy CopilotRequest and CopilotService files, which previously handled authentication, completion requests, and server initialization. This change consolidates the service logic, likely to support the new notification handling and configuration features introduced in other parts of the update.

Core/Sources/CopilotService · medium confidence

Introduce dedicated command handlers for suggestions and custom commands

The service layer now uses a new \SuggestionCommandHandler\ protocol and concrete implementations (\WindowBaseCommandHandler\, \PseudoCommandHandler\) to manage code suggestions and custom commands. This change centralizes the logic for presenting, accepting, and rejecting suggestions, as well as handling real-time suggestion generation and custom command execution, replacing previous ad-hoc handling mechanisms.

Core/Sources/Service/SuggestionCommandHandler · high confidence

Migrate preferences to a typed, key-path-based storage system

The application now uses a new, type-safe preference system in the Tool/Sources/Preferences module. This change introduces a structured \UserDefaultPreferenceKeys\ registry and custom \AppStorage\ initializers that bind directly to these keys via key paths, replacing the previous flat string-based UserDefaults access. This migration ensures that all preference values (including complex types like models and fonts) are strongly typed, have defined defaults, and are consistently managed, reducing the risk of configuration errors and improving maintainability.

Tool/Sources/Preferences · high confidence

Behavioural changes

Accessibility notification stream handles sleep/wake invalidation

The AXNotificationStream now includes a retry loop when registering accessibility notifications, specifically addressing cases where UI elements become invalid after macOS wakes from sleep. The stream also respects a user preference to choose between the default or common runloop modes for observing notifications.

Tool/Sources/AXNotificationStream · high confidence

Added Xcode workspace to support playgrounds

A new Xcode workspace has been created that groups the main project and the playground, enabling the playground to function correctly within the development environment.

Copilot for Xcode.xcworkspace · high confidence

Async token counting and new encoder implementations

The token counting mechanism in the TokenEncoder module has been updated to be asynchronous, allowing for non-blocking operations when determining token usage. This change introduces a new \TokenCounter\ protocol and updates the \TokenEncoder\ protocol to support async encoding. Additionally, new implementations have been added: \CharacterTokenCounter\ for simple character-based counting, \GoogleAITokenCounter\ which integrates with the Google Generative AI SDK for accurate token estimation, and \TiktokenCl100kBaseTokenEncoder\ which uses the Tiktoken library with the cl100k\_base vocabulary for GPT-4 style encoding. A resource file for the cl100k\_base encoding has also been included to support the Tiktoken encoder.

Tool/Sources/TokenEncoder · high confidence

Automated migration for file structure and model configuration changes

The application now automatically migrates user settings when updating to version 0.17.0. For users upgrading from version 1.3.5 or earlier, the system reorganizes the application support directory by moving the 'undefined' folder and setting correct permissions on the Copilot executable. For users upgrading from version 2.4.0 or earlier, the migration converts legacy API keys and model settings into the new unified Chat and Embedding model structures, ensuring that existing OpenAI and Azure OpenAI configurations are preserved and correctly mapped to the new model management system.

Core/Sources/ServiceUpdateMigration · high confidence

Centralized suggestion and chat presentation logic

The SuggestionPresenter now uses a new PresentInWindowSuggestionPresenter to handle code suggestion and chat interactions. This change consolidates how suggestions are presented, discarded, and marked as processing, while also introducing explicit error handling that filters out cancellation errors to prevent confusing user notifications. Additionally, it provides a dedicated method to open the chat panel, ensuring consistent behavior for launching the global chat feature from the service layer.

Core/Sources/Service/SuggestionPresenter · high confidence

Chat tabs now support self-closing and dynamic tab item generation

The ChatTab module has been restructured to allow individual chat tabs to close themselves and to build their own tab items, icons, and menus. This change introduces a new \ChatTabPool\ for managing active tabs and updates the \ChatTabItem\ reducer to handle close and focus actions, enabling users to manage their chat workspace more flexibly.

Tool/Sources/ChatTab · high confidence

ChatGPT chat tab rebuilt with new UI, architecture, and configuration options

The ChatGPT chat tab has been completely rewritten to use the Composable Architecture (TCA) and the new @ObservableState macro, replacing the previous implementation. This change introduces a redesigned chat panel with improved scroll-to-bottom behavior, asynchronous code block highlighting for better performance, and the ability to display file references within messages. Users can now customize the chat experience directly from the tab menu by selecting specific chat models, adjusting the temperature, and toggling default scopes. The tab also supports persistence, allowing chat history and configuration to be restored across sessions, and includes fixes for UI glitches and command injection vulnerabilities.

Core/Sources/ChatGPTChatTab · high confidence

Code highlight theme sync and smart text substitution controls

Users can now control whether code highlight themes sync with Xcode via a new CodeHighlightThemePicker component that exposes sync toggles for suggestions, prompt-to-code, and chat scenarios. Additionally, the EditableText component disables automatic smart quote and dash substitution in text editors to preserve literal input.

Core/Sources/HostApp/SharedComponents · high confidence

Codeium integration now supports Enterprise mode and automatic language server updates

The Codeium service has been restructured to support both automatic and custom Enterprise Language Server updates, including fixes for versioning issues. This change introduces a new authentication flow that routes user registration to a configurable enterprise endpoint when enterprise mode is enabled, and adds background tasks for periodic indexing updates and heartbeat monitoring to keep the language server synchronized.

Tool/Sources/CodeiumService/Services · high confidence

Copilot for Xcode project structure and command definitions

The Xcode project file for Copilot for Xcode has been restructured to include a comprehensive set of new source files and build configurations. This update introduces several new commands for the extension, including \ToggleRealtimeSuggestionsCommand\, \RealtimeSuggestionCommand\, \PrefetchSuggestionsCommand\, and \AcceptPromptToCodeCommand\, alongside existing ones like \GetSuggestionsCommand\ and \OpenChat\. The project now explicitly embeds the \Copilot.appex\ extension, the \XcodeKit.framework\, and various XPC services (\CommunicationBridge\, \Helper\, \CopilotForXcodeExtensionService.app\) into the final bundle. Additionally, it configures the copying of an extension point file and a launch agent plist, establishing the necessary infrastructure for the extension's background services and system integration.

Copilot for Xcode.xcodeproj · high confidence

Custom command templates now support dynamic editor context variables

The CustomCommandTemplateProcessor has been moved to the Tool module and now dynamically injects context from the active Xcode editor into command templates. Users can utilize placeholders such as {{selected\_code}}, {{active\_editor\_language}}, {{active\_editor\_file\_url}}, {{active\_editor\_file\_name}}, and {{clipboard}} to include the currently selected text, file details, language identifier, and clipboard content in their custom commands.

Tool/Sources/CustomCommandTemplateProcessor · high confidence

Dynamic App Group and Keychain Configuration

The app now dynamically generates the User Defaults suite name, Keychain access group, and Keychain service identifier at runtime by reading the TEAM\_ID\_PREFIX and BUNDLE\_IDENTIFIER\_BASE values from the Info.plist. This replaces any previous static configuration, ensuring that shared resources are correctly scoped to the specific team and bundle identifier without requiring manual updates to hardcoded strings.

Tool/Sources/Configs · high confidence

Editor extension commands restructured with new capabilities and improved responsiveness

The EditorExtension has been refactored to support a dynamic command system, introducing new user-facing commands including 'Write or Edit Code' (Prompt to Code), 'Open Chat', 'Accept Modification', 'Close Idle Tabs', and 'Prefetch Suggestions'. Existing commands like 'Accept Suggestion' now include a dedicated 'Accept Suggestion Line' option, and real-time suggestions are managed via 'Prepare for Real-time Suggestions' and 'Toggle Real-time Suggestions'. To improve responsiveness, commands now return immediately to the UI while processing in the background, and a 7-second timeout has been added to suggestion acceptance operations. The extension also now supports in-place buffer mutations for better cursor and selection handling, and allows users to define custom commands via settings.

EditorExtension · high confidence

Expose XPC extension service via a client accessor

The Client module now provides a \getService()\ function that returns the shared \XPCExtensionService\ instance. This accessor includes a safety check that throws an error if the code is running in Xcode Previews, ensuring the service is only used in actual app execution contexts.

Core/Sources/Client · high confidence

ExtensionService replaces XPCService with a menu bar app and updated XPC bridge

The background component has been renamed from XPCService to ExtensionService and now runs as a menu bar application (accessory activation policy) instead of a pure XPC service. It provides a status bar menu with items to open the host app, open the Extension Manager, open a global chat, check for updates, and access debug/observation controls (including an Xcode Inspector debug submenu and a Reactivate Observations button). The service now requests Accessibility API permission on launch, displays its permission status in the menu, and handles graceful shutdown via prepareForExit. XPC communication is managed by a new XPCController that maintains a bridge and a ping task to keep the connection alive, and entitlements have been updated to include keychain access groups.

ExtensionService · high confidence

GitHub Copilot language server integration and self-signed certificate support

The GitHub Copilot language server is now managed and updated automatically by the IDE, with a minimum supported version of 1.32.0 and a latest supported version of 1.57.0. To support enterprise environments, the service now includes a custom local process server that handles self-signed certificates by loading system root certificates via a bundled JavaScript helper, and it exposes a configurable notification handler to manage server-side events more reliably.

Tool/Sources/GitHubCopilotService/LanguageServer · high confidence

Introduce Tree-sitter based AST parser for Objective-C

The AST parser module has been replaced with a new implementation powered by Tree-sitter, specifically supporting Objective-C source code. This change introduces a new parsing engine that exposes syntax trees, node traversal capabilities, and debugging dump utilities, shifting the underlying technology from the previous parser to Tree-sitter for Objective-C files.

Tool/Sources/ASTParser · high confidence

Introduce new TCA-based reducers for the Suggestion Widget UI

The Suggestion Widget's user interface logic has been restructured into a new set of Composable Architecture (TCA) reducers. This change introduces dedicated reducers for the main widget container (Widget), the circular status widget (CircularWidget), the chat interface (ChatPanel), and the code modification interface (PromptToCodeGroup and PromptToCodePanel). It also adds reducers for toast notifications (ToastPanel) and panel state management (WidgetPanel, SharedPanel, SuggestionPanel). These files define the state, actions, and side effects for displaying, detaching, and interacting with the chat and prompt-to-code panels within the widget.

Core/Sources/SuggestionWidget/FeatureReducers · high confidence

Introduces new chat history management strategies with token-aware truncation

The chat memory system now supports multiple history management strategies via the new \AutoManagedChatGPTMemory\ and \TemplateChatGPTMemory\ actors, replacing the previous simple history storage. \AutoManagedChatGPTMemory\ automatically truncates conversation history based on token limits and message counts, supporting custom composition logic and handling tool call responses. \TemplateChatGPTMemory\ allows for dynamic content resolution and priority-based truncation rules. These changes enable more robust context window management for both OpenAI and Google AI models, ensuring that generated prompts stay within API limits while preserving critical system prompts and retrieved content.

Tool/Sources/OpenAIService/Memory · high confidence

Major UI overhaul and new update infrastructure

The host application's interface has been completely redesigned: the previous single-page layout (comprising AppInfo, Copilot, Instruction, and LaunchAgent views) has been removed and replaced with a tabbed interface (TabContainer) featuring a visual effect background. The app now integrates a Sparkle-based update checker with a delegate to handle service quiescence during relaunch. Additionally, the app's entitlements have been expanded to include Apple Events automation and a shared keychain access group, supporting the new modular architecture.

Copilot for Xcode · high confidence

Modernized launch agent installation and added file-change detection

The application now uses the macOS 13+ SMAppService API for registering launch agents, while falling back to dynamic plist generation and launchctl for earlier versions. It supports installing launch agents in \~/Library/LaunchAgents when the app is not located in /Applications, and enforces a minimum version check (40) to manage migration. Additionally, a new FileChangeChecker component was introduced to monitor executable integrity via MD5 checksums, enabling the system to detect when the executable has changed.

Core/Sources/LaunchAgentManager · high confidence

New Chat and Embedding model configuration structures

The AIModel module introduces new \ChatModel\ and \EmbeddingModel\ data structures to manage provider-specific settings. These models support multiple formats including OpenAI, Azure OpenAI, OpenAI-compatible, Google AI, Ollama, Claude, and GitHub Copilot. Users can now configure detailed options such as custom base URLs, API keys, organization/project IDs, and provider-specific parameters like Ollama's keep-alive or Google's API version. The embedding model structure also includes a \dimensions\ field and supports GitHub Copilot for embeddings.

Tool/Sources/AIModel · high confidence

New Suggestion feature settings UI with provider and scope controls

The settings interface for the Suggestion feature has been updated to include a dedicated General section where users can select the suggestion provider (GitHub Copilot, Codeium, or extensions), toggle real-time suggestions, and configure acceptance/dismissal shortcuts (including a configurable Tab-to-accept modifier). Users can now explicitly manage which projects have suggestions enabled and which languages are disabled for the feature, with new list views allowing them to add or remove projects and languages directly from the settings panel.

Core/Sources/HostApp/FeatureSettings/Suggestion · high confidence

Prompt-to-code service refactored to use ModificationAgent protocol

The prompt-to-code functionality has been restructured to implement the \ModificationAgent\ protocol, replacing the previous \PromptToCodeServiceType\. This change introduces a new \PromptToCodeSource\ model to encapsulate editor context (language, URLs, content, lines, and cursor range) and provides concrete implementations including \SimpleModificationAgent\ for live code modification via OpenAI and \PreviewModificationAgent\ for generating static preview content. Users will experience this as the underlying engine for AI-assisted code generation and modification, now driven by a more explicit source-context model and distinct agent roles.

Core/Sources/PromptToCodeService · high confidence

Real-time suggestions now use debounced throttling and automatic workspace cleanup

The service layer now manages real-time code suggestions with improved responsiveness and resource efficiency. The RealtimeSuggestionController uses a 200ms throttle on editor value and selection changes to debounce triggers, and enforces a minimum 0.15-second debounce for prefetching to prevent excessive requests. Additionally, a new ScheduledCleaner runs every 10 minutes (or when Xcode is no longer active) to automatically remove idle workspaces and filespaces, ensuring that background resources are released when they are no longer needed.

Core/Sources/Service · high confidence

Redesigned Codeium language server integration with enterprise support and local indexing

The Codeium language server integration has been restructured to support automatic and custom enterprise updates, allowing enterprise users to receive version updates from their own portal rather than the public Codeium release channel. The new installation manager handles version checking, downloading, and extraction for both standard and enterprise modes. Additionally, the integration now supports local code indexing and search, configurable via user preferences for maximum file size and workspace file count, enhancing code completion context. The language server process is now managed with explicit argument passing for API server URLs, enterprise mode flags, and indexing features, and includes a heartbeat mechanism to maintain connection stability.

Tool/Sources/CodeiumService/LanguageServer · high confidence

Redesigned chat message UI with reference support and customizable markdown themes

The chat interface now displays bot and user messages with distinct visual styles, including context menus for copying, deleting, and setting extra system prompts. Bot messages feature a new reference system that lists used sources in a popover, with color-coded icons distinguishing between code symbols, text files, and webpages. Markdown rendering is now themeable via \ThemedMarkdownText\, allowing users to customize code block colors and fonts, with an option to sync with the editor's highlight theme. Code blocks can be configured to wrap or scroll horizontally based on user preferences, and function call messages receive a specialized markdown theme.

Core/Sources/ChatGPTChatTab/Views · high confidence

Refactor XcodeInspector to use Perceptible and handle accessibility notifications

The XcodeAppInstanceInspector class has been rewritten to adopt the Perceptible framework instead of ObservableObject, enabling more efficient reactive updates for UI elements. It now explicitly handles a wide range of AXNotification events (such as title changes, window moves, and completion panel updates) via an AsyncPassthroughSubject, allowing the inspector to react to real-time accessibility changes in Xcode. Additionally, the implementation includes logic to detect and manage the completion panel state and document URLs, improving the accuracy of tracking active files and workspaces.

Tool/Sources/XcodeInspector/Apps · high confidence

Refactored active document context collection with gitignore awareness

The ActiveDocumentChatContextCollector has been rewritten to replace the legacy logic with a new implementation that respects gitignore status. When the active file is gitignored, the collector now suppresses sensitive file content and restricts available functions, prompting the user to select code manually. The new collector also introduces a \GetCodeCodeAroundLineFunction\ to retrieve specific line ranges on demand, while the legacy collector is preserved as \LegacyActiveDocumentChatContextCollector\ for compatibility.

Tool/Sources/ChatContextCollectors/ActiveDocumentChatContextCollector · high confidence

Refactored chat tab management and widget data handling

The GUI service has been restructured to centralize chat tab creation and persistence. A new ChatTabFactory manages the collection of chat tab builders, distinguishing between default replacements and other tabs from extensions. The GraphicalUserInterfaceController now orchestrates chat tab lifecycle events (creation, closing, switching) via a chat tab pool and integrates with ChatTabPersistent for restoring tab state and order. Additionally, a dedicated WidgetDataSource class implements SuggestionWidgetDataSource to provide code suggestions to the widget by querying the active workspace's file spaces.

Core/Sources/Service/GUI · high confidence

Refactored suggestion service to support pluggable providers and middleware

The SuggestionService has been restructured to decouple the core service logic from specific suggestion providers, allowing for easier swapping of backend services (such as Codeium or GitHub Copilot) via a new SuggestionServiceProvider protocol. The service now supports a middleware pipeline for post-processing suggestions and an event handler system to track user interactions like accepting or rejecting suggestions. Additionally, a new UserDefaultsObserver utility was added to facilitate observing preference changes, enabling the service to dynamically adapt to user configuration updates.

Core/Sources/SuggestionService · high confidence

Refactored suggestion service with improved validation and gitignore handling

The workspace suggestion service has been restructured to improve reliability and user control. Validation logic is now stricter: suggestions are invalidated if the user's cursor moves to a different line, if the typed content diverges from the suggestion's prefix, or if the suggestion would result in no change to the file. The service now correctly handles Unicode characters (including emojis) by operating on UTF-16 views rather than string manipulation, preventing corruption or incorrect invalidation. Additionally, suggestions are no longer generated for files that are ignored by Git, and the gitignore check is disabled by default to prevent unexpected behavior in mixed environments. The service architecture has been split into a provider and a service, with configuration managed via user defaults for enabling/disabling the feature globally or per-project.

Tool/Sources/WorkspaceSuggestionService · high confidence

Removal of CopilotCompletion and LSP type aliases

The CopilotCompletion struct and the CursorPosition/CursorRange type aliases (ExportedFromLSP) have been removed from the CopilotModel module. This eliminates the direct dependency on the LanguageServerProtocol types for these specific definitions, likely as part of a refactoring to decouple the model layer from the LSP protocol layer.

Core/Sources/CopilotModel · high confidence

Suggestion post-processing and middleware architecture

The suggestion provider now uses a middleware pipeline to refine code suggestions before they reach the user. A new PostProcessingSuggestionServiceMiddleware cleans up raw output by removing trailing whitespace, stripping redundant closing parentheses that duplicate the next line, and filtering out suggestions that would have no effect on the code. The system also introduces a SuggestionServiceEventHandler to track accepted and rejected suggestions, and a DisabledLanguageSuggestionServiceMiddleware to block suggestions for languages explicitly disabled in settings.

Tool/Sources/SuggestionProvider · high confidence

Toast notifications now support buttons and namespace-based deduplication

The Toast component has been enhanced to allow interactive toasts with action buttons and to prevent duplicate messages. Users can now add buttons to toast messages, enabling direct actions from the notification. Additionally, toasts are now deduplicated based on content, type, and an optional namespace, ensuring that repeated toasts with the same details do not clutter the interface. This change also introduces a new reducer for managing toast state within the Composable Architecture.

Tool/Sources/Toast · high confidence

Unified app activation with Accessibility API fallback

The AppActivator tool now uses a unified implementation to bring applications to the front, preferring the standard NSRunningApplication.activate() method which only affects the active window. If that fails, it falls back to the macOS Accessibility API (AXUIElement) to force the app to the front. This change also introduces a configurable delay before activation and exposes these activation behaviors through the Dependencies framework for easier testing and customization.

Tool/Sources/AppActivator · high confidence

Updated Xcode scheme configurations for Core components

The Xcode scheme files for the Client, HostApp, Service, and SuggestionInjector targets have been updated to align with the new project structure. This includes adding new scheme definitions for Client, HostApp, and Service, and upgrading the SuggestionInjector scheme's last upgrade version from 1410 to 1520, ensuring compatibility with the current development environment.

Core/.swiftpm · high confidence

Workspace cleanup now cancels in-flight suggestion requests

The Workspace now includes logic to cancel any active real-time suggestion requests during the cleanup process. This ensures that stale or abandoned suggestions are properly terminated when files are closed or workspaces are tidied up, preventing potential resource leaks or inconsistent state in the suggestion service.

Core/Sources/Service/WorkspaceExtension · high confidence

XcodeInspector refactored into modular components with improved editor content handling

The XcodeInspector tool has been restructured into distinct modules (AppInstanceInspector, SourceEditor, XcodeWindowInspector, and TriggerCommand) to improve maintainability and thread safety. The SourceEditor now includes a caching mechanism to optimize the expensive process of retrieving editor content, and it exposes accessibility notifications for content and scroll changes. The inspector now tracks the latest focused editor and workspace URLs more robustly, supporting various project types like git worktrees and playgrounds. Additionally, command triggering logic has been extracted to allow optional Xcode activation, and the main inspector class now uses the Perceptible framework for state observation.

Tool/Sources/XcodeInspector · high confidence

Test coverage

Added and reorganized tests for GitHub Copilot suggestion service; Added empty test file for SuggestionWidgetTests; Added initial test file for OverlayWindow; Added test file for TiktokenCl100kBaseTokenEncoder; Added tests for AST parser cursor deep-first search; Added tests for ExplanationThenCodeStreamParser; Added tests for HeadlessBrowserSearchService; Added tests for Objective-C and Swift focused code finding; Added tests for PostProcessingSuggestionServiceMiddleware; Added tests for SourceEditor range conversion and caching; Added tests for SuggestionBasic text extraction and modification logic; Added tests for Tab-to-Accept suggestion logic; Added tests for USearch vector store integration; Added tests for chat scope parsing; Added tests for code extraction logic; Added tests for code line conversion and leading space handling; Added tests for code suggestion validation and selection extraction; Added tests for suggestion acceptance logic; Added tests for the v2.4.0 data migration logic; Added unit tests for ChatAgent output parsing; Added unit tests for JoinJSON; Added unit tests for Keychain scope handling; Added unit tests for OpenAIService memory management and API integration; Added unit tests for text splitting and chunk merging logic; Added unit tests for the CodeDiff module; Removed XCPServiceTests test suite and test infrastructure; Removed legacy SuggestionInjector tests.

Dependencies

Dependency updates and new ChatPlugins package

The project has added a new ChatPlugins package containing TerminalChatPlugin and ShortcutChatPlugin targets, which depend on the Tool package. Several dependencies have been updated or added, including Sparkle (2.4.0 to 2.7.0 in some manifests), swift-composable-architecture (0.55.0 to 1.16.1), swift-dependencies (0.5.1 to 1.4.0), and swift-markdown-ui (2.1.0 to 2.4.1). The Core package now depends on Tool, ChatPlugins, and OverlayWindow, and has added dependencies on swift-markdown-ui, Sparkle, swift-parsing, swift-dependencies, KeyboardShortcuts, and CGEventOverride. The minimum macOS platform for Core has been raised from 12 to 13.

(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 45 → 33 (-12.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 78 → 71 (-6.6)
  • Architecture 90 → 90 (+0.0)
  • Maturity 58 → 63 (+5.2)
  • Readiness 27 → 27 (-0.0)
  • Security 98 → 95 (-2.5)
  • Event Sourcing 49 → 10 (-38.6)
  • Performance 78 → 100 (+22.3)

Resolved (28)

  • Change coupling: ObjectiveCCodeFinder.swift ↔ SwiftFocusedCodeFinder.swift (Tool/Sources/FocusedCodeFinder/ObjectiveC/ObjectiveCCodeFinder.swift)
  • Duplicated block (10 lines × 2) (Tool/Sources/CodeiumService/Services/CodeiumService.swift)
  • Duplicated block (10 lines × 3) (Tool/Sources/OpenAIService/EmbeddingService.swift)
  • Duplicated block (12 lines × 2) (Core/Sources/HostApp/AccountSettings/ChatModelManagement/ChatModelManagement.swift)
  • Duplicated block (12 lines × 2) (Core/Sources/UserDefaultsObserver/UserDefaultsObserver.swift)
  • Duplicated block (12 lines × 2) (Tool/Sources/OpenAIService/APIs/OpenAIChatCompletionsService.swift)
  • Duplicated block (12 lines × 2) (Tool/Sources/OpenAIService/APIs/OpenAIChatCompletionsService.swift)
  • Duplicated block (14 lines × 2) (Tool/Sources/Terminal/Terminal.swift)
  • Duplicated block (16 lines × 2) (Tool/Sources/ModificationBasic/ExplanationThenCodeStreamParser.swift)
  • Duplicated block (17 lines × 2) (Tool/Sources/AIModel/ChatModel.swift)
  • Duplicated block (17–18 lines × 3) (Core/Sources/Service/SuggestionCommandHandler/PseudoCommandHandler.swift)
  • Duplicated block (21 lines × 3) (Core/Sources/Service/SuggestionCommandHandler/PseudoCommandHandler.swift)
  • Duplicated block (27 lines × 2) (Tool/Sources/SharedUIComponents/AsyncCodeBlock.swift)
  • Duplicated block (28 lines × 2) (Core/Sources/HostApp/AccountSettings/ChatModelManagement/ChatModelEdit.swift)
  • Duplicated block (41 lines × 2) (Core/Sources/HostApp/AccountSettings/ChatModelManagement/ChatModelManagement.swift)
  • Duplicated block (5 lines × 2) (Core/Sources/LaunchAgentManager/LaunchAgentManager.swift)
  • Duplicated block (5 lines × 2) (Core/Sources/PromptToCodeService/OpenAIPromptToCodeService.swift)
  • Duplicated block (5 lines × 2) (Tool/Sources/ChatBasic/ChatGPTFunction.swift)
  • Duplicated block (6 lines × 2) (Tool/Sources/AIModel/ChatModel.swift)
  • Duplicated block (6 lines × 2) (Tool/Sources/CodeiumService/CodeiumExtension.swift)
  • …and 8 more

New (104)

  • Duplicated block (10 lines × 2) (Tool/Sources/OpenAIService/APIs/OpenAIChatCompletionsService.swift)
  • Duplicated block (10 lines × 3) (Tool/Sources/OpenAIService/EmbeddingService.swift)
  • Duplicated block (12 lines × 2) (Core/Sources/HostApp/AccountSettings/ChatModelManagement/ChatModelManagement.swift)
  • Duplicated block (12 lines × 2) (Core/Sources/UserDefaultsObserver/UserDefaultsObserver.swift)
  • Duplicated block (12 lines × 2) (Tool/Sources/OpenAIService/APIs/OpenAIChatCompletionsService.swift)
  • Duplicated block (14 lines × 2) (Tool/Sources/Terminal/Terminal.swift)
  • Duplicated block (16 lines × 2) (Tool/Sources/ModificationBasic/ExplanationThenCodeStreamParser.swift)
  • Duplicated block (27 lines × 2) (Tool/Sources/SharedUIComponents/AsyncCodeBlock.swift)
  • Duplicated block (28 lines × 2) (Core/Sources/HostApp/AccountSettings/ChatModelManagement/ChatModelEdit.swift)
  • Duplicated block (38–39 lines × 3) (Core/Sources/Service/SuggestionCommandHandler/PseudoCommandHandler.swift)
  • Duplicated block (41 lines × 2) (Core/Sources/HostApp/AccountSettings/ChatModelManagement/ChatModelManagement.swift)
  • Duplicated block (6 lines × 2) (Tool/Sources/AIModel/ChatModel.swift)
  • Duplicated block (6 lines × 2) (Tool/Sources/CodeiumService/CodeiumExtension.swift)
  • Duplicated block (7 lines × 2) (Tool/Sources/CodeiumService/CodeiumExtension.swift)
  • Duplicated block (7 lines × 2) (Tool/Sources/GitHubCopilotService/LanguageServer/GitHubCopilotService.swift)
  • Duplicated block (7 lines × 2) (Tool/Sources/SharedUIComponents/CustomTextEditor.swift)
  • Duplicated block (8 lines × 3) (Core/Sources/HostApp/AccountSettings/ChatModelManagement/ChatModelEditView.swift)
  • Duplicated block (9 lines × 2) (Tool/Sources/OpenAIService/APIs/ClaudeChatCompletionsService.swift)
  • Duplicated block (9 lines × 3) (Tool/Sources/OpenAIService/APIs/OpenAIChatCompletionsService.swift)
  • Edited copies of one member (3 members, 10+ corresponding lines) (Core/Sources/Service/SuggestionCommandHandler/WindowBaseCommandHandler.swift)
  • …and 84 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

intitni/CopilotForXcode 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 14 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 b59c57aa8c1d777d6c5d7057e9a5fc97ed5b8aab — the exact code this score is about.
  • Scored under rubric-2026.11.4 — 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.65+preprod-e1a3b69fc8ee.