aiwcli 0.15.5 → 0.17.0

package/bin/run.js

@@ -1,9 +1,5 @@
 #!/usr/bin/env node
 
-// Load environment variable compatibility layer first
-const {loadEnvWithCompatibility} = await import('../dist/lib/env-compat.js')  
-loadEnvWithCompatibility()
-
 import {execute} from '@oclif/core'
 
 // Handle default command: inject 'launch' when no command is specified

package/dist/capabilities/branch/adapters.d.ts

@@ -0,0 +1,2 @@
+import type { BranchCommandDependencies } from './contracts.js';
+export declare function createBranchCommandDependencies(): BranchCommandDependencies;

package/dist/capabilities/branch/adapters.js

@@ -0,0 +1,21 @@
+import { promises as fs } from 'node:fs';
+import clipboardy from 'clipboardy';
+import { branchExists, createWorktree, deleteBranch, deleteWorktreeFolder, getAllWorktrees, getCurrentBranch, getMainBranch, getWorktreePath, hasMergeRequest, hasUnpushedCommits, } from '../../lib/git/index.js';
+import { launchTerminal } from '../../lib/terminal.js';
+export function createBranchCommandDependencies() {
+    return {
+        access: fs.access,
+        branchExists,
+        copyToClipboard: clipboardy.write,
+        createWorktree,
+        deleteBranch,
+        deleteWorktreeFolder,
+        getAllWorktrees,
+        getCurrentBranch,
+        getMainBranch,
+        getWorktreePath,
+        hasMergeRequest,
+        hasUnpushedCommits,
+        launchTerminal,
+    };
+}

package/dist/capabilities/branch/contracts.d.ts

@@ -0,0 +1,57 @@
+export interface BranchTerminalLaunchOptions {
+    command: string;
+    cwd: string;
+    debugLog?: (message: string) => void;
+}
+export interface BranchTerminalLaunchResult {
+    error?: string;
+    success: boolean;
+}
+export interface BranchCommandRequest {
+    args: {
+        branchName?: string | undefined;
+    };
+    cwd: string;
+    flags: {
+        all?: boolean | undefined;
+        delete?: boolean | undefined;
+        launch?: boolean | undefined;
+        main?: boolean | undefined;
+    };
+}
+export interface BranchCommandLogger {
+    debug: (...args: unknown[]) => void;
+    error: (message: string, options?: {
+        exit?: number | undefined;
+    }) => never;
+    log: (message?: string) => void;
+    logInfo: (message: string) => void;
+    logSuccess: (message: string) => void;
+}
+export interface WorktreeRecord {
+    branch: null | string;
+    path: string;
+}
+export interface BranchCommandDependencies {
+    access(path: string): Promise<void>;
+    branchExists(branchName: string): boolean;
+    copyToClipboard(text: string): Promise<void>;
+    createWorktree(branchName: string, worktreePath: string): Promise<void>;
+    deleteBranch(branchName: string, options?: {
+        debugLog?: ((message: string) => void) | undefined;
+    }): void;
+    deleteWorktreeFolder(worktreePath: string, options?: {
+        debugLog?: ((message: string) => void) | undefined;
+    }): Promise<void>;
+    getAllWorktrees(): WorktreeRecord[];
+    getCurrentBranch(): string;
+    getMainBranch(): null | string;
+    getWorktreePath(branchName: string): null | string;
+    hasMergeRequest(branchName: string, options?: {
+        debugLog?: ((message: string) => void) | undefined;
+    }): boolean;
+    hasUnpushedCommits(branchName: string, options?: {
+        debugLog?: ((message: string) => void) | undefined;
+    }): boolean;
+    launchTerminal(options: BranchTerminalLaunchOptions): Promise<BranchTerminalLaunchResult>;
+}

package/dist/capabilities/branch/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/capabilities/branch/control-plane.d.ts

@@ -0,0 +1,2 @@
+import type { BranchCommandDependencies, BranchCommandLogger, BranchCommandRequest } from './contracts.js';
+export declare function executeBranchCommand(request: BranchCommandRequest, logger: BranchCommandLogger, dependencies: BranchCommandDependencies): Promise<void>;

package/dist/capabilities/branch/control-plane.js

@@ -0,0 +1,343 @@
+import { join, resolve } from 'node:path';
+import { deriveWorktreePath, determineBranchMode, validateLaunchBranchName } from './runtime-core.js';
+import { EXIT_CODES } from '../../types/index.js';
+export async function executeBranchCommand(request, logger, dependencies) {
+    try {
+        const mode = determineBranchMode(request);
+        if (mode === 'main') {
+            await handleMainBranch(request.cwd, logger, dependencies);
+            return;
+        }
+        if (mode === 'launch') {
+            await handleWorktreeLaunch(request.cwd, request.args.branchName, logger, dependencies);
+            return;
+        }
+        if (mode === 'delete-all') {
+            await handleDeleteAll(request.cwd, logger, dependencies);
+            return;
+        }
+        await handleDelete(request.cwd, request.args.branchName, logger, dependencies);
+    }
+    catch (error) {
+        if (isUsageFailure(error)) {
+            logger.error(error.message, { exit: error.exit });
+        }
+        throw error;
+    }
+}
+async function handleDelete(cwd, branchName, logger, dependencies) {
+    try {
+        if (!branchName) {
+            logger.error('Branch name is required with --delete flag\n\nUsage: aiw branch --delete <branchName>', {
+                exit: EXIT_CODES.INVALID_USAGE,
+            });
+        }
+        logger.debug('Checking if current directory is a git repository...');
+        const isGitRepo = await isGitRepository(cwd, dependencies);
+        if (!isGitRepo) {
+            logger.error('Not a git repository. This command only works inside a git repository.', {
+                exit: EXIT_CODES.ENVIRONMENT_ERROR,
+            });
+        }
+        logger.debug('✓ Git repository detected');
+        if (branchName === 'main' || branchName === 'master') {
+            logger.error(`Cannot delete ${branchName} branch. This is a protected branch.`, {
+                exit: EXIT_CODES.INVALID_USAGE,
+            });
+        }
+        logger.debug(`Checking if branch '${branchName}' exists...`);
+        if (!dependencies.branchExists(branchName)) {
+            logger.error(`Branch '${branchName}' does not exist.`, {
+                exit: EXIT_CODES.INVALID_USAGE,
+            });
+        }
+        logger.debug(`✓ Branch '${branchName}' exists`);
+        logger.debug('Getting current branch name...');
+        let currentBranch;
+        try {
+            currentBranch = dependencies.getCurrentBranch();
+        }
+        catch (error_) {
+            const error = error_;
+            logger.error(`Failed to get current branch: ${error.message}`, {
+                exit: EXIT_CODES.ENVIRONMENT_ERROR,
+            });
+        }
+        logger.debug(`Current branch: ${currentBranch}`);
+        if (currentBranch === branchName) {
+            try {
+                await dependencies.copyToClipboard('aiw branch --main');
+                logger.debug('✓ Copied "aiw branch --main" to clipboard');
+            }
+            catch (clipboardError) {
+                logger.debug('Failed to copy to clipboard:', clipboardError);
+            }
+            logger.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 });
+        }
+        logger.debug(`✓ Not currently on branch '${branchName}'`);
+        logger.debug(`Finding worktree path for branch '${branchName}'...`);
+        const worktreePath = dependencies.getWorktreePath(branchName);
+        if (worktreePath) {
+            logger.logInfo(`Deleting worktree folder at ${worktreePath}...`);
+            await dependencies.deleteWorktreeFolder(worktreePath, { debugLog: (message) => logger.debug(message) });
+            logger.debug('✓ Worktree folder deleted');
+        }
+        else {
+            logger.debug('No worktree folder found for this branch');
+        }
+        logger.logInfo(`Deleting git branch '${branchName}'...`);
+        dependencies.deleteBranch(branchName, { debugLog: (message) => logger.debug(message) });
+        logger.debug(`✓ Git branch '${branchName}' deleted`);
+        logger.logSuccess(`✓ Branch '${branchName}' and its worktree have been deleted`);
+    }
+    catch (error) {
+        const err = error;
+        if (err.message?.includes('EEXIT'))
+            throw error;
+        logger.error(`Failed to delete branch: ${err.message}`, {
+            exit: EXIT_CODES.GENERAL_ERROR,
+        });
+    }
+}
+async function handleDeleteAll(cwd, logger, dependencies) {
+    try {
+        logger.debug('Checking if current directory is a git repository...');
+        const isGitRepo = await isGitRepository(cwd, dependencies);
+        if (!isGitRepo) {
+            logger.error('Not a git repository. This command only works inside a git repository.', {
+                exit: EXIT_CODES.ENVIRONMENT_ERROR,
+            });
+        }
+        logger.debug('✓ Git repository detected');
+        logger.logInfo('Scanning all worktrees in repository...');
+        const allWorktrees = dependencies.getAllWorktrees();
+        logger.debug(`Found ${allWorktrees.length} worktrees`);
+        const deleted = [];
+        const preserved = [];
+        const candidatesForAsyncCheck = [];
+        const normalizedCwd = resolve(cwd);
+        for (const worktree of allWorktrees) {
+            const { branch, path } = worktree;
+            if (!branch) {
+                logger.debug(`Skipping worktree at ${path} (detached HEAD)`);
+                preserved.push({ branch, path, reason: 'detached HEAD' });
+                continue;
+            }
+            if (branch === 'main' || branch === 'master') {
+                logger.debug(`Skipping protected branch: ${branch}`);
+                preserved.push({ branch, path, reason: 'protected branch (main/master)' });
+                continue;
+            }
+            if (normalizedCwd === resolve(path)) {
+                logger.debug(`Skipping current directory worktree: ${path}`);
+                preserved.push({ branch, path, reason: 'current directory (cannot delete while inside)' });
+                continue;
+            }
+            candidatesForAsyncCheck.push({ branch, path });
+        }
+        logger.debug(`Running safety checks on ${candidatesForAsyncCheck.length} candidates in parallel...`);
+        const debugLog = (message) => logger.debug(message);
+        const safetyCheckResults = await Promise.all(candidatesForAsyncCheck.map(async ({ branch, path }) => {
+            logger.debug(`Checking safety for branch '${branch}'...`);
+            if (dependencies.hasUnpushedCommits(branch, { debugLog })) {
+                logger.debug(`Branch '${branch}' has unpushed commits, skipping`);
+                return { branch, path, safe: false, reason: 'has unpushed commits' };
+            }
+            if (dependencies.hasMergeRequest(branch, { debugLog })) {
+                logger.debug(`Branch '${branch}' has an open PR, skipping`);
+                return { branch, path, safe: false, reason: 'has open pull request' };
+            }
+            logger.debug(`Branch '${branch}' is safe to delete`);
+            return { branch, path, safe: true, reason: null };
+        }));
+        const safeToDelete = safetyCheckResults.filter((result) => result.safe);
+        const unsafe = safetyCheckResults.filter((result) => !result.safe);
+        for (const { branch, path, reason } of unsafe) {
+            preserved.push({ branch, path, reason: reason });
+        }
+        for (const { branch, path } of safeToDelete) {
+            try {
+                // Sequential deletion required: worktree must be deleted before branch.
+                // eslint-disable-next-line no-await-in-loop
+                await dependencies.deleteWorktreeFolder(path, { debugLog });
+                dependencies.deleteBranch(branch, { debugLog });
+                deleted.push({ branch, path });
+                logger.debug(`✓ Deleted branch '${branch}' and worktree at ${path}`);
+            }
+            catch (error) {
+                const err = error;
+                logger.debug(`Failed to delete branch '${branch}': ${err.message}`);
+                preserved.push({ branch, path, reason: `deletion failed: ${err.message}` });
+            }
+        }
+        logger.log('');
+        logger.logSuccess('✓ Worktree cleanup complete');
+        logger.log('');
+        if (deleted.length > 0) {
+            logger.logInfo(`Deleted ${deleted.length} worktree${deleted.length === 1 ? '' : 's'}:`);
+            for (const { branch, path } of deleted) {
+                logger.log(`  - ${branch} (${path})`);
+            }
+            logger.log('');
+        }
+        else {
+            logger.logInfo('No worktrees were deleted.');
+            logger.log('');
+        }
+        if (preserved.length > 0) {
+            logger.logInfo(`Preserved ${preserved.length} worktree${preserved.length === 1 ? '' : 's'}:`);
+            for (const { branch, path, reason } of preserved) {
+                logger.log(`  - ${branch ?? 'detached'} (${path})`);
+                logger.log(`    Reason: ${reason}`);
+            }
+        }
+    }
+    catch (error) {
+        const err = error;
+        if (err.message?.includes('EEXIT'))
+            throw error;
+        logger.error(`Failed to clean up worktrees: ${err.message}`, {
+            exit: EXIT_CODES.GENERAL_ERROR,
+        });
+    }
+}
+async function handleMainBranch(cwd, logger, dependencies) {
+    try {
+        logger.debug('Checking if current directory is a git repository...');
+        const isGitRepo = await isGitRepository(cwd, dependencies);
+        if (!isGitRepo) {
+            logger.error('Not a git repository. This command only works inside a git repository.', {
+                exit: EXIT_CODES.ENVIRONMENT_ERROR,
+            });
+        }
+        logger.debug('✓ Git repository detected');
+        logger.debug('Getting current branch name...');
+        let currentBranch;
+        try {
+            currentBranch = dependencies.getCurrentBranch();
+        }
+        catch (error_) {
+            const error = error_;
+            logger.error(`Failed to get current branch: ${error.message}`, {
+                exit: EXIT_CODES.ENVIRONMENT_ERROR,
+            });
+        }
+        logger.debug(`Current branch: ${currentBranch}`);
+        if (currentBranch === 'main' || currentBranch === 'master') {
+            logger.error(`Already on ${currentBranch} branch. This command is for switching to main/master from another branch.`, {
+                exit: EXIT_CODES.INVALID_USAGE,
+            });
+        }
+        logger.debug('✓ Currently on a feature branch');
+        logger.debug('Checking which main branch exists...');
+        const mainBranch = dependencies.getMainBranch();
+        if (!mainBranch) {
+            logger.error('Neither "main" nor "master" branch exists in this repository.', {
+                exit: EXIT_CODES.INVALID_USAGE,
+            });
+        }
+        logger.debug(`✓ Found main branch: ${mainBranch}`);
+        logger.debug(`Finding worktree path for ${mainBranch} branch...`);
+        const mainBranchPath = dependencies.getWorktreePath(mainBranch);
+        if (!mainBranchPath) {
+            logger.error(`Could not find worktree for ${mainBranch} branch.`, {
+                exit: EXIT_CODES.ENVIRONMENT_ERROR,
+            });
+        }
+        logger.debug(`✓ Found ${mainBranch} worktree at: ${mainBranchPath}`);
+        logger.logInfo(`Opening new terminal with aiw launch in ${mainBranch} branch...`);
+        const result = await dependencies.launchTerminal({
+            command: 'aiw launch',
+            cwd: mainBranchPath,
+            debugLog: (message) => logger.debug(message),
+        });
+        if (!result.success) {
+            logger.error(`Failed to launch terminal: ${result.error}`, { exit: EXIT_CODES.GENERAL_ERROR });
+        }
+        logger.logSuccess(`✓ New terminal launched with aiw in ${mainBranch} branch`);
+    }
+    catch (error) {
+        const err = error;
+        if (err.message?.includes('EEXIT'))
+            throw error;
+        logger.error(`Failed to launch terminal: ${err.message}`, {
+            exit: EXIT_CODES.GENERAL_ERROR,
+        });
+    }
+}
+async function handleWorktreeLaunch(cwd, branchName, logger, dependencies) {
+    const validatedBranchName = validateLaunchBranchName(branchName);
+    try {
+        const isGitRepo = await isGitRepository(cwd, dependencies);
+        if (!isGitRepo) {
+            logger.error('Not a git repository. This command only works inside a git repository.', {
+                exit: EXIT_CODES.ENVIRONMENT_ERROR,
+            });
+        }
+        const worktreePath = deriveWorktreePath(cwd, validatedBranchName);
+        logger.debug(`Checking for existing worktree at: ${worktreePath}`);
+        let worktreeExists = false;
+        try {
+            await dependencies.access(worktreePath);
+            worktreeExists = true;
+            logger.logInfo(`Worktree already exists at: ${worktreePath}`);
+            logger.logInfo('Opening terminal in existing worktree...');
+        }
+        catch {
+            logger.logInfo(`Creating worktree for branch: ${validatedBranchName}`);
+            logger.logInfo(`Worktree location: ${worktreePath}`);
+        }
+        if (!worktreeExists) {
+            await dependencies.createWorktree(validatedBranchName, worktreePath);
+            logger.logSuccess(`✓ Created worktree at ${worktreePath}`);
+            logger.logSuccess(`✓ Created and checked out branch: ${validatedBranchName}`);
+        }
+        const result = await dependencies.launchTerminal({
+            command: 'aiw launch',
+            cwd: worktreePath,
+            debugLog: (message) => logger.debug(message),
+        });
+        if (!result.success) {
+            logger.error(`Failed to launch terminal: ${result.error}`, { exit: EXIT_CODES.GENERAL_ERROR });
+        }
+        logger.logSuccess('✓ Launched terminal with aiw launch');
+        logger.log('');
+        logger.logInfo('New terminal window opened at worktree location.');
+        logger.logInfo('Claude Code should be launching automatically.');
+    }
+    catch (error) {
+        const err = error;
+        if (err.message?.includes('EEXIT'))
+            throw error;
+        if (err.message?.includes('already exists')) {
+            logger.error(`Branch '${validatedBranchName}' already exists. Choose a different name.`, {
+                exit: EXIT_CODES.INVALID_USAGE,
+            });
+        }
+        if (err.stderr?.includes('fatal: not a git repository')) {
+            logger.error('Not a git repository. Please run this command from a git repository root.', {
+                exit: EXIT_CODES.INVALID_USAGE,
+            });
+        }
+        logger.error(`Failed to create/open worktree: ${err.message}`, { exit: EXIT_CODES.GENERAL_ERROR });
+    }
+}
+async function isGitRepository(cwd, dependencies) {
+    try {
+        await dependencies.access(join(cwd, '.git'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isUsageFailure(error) {
+    return typeof error === 'object'
+        && error !== null
+        && 'exit' in error
+        && 'message' in error
+        && typeof error.exit === 'number'
+        && typeof error.message === 'string';
+}

package/dist/capabilities/branch/runtime-core.d.ts

@@ -0,0 +1,5 @@
+import type { BranchCommandRequest } from './contracts.js';
+export type BranchMode = 'delete' | 'delete-all' | 'launch' | 'main';
+export declare function determineBranchMode(request: BranchCommandRequest): BranchMode;
+export declare function validateLaunchBranchName(branchName: string | undefined): string;
+export declare function deriveWorktreePath(cwd: string, branchName: string): string;

package/dist/capabilities/branch/runtime-core.js

@@ -0,0 +1,36 @@
+import { basename, dirname, resolve } from 'node:path';
+import { EXIT_CODES } from '../../types/index.js';
+const VALID_BRANCH_NAME_PATTERN = /^[a-zA-Z0-9._/-]+$/;
+export function determineBranchMode(request) {
+    const { args, flags } = request;
+    if (!flags.main && !flags.launch && !flags.delete) {
+        if (args.branchName) {
+            return 'launch';
+        }
+        throw usageFailure('Either provide a branch name directly (aiw branch <name>) or use --main, --launch, or --delete');
+    }
+    if (flags.main)
+        return 'main';
+    if (flags.launch)
+        return 'launch';
+    if (flags.delete && flags.all)
+        return 'delete-all';
+    return 'delete';
+}
+export function validateLaunchBranchName(branchName) {
+    if (!branchName || branchName.trim().length === 0) {
+        throw usageFailure('Branch name is required. Usage: aiw branch <name> or aiw branch --launch <name>');
+    }
+    if (!VALID_BRANCH_NAME_PATTERN.test(branchName)) {
+        throw usageFailure('Branch name contains invalid characters. Use only letters, numbers, dots, dashes, underscores, and slashes.');
+    }
+    return branchName;
+}
+export function deriveWorktreePath(cwd, branchName) {
+    const currentDirName = basename(cwd);
+    const parentDir = dirname(cwd);
+    return resolve(parentDir, `${currentDirName}-${branchName}`);
+}
+function usageFailure(message) {
+    return Object.assign(new Error(message), { exit: EXIT_CODES.INVALID_USAGE });
+}

package/dist/capabilities/installation/control-plane/clean-command.d.ts

@@ -0,0 +1,41 @@
+import BaseCommand from '../../../cli/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;
+}