@hyperdrive.bot/gut 0.1.3

package/dist/commands/patterns.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class Patterns extends base_command_1.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: core_1.Flags.string({
+            char: 'e',
+            description: 'show patterns for specific entity',
+        }),
+        type: core_1.Flags.string({
+            char: 't',
+            description: 'show patterns for entity type',
+            options: ['client', 'prospect', 'company', 'initiative', 'system'],
+        }),
+        mode: core_1.Flags.string({
+            char: 'm',
+            description: 'show patterns for focus mode',
+            options: ['delivery', 'strategy', 'audit', 'debug', 'research', 'proposal'],
+        }),
+        json: core_1.Flags.boolean({
+            description: 'output as JSON',
+            default: false,
+        }),
+    };
+    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;
+        let targetMode = flags.mode || currentFocus?.mode;
+        if (flags.entity) {
+            targetEntity = this.entityService.findEntity(flags.entity);
+            if (!targetEntity) {
+                this.error(`Entity '${flags.entity}' not found`);
+            }
+        }
+        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);
+    }
+    async analyzePatterns(entity, type, mode) {
+        const allEntities = this.entityService.getAllEntities();
+        const patterns = {
+            entity_patterns: {},
+            type_patterns: {},
+            mode_patterns: {},
+            cross_entity_patterns: {},
+            temporal_patterns: {},
+            productivity_patterns: {}
+        };
+        // Entity-specific patterns
+        if (entity) {
+            patterns.entity_patterns = await this.analyzeEntityPatterns(entity);
+        }
+        // Type-based patterns
+        if (type) {
+            const entitiesOfType = allEntities.filter(e => e.type === type);
+            patterns.type_patterns = await this.analyzeTypePatterns(entitiesOfType, type);
+        }
+        // Mode-based patterns
+        if (mode) {
+            patterns.mode_patterns = await this.analyzeModePatterns(mode);
+        }
+        // Cross-entity patterns
+        patterns.cross_entity_patterns = await this.analyzeCrossEntityPatterns(allEntities);
+        // Temporal patterns (simulated - would come from actual usage data)
+        patterns.temporal_patterns = this.generateTemporalPatterns();
+        // Productivity patterns (simulated - would come from focus analytics)
+        patterns.productivity_patterns = this.generateProductivityPatterns(entity, type, mode);
+        return patterns;
+    }
+    async analyzeEntityPatterns(entity) {
+        const metadata = entity.metadata || {};
+        return {
+            working_patterns: metadata.working_patterns || {},
+            relationships: metadata.relationships || {},
+            focus_intelligence: metadata.focus_intelligence || {},
+            common_workflows: [
+                'Focus → Edit → Commit → Push',
+                'Research → Document → Review',
+                'Debug → Fix → Test → Deploy'
+            ],
+            file_patterns: this.analyzeFilePatterns(entity),
+            collaboration_patterns: this.analyzeCollaborationPatterns(entity)
+        };
+    }
+    async analyzeTypePatterns(entities, type) {
+        const commonPatterns = {
+            typical_duration: this.calculateTypicalDuration(entities, type),
+            common_modes: this.getCommonModes(type),
+            relationship_patterns: this.analyzeRelationshipPatterns(entities),
+            success_metrics: this.getSuccessMetrics(type)
+        };
+        return commonPatterns;
+    }
+    async analyzeModePatterns(mode) {
+        return {
+            typical_activities: this.getTypicalActivities(mode),
+            optimal_duration: this.getOptimalDuration(mode),
+            common_tools: this.getCommonTools(mode),
+            success_indicators: this.getSuccessIndicators(mode),
+            transition_patterns: this.getTransitionPatterns(mode)
+        };
+    }
+    async analyzeCrossEntityPatterns(entities) {
+        return {
+            dependency_chains: this.findDependencyChains(entities),
+            similar_entity_clusters: this.findSimilarClusters(entities),
+            shared_systems: this.findSharedSystems(entities),
+            workflow_similarities: this.findWorkflowSimilarities(entities)
+        };
+    }
+    generateTemporalPatterns() {
+        return {
+            peak_productivity_hours: ['9-11am', '2-4pm'],
+            optimal_session_length: '90 minutes',
+            context_switch_cost: '8-12 minutes',
+            weekly_patterns: {
+                monday: 'Planning and strategy',
+                tuesday: 'Deep development work',
+                wednesday: 'Collaboration and reviews',
+                thursday: 'Implementation and testing',
+                friday: 'Documentation and cleanup'
+            },
+            seasonal_patterns: {
+                q1: 'Planning and architecture',
+                q2: 'Development and implementation',
+                q3: 'Testing and optimization',
+                q4: 'Documentation and review'
+            }
+        };
+    }
+    generateProductivityPatterns(entity, type, mode) {
+        const basePatterns = {
+            high_productivity_indicators: [
+                'Focused sessions > 60 minutes',
+                'Minimal context switching',
+                'Clear objectives set',
+                'Distraction-free environment'
+            ],
+            productivity_killers: [
+                'Frequent interruptions',
+                'Unclear requirements',
+                'Technical debt',
+                'Missing dependencies'
+            ],
+            optimization_suggestions: []
+        };
+        // Add context-specific suggestions
+        if (mode === 'strategy') {
+            basePatterns.optimization_suggestions = [
+                ...basePatterns.optimization_suggestions,
+                'Schedule 2+ hour blocks for strategic thinking',
+                'Minimize technical distractions',
+                'Include business context in focus'
+            ];
+        }
+        else if (mode === 'delivery') {
+            basePatterns.optimization_suggestions = [
+                ...basePatterns.optimization_suggestions,
+                'Use 90-minute focused coding sessions',
+                'Have clear technical requirements',
+                'Minimize meeting interruptions'
+            ];
+        }
+        if (type === 'client') {
+            basePatterns.optimization_suggestions = [
+                ...basePatterns.optimization_suggestions,
+                'Batch client communication',
+                'Maintain business context awareness',
+                'Regular stakeholder alignment'
+            ];
+        }
+        return basePatterns;
+    }
+    displayPatterns(patterns, entity, type, mode) {
+        this.log(chalk_1.default.bold('\n🔍 Pattern Analysis'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        // Context header
+        const context = [];
+        if (entity)
+            context.push(`Entity: ${chalk_1.default.cyan(entity.name)}`);
+        if (type)
+            context.push(`Type: ${chalk_1.default.yellow(type)}`);
+        if (mode)
+            context.push(`Mode: ${chalk_1.default.green(mode)}`);
+        if (context.length > 0) {
+            this.log(`📍 Context: ${context.join(' | ')}`);
+            this.log('');
+        }
+        // Entity patterns
+        if (patterns.entity_patterns && Object.keys(patterns.entity_patterns).length > 0) {
+            this.log(chalk_1.default.bold('🎯 Entity-Specific Patterns:'));
+            this.displayEntityPatterns(patterns.entity_patterns);
+            this.log('');
+        }
+        // Type patterns
+        if (patterns.type_patterns && Object.keys(patterns.type_patterns).length > 0) {
+            this.log(chalk_1.default.bold('📊 Type-Based Patterns:'));
+            this.displayTypePatterns(patterns.type_patterns);
+            this.log('');
+        }
+        // Mode patterns
+        if (patterns.mode_patterns && Object.keys(patterns.mode_patterns).length > 0) {
+            this.log(chalk_1.default.bold('⚙️ Mode-Specific Patterns:'));
+            this.displayModePatterns(patterns.mode_patterns);
+            this.log('');
+        }
+        // Productivity patterns
+        if (patterns.productivity_patterns) {
+            this.log(chalk_1.default.bold('📈 Productivity Patterns:'));
+            this.displayProductivityPatterns(patterns.productivity_patterns);
+            this.log('');
+        }
+        // Temporal patterns
+        if (patterns.temporal_patterns) {
+            this.log(chalk_1.default.bold('⏰ Temporal Patterns:'));
+            this.displayTemporalPatterns(patterns.temporal_patterns);
+        }
+    }
+    displayEntityPatterns(patterns) {
+        if (patterns.common_workflows) {
+            this.log(`  ${chalk_1.default.cyan('Common Workflows:')}`);
+            patterns.common_workflows.forEach((workflow) => {
+                this.log(`    • ${workflow}`);
+            });
+        }
+        if (patterns.working_patterns?.typical_focus_duration) {
+            this.log(`  ${chalk_1.default.cyan('Typical Focus Duration:')} ${patterns.working_patterns.typical_focus_duration}`);
+        }
+        if (patterns.relationships?.similar_entities?.length > 0) {
+            this.log(`  ${chalk_1.default.cyan('Similar Entities:')} ${patterns.relationships.similar_entities.join(', ')}`);
+        }
+    }
+    displayTypePatterns(patterns) {
+        if (patterns.typical_duration) {
+            this.log(`  ${chalk_1.default.cyan('Typical Duration:')} ${patterns.typical_duration}`);
+        }
+        if (patterns.common_modes?.length > 0) {
+            this.log(`  ${chalk_1.default.cyan('Common Modes:')} ${patterns.common_modes.join(', ')}`);
+        }
+        if (patterns.success_metrics?.length > 0) {
+            this.log(`  ${chalk_1.default.cyan('Success Metrics:')}`);
+            patterns.success_metrics.forEach((metric) => {
+                this.log(`    • ${metric}`);
+            });
+        }
+    }
+    displayModePatterns(patterns) {
+        if (patterns.typical_activities?.length > 0) {
+            this.log(`  ${chalk_1.default.cyan('Typical Activities:')}`);
+            patterns.typical_activities.forEach((activity) => {
+                this.log(`    • ${activity}`);
+            });
+        }
+        if (patterns.optimal_duration) {
+            this.log(`  ${chalk_1.default.cyan('Optimal Duration:')} ${patterns.optimal_duration}`);
+        }
+    }
+    displayProductivityPatterns(patterns) {
+        if (patterns.high_productivity_indicators?.length > 0) {
+            this.log(`  ${chalk_1.default.green('High Productivity Indicators:')}`);
+            patterns.high_productivity_indicators.forEach((indicator) => {
+                this.log(`    ✓ ${indicator}`);
+            });
+        }
+        if (patterns.optimization_suggestions?.length > 0) {
+            this.log(`  ${chalk_1.default.yellow('Optimization Suggestions:')}`);
+            patterns.optimization_suggestions.forEach((suggestion) => {
+                this.log(`    💡 ${suggestion}`);
+            });
+        }
+    }
+    displayTemporalPatterns(patterns) {
+        if (patterns.peak_productivity_hours) {
+            this.log(`  ${chalk_1.default.cyan('Peak Hours:')} ${patterns.peak_productivity_hours.join(', ')}`);
+        }
+        if (patterns.optimal_session_length) {
+            this.log(`  ${chalk_1.default.cyan('Optimal Session:')} ${patterns.optimal_session_length}`);
+        }
+        if (patterns.context_switch_cost) {
+            this.log(`  ${chalk_1.default.cyan('Context Switch Cost:')} ${patterns.context_switch_cost}`);
+        }
+    }
+    // Helper methods for pattern analysis
+    analyzeFilePatterns(entity) {
+        // Would analyze actual file patterns from git history
+        return ['src/', 'docs/', 'tests/'];
+    }
+    analyzeCollaborationPatterns(entity) {
+        // Would analyze commit patterns, PR patterns, etc.
+        return ['solo_work', 'pair_programming', 'code_review'];
+    }
+    calculateTypicalDuration(entities, type) {
+        // Would calculate from actual usage data
+        const durations = {
+            client: '2 hours',
+            prospect: '1 hour',
+            company: '3 hours',
+            initiative: '2.5 hours',
+            system: '1.5 hours'
+        };
+        return durations[type] || '1 hour';
+    }
+    getCommonModes(type) {
+        const modes = {
+            client: ['delivery', 'strategy', 'audit'],
+            prospect: ['research', 'proposal'],
+            company: ['strategy', 'audit'],
+            initiative: ['strategy', 'delivery'],
+            system: ['delivery', 'debug']
+        };
+        return modes[type] || ['delivery'];
+    }
+    analyzeRelationshipPatterns(entities) {
+        // Would analyze actual relationship patterns
+        return {
+            common_dependencies: ['systems/api', 'shared/design-system'],
+            typical_cluster_size: 3
+        };
+    }
+    getSuccessMetrics(type) {
+        const metrics = {
+            client: ['Client satisfaction', 'Delivery velocity', 'Code quality'],
+            prospect: ['Proposal quality', 'Response time', 'Conversion rate'],
+            company: ['Strategic alignment', 'Operational efficiency', 'Growth metrics'],
+            initiative: ['Milestone completion', 'Cross-team adoption', 'Impact measurement'],
+            system: ['Performance metrics', 'Reliability', 'Developer experience']
+        };
+        return metrics[type] || [];
+    }
+    getTypicalActivities(mode) {
+        const activities = {
+            delivery: ['Coding', 'Testing', 'Code review', 'Documentation'],
+            strategy: ['Planning', 'Analysis', 'Decision making', 'Roadmap creation'],
+            audit: ['Review', 'Compliance check', 'Risk assessment', 'Documentation'],
+            debug: ['Issue investigation', 'Log analysis', 'Testing fixes', 'Root cause analysis'],
+            research: ['Market analysis', 'Technology evaluation', 'Competitive research', 'Documentation'],
+            proposal: ['Requirements gathering', 'Solution design', 'Pricing', 'Presentation creation']
+        };
+        return activities[mode] || [];
+    }
+    getOptimalDuration(mode) {
+        const durations = {
+            delivery: '90 minutes',
+            strategy: '2-3 hours',
+            audit: '60-90 minutes',
+            debug: '45-60 minutes',
+            research: '1-2 hours',
+            proposal: '2-4 hours'
+        };
+        return durations[mode] || '1 hour';
+    }
+    getCommonTools(mode) {
+        // Would return actual tool usage patterns
+        return ['VS Code', 'Git', 'Browser', 'Terminal'];
+    }
+    getSuccessIndicators(mode) {
+        const indicators = {
+            delivery: ['Code committed', 'Tests passing', 'Features completed'],
+            strategy: ['Decisions made', 'Plans documented', 'Alignment achieved'],
+            audit: ['Issues identified', 'Compliance verified', 'Risks assessed'],
+            debug: ['Issues resolved', 'Root cause found', 'Fix verified'],
+            research: ['Insights gathered', 'Options identified', 'Recommendations made'],
+            proposal: ['Requirements clarified', 'Solution designed', 'Proposal completed']
+        };
+        return indicators[mode] || [];
+    }
+    getTransitionPatterns(mode) {
+        // Would analyze actual transition patterns
+        return {
+            common_next_modes: ['delivery', 'strategy'],
+            transition_triggers: ['completion', 'interruption', 'scheduled']
+        };
+    }
+    findDependencyChains(entities) {
+        // Would analyze actual dependency chains
+        return ['client → system → shared'];
+    }
+    findSimilarClusters(entities) {
+        // Would find clusters of similar entities
+        return [['mindtools', 'vixting'], ['api', 'shared']];
+    }
+    findSharedSystems(entities) {
+        // Would find commonly used systems
+        return ['systems/api', 'shared/design-system'];
+    }
+    findWorkflowSimilarities(entities) {
+        // Would analyze workflow similarities
+        return ['React development pattern', 'API integration pattern'];
+    }
+}
+exports.default = Patterns;

package/dist/commands/pull.d.ts

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

package/dist/commands/pull.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+class Pull extends base_command_1.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 = {
+        rebase: core_1.Flags.boolean({
+            char: 'r',
+            description: 'Rebase instead of merge',
+            default: false,
+        }),
+        all: core_1.Flags.boolean({
+            description: 'Fetch all remotes',
+            default: false,
+        }),
+        'no-commit': core_1.Flags.boolean({
+            description: 'Perform merge but do not commit',
+            default: false,
+        }),
+    };
+    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_1.default.bold('\n⬇️  Pulling from remote repositories\n'));
+        const results = {
+            success: [],
+            failed: [],
+            upToDate: [],
+            conflicts: [],
+        };
+        for (const entity of focusedEntities) {
+            const spinner = (0, ora_1.default)(`Pulling ${chalk_1.default.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_1.default.yellow(`${entity.name}: No remote configured`));
+                    results.failed.push({ repo: entity.name, error: 'No remote configured' });
+                    continue;
+                }
+                // 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_1.default.yellow(`${entity.name}: Has uncommitted changes`));
+                    results.failed.push({ repo: entity.name, error: 'Uncommitted changes. Commit or stash first' });
+                    continue;
+                }
+                // Build pull options
+                const options = {
+                    rebase: flags.rebase,
+                    noFf: flags['no-commit'],
+                };
+                await this.gitService.pull(entity.path, options);
+                spinner.succeed(chalk_1.default.green(`✓ ${entity.name}: Pulled successfully`));
+                results.success.push(entity.name);
+            }
+            catch (error) {
+                const errorMessage = error.message || error.toString();
+                if (errorMessage.includes('Already up to date') || errorMessage.includes('Already up-to-date')) {
+                    spinner.info(chalk_1.default.blue(`${entity.name}: Already up-to-date`));
+                    results.upToDate.push(entity.name);
+                }
+                else if (errorMessage.includes('CONFLICT')) {
+                    spinner.fail(chalk_1.default.red(`✗ ${entity.name}: Merge conflicts detected`));
+                    results.conflicts.push(entity.name);
+                }
+                else if (errorMessage.includes('no tracking information')) {
+                    spinner.fail(chalk_1.default.red(`✗ ${entity.name}: No tracking branch configured`));
+                    results.failed.push({ repo: entity.name, error: 'No tracking branch. Set upstream first' });
+                }
+                else if (errorMessage.includes('diverged')) {
+                    spinner.fail(chalk_1.default.red(`✗ ${entity.name}: Branches have diverged`));
+                    results.failed.push({ repo: entity.name, error: 'Branches diverged. Use --rebase or resolve manually' });
+                }
+                else {
+                    spinner.fail(chalk_1.default.red(`✗ ${entity.name}: ${errorMessage}`));
+                    results.failed.push({ repo: entity.name, error: errorMessage });
+                }
+            }
+        }
+        // Summary
+        this.log(chalk_1.default.bold('\n📊 Pull Summary'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        if (results.success.length > 0) {
+            this.log(chalk_1.default.green(`✓ Updated: ${results.success.length} entities`));
+        }
+        if (results.upToDate.length > 0) {
+            this.log(chalk_1.default.blue(`○ Up-to-date: ${results.upToDate.length} entities`));
+        }
+        if (results.conflicts.length > 0) {
+            this.log(chalk_1.default.yellow(`⚠ Conflicts: ${results.conflicts.length} entities`));
+            this.log(chalk_1.default.dim('  Resolve conflicts manually in:'));
+            for (const repo of results.conflicts) {
+                this.log(chalk_1.default.dim(`  - ${repo}`));
+            }
+        }
+        if (results.failed.length > 0) {
+            this.log(chalk_1.default.red(`✗ Failed: ${results.failed.length} entities`));
+            for (const failure of results.failed) {
+                this.log(chalk_1.default.red(`  - ${failure.repo}: ${failure.error}`));
+            }
+        }
+        if (results.success.length > 0) {
+            this.log(chalk_1.default.dim('\nTip: Use "gut status" to see the current state'));
+        }
+    }
+}
+exports.default = Pull;

package/dist/commands/push.d.ts

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

package/dist/commands/push.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+class Push extends base_command_1.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: core_1.Flags.boolean({
+            char: 'f',
+            description: 'Force push (use with caution)',
+            default: false,
+        }),
+        'set-upstream': core_1.Flags.boolean({
+            char: 'u',
+            description: 'Set upstream branch',
+            default: false,
+        }),
+        tags: core_1.Flags.boolean({
+            description: 'Push tags',
+            default: false,
+        }),
+    };
+    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_1.default.bold('\n🚀 Pushing to remote repositories\n'));
+        const results = {
+            success: [],
+            failed: [],
+            upToDate: [],
+        };
+        for (const entity of focusedEntities) {
+            const spinner = (0, ora_1.default)(`Pushing ${chalk_1.default.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_1.default.yellow(`${entity.name}: No remote configured`));
+                    results.failed.push({ repo: entity.name, error: 'No remote configured' });
+                    continue;
+                }
+                // Build push options
+                const options = {
+                    force: flags.force,
+                    tags: flags.tags,
+                    setUpstream: flags['set-upstream'],
+                };
+                await this.gitService.push(entity.path, options);
+                spinner.succeed(chalk_1.default.green(`✓ ${entity.name}: Pushed successfully`));
+                results.success.push(entity.name);
+            }
+            catch (error) {
+                const errorMessage = error.message || error.toString();
+                if (errorMessage.includes('Everything up-to-date')) {
+                    spinner.info(chalk_1.default.blue(`${entity.name}: Already up-to-date`));
+                    results.upToDate.push(entity.name);
+                }
+                else if (errorMessage.includes('no upstream branch')) {
+                    spinner.fail(chalk_1.default.red(`✗ ${entity.name}: No upstream branch. Use --set-upstream`));
+                    results.failed.push({ repo: entity.name, error: 'No upstream branch configured' });
+                }
+                else if (errorMessage.includes('rejected')) {
+                    spinner.fail(chalk_1.default.red(`✗ ${entity.name}: Push rejected (remote has changes)`));
+                    results.failed.push({ repo: entity.name, error: 'Remote has changes. Pull first or use --force' });
+                }
+                else {
+                    spinner.fail(chalk_1.default.red(`✗ ${entity.name}: ${errorMessage}`));
+                    results.failed.push({ repo: entity.name, error: errorMessage });
+                }
+            }
+        }
+        // Summary
+        this.log(chalk_1.default.bold('\n📊 Push Summary'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        if (results.success.length > 0) {
+            this.log(chalk_1.default.green(`✓ Pushed: ${results.success.length} entities`));
+        }
+        if (results.upToDate.length > 0) {
+            this.log(chalk_1.default.blue(`○ Up-to-date: ${results.upToDate.length} entities`));
+        }
+        if (results.failed.length > 0) {
+            this.log(chalk_1.default.red(`✗ Failed: ${results.failed.length} entities`));
+            for (const failure of results.failed) {
+                this.log(chalk_1.default.red(`  - ${failure.repo}: ${failure.error}`));
+            }
+            this.log(chalk_1.default.dim('\nTip: Use "gut pull" to sync with remote first'));
+        }
+    }
+}
+exports.default = Push;

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

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