aiwcli 0.15.4 → 0.15.7

package/dist/commands/branch.js

@@ -1,11 +1,7 @@
-import { promises as fs } from 'node:fs';
-import { basename, dirname, join, resolve } from 'node:path';
 import { Args, Flags } from '@oclif/core';
-import clipboardy from 'clipboardy';
+import { createBranchCommandDependencies } from '../capabilities/branch/adapters.js';
+import { executeBranchCommand } from '../capabilities/branch/control-plane.js';
 import BaseCommand from '../lib/base-command.js';
-import { branchExists, createWorktree, deleteBranch, deleteWorktreeFolder, getAllWorktrees, getCurrentBranch, getMainBranch, getWorktreePath, hasMergeRequest, hasUnpushedCommits, } from '../lib/git/index.js';
-import { launchTerminal } from '../lib/terminal.js';
-import { EXIT_CODES } from '../types/index.js';
 /**
  * Manage git branch operations: launch in main/master or delete branch and worktree.
  *
@@ -78,416 +74,28 @@ export default class BranchCommand extends BaseCommand {
     };
     async run() {
         const { args, flags } = await this.parse(BranchCommand);
-        // Validate that one of the flags is provided
-        if (!flags.main && !flags.launch && !flags.delete) {
-            if (args.branchName) {
-                // Bare positional arg = shorthand for --launch <name>
-                await this.handleWorktreeLaunch(args.branchName);
-                return;
-            }
-            this.error('Either provide a branch name directly (aiw branch <name>) or use --main, --launch, or --delete', { exit: EXIT_CODES.INVALID_USAGE });
-        }
-        // Route to appropriate handler
-        if (flags.main) {
-            await this.handleMainBranch();
-        }
-        else if (flags.launch) {
-            await this.handleWorktreeLaunch(args.branchName);
-        }
-        else if (flags.delete && flags.all) {
-            // Handle --delete --all: clean up all worktrees
-            await this.handleDeleteAll();
-        }
-        else if (flags.delete) {
-            // Handle --delete <branchName>: delete single branch
-            await this.handleDelete(args.branchName);
-        }
-    }
-    /**
-     * Handle --delete flag: Delete git branch and worktree folder
-     */
-    async handleDelete(branchName) {
-        try {
-            // Validate branch name is provided
-            if (!branchName) {
-                this.error('Branch name is required with --delete flag\n\nUsage: aiw branch --delete <branchName>', {
-                    exit: EXIT_CODES.INVALID_USAGE,
-                });
-            }
-            const cwd = process.cwd();
-            // Check 1: Verify we are in a git repository
-            this.debug('Checking if current directory is a git repository...');
-            const isGitRepo = await this.isGitRepository(cwd);
-            if (!isGitRepo) {
-                this.error('Not a git repository. This command only works inside a git repository.', {
-                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
-                });
-            }
-            this.debug('✓ Git repository detected');
-            // Check 2: Prevent deletion of main/master branches
-            if (branchName === 'main' || branchName === 'master') {
-                this.error(`Cannot delete ${branchName} branch. This is a protected branch.`, {
-                    exit: EXIT_CODES.INVALID_USAGE,
-                });
-            }
-            // Check 3: Verify the branch exists
-            this.debug(`Checking if branch '${branchName}' exists...`);
-            if (!branchExists(branchName)) {
-                this.error(`Branch '${branchName}' does not exist.`, {
-                    exit: EXIT_CODES.INVALID_USAGE,
-                });
-            }
-            this.debug(`✓ Branch '${branchName}' exists`);
-            // Check 4: Get current branch to verify we're not on the branch being deleted
-            this.debug('Getting current branch name...');
-            let currentBranch;
-            try {
-                currentBranch = getCurrentBranch();
-            }
-            catch (error_) {
-                const error = error_;
-                this.error(`Failed to get current branch: ${error.message}`, {
-                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
-                });
-            }
-            this.debug(`Current branch: ${currentBranch}`);
-            if (currentBranch === branchName) {
-                this.error(`Cannot delete branch '${branchName}' because you are currently on it.\n\n` +
-                    `Please switch to a different directory first.\n\n` +
-                    `Suggestion: 'aiw branch --main' has been copied to your clipboard.`, { exit: EXIT_CODES.INVALID_USAGE });
-                // Copy suggestion to clipboard
-                try {
-                    await clipboardy.write('aiw branch --main');
-                    this.debug('✓ Copied "aiw branch --main" to clipboard');
-                }
-                catch (clipboardError) {
-                    this.debug('Failed to copy to clipboard:', clipboardError);
-                }
-                return;
-            }
-            this.debug(`✓ Not currently on branch '${branchName}'`);
-            // Check 5: Find the worktree path for this branch
-            this.debug(`Finding worktree path for branch '${branchName}'...`);
-            const worktreePath = getWorktreePath(branchName);
-            // Delete the worktree folder first if it exists (must be done before deleting the branch)
-            if (worktreePath) {
-                this.logInfo(`Deleting worktree folder at ${worktreePath}...`);
-                await deleteWorktreeFolder(worktreePath, { debugLog: (msg) => this.debug(msg) });
-                this.debug(`✓ Worktree folder deleted`);
-            }
-            else {
-                this.debug('No worktree folder found for this branch');
-            }
-            // Delete the git branch
-            this.logInfo(`Deleting git branch '${branchName}'...`);
-            deleteBranch(branchName, { debugLog: (msg) => this.debug(msg) });
-            this.debug(`✓ Git branch '${branchName}' deleted`);
-            this.logSuccess(`✓ Branch '${branchName}' and its worktree have been deleted`);
-        }
-        catch (error) {
-            const err = error;
-            // Check if error is already handled by this.error() calls above
-            if (err.message?.includes('EEXIT')) {
-                throw error;
-            }
-            // Handle unexpected errors
-            this.error(`Failed to delete branch: ${err.message}`, {
-                exit: EXIT_CODES.GENERAL_ERROR,
-            });
-        }
-    }
-    /**
-     * Handle --delete --all flags: Clean up all worktrees safely
-     */
-    async handleDeleteAll() {
-        try {
-            const cwd = process.cwd();
-            // Check 1: Verify we are in a git repository
-            this.debug('Checking if current directory is a git repository...');
-            const isGitRepo = await this.isGitRepository(cwd);
-            if (!isGitRepo) {
-                this.error('Not a git repository. This command only works inside a git repository.', {
-                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
-                });
-            }
-            this.debug('✓ Git repository detected');
-            // Get all worktrees
-            this.logInfo('Scanning all worktrees in repository...');
-            const allWorktrees = getAllWorktrees();
-            this.debug(`Found ${allWorktrees.length} worktrees`);
-            // Track results
-            const deleted = [];
-            const preserved = [];
-            // Phase 1: Synchronous filtering
-            const candidatesForAsyncCheck = [];
-            const normalizedCwd = resolve(cwd);
-            for (const worktree of allWorktrees) {
-                const { branch, path } = worktree;
-                // Skip if no branch (detached HEAD)
-                if (!branch) {
-                    this.debug(`Skipping worktree at ${path} (detached HEAD)`);
-                    preserved.push({ branch, path, reason: 'detached HEAD' });
-                    continue;
-                }
-                // Skip main/master branches
-                if (branch === 'main' || branch === 'master') {
-                    this.debug(`Skipping protected branch: ${branch}`);
-                    preserved.push({ branch, path, reason: 'protected branch (main/master)' });
-                    continue;
-                }
-                // Check if this is the current directory
-                const normalizedPath = resolve(path);
-                if (normalizedCwd === normalizedPath) {
-                    this.debug(`Skipping current directory worktree: ${path}`);
-                    preserved.push({ branch, path, reason: 'current directory (cannot delete while inside)' });
-                    continue;
-                }
-                // Passed synchronous checks, add to async check candidates
-                candidatesForAsyncCheck.push({ branch, path });
-            }
-            // Phase 2: Parallel async safety checks (read-only operations)
-            this.debug(`Running safety checks on ${candidatesForAsyncCheck.length} candidates in parallel...`);
-            const debugLog = (msg) => this.debug(msg);
-            const safetyCheckResults = await Promise.all(candidatesForAsyncCheck.map(async ({ branch, path }) => {
-                this.debug(`Checking safety for branch '${branch}'...`);
-                if (hasUnpushedCommits(branch, { debugLog })) {
-                    this.debug(`Branch '${branch}' has unpushed commits, skipping`);
-                    return { branch, path, safe: false, reason: 'has unpushed commits' };
-                }
-                if (hasMergeRequest(branch, { debugLog })) {
-                    this.debug(`Branch '${branch}' has an open PR, skipping`);
-                    return { branch, path, safe: false, reason: 'has open pull request' };
+        await executeBranchCommand({
+            args: {
+                branchName: args.branchName,
+            },
+            cwd: process.cwd(),
+            flags: {
+                all: flags.all,
+                delete: flags.delete,
+                launch: flags.launch,
+                main: flags.main,
+            },
+        }, {
+            debug: (...parts) => this.debug(...parts),
+            error: (message, options) => {
+                if (options?.exit === undefined) {
+                    return this.error(message);
                 }
-                this.debug(`Branch '${branch}' is safe to delete`);
-                return { branch, path, safe: true, reason: null };
-            }));
-            // Separate safe and unsafe candidates
-            const safeToDelete = safetyCheckResults.filter((r) => r.safe);
-            const unsafe = safetyCheckResults.filter((r) => !r.safe);
-            // Add unsafe candidates to preserved list
-            for (const { branch, path, reason } of unsafe) {
-                preserved.push({ branch, path, reason: reason });
-            }
-            // Phase 3: Sequential deletions (destructive operations must be sequential)
-            for (const { branch, path } of safeToDelete) {
-                try {
-                    // eslint-disable-next-line no-await-in-loop -- Sequential deletion required: worktree must be deleted before branch
-                    await deleteWorktreeFolder(path, { debugLog });
-                    deleteBranch(branch, { debugLog });
-                    deleted.push({ branch, path });
-                    this.debug(`✓ Deleted branch '${branch}' and worktree at ${path}`);
-                }
-                catch (error) {
-                    const err = error;
-                    this.debug(`Failed to delete branch '${branch}': ${err.message}`);
-                    preserved.push({ branch, path, reason: `deletion failed: ${err.message}` });
-                }
-            }
-            // Output results
-            this.log('');
-            this.logSuccess('✓ Worktree cleanup complete');
-            this.log('');
-            if (deleted.length > 0) {
-                this.logInfo(`Deleted ${deleted.length} worktree${deleted.length === 1 ? '' : 's'}:`);
-                for (const { branch, path } of deleted) {
-                    this.log(`  - ${branch} (${path})`);
-                }
-                this.log('');
-            }
-            else {
-                this.logInfo('No worktrees were deleted.');
-                this.log('');
-            }
-            if (preserved.length > 0) {
-                this.logInfo(`Preserved ${preserved.length} worktree${preserved.length === 1 ? '' : 's'}:`);
-                for (const { branch, path, reason } of preserved) {
-                    this.log(`  - ${branch ?? 'detached'} (${path})`);
-                    this.log(`    Reason: ${reason}`);
-                }
-            }
-        }
-        catch (error) {
-            const err = error;
-            // Check if error is already handled by this.error() calls above
-            if (err.message?.includes('EEXIT')) {
-                throw error;
-            }
-            // Handle unexpected errors
-            this.error(`Failed to clean up worktrees: ${err.message}`, {
-                exit: EXIT_CODES.GENERAL_ERROR,
-            });
-        }
-    }
-    /**
-     * Handle --main flag: Launch aiw in main/master branch
-     */
-    async handleMainBranch() {
-        try {
-            const cwd = process.cwd();
-            // Check 1: Verify we are in a git repository
-            this.debug('Checking if current directory is a git repository...');
-            const isGitRepo = await this.isGitRepository(cwd);
-            if (!isGitRepo) {
-                this.error('Not a git repository. This command only works inside a git repository.', {
-                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
-                });
-            }
-            this.debug('✓ Git repository detected');
-            // Check 2: Get current branch
-            this.debug('Getting current branch name...');
-            let currentBranch;
-            try {
-                currentBranch = getCurrentBranch();
-            }
-            catch (error_) {
-                const error = error_;
-                this.error(`Failed to get current branch: ${error.message}`, {
-                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
-                });
-            }
-            this.debug(`Current branch: ${currentBranch}`);
-            // Check 3: Verify we are NOT on main/master
-            if (currentBranch === 'main' || currentBranch === 'master') {
-                this.error(`Already on ${currentBranch} branch. This command is for switching to main/master from another branch.`, {
-                    exit: EXIT_CODES.INVALID_USAGE,
-                });
-            }
-            this.debug('✓ Currently on a feature branch');
-            // Check 4: Determine which main branch exists (main or master)
-            this.debug('Checking which main branch exists...');
-            const mainBranch = getMainBranch();
-            if (!mainBranch) {
-                this.error('Neither "main" nor "master" branch exists in this repository.', {
-                    exit: EXIT_CODES.INVALID_USAGE,
-                });
-            }
-            this.debug(`✓ Found main branch: ${mainBranch}`);
-            // Get the worktree path for the main branch
-            this.debug(`Finding worktree path for ${mainBranch} branch...`);
-            const mainBranchPath = getWorktreePath(mainBranch);
-            if (!mainBranchPath) {
-                this.error(`Could not find worktree for ${mainBranch} branch.`, {
-                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
-                });
-            }
-            this.debug(`✓ Found ${mainBranch} worktree at: ${mainBranchPath}`);
-            // Launch new terminal with aiw launch in main/master branch
-            this.logInfo(`Opening new terminal with aiw launch in ${mainBranch} branch...`);
-            const result = await launchTerminal({
-                cwd: mainBranchPath,
-                command: 'aiw launch',
-                debugLog: (msg) => this.debug(msg),
-            });
-            if (!result.success) {
-                this.error(`Failed to launch terminal: ${result.error}`, { exit: EXIT_CODES.GENERAL_ERROR });
-            }
-            this.logSuccess(`✓ New terminal launched with aiw in ${mainBranch} branch`);
-        }
-        catch (error) {
-            const err = error;
-            // Check if error is already handled by this.error() calls above
-            if (err.message?.includes('EEXIT')) {
-                throw error;
-            }
-            // Handle unexpected errors
-            this.error(`Failed to launch terminal: ${err.message}`, {
-                exit: EXIT_CODES.GENERAL_ERROR,
-            });
-        }
-    }
-    /**
-     * Handle --launch flag: Create or open worktree in sibling folder
-     */
-    async handleWorktreeLaunch(branchName) {
-        // Validate branch name
-        if (!branchName || branchName.trim().length === 0) {
-            this.error('Branch name is required. Usage: aiw branch <name> or aiw branch --launch <name>', { exit: EXIT_CODES.INVALID_USAGE });
-        }
-        // Validate branch name format (no spaces, special chars that could cause issues)
-        const validBranchNamePattern = /^[a-zA-Z0-9._/-]+$/;
-        if (!validBranchNamePattern.test(branchName)) {
-            this.error('Branch name contains invalid characters. Use only letters, numbers, dots, dashes, underscores, and slashes.', { exit: EXIT_CODES.INVALID_USAGE });
-        }
-        try {
-            const cwd = process.cwd();
-            // Check if we're in a git repository
-            const isGitRepo = await this.isGitRepository(cwd);
-            if (!isGitRepo) {
-                this.error('Not a git repository. This command only works inside a git repository.', {
-                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
-                });
-            }
-            // Get current directory and derive sibling folder name
-            const currentDirName = basename(cwd);
-            const parentDir = dirname(cwd);
-            const worktreeFolderName = `${currentDirName}-${branchName}`;
-            const worktreePath = resolve(parentDir, worktreeFolderName);
-            this.debug(`Checking for existing worktree at: ${worktreePath}`);
-            // Check if worktree folder already exists
-            let worktreeExists = false;
-            try {
-                await fs.access(worktreePath);
-                worktreeExists = true;
-                this.logInfo(`Worktree already exists at: ${worktreePath}`);
-                this.logInfo(`Opening terminal in existing worktree...`);
-            }
-            catch {
-                // Folder doesn't exist, we'll create it
-                this.logInfo(`Creating worktree for branch: ${branchName}`);
-                this.logInfo(`Worktree location: ${worktreePath}`);
-            }
-            if (!worktreeExists) {
-                // Create git worktree
-                await createWorktree(branchName, worktreePath);
-                this.logSuccess(`✓ Created worktree at ${worktreePath}`);
-                this.logSuccess(`✓ Created and checked out branch: ${branchName}`);
-            }
-            // Launch terminal in worktree path
-            const result = await launchTerminal({
-                cwd: worktreePath,
-                command: 'aiw launch',
-                debugLog: (msg) => this.debug(msg),
-            });
-            if (!result.success) {
-                this.error(`Failed to launch terminal: ${result.error}`, { exit: EXIT_CODES.GENERAL_ERROR });
-            }
-            this.logSuccess('✓ Launched terminal with aiw launch');
-            this.log('');
-            this.logInfo('New terminal window opened at worktree location.');
-            this.logInfo('Claude Code should be launching automatically.');
-        }
-        catch (error) {
-            const err = error;
-            // Check if error is already handled by this.error() calls above
-            if (err.message?.includes('EEXIT')) {
-                throw error;
-            }
-            // Handle git-specific errors
-            if (err.message?.includes('already exists')) {
-                this.error(`Branch '${branchName}' already exists. Choose a different name.`, {
-                    exit: EXIT_CODES.INVALID_USAGE,
-                });
-            }
-            if (err.stderr?.includes('fatal: not a git repository')) {
-                this.error('Not a git repository. Please run this command from a git repository root.', {
-                    exit: EXIT_CODES.INVALID_USAGE,
-                });
-            }
-            // Generic error fallback
-            this.error(`Failed to create/open worktree: ${err.message}`, { exit: EXIT_CODES.GENERAL_ERROR });
-        }
-    }
-    /**
-     * Check if current directory is a git repository
-     */
-    async isGitRepository(cwd) {
-        try {
-            const gitPath = join(cwd, '.git');
-            await fs.access(gitPath);
-            return true;
-        }
-        catch {
-            return false;
-        }
+                return this.error(message, { exit: options.exit });
+            },
+            log: (message) => this.log(message),
+            logInfo: (message) => this.logInfo(message),
+            logSuccess: (message) => this.logSuccess(message),
+        }, createBranchCommandDependencies());
     }
 }

package/dist/commands/clean.d.ts

@@ -1,41 +1 @@
-import BaseCommand from '../lib/base-command.js';
-/**
- * Clean output folder(s) for methods.
- * Removes all files and subdirectories from the method's output folder.
- */
-export default class CleanCommand extends BaseCommand {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        method: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        help: import("@oclif/core/interfaces").BooleanFlag<void>;
-        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    run(): Promise<void>;
-    /**
-     * Display contents of folders that will be deleted.
-     *
-     * @param allContents - Folders with their contents
-     * @param targetDir - Base directory for relative path display
-     */
-    private displayContents;
-    /**
-     * Find all output folders in the target directory.
-     * Matches folders with pattern _*-output (e.g., _bmad-output, _gsd-output).
-     *
-     * @param targetDir - Directory to search in
-     * @returns Array of output folder names
-     */
-    private findAllOutputFolders;
-    /**
-     * Get all top-level contents of a directory.
-     *
-     * @param dirPath - Directory to list contents of
-     * @returns Array of content items with path and type info
-     */
-    private getContents;
-}
+export { default } from '../capabilities/installation/control-plane/clean-command.js';