Experimental incremental build support!

Author: cameroncooke

.gitignore

@@ -87,3 +87,6 @@ xcuserdata/
 
 # Sentry Config File
 .sentryclirc
+
+# incremental builds
+Makefile

README.md

@@ -18,6 +18,7 @@ A Model Context Protocol (MCP) server that provides Xcode-related tools for inte
    * [One-line setup with mise](#one-line-setup-with-mise)
    * [Configure MCP clients](#configure-mcp-clients)
    * [Enabling UI Automation (beta)](#enabling-ui-automation-beta)
+- [Incremental build support](#incremental-build-support)   
 - [Troubleshooting](#troubleshooting)
    * [Diagnostic Tool](#diagnostic-tool)
       + [Using with mise](#using-with-mise)
@@ -56,6 +57,7 @@ The XcodeBuildMCP server provides the following tool capabilities:
 - **Build Operations**: Platform-specific build tools for macOS, iOS simulator, and iOS device targets
 - **Project Information**: Tools to list schemes and show build settings for Xcode projects and workspaces
 - **Clean Operations**: Clean build products using xcodebuild's native clean action
+- **Incremental build support**: Lightning fast builds using incremental build support (experimental, opt-in required)
 
 ### Simulator management
 - **Simulator Control**: List, boot, and open iOS simulators 
@@ -136,6 +138,35 @@ pip install fb-idb==1.1.7
 > [!NOTE]
 > Displaying images in tool responses and embedding them in chat context may not be supported by all MCP Clients; it's currently known to be supported in Cursor.
 
+## Incremental build support
+
+XcodeBuildMCP includes experimental support for incremental builds. This feature is disabled by default and can be enabled by setting the `INCREMENTAL_BUILDS_ENABLED` environment variable to `true`:
+
+To enable incremental builds, set the `INCREMENTAL_BUILDS_ENABLED` environment variable to `true`:
+
+Example MCP client configuration:
+```bash
+{
+  "mcpServers": {
+    "XcodeBuildMCP": {
+      "command": "mise",
+      "args": [
+        "x",
+        "npm:xcodebuildmcp@1.3.5",
+        "--",
+        "xcodebuildmcp"
+      ],
+      "env": {
+        "INCREMENTAL_BUILDS_ENABLED": "true"
+      }        
+    }
+  }
+}
+```
+
+> [!IMPORTANT]
+> Please note that incremental builds support is currently highly experimental and your mileage may vary. Please report any issues you encounter to the [issue tracker](https://github.com/cameroncooke/XcodeBuildMCP/issues).
+
 ## Troubleshooting
 
 If you encounter issues with XcodeBuildMCP, the diagnostic tool can help identify the problem by providing detailed information about your environment and dependencies.

example_projects/iOS/MCPTest/ContentView.swift

@@ -9,7 +9,7 @@ import SwiftUI
 import OSLog
 
 struct ContentView: View {
-    @State private var text = ""
+    @State private var text: String = ""
 
     var body: some View {
         VStack {
@@ -24,7 +24,7 @@ struct ContentView: View {
             Button("Log something") {
                 let message = ProcessInfo.processInfo.environment.map { "\($0.key): \($0.value)" }.joined(separator: "\n")
                 Logger.myApp.debug("Environment: \(message)")                
-                debugPrint("Button was pressed")
+                debugPrint("Button was pressed.")
 
                 text = "You just pressed the button!"
             }

src/index.ts

@@ -92,11 +92,30 @@ import { registerDiagnosticTool } from './tools/diagnostic.js';
 import { setupIdb } from './utils/idb-setup.js';
 import { version } from './version.js';
 
+// Import xcodemake utilities
+import { isXcodemakeEnabled, isXcodemakeAvailable } from './utils/xcodemake.js';
+
 /**
  * Main function to start the server
  */
 async function main(): Promise<void> {
   try {
+    // Check if xcodemake is enabled and available
+    if (isXcodemakeEnabled()) {
+      log('info', 'xcodemake is enabled, checking if available...');
+      const available = await isXcodemakeAvailable();
+      if (available) {
+        log('info', 'xcodemake is available and will be used for builds');
+      } else {
+        log(
+          'warn',
+          'xcodemake is enabled but could not be made available, falling back to xcodebuild',
+        );
+      }
+    } else {
+      log('debug', 'xcodemake is disabled, using standard xcodebuild');
+    }
+
     // Create the server
     const server = createServer();
 

src/tools/diagnostic.ts

@@ -19,6 +19,7 @@ import { log } from '../utils/logger.js';
 import { execSync } from 'child_process';
 import { version } from '../version.js';
 import { areIdbToolsAvailable } from '../utils/idb-setup.js';
+import { isXcodemakeEnabled, isXcodemakeAvailable, doesMakefileExist } from '../utils/xcodemake.js';
 import * as os from 'os';
 
 // Constants
@@ -109,7 +110,7 @@ export function getXcodeInfo():
 export function getEnvironmentVariables(): Record<string, string | undefined> {
   const relevantVars = [
     'XCODEBUILDMCP_DEBUG',
-    'XCODEMAKE_ENABLED',
+    'INCREMENTAL_BUILDS_ENABLED',
     'XCODEBUILDMCP_RUNNING_UNDER_MISE',
     'PATH',
     'DEVELOPER_DIR',
@@ -195,6 +196,11 @@ export async function runDiagnosticTool(_params: unknown): Promise<ToolResponse>
   // Check for idb tools availability
   const idbAvailable = areIdbToolsAvailable();
 
+  // Check for xcodemake configuration
+  const xcodemakeEnabled = isXcodemakeEnabled();
+  const xcodemakeAvailable = await isXcodemakeAvailable();
+  const makefileExists = doesMakefileExist('./');
+
   // Compile the diagnostic information
   const diagnosticInfo = {
     serverVersion: version,
@@ -210,6 +216,11 @@ export async function runDiagnosticTool(_params: unknown): Promise<ToolResponse>
         uiAutomationSupported:
           idbAvailable && binaryStatus['idb'].available && binaryStatus['idb_companion'].available,
       },
+      xcodemake: {
+        enabled: xcodemakeEnabled,
+        available: xcodemakeAvailable,
+        makefileExists: makefileExists,
+      },
       mise: {
         running_under_mise: Boolean(process.env.XCODEBUILDMCP_RUNNING_UNDER_MISE),
         available: binaryStatus['mise'].available,
@@ -255,19 +266,27 @@ export async function runDiagnosticTool(_params: unknown): Promise<ToolResponse>
     `- Available: ${diagnosticInfo.features.idb.available ? '✅ Yes' : '❌ No'}`,
     `- UI Automation Supported: ${diagnosticInfo.features.idb.uiAutomationSupported ? '✅ Yes' : '❌ No'}`,
 
+    `\n### Incremental Builds`,
+    `- Enabled: ${diagnosticInfo.features.xcodemake.enabled ? '✅ Yes' : '❌ No'}`,
+    `- Available: ${diagnosticInfo.features.xcodemake.available ? '✅ Yes' : '❌ No'}`,
+    `- Makefile exists: ${diagnosticInfo.features.xcodemake.makefileExists ? '✅ Yes' : '❌ No'}`,
+
     `\n### Mise Integration`,
     `- Running under mise: ${diagnosticInfo.features.mise.running_under_mise ? '✅ Yes' : '❌ No'}`,
     `- Mise available: ${diagnosticInfo.features.mise.available ? '✅ Yes' : '❌ No'}`,
 
     `\n## Tool Availability Summary`,
     `- Build Tools: ${!('error' in diagnosticInfo.xcode) ? '\u2705 Available' : '\u274c Not available'}`,
     `- UI Automation Tools: ${diagnosticInfo.features.idb.uiAutomationSupported ? '\u2705 Available' : '\u274c Not available'}`,
+    `- Incremental Build Support: ${diagnosticInfo.features.xcodemake.available && diagnosticInfo.features.xcodemake.enabled ? '\u2705 Available & Enabled' : diagnosticInfo.features.xcodemake.available ? '\u2705 Available but Disabled' : '\u274c Not available'}`,
 
     `\n## Sentry`,
     `- Sentry enabled: ${diagnosticInfo.environmentVariables.SENTRY_DISABLED !== 'true' ? '✅ Yes' : '❌ No'}`,
 
     `\n## Troubleshooting Tips`,
     `- If UI automation tools are not available, install idb: \`pip3 install fb-idb\``,
+    `- If incremental build support is not available, you can download the tool from https://github.com/cameroncooke/xcodemake. Make sure it's executable and available in your PATH`,
+    `- To enable xcodemake, set environment variable: \`export INCREMENTAL_BUILDS_ENABLED=1\``,
     `- For mise integration, follow instructions in the README.md file`,
   ].join('\n');
 

src/types/common.ts

@@ -64,14 +64,19 @@ export interface ValidationResult {
 }
 
 /**
- * XcodeCommandResponse - Result of xcodebuild command execution
+ * CommandResponse - Generic result of command execution
  */
-export interface XcodeCommandResponse {
+export interface CommandResponse {
   success: boolean;
   output: string;
   error?: string;
 }
 
+/**
+ * XcodeCommandResponse - Result of xcodebuild command execution
+ */
+export type XcodeCommandResponse = CommandResponse;
+
 /**
  * Interface for shared build parameters
  */

src/utils/build-utils.ts

@@ -11,6 +11,7 @@
  * - Standardizing response formatting for build results
  * - Managing build-specific error handling and reporting
  * - Supporting various build actions (build, clean, showBuildSettings, etc.)
+ * - Supporting xcodemake as an alternative build strategy for faster incremental builds
  *
  * This file depends on the lower-level utilities in xcode.ts for command execution
  * while adding build-specific behavior, formatting, and error handling.
@@ -20,6 +21,15 @@ import { log } from './logger.js';
 import { executeXcodeCommand, XcodePlatform, constructDestinationString } from './xcode.js';
 import { ToolResponse, SharedBuildParams, PlatformBuildOptions } from '../types/common.js';
 import { createTextResponse } from './validation.js';
+import {
+  isXcodemakeEnabled,
+  isXcodemakeAvailable,
+  executeXcodemakeCommand,
+  executeMakeCommand,
+  doesMakefileExist,
+  doesMakeLogFileExist,
+} from './xcodemake.js';
+import path from 'path';
 
 /**
  * Common function to execute an Xcode build command across platforms
@@ -48,12 +58,36 @@ export async function executeXcodeBuild(
 
   log('info', `Starting ${platformOptions.logPrefix} ${buildAction} for scheme ${params.scheme}`);
 
+  // Check if xcodemake is enabled and available
+  const useXcodemake = isXcodemakeEnabled();
+  let xcodemakeAvailable = false;
+
+  if (useXcodemake && buildAction === 'build') {
+    xcodemakeAvailable = await isXcodemakeAvailable();
+    if (!xcodemakeAvailable) {
+      log('info', 'xcodemake is enabled but not available. Falling back to xcodebuild.');
+      buildMessages.push({
+        type: 'text',
+        text: '⚠️ incremental build support is enabled but xcodemake is not found in PATH. Falling back to xcodebuild.',
+      });
+    } else {
+      log('info', 'Using xcodemake for faster incremental builds.');
+      buildMessages.push({
+        type: 'text',
+        text: 'ℹ️ Using xcodemake for faster incremental builds.',
+      });
+    }
+  }
+
   try {
     const command = ['xcodebuild'];
 
+    let projectDir = '';
     if (params.workspacePath) {
+      projectDir = path.dirname(params.workspacePath);
       command.push('-workspace', params.workspacePath);
     } else if (params.projectPath) {
+      projectDir = path.dirname(params.projectPath);
       command.push('-project', params.projectPath);
     }
 
@@ -116,13 +150,47 @@ export async function executeXcodeBuild(
       command.push('-derivedDataPath', params.derivedDataPath);
     }
 
-    if (params.extraArgs) {
+    if (params.extraArgs && params.extraArgs.length > 0) {
       command.push(...params.extraArgs);
     }
 
     command.push(buildAction);
 
-    const result = await executeXcodeCommand(command, platformOptions.logPrefix);
+    // Execute the command using xcodemake or xcodebuild
+    let result;
+    if (useXcodemake && xcodemakeAvailable) {
+      // Check if Makefile already exists
+      const makefileExists = doesMakefileExist(projectDir);
+      log('debug', 'Makefile exists: ' + makefileExists);
+
+      // Check if Makefile log already exists
+      const makeLogFileExists = doesMakeLogFileExist(projectDir, command);
+      log('debug', 'Makefile log exists: ' + makeLogFileExists);
+
+      if (makefileExists && makeLogFileExists) {
+        // Use make for incremental builds
+        buildMessages.push({
+          type: 'text',
+          text: 'ℹ️ Using make for incremental build',
+        });
+        result = await executeMakeCommand(projectDir, platformOptions.logPrefix);
+      } else {
+        // Generate Makefile using xcodemake
+        buildMessages.push({
+          type: 'text',
+          text: 'ℹ️ Generating Makefile with xcodemake (first build may take longer)',
+        });
+        // Remove 'xcodebuild' from the command array before passing to executeXcodemakeCommand
+        result = await executeXcodemakeCommand(
+          projectDir,
+          command.slice(1),
+          platformOptions.logPrefix,
+        );
+      }
+    } else {
+      // Use standard xcodebuild
+      result = await executeXcodeCommand(command, platformOptions.logPrefix);
+    }
 
     // Grep warnings and errors from stdout (build output)
     const warningOrErrorLines = grepWarningsAndErrors(result.output);
@@ -163,6 +231,14 @@ export async function executeXcodeBuild(
     // Create additional info based on platform and action
     let additionalInfo = '';
 
+    // Add xcodemake info if relevant
+    if (useXcodemake && xcodemakeAvailable && buildAction === 'build') {
+      additionalInfo += `xcodemake: Using faster incremental builds with xcodemake. 
+Future builds will use the generated Makefile for improved performance.
+
+`;
+    }
+
     // Only show next steps for 'build' action
     if (buildAction === 'build') {
       if (platformOptions.platform === XcodePlatform.macOS) {

src/utils/command.ts

@@ -0,0 +1,63 @@
+/**
+ * Command Utilities - Generic command execution utilities
+ *
+ * This utility module provides functions for executing shell commands.
+ * It serves as a foundation for other utility modules that need to execute commands.
+ *
+ * Responsibilities:
+ * - Executing shell commands with proper argument handling
+ * - Managing process spawning, output capture, and error handling
+ */
+
+import { spawn } from 'child_process';
+import { log } from './logger.js';
+
+/**
+ * Command execution response interface
+ */
+export interface CommandResponse {
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+/**
+ * Execute a shell command
+ * @param command Command string to execute
+ * @returns Promise resolving to command response
+ */
+export async function executeCommand(command: string): Promise<CommandResponse> {
+  log('info', `Executing command: ${command}`);
+
+  return new Promise((resolve, reject) => {
+    const process = spawn('sh', ['-c', command], {
+      stdio: ['ignore', 'pipe', 'pipe'], // ignore stdin, pipe stdout/stderr
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    process.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    process.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    process.on('close', (code) => {
+      const success = code === 0;
+      const response: CommandResponse = {
+        success,
+        output: stdout,
+        error: success ? undefined : stderr,
+      };
+
+      resolve(response);
+    });
+
+    process.on('error', (err) => {
+      reject(err);
+    });
+  });
+}

src/utils/sentry.ts

@@ -50,7 +50,7 @@ if ('version' in xcodeInfo) {
 
 const envVars = getEnvironmentVariables();
 tags.env_XCODEBUILDMCP_DEBUG = envVars.XCODEBUILDMCP_DEBUG || 'false';
-tags.env_XCODEMAKE_ENABLED = envVars.XCODEMAKE_ENABLED || 'false';
+tags.env_XCODEMAKE_ENABLED = envVars.INCREMENTAL_BUILDS_ENABLED || 'false';
 tags.env_XCODEBUILDMCP_RUNNING_UNDER_MISE = envVars.XCODEBUILDMCP_RUNNING_UNDER_MISE || 'false';
 
 const miseAvailable = checkBinaryAvailability('mise');