aiwcli 0.9.0

package/dist/lib/git/worktree.js

@@ -0,0 +1,220 @@
+/**
+ * @file Git worktree operations.
+ *
+ * Provides utilities for managing git worktrees.
+ *
+ * @module lib/git/worktree
+ */
+import { execSync, spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+/**
+ * Get all worktrees in the repository.
+ *
+ * @returns Array of worktree info objects
+ * @throws Error if unable to list worktrees
+ *
+ * @example
+ * ```typescript
+ * const worktrees = getAllWorktrees()
+ * for (const wt of worktrees) {
+ *   console.log(`${wt.branch}: ${wt.path}`)
+ * }
+ * ```
+ */
+export function getAllWorktrees() {
+    try {
+        const output = execSync('git worktree list --porcelain', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Parse worktree list output
+        // Format:
+        // worktree /path/to/worktree
+        // HEAD <commit-hash>
+        // branch refs/heads/branchname
+        // (blank line between entries)
+        const worktrees = [];
+        const lines = output.split('\n');
+        let currentWorktree = null;
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                if (currentWorktree) {
+                    worktrees.push(currentWorktree);
+                }
+                currentWorktree = {
+                    branch: null,
+                    head: '',
+                    path: line.slice('worktree '.length).trim(),
+                };
+            }
+            else if (line.startsWith('HEAD ')) {
+                if (currentWorktree) {
+                    currentWorktree.head = line.slice('HEAD '.length).trim();
+                }
+            }
+            else if (line.startsWith('branch ')) {
+                if (currentWorktree) {
+                    const branchRef = line.slice('branch '.length).trim();
+                    // Extract branch name from refs/heads/branchname
+                    currentWorktree.branch = branchRef.replace('refs/heads/', '');
+                }
+            }
+            else if (line === '' && currentWorktree) {
+                // Empty line marks end of worktree entry
+                worktrees.push(currentWorktree);
+                currentWorktree = null;
+            }
+        }
+        // Push the last worktree if exists
+        if (currentWorktree) {
+            worktrees.push(currentWorktree);
+        }
+        return worktrees;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to get worktrees: ${err.message}`);
+    }
+}
+/**
+ * Get the worktree path for a branch.
+ *
+ * @param branchName - Name of the branch
+ * @returns Worktree path if found, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const path = getWorktreePath('main')
+ * if (path) {
+ *   console.log(`Main branch worktree: ${path}`)
+ * }
+ * ```
+ */
+export function getWorktreePath(branchName) {
+    try {
+        const output = execSync('git worktree list --porcelain', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Parse worktree list output
+        const lines = output.split('\n');
+        let currentWorktreePath = null;
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                currentWorktreePath = line.slice('worktree '.length).trim();
+            }
+            else if (line.startsWith('branch ')) {
+                const branchRef = line.slice('branch '.length).trim();
+                if (branchRef === `refs/heads/${branchName}` && currentWorktreePath) {
+                    return currentWorktreePath;
+                }
+            }
+            else if (line === '') {
+                // Reset for next worktree entry
+                currentWorktreePath = null;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a git worktree with the specified branch name.
+ *
+ * @param branchName - Name of the branch to create
+ * @param worktreePath - Path where the worktree should be created
+ * @returns Promise that resolves when worktree is created
+ * @throws Error if unable to create worktree
+ *
+ * @example
+ * ```typescript
+ * await createWorktree('feature-branch', '/path/to/worktree')
+ * ```
+ */
+export async function createWorktree(branchName, worktreePath) {
+    return new Promise((resolve, reject) => {
+        const gitProcess = spawn('git', ['worktree', 'add', '-b', branchName, worktreePath], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        gitProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        gitProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                const error = new Error(`Git worktree creation failed: ${stderr}`);
+                error.code = 'GIT_ERROR';
+                error.stderr = stderr;
+                reject(error);
+            }
+        });
+        gitProcess.on('error', (err) => {
+            reject(new Error(`Failed to execute git command: ${err.message}`));
+        });
+    });
+}
+/**
+ * Delete a worktree folder and remove worktree from git.
+ *
+ * @param worktreePath - Path to the worktree to delete
+ * @param options - Command options including debug logging
+ * @throws Error if unable to delete worktree folder
+ *
+ * @example
+ * ```typescript
+ * await deleteWorktreeFolder('/path/to/worktree', {
+ *   debugLog: (msg) => console.debug(msg)
+ * })
+ * ```
+ */
+export async function deleteWorktreeFolder(worktreePath, options) {
+    const { debugLog } = options || {};
+    // First, try to remove the worktree from git
+    debugLog?.(`Removing worktree from git: ${worktreePath}`);
+    // Platform-specific path escaping for git commands
+    const escapedPath = process.platform === 'win32'
+        ? `"${worktreePath.replaceAll('"', String.raw `\"`)}"` // Windows: double quotes
+        : `'${worktreePath.replaceAll('\'', String.raw `'\''`)}'`; // Unix/macOS: single quotes
+    try {
+        execSync(`git worktree remove ${escapedPath} --force`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        debugLog?.('Git worktree removed successfully');
+    }
+    catch (error) {
+        const err = error;
+        // If git reports the worktree doesn't exist, that's fine - the folder might be orphaned
+        // We'll still try to delete the folder below
+        if (err.message?.includes('not a working tree')) {
+            debugLog?.(`Git worktree not found (orphaned folder): ${err.message}`);
+        }
+        else {
+            // For other git errors, log but continue to folder deletion
+            debugLog?.(`Git worktree remove failed: ${err.message}`);
+        }
+    }
+    // Always try to delete the folder if it exists
+    try {
+        await fs.access(worktreePath);
+        debugLog?.(`Deleting folder: ${worktreePath}`);
+        await fs.rm(worktreePath, { recursive: true, force: true });
+        debugLog?.('Folder deleted successfully');
+    }
+    catch (error) {
+        const err = error;
+        // If folder doesn't exist, that's fine
+        if (err.code === 'ENOENT') {
+            debugLog?.('Folder already deleted');
+        }
+        else {
+            // For real errors (permissions, locks, etc), throw
+            throw new Error(`Failed to delete worktree folder: ${err.message}`);
+        }
+    }
+}

package/dist/lib/gitignore-manager.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Update .gitignore with patterns for installed folders.
+ *
+ * Creates .gitignore if it doesn't exist, or appends to existing file.
+ * Prevents duplicate patterns by checking each pattern individually.
+ *
+ * @param targetDir - Directory containing .gitignore file
+ * @param folders - List of folder names to add as gitignore patterns (e.g., ['_bmad', '.claude'])
+ */
+export declare function updateGitignore(targetDir: string, folders: string[]): Promise<void>;

package/dist/lib/gitignore-manager.js

@@ -0,0 +1,60 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Update .gitignore with patterns for installed folders.
+ *
+ * Creates .gitignore if it doesn't exist, or appends to existing file.
+ * Prevents duplicate patterns by checking each pattern individually.
+ *
+ * @param targetDir - Directory containing .gitignore file
+ * @param folders - List of folder names to add as gitignore patterns (e.g., ['_bmad', '.claude'])
+ */
+export async function updateGitignore(targetDir, folders) {
+    const gitignorePath = join(targetDir, '.gitignore');
+    try {
+        // Try to read existing .gitignore
+        const existing = await fs.readFile(gitignorePath, 'utf8');
+        // Filter out patterns that already exist in .gitignore
+        const newPatterns = folders.filter((folder) => {
+            const pattern = `${folder}/`;
+            // Check if this exact pattern exists in the file
+            return !existing.includes(pattern);
+        });
+        // If no new patterns to add, we're done
+        if (newPatterns.length === 0) {
+            return;
+        }
+        // Build patterns string
+        const patterns = newPatterns.map((folder) => `${folder}/`).join('\n');
+        // Check if AIW Installation header already exists
+        const hasAiwHeader = existing.includes('# AIW Installation');
+        let updatedContent;
+        if (hasAiwHeader) {
+            // Find the AIW Installation section and append to it
+            const lines = existing.split('\n');
+            const headerIndex = lines.findIndex((line) => line.includes('# AIW Installation'));
+            if (headerIndex === -1) {
+                // Fallback: append at the end with header (shouldn't happen, but defensive)
+                const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+                updatedContent = existing + separator + `# AIW Installation\n${patterns}\n`;
+            }
+            else {
+                // Insert new patterns right after the header
+                lines.splice(headerIndex + 1, 0, patterns);
+                updatedContent = lines.join('\n');
+            }
+        }
+        else {
+            // Add new section with header
+            const separator = existing.length > 0 && existing.endsWith('\n') ? '\n' : existing.length > 0 ? '\n\n' : '';
+            updatedContent = existing + separator + `# AIW Installation\n${patterns}\n`;
+        }
+        await fs.writeFile(gitignorePath, updatedContent, 'utf8');
+    }
+    catch {
+        // .gitignore doesn't exist, create it
+        const patterns = folders.map((folder) => `${folder}/`).join('\n');
+        const patternsBlock = `# AIW Installation\n${patterns}`;
+        await fs.writeFile(gitignorePath, patternsBlock + '\n', 'utf8');
+    }
+}

package/dist/lib/hooks-merger.d.ts

@@ -0,0 +1,28 @@
+import type { ClaudeSettings, HooksConfig } from './claude-settings-types.js';
+/**
+ * Merge hooks configurations from template into existing
+ *
+ * Strategy:
+ * - For each event type in template hooks
+ * - Concatenate with existing hooks for that event
+ * - Deduplicate based on matcher configuration
+ * - Maintain order: existing hooks first, then template hooks
+ *
+ * @param existing - Existing hooks configuration (will not be modified)
+ * @param template - Template hooks configuration to merge
+ * @returns New merged hooks configuration
+ */
+export declare function mergeHooks(existing: HooksConfig | undefined, template: HooksConfig | undefined): HooksConfig;
+/**
+ * Merge complete Claude settings configurations
+ *
+ * Strategy:
+ * - Shallow merge most properties (template overrides existing)
+ * - Deep merge hooks using mergeHooks function
+ * - Deep merge permissions by concatenating arrays
+ *
+ * @param existing - Existing settings (will not be modified)
+ * @param template - Template settings to merge
+ * @returns New merged settings configuration
+ */
+export declare function mergeClaudeSettings(existing: ClaudeSettings | undefined, template: ClaudeSettings | undefined): ClaudeSettings;

package/dist/lib/hooks-merger.js

@@ -0,0 +1,94 @@
+import { mergeArraysWithDedup, mergeConfigByEventType } from './generic-merge.js';
+/**
+ * Check if two hook commands are equivalent
+ */
+function areHookCommandsEqual(a, b) {
+    return a.type === b.type && a.command === b.command && a.timeout === b.timeout;
+}
+/**
+ * Check if two hook matchers are equivalent
+ */
+function areHookMatchersEqual(a, b) {
+    if (a.matcher !== b.matcher || a.once !== b.once) {
+        return false;
+    }
+    if (a.hooks.length !== b.hooks.length) {
+        return false;
+    }
+    // Check if all hooks are equivalent (order-independent)
+    return a.hooks.every((hookA) => b.hooks.some((hookB) => areHookCommandsEqual(hookA, hookB)));
+}
+/**
+ * Merge hooks configurations from template into existing
+ *
+ * Strategy:
+ * - For each event type in template hooks
+ * - Concatenate with existing hooks for that event
+ * - Deduplicate based on matcher configuration
+ * - Maintain order: existing hooks first, then template hooks
+ *
+ * @param existing - Existing hooks configuration (will not be modified)
+ * @param template - Template hooks configuration to merge
+ * @returns New merged hooks configuration
+ */
+export function mergeHooks(existing, template) {
+    return mergeConfigByEventType(existing, template, (existingMatchers, templateMatchers) => mergeArraysWithDedup(existingMatchers, templateMatchers, areHookMatchersEqual));
+}
+/**
+ * Merge complete Claude settings configurations
+ *
+ * Strategy:
+ * - Shallow merge most properties (template overrides existing)
+ * - Deep merge hooks using mergeHooks function
+ * - Deep merge permissions by concatenating arrays
+ *
+ * @param existing - Existing settings (will not be modified)
+ * @param template - Template settings to merge
+ * @returns New merged settings configuration
+ */
+export function mergeClaudeSettings(existing, template) {
+    // If no template settings, return existing (or empty object)
+    if (!template || Object.keys(template).length === 0) {
+        return existing || {};
+    }
+    // If no existing settings, return template
+    if (!existing || Object.keys(existing).length === 0) {
+        return template;
+    }
+    // Merge permissions by concatenating arrays (no duplicates)
+    const mergedPermissions = {
+        allow: [...new Set([...(existing.permissions?.allow || []), ...(template.permissions?.allow || [])])],
+        deny: [...new Set([...(existing.permissions?.deny || []), ...(template.permissions?.deny || [])])],
+    };
+    // Merge environment variables (template values override)
+    const mergedEnv = {
+        ...existing.env,
+        ...template.env,
+    };
+    // Merge enabled plugins (template values override)
+    const mergedEnabledPlugins = {
+        ...existing.enabledPlugins,
+        ...template.enabledPlugins,
+    };
+    // Merge hooks using dedicated function
+    const mergedHooks = mergeHooks(existing.hooks, template.hooks);
+    // Merge methods tracking (existing takes precedence, template adds new)
+    const mergedMethods = {
+        ...template.methods,
+        ...existing.methods,
+    };
+    // Create merged settings
+    const merged = {
+        ...existing,
+        ...template,
+        permissions: mergedPermissions,
+        env: mergedEnv,
+        enabledPlugins: mergedEnabledPlugins,
+        hooks: mergedHooks,
+    };
+    // Only add methods if there are any (avoid setting to undefined)
+    if (Object.keys(mergedMethods).length > 0) {
+        merged.methods = mergedMethods;
+    }
+    return merged;
+}

package/dist/lib/ide-path-resolver.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Centralized IDE and AIW path resolver.
+ * Provides consistent path construction for all IDE and AIW folders/files.
+ *
+ * This utility ensures that path construction is consistent across the codebase
+ * and reduces coupling by providing a single source of truth for path patterns.
+ *
+ * @example
+ * ```typescript
+ * const resolver = new IdePathResolver('/path/to/project')
+ *
+ * // Get .claude folder path
+ * const claudePath = resolver.getClaudeDir()
+ * // Returns: /path/to/project/.claude
+ *
+ * // Get .claude/settings.json path
+ * const settingsPath = resolver.getClaudeSettings()
+ * // Returns: /path/to/project/.claude/settings.json
+ * ```
+ */
+export declare class IdePathResolver {
+    private readonly projectRoot;
+    constructor(projectRoot: string);
+    /**
+     * Get the .aiwcli container directory path
+     *
+     * @returns Absolute path to .aiwcli directory
+     */
+    getAiwcliContainer(): string;
+    /**
+     * Get path to a folder within the .aiwcli container
+     *
+     * @param folderName - Folder name within .aiwcli (e.g., '_shared', '_bmad')
+     * @returns Absolute path to the folder
+     */
+    getAiwcliFolder(folderName: string): string;
+    /**
+     * Get path to a file/folder within .claude directory
+     *
+     * @param relativePath - Relative path within .claude (e.g., 'settings.json', 'commands/bmad')
+     * @returns Absolute path to the file/folder
+     */
+    getClaude(relativePath: string): string;
+    /**
+     * Get the .claude directory path
+     *
+     * @returns Absolute path to .claude directory
+     */
+    getClaudeDir(): string;
+    /**
+     * Get the .claude/settings.json path
+     *
+     * @returns Absolute path to Claude settings file
+     */
+    getClaudeSettings(): string;
+    /**
+     * Get IDE directory path by IDE name
+     *
+     * @param ideName - IDE name ('claude', 'windsurf', etc.)
+     * @returns Absolute path to IDE directory
+     */
+    getIdeDir(ideName: string): string;
+    /**
+     * Get method-specific folder path within .aiwcli
+     * Convention: _{methodName} (e.g., _bmad, _gsd, _cc-native)
+     *
+     * @param methodName - Method name (e.g., 'bmad', 'gsd')
+     * @returns Absolute path to method folder
+     */
+    getMethodFolder(methodName: string): string;
+    /**
+     * Get the project root directory
+     *
+     * @returns Absolute path to project root
+     */
+    getProjectRoot(): string;
+    /**
+     * Get the shared folder path within .aiwcli
+     *
+     * @returns Absolute path to _shared directory
+     */
+    getSharedFolder(): string;
+    /**
+     * Get path to a file/folder within .windsurf directory
+     *
+     * @param relativePath - Relative path within .windsurf (e.g., 'hooks.json', 'workflows/bmad')
+     * @returns Absolute path to the file/folder
+     */
+    getWindsurf(relativePath: string): string;
+    /**
+     * Get the .windsurf directory path
+     *
+     * @returns Absolute path to .windsurf directory
+     */
+    getWindsurfDir(): string;
+    /**
+     * Get the .windsurf/hooks.json path
+     *
+     * @returns Absolute path to Windsurf hooks file
+     */
+    getWindsurfHooks(): string;
+}

package/dist/lib/ide-path-resolver.js

@@ -0,0 +1,129 @@
+import { join } from 'node:path';
+/**
+ * Centralized IDE and AIW path resolver.
+ * Provides consistent path construction for all IDE and AIW folders/files.
+ *
+ * This utility ensures that path construction is consistent across the codebase
+ * and reduces coupling by providing a single source of truth for path patterns.
+ *
+ * @example
+ * ```typescript
+ * const resolver = new IdePathResolver('/path/to/project')
+ *
+ * // Get .claude folder path
+ * const claudePath = resolver.getClaudeDir()
+ * // Returns: /path/to/project/.claude
+ *
+ * // Get .claude/settings.json path
+ * const settingsPath = resolver.getClaudeSettings()
+ * // Returns: /path/to/project/.claude/settings.json
+ * ```
+ */
+export class IdePathResolver {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    /**
+     * Get the .aiwcli container directory path
+     *
+     * @returns Absolute path to .aiwcli directory
+     */
+    getAiwcliContainer() {
+        return join(this.projectRoot, '.aiwcli');
+    }
+    /**
+     * Get path to a folder within the .aiwcli container
+     *
+     * @param folderName - Folder name within .aiwcli (e.g., '_shared', '_bmad')
+     * @returns Absolute path to the folder
+     */
+    getAiwcliFolder(folderName) {
+        return join(this.getAiwcliContainer(), folderName);
+    }
+    /**
+     * Get path to a file/folder within .claude directory
+     *
+     * @param relativePath - Relative path within .claude (e.g., 'settings.json', 'commands/bmad')
+     * @returns Absolute path to the file/folder
+     */
+    getClaude(relativePath) {
+        return join(this.getClaudeDir(), relativePath);
+    }
+    /**
+     * Get the .claude directory path
+     *
+     * @returns Absolute path to .claude directory
+     */
+    getClaudeDir() {
+        return join(this.projectRoot, '.claude');
+    }
+    /**
+     * Get the .claude/settings.json path
+     *
+     * @returns Absolute path to Claude settings file
+     */
+    getClaudeSettings() {
+        return this.getClaude('settings.json');
+    }
+    /**
+     * Get IDE directory path by IDE name
+     *
+     * @param ideName - IDE name ('claude', 'windsurf', etc.)
+     * @returns Absolute path to IDE directory
+     */
+    getIdeDir(ideName) {
+        return join(this.projectRoot, `.${ideName}`);
+    }
+    /**
+     * Get method-specific folder path within .aiwcli
+     * Convention: _{methodName} (e.g., _bmad, _gsd, _cc-native)
+     *
+     * @param methodName - Method name (e.g., 'bmad', 'gsd')
+     * @returns Absolute path to method folder
+     */
+    getMethodFolder(methodName) {
+        return this.getAiwcliFolder(`_${methodName}`);
+    }
+    /**
+     * Get the project root directory
+     *
+     * @returns Absolute path to project root
+     */
+    getProjectRoot() {
+        return this.projectRoot;
+    }
+    /**
+     * Get the shared folder path within .aiwcli
+     *
+     * @returns Absolute path to _shared directory
+     */
+    getSharedFolder() {
+        return this.getAiwcliFolder('_shared');
+    }
+    /**
+     * Get path to a file/folder within .windsurf directory
+     *
+     * @param relativePath - Relative path within .windsurf (e.g., 'hooks.json', 'workflows/bmad')
+     * @returns Absolute path to the file/folder
+     */
+    getWindsurf(relativePath) {
+        return join(this.getWindsurfDir(), relativePath);
+    }
+    /**
+     * Get the .windsurf directory path
+     *
+     * @returns Absolute path to .windsurf directory
+     */
+    getWindsurfDir() {
+        return join(this.projectRoot, '.windsurf');
+    }
+    /**
+     * Get the .windsurf/hooks.json path
+     *
+     * @returns Absolute path to Windsurf hooks file
+     */
+    getWindsurfHooks() {
+        return this.getWindsurf('hooks.json');
+    }
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared library code for AI Workflow CLI.
+ * Re-exports all library modules from this barrel file.
+ */
+export { type AiwcliConfig, getAiwDir, loadConfig, validateAiwDir, } from './config.js';
+export { debug, debugConfig, debugSpawn, debugVersion, isDebugEnabled, setDebugEnabled } from './debug.js';
+export { getAiwConfig, getAiwDir as getAiwDirFromEnv, isUsingLegacyEnvVars, loadEnvWithCompatibility, } from './env-compat.js';
+export { AiwError, ConfigNotFoundError, EnvironmentError, formatErrorMessage, InvalidUsageError, ProcessSpawnError, } from './errors.js';
+export { mergeArraysWithDedup, mergeConfigByEventType } from './generic-merge.js';
+export { branchExists, createWorktree, deleteBranch, deleteWorktreeFolder, getAllWorktrees, getCurrentBranch, getMainBranch, getWorktreePath, type GitCommandOptions, hasMergeRequest, hasUnpushedCommits, type WorktreeInfo, } from './git/index.js';
+export { expandPath, findWorkspaceRoot, getHomePath, getWorkspacePath, isWorkspace, normalizePath, pathExists, resolvePath, toUnixPath, toWindowsPath, } from './paths.js';
+export { spawnProcess, type SpawnProcessOptions } from './spawn.js';
+export { escapeShellArg, launchTerminal, type TerminalLaunchOptions, type TerminalLaunchResult, } from './terminal.js';

package/dist/lib/index.js

@@ -0,0 +1,22 @@
+/**
+ * Shared library code for AI Workflow CLI.
+ * Re-exports all library modules from this barrel file.
+ */
+// Configuration resolution
+export { getAiwDir, loadConfig, validateAiwDir, } from './config.js';
+// Debug logging
+export { debug, debugConfig, debugSpawn, debugVersion, isDebugEnabled, setDebugEnabled } from './debug.js';
+// Environment variable compatibility
+export { getAiwConfig, getAiwDir as getAiwDirFromEnv, isUsingLegacyEnvVars, loadEnvWithCompatibility, } from './env-compat.js';
+// Custom error classes and utilities
+export { AiwError, ConfigNotFoundError, EnvironmentError, formatErrorMessage, InvalidUsageError, ProcessSpawnError, } from './errors.js';
+// Generic merge utilities
+export { mergeArraysWithDedup, mergeConfigByEventType } from './generic-merge.js';
+// Git utilities
+export { branchExists, createWorktree, deleteBranch, deleteWorktreeFolder, getAllWorktrees, getCurrentBranch, getMainBranch, getWorktreePath, hasMergeRequest, hasUnpushedCommits, } from './git/index.js';
+// Cross-platform path utilities
+export { expandPath, findWorkspaceRoot, getHomePath, getWorkspacePath, isWorkspace, normalizePath, pathExists, resolvePath, toUnixPath, toWindowsPath, } from './paths.js';
+// Process spawning utilities
+export { spawnProcess } from './spawn.js';
+// Cross-platform terminal launching
+export { escapeShellArg, launchTerminal, } from './terminal.js';