ericvoltolin/xc-mcp

XC-MCP: Lean Xcode CLI Wrapper to Cut LLM Token Usage
🚀 XCode CLI MCP is a convenient wrapper for Xcode CLI tools. It shortens long outputs by summarizing them, helping reduce token usage when interacting with language models. It keeps your workflow smooth while you focus on code, builds, and diagnostics.
Table of Contents
- Why XC-MCP
- Core ideas and concepts
- Features
- How it works
- Getting started
- Installation
- Quick start guide
- CLI reference
- Model Context Protocol
- Architecture and components
- How to contribute
- Roadmap
- License and credits
- Frequently asked questions
Why XC-MCP
- You work with Xcode CLI tools daily. The outputs can be verbose and noisy.
- You want fewer tokens when you feed logs and commands into an LLM.
- You need a reliable wrapper that can summarize, filter, and structure CLI results.
- You want a simple tool that stays out of your way and focuses on your code.
Core ideas and concepts
- Convenience wrapper: It sits on top of the standard Xcode command line tools, adding a friendly layer that surfaces essential information.
- Output summarization: Long CLI outputs get converted into concise, context-rich summaries.
- Model-context friendly: The wrapper prepares compact prompts that preserve meaning and intent for LLMs.
- Extensible: The architecture supports multiple “contexts” and adapters, enabling easy integration with different tooling chains.
- Local-first by default: Summaries and context data stay on your machine unless you opt-in to share.
Features
- Lightweight CLI with sensible defaults
- Summarize long build logs, test results, and diagnostic outputs
- Preserve critical details like errors, warnings, and stack traces in a compact form
- Easy to extend with a Model Context Protocol
- Shop-friendly design for local development and CI pipelines
- Clear, actionable prompts for LLMs without large token bloat
- Simple, deterministic outputs for automation and scripting
- Supports common Xcode workflows and tooling ecosystems
How it works
- Wraps Xcode CLI calls
- Captures standard output and standard error
- Applies a summarization step that preserves key signals (errors, failures, durations)
- Produces concise context blocks suitable for LLM prompts
- Exposes a clean CLI for quick operations and a modular codebase for expansion
Model Context Protocol
- The Model Context Protocol defines how to structure data for models.
- It focuses on keeping prompts short while carrying enough signal for accurate responses.
- Context blocks include:
- Problem statement or goal
- Key outputs (summaries of logs)
- Critical signals (errors, timeouts, warnings)
- Optional metadata (timestamps, IDs)
- Implementations can adapt to different LLMs, languages, or prompt formats.
- The protocol is designed to be simple to extend, so you can add your own adapters without breaking existing behavior.
Architecture and components
- Core wrapper: The main entry point for interacting with Xcode CLI tools.
- Summarization module: A deterministic algorithm that reduces lengthy outputs to compact summaries.
- Context builder: Gathers necessary signals and formats them for your chosen model.
- Plugin/adapter layer: Allows adding new commands, outputs, or integration points without changing core logic.
- Server module (optional): A lightweight service to coordinate multiple XC-MCP clients or tools.
- Tools and Xcode integration: Bridges to common Xcode CLI commands (build, test, archive, run, etc.)
- Data model: Simple, human-readable, versioned structures for outputs and summaries.
Getting started
- Prerequisites
- macOS with Xcode Command Line Tools installed
- A working Xcode installation and access to xcodebuild or other standard CLI tools
- Basic familiarity with terminal usage and JSON or plain-text logs
- What you’ll get
- A single, focused CLI tool to execute Xcode commands and receive concise outputs