refactor(utils): unify path resolution helpers in src/utils/path.ts

Consolidate the duplicated expand-tilde + resolve-cwd path helpers into a
single canonical pair (expandHomePrefix, resolvePathFromCwd) in
src/utils/path.ts. The helper accepts an optional cwd argument so the
project-config call site (which passes its own cwd) shares the same
function as the default-cwd callers.

Drives out the cursor-bugbot-flagged inconsistency in app-path-resolver.ts:
its private resolvePathFromCwd was missing the expandHomePrefix step, so
xcodebuild -showBuildSettings received literal '~' paths even when
executeXcodeBuildCommand expanded them for the build step. Both copies
now resolve to the shared helper, eliminating the class of defect.

Migrations:
- Remove src/utils/expand-home.ts (contents moved into path.ts).
- build-utils.ts, app-path-resolver.ts: drop private resolvePathFromCwd,
  import shared helper. app-path-resolver call sites pre-check optional
  params (matches build-utils style) so no overloads are needed.
- derived-data-path.ts: keep public resolveEffectiveDerivedDataPath, body
  simplified to fallback-then-delegate.
- project-config.ts: keep normalizePathValue, body simplified to keep
  tryFileUrlToPath step then delegate.
- init.ts: delete the 1-line resolveDestinationPath forwarder, call sites
  use resolvePathFromCwd directly.

Tests:
- src/utils/__tests__/path.test.ts covers expandHomePrefix and the new
  resolvePathFromCwd (default cwd, explicit cwd, tilde, absolute,
  relative, ~user passthrough).
- src/utils/__tests__/app-path-resolver.test.ts asserts the captured
  xcodebuild command sees expanded projectPath/workspacePath, locking in
  parity with the build-utils end-to-end test.

Author: cameroncooke

src/cli/commands/init.ts

@@ -5,7 +5,7 @@ import * as os from 'node:os';
 import * as clack from '@clack/prompts';
 import { getResourceRoot } from '../../core/resource-root.ts';
 import { createPrompter, isInteractiveTTY, type Prompter } from '../interactive/prompts.ts';
-import { expandHomePrefix } from '../../utils/expand-home.ts';
+import { resolvePathFromCwd } from '../../utils/path.ts';
 
 type SkillType = 'mcp' | 'cli';
 
@@ -73,10 +73,6 @@ function readSkillContent(skillType: SkillType): string {
   return fs.readFileSync(sourcePath, 'utf8');
 }
 
-function resolveDestinationPath(inputPath: string): string {
-  return path.resolve(expandHomePrefix(inputPath));
-}
-
 async function promptConfirm(question: string): Promise<boolean> {
   if (!isInteractiveTTY()) {
     return false;
@@ -205,7 +201,7 @@ function resolveTargets(
   operation: 'install' | 'uninstall',
 ): ClientInfo[] {
   if (destFlag) {
-    const resolvedDest = resolveDestinationPath(destFlag);
+    const resolvedDest = resolvePathFromCwd(destFlag);
     if (resolvedDest === path.parse(resolvedDest).root) {
       throw new Error(
         'Refusing to use filesystem root as skills destination. Use a dedicated directory.',
@@ -350,7 +346,7 @@ async function collectInitSelection(
   }
 
   if (destProvided) {
-    const resolvedDest = resolveDestinationPath(argv.dest!);
+    const resolvedDest = resolvePathFromCwd(argv.dest!);
     if (resolvedDest === path.parse(resolvedDest).root) {
       throw new Error(
         'Refusing to use filesystem root as skills destination. Use a dedicated directory.',
@@ -432,7 +428,7 @@ async function promptCustomPath(): Promise<string> {
     message: 'Enter the destination directory path:',
     validate: (value: string | undefined) => {
       if (!value?.trim()) return 'Path cannot be empty.';
-      const resolved = resolveDestinationPath(value);
+      const resolved = resolvePathFromCwd(value);
       if (resolved === path.parse(resolved).root) {
         return 'Refusing to use filesystem root. Use a dedicated directory.';
       }
@@ -445,7 +441,7 @@ async function promptCustomPath(): Promise<string> {
     throw new Error('Operation cancelled.');
   }
 
-  return resolveDestinationPath(result as string);
+  return resolvePathFromCwd(result as string);
 }
 
 export function registerInitCommand(app: Argv, ctx?: { workspaceRoot: string }): void {

src/utils/__tests__/app-path-resolver.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { createMockExecutor } from '../../test-utils/mock-executors.ts';
+import { resolveAppPathFromBuildSettings } from '../app-path-resolver.ts';
+import { XcodePlatform } from '../../types/common.ts';
+
+describe('resolveAppPathFromBuildSettings', () => {
+  it('expands tilde-prefixed projectPath when invoking xcodebuild', async () => {
+    let capturedCommand: string[] | undefined;
+
+    const mockExecutor = createMockExecutor({
+      success: true,
+      output:
+        'BUILT_PRODUCTS_DIR = /Build/Products/Debug-iphonesimulator\nFULL_PRODUCT_NAME = App.app\n',
+      exitCode: 0,
+      onExecute: (command) => {
+        capturedCommand = command;
+      },
+    });
+
+    await resolveAppPathFromBuildSettings(
+      {
+        projectPath: '~/Code/App.xcodeproj',
+        scheme: 'App',
+        platform: XcodePlatform.iOSSimulator,
+      },
+      mockExecutor,
+    );
+
+    const expected = path.join(homedir(), 'Code/App.xcodeproj');
+    expect(capturedCommand).toBeDefined();
+    expect(capturedCommand).toContain(expected);
+    expect(capturedCommand).not.toContain('~/Code/App.xcodeproj');
+  });
+
+  it('expands tilde-prefixed workspacePath when invoking xcodebuild', async () => {
+    let capturedCommand: string[] | undefined;
+
+    const mockExecutor = createMockExecutor({
+      success: true,
+      output:
+        'BUILT_PRODUCTS_DIR = /Build/Products/Debug-iphonesimulator\nFULL_PRODUCT_NAME = App.app\n',
+      exitCode: 0,
+      onExecute: (command) => {
+        capturedCommand = command;
+      },
+    });
+
+    await resolveAppPathFromBuildSettings(
+      {
+        workspacePath: '~/Code/App.xcworkspace',
+        scheme: 'App',
+        platform: XcodePlatform.iOSSimulator,
+      },
+      mockExecutor,
+    );
+
+    const expected = path.join(homedir(), 'Code/App.xcworkspace');
+    expect(capturedCommand).toBeDefined();
+    expect(capturedCommand).toContain(expected);
+  });
+
+  it('leaves absolute paths unchanged', async () => {
+    let capturedCommand: string[] | undefined;
+
+    const mockExecutor = createMockExecutor({
+      success: true,
+      output:
+        'BUILT_PRODUCTS_DIR = /Build/Products/Debug-iphonesimulator\nFULL_PRODUCT_NAME = App.app\n',
+      exitCode: 0,
+      onExecute: (command) => {
+        capturedCommand = command;
+      },
+    });
+
+    await resolveAppPathFromBuildSettings(
+      {
+        projectPath: '/abs/path/App.xcodeproj',
+        scheme: 'App',
+        platform: XcodePlatform.iOSSimulator,
+      },
+      mockExecutor,
+    );
+
+    expect(capturedCommand).toContain('/abs/path/App.xcodeproj');
+  });
+});

src/utils/__tests__/expand-home.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { expandHomePrefix, resolvePathFromCwd } from '../path.ts';
+
+describe('expandHomePrefix', () => {
+  it('expands a bare ~ to the home directory', () => {
+    expect(expandHomePrefix('~')).toBe(homedir());
+  });
+
+  it('expands a leading ~/ to the home directory', () => {
+    expect(expandHomePrefix('~/foo/bar')).toBe(path.join(homedir(), 'foo/bar'));
+  });
+
+  it('expands a leading ~\\ on Windows-style separators', () => {
+    expect(expandHomePrefix('~\\foo\\bar')).toBe(path.join(homedir(), 'foo\\bar'));
+  });
+
+  it('returns absolute paths unchanged', () => {
+    expect(expandHomePrefix('/absolute/path')).toBe('/absolute/path');
+  });
+
+  it('returns relative paths unchanged', () => {
+    expect(expandHomePrefix('relative/path')).toBe('relative/path');
+  });
+
+  it('does not expand ~user style prefixes', () => {
+    expect(expandHomePrefix('~other/foo')).toBe('~other/foo');
+  });
+
+  it('does not expand ~ embedded later in the path', () => {
+    expect(expandHomePrefix('foo/~/bar')).toBe('foo/~/bar');
+  });
+
+  it('returns an empty string unchanged', () => {
+    expect(expandHomePrefix('')).toBe('');
+  });
+});
+
+describe('resolvePathFromCwd', () => {
+  it('expands a bare ~ to the home directory', () => {
+    expect(resolvePathFromCwd('~')).toBe(homedir());
+  });
+
+  it('expands a leading ~/ under the home directory', () => {
+    expect(resolvePathFromCwd('~/.foo/derivedData')).toBe(path.join(homedir(), '.foo/derivedData'));
+  });
+
+  it('returns absolute paths unchanged', () => {
+    expect(resolvePathFromCwd('/abs/path')).toBe('/abs/path');
+  });
+
+  it('resolves relative paths against process.cwd() by default', () => {
+    expect(resolvePathFromCwd('rel/path')).toBe(path.resolve(process.cwd(), 'rel/path'));
+  });
+
+  it('resolves relative paths against an explicit cwd when provided', () => {
+    expect(resolvePathFromCwd('rel/path', '/some/base')).toBe(
+      path.resolve('/some/base', 'rel/path'),
+    );
+  });
+
+  it('does not resolve absolute paths against an explicit cwd', () => {
+    expect(resolvePathFromCwd('/abs/path', '/some/base')).toBe('/abs/path');
+  });
+
+  it('does not expand ~user style prefixes', () => {
+    expect(resolvePathFromCwd('~other/foo')).toBe(path.resolve(process.cwd(), '~other/foo'));
+  });
+});

src/utils/__tests__/path.test.ts

@@ -2,18 +2,7 @@ import path from 'node:path';
 import type { XcodePlatform } from '../types/common.ts';
 import type { CommandExecutor } from './command.ts';
 import { resolveEffectiveDerivedDataPath } from './derived-data-path.ts';
-
-function resolvePathFromCwd(pathValue?: string): string | undefined {
-  if (!pathValue) {
-    return undefined;
-  }
-
-  if (path.isAbsolute(pathValue)) {
-    return pathValue;
-  }
-
-  return path.resolve(process.cwd(), pathValue);
-}
+import { resolvePathFromCwd } from './path.ts';
 
 export function getBuildSettingsDestination(platform: XcodePlatform, deviceId?: string): string {
   if (deviceId) {
@@ -57,8 +46,8 @@ export async function resolveAppPathFromBuildSettings(
 ): Promise<string> {
   const command = ['xcodebuild', '-showBuildSettings'];
 
-  const workspacePath = resolvePathFromCwd(params.workspacePath);
-  const projectPath = resolvePathFromCwd(params.projectPath);
+  const workspacePath = params.workspacePath ? resolvePathFromCwd(params.workspacePath) : undefined;
+  const projectPath = params.projectPath ? resolvePathFromCwd(params.projectPath) : undefined;
   const derivedDataPath = resolveEffectiveDerivedDataPath(params.derivedDataPath);
 
   let projectDir: string | undefined;

src/utils/app-path-resolver.ts

@@ -13,7 +13,7 @@ import {
 import path from 'path';
 import os from 'node:os';
 import { resolveEffectiveDerivedDataPath } from './derived-data-path.ts';
-import { expandHomePrefix } from './expand-home.ts';
+import { resolvePathFromCwd } from './path.ts';
 import type { XcodebuildPipeline } from './xcodebuild-pipeline.ts';
 import { createNoticeFragment } from './xcodebuild-output.ts';
 
@@ -22,14 +22,6 @@ export interface BuildCommandResult {
   isError?: boolean;
 }
 
-function resolvePathFromCwd(pathValue: string): string {
-  const expanded = expandHomePrefix(pathValue);
-  if (path.isAbsolute(expanded)) {
-    return expanded;
-  }
-  return path.resolve(process.cwd(), expanded);
-}
-
 function getDefaultSwiftPackageCachePath(): string {
   return path.join(os.homedir(), 'Library', 'Caches', 'org.swift.swiftpm');
 }

src/utils/build-utils.ts

@@ -1,14 +1,9 @@
-import * as path from 'node:path';
 import { DERIVED_DATA_DIR } from './log-paths.ts';
-import { expandHomePrefix } from './expand-home.ts';
+import { resolvePathFromCwd } from './path.ts';
 
 export function resolveEffectiveDerivedDataPath(input?: string): string {
   if (!input || input.trim().length === 0) {
     return DERIVED_DATA_DIR;
   }
-  const expanded = expandHomePrefix(input);
-  if (path.isAbsolute(expanded)) {
-    return expanded;
-  }
-  return path.resolve(process.cwd(), expanded);
+  return resolvePathFromCwd(input);
 }

src/utils/derived-data-path.ts

@@ -0,0 +1,30 @@
+import path from 'node:path';
+import { homedir } from 'node:os';
+
+/**
+ * Expand a leading ~ or ~/ (or ~\ on Windows) prefix to the user's home directory.
+ * Returns the path unchanged if it does not start with ~ or starts with ~userName.
+ */
+export function expandHomePrefix(inputPath: string): string {
+  if (inputPath === '~') {
+    return homedir();
+  }
+
+  if (inputPath.startsWith('~/') || inputPath.startsWith('~\\')) {
+    return path.join(homedir(), inputPath.slice(2));
+  }
+
+  return inputPath;
+}
+
+/**
+ * Resolve a user-supplied path: expand ~ then return as-is when absolute,
+ * otherwise resolve against `cwd` (defaults to process.cwd()).
+ */
+export function resolvePathFromCwd(pathValue: string, cwd: string = process.cwd()): string {
+  const expanded = expandHomePrefix(pathValue);
+  if (path.isAbsolute(expanded)) {
+    return expanded;
+  }
+  return path.resolve(cwd, expanded);
+}