xcode-cli 1.0.5

package/src/xcode-ctl.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import {
+  DEFAULT_SERVICE_PORT,
+  installService,
+  uninstallService,
+  startService,
+  stopService,
+  restartService,
+  printServiceStatus,
+  tailLogs,
+  killPortOccupant,
+} from './xcode-service.ts';
+import { startMcpBridge } from './xcode-mcp.ts';
+import { installSkill, uninstallSkill } from './xcode-skill.ts';
+import os from 'node:os';
+import path from 'node:path';
+
+const program = new Command();
+program
+  .name('xcode-cli-ctl')
+  .description('Setup and manage the xcode-cli MCP bridge service.');
+
+program
+  .command('install')
+  .description('Install and start bridge as a macOS launchd service')
+  .option('--port <port>', 'Bridge port', String(DEFAULT_SERVICE_PORT))
+  .action(async (options: { port: string }) => {
+    await installService({ port: Number(options.port) });
+  });
+
+program
+  .command('uninstall')
+  .description('Stop and remove bridge launchd service')
+  .action(async () => {
+    await uninstallService();
+  });
+
+program
+  .command('start')
+  .description('Start the installed bridge service')
+  .action(async () => {
+    await startService();
+  });
+
+program
+  .command('stop')
+  .description('Stop the bridge service')
+  .action(async () => {
+    await stopService();
+  });
+
+program
+  .command('restart')
+  .description('Restart the bridge service')
+  .action(async () => {
+    await restartService();
+  });
+
+program
+  .command('status')
+  .description('Show bridge service status and health')
+  .option('--port <port>', 'Bridge port for health check', String(DEFAULT_SERVICE_PORT))
+  .action(async (options: { port: string }) => {
+    await printServiceStatus(Number(options.port));
+  });
+
+program
+  .command('logs')
+  .description('Show bridge service logs')
+  .option('-n, --lines <n>', 'Number of lines', '50')
+  .option('-f, --follow', 'Follow log output')
+  .action((options: { lines: string; follow?: boolean }) => {
+    tailLogs({ lines: Number(options.lines), follow: options.follow });
+  });
+
+program
+  .command('run')
+  .description('Run the MCP bridge in the foreground (for debugging or launchd)')
+  .option('--host <host>', 'Bind host', '127.0.0.1')
+  .option('--port <port>', 'Bind port', String(DEFAULT_SERVICE_PORT))
+  .option('--path <path>', 'MCP endpoint path', '/mcp')
+  .action(async (options: { host: string; port: string; path: string }) => {
+    const port = Number(options.port);
+    await killPortOccupant(port);
+    await startMcpBridge({
+      host: options.host,
+      port,
+      path: options.path,
+    });
+  });
+
+// ── skill ────────────────────────────────────────────────────────────
+
+const skill = program.command('skill').description('Manage xcode-cli skill for agents');
+
+skill
+  .command('install')
+  .description('Install xcode-cli skill (default: both Claude and Codex)')
+  .option('--claude', 'Install to ~/.claude/skills only')
+  .option('--codex', 'Install to ~/.codex/skills only')
+  .option('--skill-root-dir <path>', 'Install to a custom skills directory')
+  .action(async (options: { claude?: boolean; codex?: boolean; skillRootDir?: string }) => {
+    const dirs = resolveSkillDirs(options);
+    for (const dir of dirs) {
+      await installSkill(dir);
+    }
+  });
+
+skill
+  .command('uninstall')
+  .description('Uninstall xcode-cli skill (default: both Claude and Codex)')
+  .option('--claude', 'Uninstall from ~/.claude/skills only')
+  .option('--codex', 'Uninstall from ~/.codex/skills only')
+  .option('--skill-root-dir <path>', 'Uninstall from a custom skills directory')
+  .action(async (options: { claude?: boolean; codex?: boolean; skillRootDir?: string }) => {
+    const dirs = resolveSkillDirs(options);
+    for (const dir of dirs) {
+      await uninstallSkill(dir);
+    }
+  });
+
+program.parseAsync(process.argv).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+
+function resolveSkillDirs(options: { claude?: boolean; codex?: boolean; skillRootDir?: string }): string[] {
+  if (options.skillRootDir) {
+    return [options.skillRootDir];
+  }
+  const home = os.homedir();
+  const claude = path.join(home, '.claude', 'skills');
+  const codex = path.join(home, '.codex', 'skills');
+  if (options.claude) return [claude];
+  if (options.codex) return [codex];
+  return [claude, codex];
+}

package/src/xcode-issues.ts

@@ -0,0 +1,165 @@
+import type { IssueEntry } from './xcode-types.ts';
+
+export function extractIssues(value: unknown): IssueEntry[] {
+  const issues: IssueEntry[] = [];
+  const queue: unknown[] = [value];
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    if (Array.isArray(current)) {
+      queue.push(...current);
+      continue;
+    }
+    if (typeof current !== 'object') {
+      continue;
+    }
+
+    const record = current as Record<string, unknown>;
+    const message = firstString(record, ['message', 'diagnostic', 'title', 'text']);
+    const pathValue = firstString(record, ['path', 'filePath', 'file', 'sourceFilePath']);
+    const severity = firstString(record, ['severity', 'level', 'kind']);
+    const line = firstNumber(record, ['line', 'lineNumber', 'startLine']);
+    const column = firstNumber(record, ['column', 'col', 'startColumn']);
+
+    if (message && (pathValue || severity || line || column)) {
+      issues.push({
+        path: pathValue,
+        message,
+        severity: severity?.toLowerCase(),
+        line,
+        column,
+      });
+    }
+
+    for (const nested of Object.values(record)) {
+      if (nested && typeof nested === 'object') {
+        queue.push(nested);
+      }
+      if (Array.isArray(nested)) {
+        queue.push(...nested);
+      }
+    }
+  }
+
+  return dedupeIssues(issues);
+}
+
+export function summarizeIssues(issues: IssueEntry[]): Record<string, number> {
+  const summary = { total: issues.length, error: 0, warning: 0, remark: 0, unknown: 0 };
+  for (const issue of issues) {
+    const severity = issue.severity ?? 'unknown';
+    if (severity.includes('error')) {
+      summary.error += 1;
+    } else if (severity.includes('warning')) {
+      summary.warning += 1;
+    } else if (severity.includes('remark') || severity.includes('note')) {
+      summary.remark += 1;
+    } else {
+      summary.unknown += 1;
+    }
+  }
+  return summary;
+}
+
+export function summarizeBuildLog(value: unknown): Record<string, unknown> {
+  const text = stringifyValue(value).toLowerCase();
+  const inProgress =
+    text.includes('in progress') || text.includes('"inprogress":true') || text.includes('building');
+  const hasErrors = text.includes(' error') || text.includes('"error"');
+  const hasWarnings = text.includes(' warning') || text.includes('"warning"');
+  return { inProgress, hasErrors, hasWarnings };
+}
+
+export function summarizeTestList(value: unknown): Record<string, unknown> {
+  const tests = collectStringsByKeys(value, ['testIdentifier', 'identifier', 'name']);
+  const uniqueCount = new Set(tests).size;
+  return {
+    discovered: uniqueCount,
+    hasTests: uniqueCount > 0,
+  };
+}
+
+function dedupeIssues(issues: IssueEntry[]): IssueEntry[] {
+  const seen = new Set<string>();
+  const result: IssueEntry[] = [];
+  for (const issue of issues) {
+    const key = `${issue.path ?? '<unknown>'}|${issue.severity ?? 'unknown'}|${issue.line ?? 0}|${issue.column ?? 0}|${issue.message}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(issue);
+  }
+  return result;
+}
+
+function firstString(record: Record<string, unknown>, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === 'string' && value.trim()) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function firstNumber(record: Record<string, unknown>, keys: string[]): number | undefined {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === 'string' && value.trim() && Number.isFinite(Number(value))) {
+      return Number(value);
+    }
+  }
+  return undefined;
+}
+
+function collectStringsByKeys(value: unknown, keys: string[]): string[] {
+  const found: string[] = [];
+  const queue: unknown[] = [value];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    if (Array.isArray(current)) {
+      queue.push(...current);
+      continue;
+    }
+    if (typeof current !== 'object') {
+      continue;
+    }
+    const record = current as Record<string, unknown>;
+    for (const key of keys) {
+      const candidate = record[key];
+      if (typeof candidate === 'string' && candidate.trim()) {
+        found.push(candidate);
+      }
+    }
+    for (const nested of Object.values(record)) {
+      if (nested && typeof nested === 'object') {
+        queue.push(nested);
+      }
+      if (Array.isArray(nested)) {
+        queue.push(...nested);
+      }
+    }
+  }
+  return found;
+}
+
+function stringifyValue(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}