intitni/CopilotForXcode
32.7
Weak · 14 November 2026
56.9k
lines of production code
Swift
primary language
5
measurements over time
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.