@hyperdrive.bot/gut 0.1.8 → 0.1.10

package/dist/commands/checkout.js

@@ -0,0 +1,124 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class Checkout extends BaseCommand {
+    static args = {
+        branch: Args.string({
+            description: 'Branch name to checkout or create',
+            required: true,
+        }),
+    };
+    static description = 'Checkout or create branches in focused repositories';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> main',
+        '<%= config.bin %> <%= command.id %> -b feature/new-feature',
+        '<%= config.bin %> <%= command.id %> -b PRD-123 --from main',
+    ];
+    static flags = {
+        'create-branch': Flags.boolean({
+            char: 'b',
+            default: false,
+            description: 'Create a new branch',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force checkout (discard local changes)',
+        }),
+        from: Flags.string({
+            description: 'Base branch to create from (use with -b)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Checkout);
+        const { branch } = args;
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.error('No entities are focused. Use "gut focus <entity>" first.');
+        }
+        const action = flags['create-branch'] ? 'Creating branch' : 'Checking out';
+        this.log(chalk.bold(`\n🔀 ${action} "${chalk.cyan(branch)}" in focused entities\n`));
+        const results = {
+            alreadyOnBranch: [],
+            created: [],
+            failed: [],
+            switched: [],
+        };
+        for (const entity of focusedEntities) {
+            const spinner = ora(`${action} in ${chalk.cyan(entity.name)}`).start();
+            try {
+                // Get current branch
+                const currentBranch = await this.gitService.getCurrentBranch(entity.path);
+                // Check if already on target branch
+                if (currentBranch === branch && !flags['create-branch']) {
+                    spinner.info(chalk.blue(`${entity.name}: Already on branch "${branch}"`));
+                    results.alreadyOnBranch.push(entity.name);
+                    continue;
+                }
+                if (flags['create-branch']) {
+                    // If --from is specified, checkout that branch first
+                    if (flags.from) {
+                        await this.gitService.checkout(entity.path, flags.from);
+                    }
+                    // Create and checkout new branch
+                    await this.gitService.createBranch(entity.path, branch, true);
+                    spinner.succeed(chalk.green(`✓ ${entity.name}: Created and checked out "${branch}"`));
+                    results.created.push(entity.name);
+                }
+                else {
+                    // Switch to existing branch
+                    if (flags.force) {
+                        await this.gitService.exec(['checkout', '-f', branch], { cwd: entity.path });
+                    }
+                    else {
+                        await this.gitService.checkout(entity.path, branch);
+                    }
+                    spinner.succeed(chalk.green(`✓ ${entity.name}: Switched to "${branch}"`));
+                    results.switched.push(entity.name);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('already exists')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: Branch "${branch}" already exists`));
+                    results.failed.push({ error: `Branch already exists`, repo: entity.name });
+                }
+                else if (errorMessage.includes('did not match any')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: Branch "${branch}" not found`));
+                    results.failed.push({ error: `Branch not found`, repo: entity.name });
+                }
+                else if (errorMessage.includes('local changes')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: Local changes would be overwritten`));
+                    results.failed.push({ error: 'Local changes would be overwritten. Commit or stash first, or use --force', repo: entity.name });
+                }
+                else {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: ${errorMessage}`));
+                    results.failed.push({ error: errorMessage, repo: entity.name });
+                }
+            }
+        }
+        // Summary
+        this.log(chalk.bold('\n📊 Checkout Summary'));
+        this.log(chalk.dim('─'.repeat(50)));
+        if (results.created.length > 0) {
+            this.log(chalk.green(`✓ Created: ${results.created.length} entities`));
+        }
+        if (results.switched.length > 0) {
+            this.log(chalk.green(`✓ Switched: ${results.switched.length} entities`));
+        }
+        if (results.alreadyOnBranch.length > 0) {
+            this.log(chalk.blue(`○ Already on branch: ${results.alreadyOnBranch.length} entities`));
+        }
+        if (results.failed.length > 0) {
+            this.log(chalk.red(`✗ Failed: ${results.failed.length} entities`));
+            for (const failure of results.failed) {
+                this.log(chalk.red(`  - ${failure.repo}: ${failure.error}`));
+            }
+        }
+        if (results.created.length > 0) {
+            this.log(chalk.dim('\nTip: Use "gut push -u" to push new branches to remote'));
+        }
+    }
+}

package/dist/commands/commit.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../base-command.js';
+export default class Commit extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        amend: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/commit.js

@@ -0,0 +1,107 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class Commit extends BaseCommand {
+    static description = 'Commit changes in focused repositories';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> -m "Fix bug"',
+        '<%= config.bin %> <%= command.id %> --message "Add feature"',
+        '<%= config.bin %> <%= command.id %>', // Interactive mode
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Stage all changes before committing',
+        }),
+        amend: Flags.boolean({
+            default: false,
+            description: 'Amend the previous commit',
+        }),
+        message: Flags.string({
+            char: 'm',
+            description: 'Commit message',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Commit);
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.error('No entities are focused. Use "gut focus <entity>" first.');
+        }
+        let { message } = flags;
+        // Interactive prompt for commit message if not provided
+        if (!message && !flags.amend) {
+            const response = await inquirer.prompt([
+                {
+                    message: 'Enter commit message:',
+                    name: 'message',
+                    type: 'input',
+                    validate(input) {
+                        if (!input || input.trim().length === 0) {
+                            return 'Commit message cannot be empty';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            message = response.message;
+        }
+        this.log(chalk.bold('\n💾 Committing changes in focused entities\n'));
+        const results = {
+            failed: [],
+            noChanges: [],
+            success: [],
+        };
+        for (const entity of focusedEntities) {
+            const spinner = ora(`Committing in ${chalk.cyan(entity.name)}`).start();
+            try {
+                // Check if there are changes to commit
+                const status = await this.gitService.getStatus(entity.path);
+                const hasChanges = status.changes.length > 0 || status.untracked.length > 0;
+                if (!hasChanges && !flags.amend) {
+                    spinner.info(chalk.yellow(`${entity.name}: No changes to commit`));
+                    results.noChanges.push(entity.name);
+                    continue;
+                }
+                // Build commit options
+                const options = {
+                    all: flags.all,
+                    amend: flags.amend,
+                };
+                // Amend without changing message, or commit with new message
+                await (!message && flags.amend
+                    ? this.gitService.exec(['commit', '--amend', '--no-edit'], { cwd: entity.path })
+                    : this.gitService.commit(entity.path, message || '', options));
+                spinner.succeed(chalk.green(`✓ ${entity.name}: Committed successfully`));
+                results.success.push(entity.name);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                spinner.fail(chalk.red(`✗ ${entity.name}: ${errorMessage}`));
+                results.failed.push({ error: errorMessage, repo: entity.name });
+            }
+        }
+        // Summary
+        this.log(chalk.bold('\n📊 Commit Summary'));
+        this.log(chalk.dim('─'.repeat(50)));
+        if (results.success.length > 0) {
+            this.log(chalk.green(`✓ Success: ${results.success.length} entities`));
+        }
+        if (results.noChanges.length > 0) {
+            this.log(chalk.yellow(`○ No changes: ${results.noChanges.length} entities`));
+        }
+        if (results.failed.length > 0) {
+            this.log(chalk.red(`✗ Failed: ${results.failed.length} entities`));
+            for (const failure of results.failed) {
+                this.log(chalk.red(`  - ${failure.repo}: ${failure.error}`));
+            }
+        }
+        if (results.success.length > 0) {
+            this.log(chalk.dim('\nTip: Use "gut push" to push commits to remote'));
+        }
+    }
+}

package/dist/commands/context.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '../base-command.js';
+export default class Context extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/context.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import path from 'node:path';
+import { BaseCommand } from '../base-command.js';
+export default class Context extends BaseCommand {
+    static description = 'Show current focus context with entity details';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        await this.parse(Context);
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.log(chalk.yellow('No entities are currently focused'));
+            this.log(chalk.dim('Use "gut focus <entity>" to set focus'));
+            return;
+        }
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        this.log(chalk.bold('\n📍 Current Focus Context'));
+        this.log(chalk.dim('─'.repeat(50)));
+        for (const entity of focusedEntities) {
+            this.log(`\n${chalk.green('▸')} ${chalk.bold(entity.name)}`);
+            this.log(`  ${chalk.dim('Type:')} ${entity.type}`);
+            this.log(`  ${chalk.dim('Path:')} ${path.relative(workspaceRoot, entity.path)}`);
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(`${chalk.dim('Total focused entities:')} ${focusedEntities.length}`);
+        const history = await this.configService.getHistory();
+        if (history.length > 1) {
+            this.log(`${chalk.dim('Previous focus:')} ${history[1].entities.join(', ')}`);
+        }
+    }
+}

package/dist/commands/contexts.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from '../base-command.js';
+export default class Contexts extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private formatTimeAgo;
+}

package/dist/commands/contexts.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Contexts extends BaseCommand {
+    static description = 'List all available contexts and focus history';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        await this.parse(Contexts);
+        // Show current focus
+        const currentFocus = await this.focusService.getCurrentFocus();
+        if (currentFocus) {
+            this.log(chalk.bold('\n🎯 Current Focus'));
+            this.log(chalk.dim('─'.repeat(50)));
+            const description = await this.focusService.getFocusDescription();
+            this.log(`${chalk.green('▸')} ${description}`);
+            if (currentFocus.mode) {
+                this.log(`  ${chalk.dim('Mode:')} ${currentFocus.mode}`);
+            }
+        }
+        // Show focus stack
+        const focusStack = this.focusService.getFocusStack();
+        if (focusStack.length > 0) {
+            this.log(chalk.bold('\n📚 Focus Stack'));
+            this.log(chalk.dim('─'.repeat(50)));
+            for (const [index, focus] of focusStack.entries()) {
+                const entities = focus.entities?.map(e => e.name).join(', ') || focus.name;
+                const modeText = focus.mode ? ` (${focus.mode})` : '';
+                this.log(`${chalk.yellow(`${index + 1}.`)} ${entities}${modeText}`);
+            }
+            this.log(chalk.dim('\nUse "gut back" to return to previous focus'));
+        }
+        // Show recent history
+        const history = this.configService.getHistory();
+        if (history.length > 0) {
+            this.log(chalk.bold('\n📋 Recent Focus History'));
+            this.log(chalk.dim('─'.repeat(50)));
+            const recentHistory = history.slice(-5).reverse();
+            for (const [index, entry] of recentHistory.entries()) {
+                const timeAgo = this.formatTimeAgo(entry.timestamp);
+                const entities = entry.entities.join(', ');
+                this.log(`${chalk.dim(`${index + 1}.`)} ${entities} ${chalk.dim(`(${timeAgo})`)}`);
+            }
+        }
+        // Show available entities by type
+        const entities = this.entityService.getAllEntities();
+        if (entities.length > 0) {
+            this.log(chalk.bold('\n🏢 Available Entities'));
+            this.log(chalk.dim('─'.repeat(50)));
+            const displayedTypes = ['client', 'prospect', 'company', 'initiative', 'system'];
+            for (const type of displayedTypes) {
+                const entitiesOfType = entities.filter(e => e.type === type);
+                if (entitiesOfType.length > 0) {
+                    this.log(`\n${chalk.bold(type.toUpperCase())}:`);
+                    for (const entity of entitiesOfType) {
+                        const emoji = this.getTypeEmoji(entity.type);
+                        this.log(`  ${emoji} ${entity.name}`);
+                    }
+                }
+            }
+            // Show other types
+            const otherEntities = entities.filter(e => !displayedTypes.includes(e.type));
+            if (otherEntities.length > 0) {
+                this.log(`\n${chalk.bold('OTHER')}:`);
+                for (const entity of otherEntities) {
+                    const emoji = this.getTypeEmoji(entity.type);
+                    this.log(`  ${emoji} ${entity.name} (${entity.type})`);
+                }
+            }
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(chalk.dim('Use "gut focus <entity>" or "gut focus <type> <name>" to set focus'));
+    }
+    formatTimeAgo(timestamp) {
+        const now = Date.now();
+        const diff = now - timestamp;
+        const minutes = Math.floor(diff / (1000 * 60));
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0)
+            return `${days}d ago`;
+        if (hours > 0)
+            return `${hours}h ago`;
+        if (minutes > 0)
+            return `${minutes}m ago`;
+        return 'just now';
+    }
+}

package/dist/commands/deps.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../base-command.js';
+export default class Deps extends BaseCommand {
+    static args: {
+        entity: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private analyzeDependencies;
+}

package/dist/commands/deps.js

@@ -0,0 +1,100 @@
+import { Args } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Deps extends BaseCommand {
+    static args = {
+        entity: Args.string({
+            description: 'Entity name to analyze dependencies for',
+            name: 'entity',
+            required: false,
+        }),
+    };
+    static description = 'Show dependencies of current focus or specified entity';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> mindtools',
+    ];
+    async run() {
+        const { args } = await this.parse(Deps);
+        let targetEntities = [];
+        if (args.entity) {
+            // Analyze specific entity
+            const entity = this.entityService.findEntity(args.entity);
+            if (!entity) {
+                this.error(`Entity '${args.entity}' not found`);
+            }
+            targetEntities = [entity];
+        }
+        else {
+            // Analyze current focus
+            targetEntities = await this.focusService.getFocusedEntities();
+            if (targetEntities.length === 0) {
+                this.error('No entities in focus. Use "gut focus <entity>" first or specify an entity name.');
+            }
+        }
+        this.log(chalk.bold('\n🔗 Dependencies Analysis'));
+        this.log(chalk.dim('─'.repeat(50)));
+        for (const entity of targetEntities) {
+            this.log(`\n${chalk.green('▸')} ${chalk.bold(entity.name)} (${entity.type})`);
+            const dependencies = await this.analyzeDependencies(entity);
+            if (dependencies.direct.length > 0) {
+                this.log(`\n  ${chalk.yellow('Direct Dependencies:')}`);
+                for (const dep of dependencies.direct) {
+                    this.log(`    ${this.getTypeEmoji(dep.type)} ${dep.name} (${dep.type})`);
+                }
+            }
+            if (dependencies.system.length > 0) {
+                this.log(`\n  ${chalk.blue('System Dependencies:')}`);
+                for (const dep of dependencies.system) {
+                    this.log(`    ${this.getTypeEmoji(dep.type)} ${dep.name} (${dep.type})`);
+                }
+            }
+            if (dependencies.inferred.length > 0) {
+                this.log(`\n  ${chalk.dim('Inferred Dependencies:')}`);
+                for (const dep of dependencies.inferred) {
+                    this.log(`    ${this.getTypeEmoji(dep.type)} ${dep.name} (${dep.type}) ${chalk.dim('- pattern based')}`);
+                }
+            }
+            if (dependencies.direct.length === 0 && dependencies.system.length === 0 && dependencies.inferred.length === 0) {
+                this.log(`    ${chalk.dim('No dependencies found')}`);
+            }
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(chalk.dim('Dependencies are determined from entity metadata and usage patterns'));
+    }
+    async analyzeDependencies(entity) {
+        const allEntities = this.entityService.getAllEntities();
+        // Direct dependencies from metadata
+        const directDeps = [];
+        if (entity.metadata?.relationships?.dependent_systems) {
+            for (const depName of entity.metadata.relationships.dependent_systems) {
+                const depEntity = allEntities.find(e => e.name === depName || e.path.includes(depName));
+                if (depEntity) {
+                    directDeps.push(depEntity);
+                }
+            }
+        }
+        // System dependencies (all entities depend on systems)
+        const systemDeps = allEntities.filter(e => e.type === 'system' && e.name !== entity.name);
+        // Inferred dependencies based on patterns
+        const inferredDeps = [];
+        // Clients typically depend on shared design systems
+        if (entity.type === 'client') {
+            const designSystem = allEntities.find(e => e.name.includes('design') || e.name.includes('shared') || e.type === 'module');
+            if (designSystem && !directDeps.includes(designSystem) && !systemDeps.includes(designSystem)) {
+                inferredDeps.push(designSystem);
+            }
+        }
+        // Prospects might depend on similar client patterns
+        if (entity.type === 'prospect') {
+            const similarClients = allEntities.filter(e => e.type === 'client'
+                && entity.metadata?.relationships?.similar_entities?.includes(e.name));
+            inferredDeps.push(...similarClients);
+        }
+        return {
+            direct: directDeps,
+            inferred: inferredDeps,
+            system: systemDeps.slice(0, 3), // Limit to avoid clutter
+        };
+    }
+}

package/dist/commands/entity/add.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command.js';
+export default class AddEntity extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        type: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        path: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        repo: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/entity/add.js

@@ -0,0 +1,103 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { BaseCommand } from '../../base-command.js';
+/** Entity types that support automatic directory creation */
+const DIRECTORY_CREATING_ENTITY_TYPES = ['client', 'company', 'initiative', 'prospect', 'system'];
+export default class AddEntity extends BaseCommand {
+    static args = {
+        name: Args.string({
+            description: 'Entity name',
+            name: 'name',
+            required: true,
+        }),
+        type: Args.string({
+            description: 'Entity type',
+            name: 'type',
+            options: ['client', 'prospect', 'company', 'initiative', 'system', 'delivery', 'module', 'service', 'tool'],
+            required: true,
+        }),
+    };
+    static description = 'Add a new entity to the workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> delivery my-app --path ./apps/my-app',
+        '<%= config.bin %> <%= command.id %> module my-lib --path ./libs/my-lib --remote git@github.com:org/my-lib.git',
+    ];
+    static flags = {
+        description: Flags.string({
+            char: 'd',
+            description: 'entity description',
+        }),
+        path: Flags.string({
+            char: 'p',
+            description: 'path to entity',
+            required: true,
+        }),
+        remote: Flags.string({
+            char: 'r',
+            description: 'git remote URL',
+        }),
+        repo: Flags.string({
+            description: 'repository name (for GitLab/GitHub)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AddEntity);
+        // Validate entity name
+        if (!this.entityService.validateEntityName(args.name)) {
+            this.error('Entity name must be alphanumeric with hyphens or underscores');
+        }
+        // Check if entity already exists
+        if (this.entityService.findEntity(args.name)) {
+            this.error(`Entity '${args.name}' already exists`);
+        }
+        // Validate and resolve path
+        const entityPath = path.isAbsolute(flags.path)
+            ? flags.path
+            : path.join(this.configService.getWorkspaceRoot(), flags.path);
+        // Create directory if it doesn't exist (especially for new entity types)
+        if (!fs.existsSync(entityPath)) {
+            const supportsDirectoryCreation = DIRECTORY_CREATING_ENTITY_TYPES.includes(args.type);
+            if (supportsDirectoryCreation) {
+                fs.mkdirSync(entityPath, { recursive: true });
+                this.log(`✓ Created directory: ${flags.path}`);
+            }
+            else {
+                this.error(`Path '${flags.path}' does not exist`);
+            }
+        }
+        if (!fs.statSync(entityPath).isDirectory()) {
+            this.error(`Path '${flags.path}' is not a directory`);
+        }
+        // Check if it's a git repository
+        const isGitRepo = await this.gitService.isRepository(entityPath);
+        // Get remote URL if it's a git repo and no remote provided
+        let remoteUrl = flags.remote;
+        if (isGitRepo && !remoteUrl) {
+            remoteUrl = await this.gitService.getRemoteUrl(entityPath) || undefined;
+        }
+        // Create entity
+        const entity = {
+            description: flags.description,
+            name: args.name,
+            path: flags.path.startsWith('./') ? flags.path : `./${flags.path}`,
+            remote: remoteUrl,
+            repo: flags.repo,
+            type: args.type,
+        };
+        // Add entity
+        await this.entityService.addEntity(entity.name, entity.type, entity.path, entity.remote || entity.repo);
+        this.log(`✅ Added ${args.type} entity '${args.name}'`);
+        this.log(`   Path: ${entity.path}`);
+        if (entity.remote) {
+            this.log(`   Remote: ${entity.remote}`);
+        }
+        if (entity.description) {
+            this.log(`   Description: ${entity.description}`);
+        }
+        this.log('\nYou can now:');
+        this.log(`  • Focus on this entity: gut focus ${args.name}`);
+        this.log(`  • Clone it elsewhere: gut entity clone ${args.name}`);
+        this.log('  • View all entities: gut entity list');
+    }
+}

package/dist/commands/entity/clone-all.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command.js';
+export default class CloneAll extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        depth: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        parallel: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'skip-existing': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private detectWorkspaceBranch;
+    private cloneEntity;
+    private cloneInParallel;
+    private cloneSequentially;
+    private printSummary;
+}