@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/commands/patterns.js

@@ -0,0 +1,405 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Patterns extends BaseCommand {
+    static description = 'Show learned patterns for current context or entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --entity mindtools',
+        '<%= config.bin %> <%= command.id %> --type client',
+        '<%= config.bin %> <%= command.id %> --mode strategy',
+    ];
+    static flags = {
+        entity: Flags.string({
+            char: 'e',
+            description: 'show patterns for specific entity',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'output as JSON',
+        }),
+        mode: Flags.string({
+            char: 'm',
+            description: 'show patterns for focus mode',
+            options: ['delivery', 'strategy', 'audit', 'debug', 'research', 'proposal'],
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'show patterns for entity type',
+            options: ['client', 'prospect', 'company', 'initiative', 'system'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Patterns);
+        const currentFocus = await this.focusService.getCurrentFocus();
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        // Determine what patterns to analyze
+        let targetEntity = null;
+        let targetType = flags.type;
+        const targetMode = (flags.mode || currentFocus?.mode);
+        if (flags.entity) {
+            const foundEntity = this.entityService.findEntity(flags.entity);
+            if (!foundEntity) {
+                this.error(`Entity '${flags.entity}' not found`);
+            }
+            targetEntity = foundEntity;
+        }
+        else if (focusedEntities.length > 0) {
+            targetEntity = focusedEntities[0]; // Use first focused entity
+            targetType = targetType || targetEntity.type;
+        }
+        const patterns = await this.analyzePatterns(targetEntity, targetType, targetMode);
+        if (flags.json) {
+            this.log(JSON.stringify(patterns, null, 2));
+            return;
+        }
+        this.displayPatterns(patterns, targetEntity, targetType, targetMode);
+    }
+    analyzeCollaborationPatterns(_entity) {
+        // Would analyze commit patterns, PR patterns, etc.
+        return ['solo_work', 'pair_programming', 'code_review'];
+    }
+    async analyzeCrossEntityPatterns(entities) {
+        return {
+            dependencyChains: this.findDependencyChains(entities),
+            sharedSystems: this.findSharedSystems(entities),
+            similarEntityClusters: this.findSimilarClusters(entities),
+            workflowSimilarities: this.findWorkflowSimilarities(entities),
+        };
+    }
+    async analyzeEntityPatterns(entity) {
+        const metadata = entity.metadata || {};
+        return {
+            collaborationPatterns: this.analyzeCollaborationPatterns(entity),
+            commonWorkflows: [
+                'Focus → Edit → Commit → Push',
+                'Research → Document → Review',
+                'Debug → Fix → Test → Deploy',
+            ],
+            filePatterns: this.analyzeFilePatterns(entity),
+            focusIntelligence: {},
+            relationships: metadata.relationships || {},
+            workingPatterns: metadata.working_patterns || {},
+        };
+    }
+    // Helper methods for pattern analysis
+    analyzeFilePatterns(_entity) {
+        // Would analyze actual file patterns from git history
+        return ['src/', 'docs/', 'tests/'];
+    }
+    async analyzeModePatterns(mode) {
+        return {
+            commonTools: this.getCommonTools(mode),
+            optimalDuration: this.getOptimalDuration(mode),
+            successIndicators: this.getSuccessIndicators(mode),
+            transitionPatterns: this.getTransitionPatterns(mode),
+            typicalActivities: this.getTypicalActivities(mode),
+        };
+    }
+    async analyzePatterns(entity, type, mode) {
+        const allEntities = this.entityService.getAllEntities();
+        const patterns = {
+            crossEntityPatterns: {},
+            entityPatterns: {},
+            modePatterns: {},
+            productivityPatterns: this.generateProductivityPatterns(entity, type, mode),
+            temporalPatterns: this.generateTemporalPatterns(),
+            typePatterns: {},
+        };
+        // Entity-specific patterns
+        if (entity) {
+            patterns.entityPatterns = await this.analyzeEntityPatterns(entity);
+        }
+        // Type-based patterns
+        if (type) {
+            const entitiesOfType = allEntities.filter(e => e.type === type);
+            patterns.typePatterns = await this.analyzeTypePatterns(entitiesOfType, type);
+        }
+        // Mode-based patterns
+        if (mode) {
+            patterns.modePatterns = await this.analyzeModePatterns(mode);
+        }
+        // Cross-entity patterns
+        patterns.crossEntityPatterns = await this.analyzeCrossEntityPatterns(allEntities);
+        return patterns;
+    }
+    analyzeRelationshipPatterns(_entities) {
+        // Would analyze actual relationship patterns
+        return {
+            commonDependencies: ['systems/api', 'shared/design-system'],
+            typicalClusterSize: 3,
+        };
+    }
+    async analyzeTypePatterns(entities, type) {
+        const commonPatterns = {
+            commonModes: this.getCommonModes(type),
+            relationshipPatterns: this.analyzeRelationshipPatterns(entities),
+            successMetrics: this.getSuccessMetrics(type),
+            typicalDuration: this.calculateTypicalDuration(entities, type),
+        };
+        return commonPatterns;
+    }
+    calculateTypicalDuration(_entities, type) {
+        // Would calculate from actual usage data
+        const durations = {
+            client: '2 hours',
+            company: '3 hours',
+            initiative: '2.5 hours',
+            prospect: '1 hour',
+            system: '1.5 hours',
+        };
+        return durations[type] || '1 hour';
+    }
+    displayEntityPatterns(patterns) {
+        if (patterns.commonWorkflows) {
+            this.log(`  ${chalk.cyan('Common Workflows:')}`);
+            for (const workflow of patterns.commonWorkflows) {
+                this.log(`    • ${workflow}`);
+            }
+        }
+        if (patterns.workingPatterns?.typical_focus_duration) {
+            this.log(`  ${chalk.cyan('Typical Focus Duration:')} ${patterns.workingPatterns.typical_focus_duration}`);
+        }
+        if (patterns.relationships?.similar_entities && patterns.relationships.similar_entities.length > 0) {
+            this.log(`  ${chalk.cyan('Similar Entities:')} ${patterns.relationships.similar_entities.join(', ')}`);
+        }
+    }
+    displayModePatterns(patterns) {
+        if (patterns.typicalActivities?.length > 0) {
+            this.log(`  ${chalk.cyan('Typical Activities:')}`);
+            for (const activity of patterns.typicalActivities) {
+                this.log(`    • ${activity}`);
+            }
+        }
+        if (patterns.optimalDuration) {
+            this.log(`  ${chalk.cyan('Optimal Duration:')} ${patterns.optimalDuration}`);
+        }
+    }
+    displayPatterns(patterns, entity, type, mode) {
+        this.log(chalk.bold('\n🔍 Pattern Analysis'));
+        this.log(chalk.dim('─'.repeat(50)));
+        // Context header
+        const context = [];
+        if (entity)
+            context.push(`Entity: ${chalk.cyan(entity.name)}`);
+        if (type)
+            context.push(`Type: ${chalk.yellow(type)}`);
+        if (mode)
+            context.push(`Mode: ${chalk.green(mode)}`);
+        if (context.length > 0) {
+            this.log(`📍 Context: ${context.join(' | ')}`);
+            this.log('');
+        }
+        // Entity patterns
+        if (patterns.entityPatterns && Object.keys(patterns.entityPatterns).length > 0) {
+            this.log(chalk.bold('🎯 Entity-Specific Patterns:'));
+            this.displayEntityPatterns(patterns.entityPatterns);
+            this.log('');
+        }
+        // Type patterns
+        if (patterns.typePatterns && Object.keys(patterns.typePatterns).length > 0) {
+            this.log(chalk.bold('📊 Type-Based Patterns:'));
+            this.displayTypePatterns(patterns.typePatterns);
+            this.log('');
+        }
+        // Mode patterns
+        if (patterns.modePatterns && Object.keys(patterns.modePatterns).length > 0) {
+            this.log(chalk.bold('⚙️ Mode-Specific Patterns:'));
+            this.displayModePatterns(patterns.modePatterns);
+            this.log('');
+        }
+        // Productivity patterns
+        if (patterns.productivityPatterns) {
+            this.log(chalk.bold('📈 Productivity Patterns:'));
+            this.displayProductivityPatterns(patterns.productivityPatterns);
+            this.log('');
+        }
+        // Temporal patterns
+        if (patterns.temporalPatterns) {
+            this.log(chalk.bold('⏰ Temporal Patterns:'));
+            this.displayTemporalPatterns(patterns.temporalPatterns);
+        }
+    }
+    displayProductivityPatterns(patterns) {
+        if (patterns.highProductivityIndicators?.length > 0) {
+            this.log(`  ${chalk.green('High Productivity Indicators:')}`);
+            for (const indicator of patterns.highProductivityIndicators) {
+                this.log(`    ✓ ${indicator}`);
+            }
+        }
+        if (patterns.optimizationSuggestions?.length > 0) {
+            this.log(`  ${chalk.yellow('Optimization Suggestions:')}`);
+            for (const suggestion of patterns.optimizationSuggestions) {
+                this.log(`    💡 ${suggestion}`);
+            }
+        }
+    }
+    displayTemporalPatterns(patterns) {
+        if (patterns.peakProductivityHours) {
+            this.log(`  ${chalk.cyan('Peak Hours:')} ${patterns.peakProductivityHours.join(', ')}`);
+        }
+        if (patterns.optimalSessionLength) {
+            this.log(`  ${chalk.cyan('Optimal Session:')} ${patterns.optimalSessionLength}`);
+        }
+        if (patterns.contextSwitchCost) {
+            this.log(`  ${chalk.cyan('Context Switch Cost:')} ${patterns.contextSwitchCost}`);
+        }
+    }
+    displayTypePatterns(patterns) {
+        if (patterns.typicalDuration) {
+            this.log(`  ${chalk.cyan('Typical Duration:')} ${patterns.typicalDuration}`);
+        }
+        if (patterns.commonModes?.length > 0) {
+            this.log(`  ${chalk.cyan('Common Modes:')} ${patterns.commonModes.join(', ')}`);
+        }
+        if (patterns.successMetrics?.length > 0) {
+            this.log(`  ${chalk.cyan('Success Metrics:')}`);
+            for (const metric of patterns.successMetrics) {
+                this.log(`    • ${metric}`);
+            }
+        }
+    }
+    findDependencyChains(_entities) {
+        // Would analyze actual dependency chains
+        return ['client → system → shared'];
+    }
+    findSharedSystems(_entities) {
+        // Would find commonly used systems
+        return ['systems/api', 'shared/design-system'];
+    }
+    findSimilarClusters(_entities) {
+        // Would find clusters of similar entities
+        return [['mindtools', 'vixting'], ['api', 'shared']];
+    }
+    findWorkflowSimilarities(_entities) {
+        // Would analyze workflow similarities
+        return ['React development pattern', 'API integration pattern'];
+    }
+    generateProductivityPatterns(_entity, type, mode) {
+        const basePatterns = {
+            highProductivityIndicators: [
+                'Focused sessions > 60 minutes',
+                'Minimal context switching',
+                'Clear objectives set',
+                'Distraction-free environment',
+            ],
+            optimizationSuggestions: [],
+            productivityKillers: [
+                'Frequent interruptions',
+                'Unclear requirements',
+                'Technical debt',
+                'Missing dependencies',
+            ],
+        };
+        // Add context-specific suggestions
+        if (mode === 'strategy') {
+            basePatterns.optimizationSuggestions = [
+                ...basePatterns.optimizationSuggestions,
+                'Schedule 2+ hour blocks for strategic thinking',
+                'Minimize technical distractions',
+                'Include business context in focus',
+            ];
+        }
+        else if (mode === 'delivery') {
+            basePatterns.optimizationSuggestions = [
+                ...basePatterns.optimizationSuggestions,
+                'Use 90-minute focused coding sessions',
+                'Have clear technical requirements',
+                'Minimize meeting interruptions',
+            ];
+        }
+        if (type === 'client') {
+            basePatterns.optimizationSuggestions = [
+                ...basePatterns.optimizationSuggestions,
+                'Batch client communication',
+                'Maintain business context awareness',
+                'Regular stakeholder alignment',
+            ];
+        }
+        return basePatterns;
+    }
+    generateTemporalPatterns() {
+        return {
+            contextSwitchCost: '8-12 minutes',
+            optimalSessionLength: '90 minutes',
+            peakProductivityHours: ['9-11am', '2-4pm'],
+            seasonalPatterns: {
+                q1: 'Planning and architecture',
+                q2: 'Development and implementation',
+                q3: 'Testing and optimization',
+                q4: 'Documentation and review',
+            },
+            weeklyPatterns: {
+                friday: 'Documentation and cleanup',
+                monday: 'Planning and strategy',
+                thursday: 'Implementation and testing',
+                tuesday: 'Deep development work',
+                wednesday: 'Collaboration and reviews',
+            },
+        };
+    }
+    getCommonModes(type) {
+        const modes = {
+            client: ['delivery', 'strategy', 'audit'],
+            company: ['strategy', 'audit'],
+            initiative: ['strategy', 'delivery'],
+            prospect: ['research', 'proposal'],
+            system: ['delivery', 'debug'],
+        };
+        return modes[type] || ['delivery'];
+    }
+    getCommonTools(_mode) {
+        // Would return actual tool usage patterns
+        return ['VS Code', 'Git', 'Browser', 'Terminal'];
+    }
+    getOptimalDuration(mode) {
+        const durations = {
+            audit: '60-90 minutes',
+            debug: '45-60 minutes',
+            delivery: '90 minutes',
+            proposal: '2-4 hours',
+            research: '1-2 hours',
+            strategy: '2-3 hours',
+        };
+        return durations[mode] || '1 hour';
+    }
+    getSuccessIndicators(mode) {
+        const indicators = {
+            audit: ['Issues identified', 'Compliance verified', 'Risks assessed'],
+            debug: ['Issues resolved', 'Root cause found', 'Fix verified'],
+            delivery: ['Code committed', 'Tests passing', 'Features completed'],
+            proposal: ['Requirements clarified', 'Solution designed', 'Proposal completed'],
+            research: ['Insights gathered', 'Options identified', 'Recommendations made'],
+            strategy: ['Decisions made', 'Plans documented', 'Alignment achieved'],
+        };
+        return indicators[mode] || [];
+    }
+    getSuccessMetrics(type) {
+        const metrics = {
+            client: ['Client satisfaction', 'Delivery velocity', 'Code quality'],
+            company: ['Strategic alignment', 'Operational efficiency', 'Growth metrics'],
+            initiative: ['Milestone completion', 'Cross-team adoption', 'Impact measurement'],
+            prospect: ['Proposal quality', 'Response time', 'Conversion rate'],
+            system: ['Performance metrics', 'Reliability', 'Developer experience'],
+        };
+        return metrics[type] || [];
+    }
+    getTransitionPatterns(_mode) {
+        // Would analyze actual transition patterns
+        return {
+            commonNextModes: ['delivery', 'strategy'],
+            transitionTriggers: ['completion', 'interruption', 'scheduled'],
+        };
+    }
+    getTypicalActivities(mode) {
+        const activities = {
+            audit: ['Review', 'Compliance check', 'Risk assessment', 'Documentation'],
+            debug: ['Issue investigation', 'Log analysis', 'Testing fixes', 'Root cause analysis'],
+            delivery: ['Coding', 'Testing', 'Code review', 'Documentation'],
+            proposal: ['Requirements gathering', 'Solution design', 'Pricing', 'Presentation creation'],
+            research: ['Market analysis', 'Technology evaluation', 'Competitive research', 'Documentation'],
+            strategy: ['Planning', 'Analysis', 'Decision making', 'Roadmap creation'],
+        };
+        return activities[mode] || [];
+    }
+}

package/dist/commands/pull.d.ts

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

package/dist/commands/pull.js

@@ -0,0 +1,121 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class Pull extends BaseCommand {
+    static description = 'Pull changes from remote repositories';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --rebase',
+        '<%= config.bin %> <%= command.id %> --all',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            default: false,
+            description: 'Fetch all remotes',
+        }),
+        'no-commit': Flags.boolean({
+            default: false,
+            description: 'Perform merge but do not commit',
+        }),
+        rebase: Flags.boolean({
+            char: 'r',
+            default: false,
+            description: 'Rebase instead of merge',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Pull);
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.error('No entities are focused. Use "gut focus <entity>" first.');
+        }
+        this.log(chalk.bold('\n⬇️  Pulling from remote repositories\n'));
+        const results = {
+            conflicts: [],
+            failed: [],
+            success: [],
+            upToDate: [],
+        };
+        for (const entity of focusedEntities) {
+            const spinner = ora(`Pulling ${chalk.cyan(entity.name)}`).start();
+            try {
+                // Check if there's a remote configured
+                const remoteOutput = await this.gitService.exec(['remote', '-v'], { cwd: entity.path });
+                if (!remoteOutput || remoteOutput.trim().length === 0) {
+                    spinner.warn(chalk.yellow(`${entity.name}: No remote configured`));
+                    results.failed.push({ error: 'No remote configured', repo: entity.name });
+                    continue;
+                }
+                // Fetch all remotes if requested
+                if (flags.all) {
+                    await this.gitService.exec(['fetch', '--all'], { cwd: entity.path });
+                }
+                // Check for uncommitted changes
+                const status = await this.gitService.getStatus(entity.path);
+                const hasUncommitted = status.changes.length > 0;
+                if (hasUncommitted && !flags['no-commit']) {
+                    spinner.warn(chalk.yellow(`${entity.name}: Has uncommitted changes`));
+                    results.failed.push({ error: 'Uncommitted changes. Commit or stash first', repo: entity.name });
+                    continue;
+                }
+                // Build pull options
+                const options = {
+                    noFf: flags['no-commit'],
+                    rebase: flags.rebase,
+                };
+                await this.gitService.pull(entity.path, options);
+                spinner.succeed(chalk.green(`✓ ${entity.name}: Pulled successfully`));
+                results.success.push(entity.name);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('Already up to date') || errorMessage.includes('Already up-to-date')) {
+                    spinner.info(chalk.blue(`${entity.name}: Already up-to-date`));
+                    results.upToDate.push(entity.name);
+                }
+                else if (errorMessage.includes('CONFLICT')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: Merge conflicts detected`));
+                    results.conflicts.push(entity.name);
+                }
+                else if (errorMessage.includes('no tracking information')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: No tracking branch configured`));
+                    results.failed.push({ error: 'No tracking branch. Set upstream first', repo: entity.name });
+                }
+                else if (errorMessage.includes('diverged')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: Branches have diverged`));
+                    results.failed.push({ error: 'Branches diverged. Use --rebase or resolve manually', 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📊 Pull Summary'));
+        this.log(chalk.dim('─'.repeat(50)));
+        if (results.success.length > 0) {
+            this.log(chalk.green(`✓ Updated: ${results.success.length} entities`));
+        }
+        if (results.upToDate.length > 0) {
+            this.log(chalk.blue(`○ Up-to-date: ${results.upToDate.length} entities`));
+        }
+        if (results.conflicts.length > 0) {
+            this.log(chalk.yellow(`⚠ Conflicts: ${results.conflicts.length} entities`));
+            this.log(chalk.dim('  Resolve conflicts manually in:'));
+            for (const repo of results.conflicts) {
+                this.log(chalk.dim(`  - ${repo}`));
+            }
+        }
+        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 status" to see the current state'));
+        }
+    }
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../base-command.js';
+export default class Push extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'set-upstream': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        tags: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/push.js

@@ -0,0 +1,97 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class Push extends BaseCommand {
+    static description = 'Push commits to remote repositories';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --force',
+        '<%= config.bin %> <%= command.id %> --set-upstream',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force push (use with caution)',
+        }),
+        'set-upstream': Flags.boolean({
+            char: 'u',
+            default: false,
+            description: 'Set upstream branch',
+        }),
+        tags: Flags.boolean({
+            default: false,
+            description: 'Push tags',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Push);
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.error('No entities are focused. Use "gut focus <entity>" first.');
+        }
+        this.log(chalk.bold('\n🚀 Pushing to remote repositories\n'));
+        const results = {
+            failed: [],
+            success: [],
+            upToDate: [],
+        };
+        for (const entity of focusedEntities) {
+            const spinner = ora(`Pushing ${chalk.cyan(entity.name)}`).start();
+            try {
+                // Check if there's a remote configured
+                const remoteOutput = await this.gitService.exec(['remote', '-v'], { cwd: entity.path });
+                if (!remoteOutput || remoteOutput.trim().length === 0) {
+                    spinner.warn(chalk.yellow(`${entity.name}: No remote configured`));
+                    results.failed.push({ error: 'No remote configured', repo: entity.name });
+                    continue;
+                }
+                // Build push options
+                const options = {
+                    force: flags.force,
+                    setUpstream: flags['set-upstream'],
+                    tags: flags.tags,
+                };
+                await this.gitService.push(entity.path, options);
+                spinner.succeed(chalk.green(`✓ ${entity.name}: Pushed successfully`));
+                results.success.push(entity.name);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('Everything up-to-date')) {
+                    spinner.info(chalk.blue(`${entity.name}: Already up-to-date`));
+                    results.upToDate.push(entity.name);
+                }
+                else if (errorMessage.includes('no upstream branch')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: No upstream branch. Use --set-upstream`));
+                    results.failed.push({ error: 'No upstream branch configured', repo: entity.name });
+                }
+                else if (errorMessage.includes('rejected')) {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: Push rejected (remote has changes)`));
+                    results.failed.push({ error: 'Remote has changes. Pull 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📊 Push Summary'));
+        this.log(chalk.dim('─'.repeat(50)));
+        if (results.success.length > 0) {
+            this.log(chalk.green(`✓ Pushed: ${results.success.length} entities`));
+        }
+        if (results.upToDate.length > 0) {
+            this.log(chalk.blue(`○ Up-to-date: ${results.upToDate.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}`));
+            }
+            this.log(chalk.dim('\nTip: Use "gut pull" to sync with remote first'));
+        }
+    }
+}

package/dist/commands/quick-setup.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../base-command.js';
+export default class QuickSetup extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        auto: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'clone-missing': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'scan-depth': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private profiles;
+    run(): Promise<void>;
+    private categorizeEntities;
+    private detectProfile;
+    private findMissingEntities;
+    private printDetectedEntities;
+    private printNextSteps;
+    private printSetupSummary;
+    private scanWorkspace;
+}