@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/commands/status.js

@@ -0,0 +1,193 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Status extends BaseCommand {
+    static description = 'Show git status for focused entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --verbose',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            description: 'show status for all entities',
+        }),
+        json: Flags.boolean({
+            description: 'output as JSON',
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            description: 'show detailed status',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Status);
+        // Get entities to check
+        const entities = flags.all
+            ? this.entityService.getAllEntities()
+            : await this.focusService.getFocusedEntities();
+        if (entities.length === 0) {
+            if (flags.all) {
+                this.error('No entities configured');
+            }
+            else {
+                this.error('No entities focused. Use "gut focus <entity>" first.');
+            }
+        }
+        // Collect status for each entity
+        const statuses = [];
+        for (const entity of entities) {
+            const entityPath = this.entityService.resolveEntityPath(entity);
+            try {
+                // Check if it's a git repository
+                const isRepo = await this.gitService.isRepository(entityPath);
+                if (isRepo) {
+                    const status = await this.gitService.getStatus(entityPath);
+                    statuses.push({
+                        ...status,
+                        entity: entity.name,
+                        error: undefined,
+                        hasChanges: status.hasChanges,
+                        type: entity.type,
+                    });
+                }
+                else {
+                    statuses.push({
+                        ahead: 0,
+                        behind: 0,
+                        branch: '',
+                        changes: [],
+                        entity: entity.name,
+                        error: 'Not a git repository',
+                        hasChanges: false,
+                        path: entityPath,
+                        type: entity.type,
+                        untracked: [],
+                    });
+                }
+            }
+            catch (error) {
+                statuses.push({
+                    ahead: 0,
+                    behind: 0,
+                    branch: '',
+                    changes: [],
+                    entity: entity.name,
+                    error: error instanceof Error ? error.message : String(error),
+                    hasChanges: false,
+                    path: entityPath,
+                    type: entity.type,
+                    untracked: [],
+                });
+            }
+        }
+        // Output results
+        if (flags.json) {
+            this.log(JSON.stringify(statuses, null, 2));
+            return;
+        }
+        // Enhanced workspace-style display
+        await this.displayEnhancedStatus(statuses, flags.verbose);
+    }
+    async displayEnhancedStatus(statuses, verbose) {
+        const currentFocus = await this.focusService.getCurrentFocus();
+        // Header with workspace context
+        this.log(chalk.bold('\n=== DevSquad Workspace Status ==='));
+        if (currentFocus) {
+            const focusDescription = await this.focusService.getFocusDescription();
+            this.log(`📍 Current focus: ${chalk.cyan(focusDescription)}`);
+            if (currentFocus.mode) {
+                this.log(`🎯 Mode: ${chalk.yellow(currentFocus.mode)}`);
+            }
+        }
+        else {
+            this.log(`📍 Current focus: ${chalk.dim('none')}`);
+        }
+        // Last sync info (placeholder for now)
+        this.log(`🔄 Last sync: ${chalk.dim('just now')}`);
+        this.log('');
+        // Group statuses by entity type
+        const byType = {};
+        for (const status of statuses) {
+            if (!byType[status.type])
+                byType[status.type] = [];
+            byType[status.type].push(status);
+        }
+        // Display entities by type
+        const typeOrder = ['client', 'prospect', 'company', 'initiative', 'system', 'delivery', 'module', 'service', 'tool'];
+        for (const type of typeOrder) {
+            if (!byType[type] || byType[type].length === 0)
+                continue;
+            const entities = byType[type];
+            const dirtyCount = entities.filter((e) => e.hasChanges).length;
+            if (dirtyCount > 0) {
+                this.log(chalk.bold(`${type.toUpperCase()}:`));
+                for (const status of entities) {
+                    if (status.hasChanges) {
+                        this.displayEntityStatus(status, verbose);
+                    }
+                }
+                this.log('');
+            }
+        }
+        // Show clean entities if verbose
+        if (verbose) {
+            const cleanEntities = statuses.filter(s => !s.hasChanges && !s.error);
+            if (cleanEntities.length > 0) {
+                this.log(chalk.dim('CLEAN:'));
+                for (const status of cleanEntities) {
+                    this.log(`  ${this.getTypeEmoji(status.type)} ${status.entity}/ ${chalk.dim('(clean)')}`);
+                }
+                this.log('');
+            }
+        }
+        // Enhanced summary
+        const dirtyRepos = statuses.filter(s => s.hasChanges).length;
+        const totalRepos = statuses.filter(s => !s.error).length;
+        const readyToCommit = statuses.filter(s => s.hasChanges).map(s => s.entity);
+        this.log(chalk.bold('=== Summary ==='));
+        if (dirtyRepos === 0) {
+            this.log(`✨ All ${totalRepos} repositories are clean`);
+        }
+        else {
+            this.log(`✨ ${dirtyRepos} ${dirtyRepos === 1 ? 'repo' : 'repos'} with changes`);
+            if (readyToCommit.length > 0) {
+                this.log(`🚀 Ready to commit across: ${chalk.cyan(readyToCommit.join(', '))}`);
+            }
+        }
+        // Suggested actions
+        if (dirtyRepos > 0) {
+            this.log('');
+            this.log(chalk.dim('Suggested actions:'));
+            this.log(chalk.dim('• gut add .          # Stage all changes'));
+            this.log(chalk.dim('• gut commit -m "..."  # Commit across repos'));
+            this.log(chalk.dim('• gut push           # Push to remotes'));
+        }
+    }
+    displayEntityStatus(status, verbose) {
+        const changesText = status.changes.length > 0 ? `${status.changes.length} changes` : '';
+        const untrackedText = status.untracked.length > 0 ? `${status.untracked.length} untracked` : '';
+        const statusText = [changesText, untrackedText].filter(Boolean).join(', ');
+        this.log(`  ${status.entity}/  ${chalk.green('🟢')} ${statusText}`);
+        if (verbose) {
+            // Show specific files
+            if (status.changes.length > 0) {
+                for (const change of status.changes.slice(0, 3)) {
+                    this.log(`    M  ${change}`);
+                }
+                if (status.changes.length > 3) {
+                    this.log(`    ... and ${status.changes.length - 3} more`);
+                }
+            }
+            if (status.untracked.length > 0) {
+                for (const file of status.untracked.slice(0, 2)) {
+                    this.log(`    A  ${file}`);
+                }
+                if (status.untracked.length > 2) {
+                    this.log(`    ... and ${status.untracked.length - 2} more`);
+                }
+            }
+        }
+    }
+}

package/dist/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -0,0 +1,139 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class Sync extends BaseCommand {
+    static description = 'Synchronize repositories with remote (fetch, merge/rebase, push)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --rebase',
+        '<%= config.bin %> <%= command.id %> --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force push after sync',
+        }),
+        'no-push': Flags.boolean({
+            default: false,
+            description: 'Skip the push step',
+        }),
+        rebase: Flags.boolean({
+            char: 'r',
+            default: false,
+            description: 'Use rebase instead of merge',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Sync);
+        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🔄 Synchronizing repositories with remote\n'));
+        const results = {
+            failed: [],
+            partial: [],
+            success: [],
+        };
+        for (const entity of focusedEntities) {
+            const spinner = ora(`Syncing ${chalk.cyan(entity.name)}`).start();
+            let currentStep = 'fetch';
+            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, step: 'check' });
+                    continue;
+                }
+                // Step 1: Fetch
+                spinner.text = `${chalk.cyan(entity.name)}: Fetching from remote...`;
+                await this.gitService.fetch(entity.path);
+                // Step 2: Check status
+                currentStep = 'status';
+                const status = await this.gitService.getStatus(entity.path);
+                const hasUncommitted = status.changes.length > 0;
+                if (hasUncommitted) {
+                    spinner.warn(chalk.yellow(`${entity.name}: Has uncommitted changes (fetch completed)`));
+                    results.partial.push({ repo: entity.name, step: 'Fetched only - uncommitted changes present' });
+                    continue;
+                }
+                // Step 3: Pull (merge or rebase)
+                currentStep = 'pull';
+                spinner.text = `${chalk.cyan(entity.name)}: ${flags.rebase ? 'Rebasing' : 'Merging'}...`;
+                const pullOptions = {
+                    rebase: flags.rebase,
+                };
+                await this.gitService.pull(entity.path, pullOptions);
+                // Step 4: Push (if not skipped)
+                if (!flags['no-push']) {
+                    currentStep = 'push';
+                    spinner.text = `${chalk.cyan(entity.name)}: Pushing to remote...`;
+                    const pushOptions = {
+                        force: flags.force,
+                    };
+                    await this.gitService.push(entity.path, pushOptions);
+                }
+                spinner.succeed(chalk.green(`✓ ${entity.name}: Fully synchronized`));
+                results.success.push(entity.name);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('Already up to date') && currentStep === 'pull') {
+                    // Not an error, just nothing to pull
+                    if (flags['no-push']) {
+                        spinner.succeed(chalk.green(`✓ ${entity.name}: Up-to-date`));
+                        results.success.push(entity.name);
+                    }
+                    else {
+                        try {
+                            currentStep = 'push';
+                            spinner.text = `${chalk.cyan(entity.name)}: Pushing to remote...`;
+                            const pushOptions = { force: flags.force };
+                            await this.gitService.push(entity.path, pushOptions);
+                            spinner.succeed(chalk.green(`✓ ${entity.name}: Fully synchronized`));
+                            results.success.push(entity.name);
+                        }
+                        catch (pushError) {
+                            const pushErrorMessage = pushError instanceof Error ? pushError.message : String(pushError);
+                            spinner.warn(chalk.yellow(`${entity.name}: Up-to-date locally, push failed`));
+                            results.partial.push({ repo: entity.name, step: `Pull up-to-date, push failed: ${pushErrorMessage}` });
+                        }
+                    }
+                }
+                else {
+                    spinner.fail(chalk.red(`✗ ${entity.name}: Failed at ${currentStep}`));
+                    results.failed.push({ error: errorMessage, repo: entity.name, step: currentStep });
+                }
+            }
+        }
+        // Summary
+        this.log(chalk.bold('\n📊 Sync Summary'));
+        this.log(chalk.dim('─'.repeat(50)));
+        if (results.success.length > 0) {
+            this.log(chalk.green(`✓ Fully synced: ${results.success.length} entities`));
+            for (const repo of results.success) {
+                this.log(chalk.green(`  - ${repo}`));
+            }
+        }
+        if (results.partial.length > 0) {
+            this.log(chalk.yellow(`⚠ Partially synced: ${results.partial.length} entities`));
+            for (const partial of results.partial) {
+                this.log(chalk.yellow(`  - ${partial.repo}: ${partial.step}`));
+            }
+        }
+        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} (at ${failure.step})`));
+            }
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(chalk.dim('Sync performs: fetch → pull → push'));
+        if (results.partial.length > 0 || results.failed.length > 0) {
+            this.log(chalk.dim('Tip: Use "gut status" to check repository states'));
+        }
+    }
+}

package/dist/commands/ticket/focus.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../base-command.js';
+export default class TicketFocus extends BaseCommand {
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        checkout: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'manifest-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected get requiresInit(): boolean;
+    run(): Promise<void>;
+    private cloneEntities;
+    private runGutAdd;
+    private checkoutBranch;
+    private formatConfidence;
+}

package/dist/commands/ticket/focus.js

@@ -0,0 +1,217 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import ora from 'ora';
+import { BaseCommand } from '../../base-command.js';
+import { getStatusEmoji } from '../../models/ticket.model.js';
+import { TicketService } from '../../services/ticket.service.js';
+export default class TicketFocus extends BaseCommand {
+    static args = {
+        ticketId: Args.string({
+            description: 'ticket ID to focus on (e.g., PROJ-1234)',
+            name: 'ticketId',
+            required: true
+        })
+    };
+    static description = 'Focus on a ticket - downloads manifest and clones required entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> PROJ-1234',
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --checkout',
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --manifest-only',
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --output ./my-ticket'
+    ];
+    static flags = {
+        checkout: Flags.boolean({
+            char: 'c',
+            default: true,
+            description: 'checkout the ticket branch after cloning'
+        }),
+        json: Flags.boolean({
+            char: 'j',
+            description: 'output as JSON'
+        }),
+        'manifest-only': Flags.boolean({
+            char: 'm',
+            description: 'only download manifest, do not clone entities'
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'output directory for manifest (default: focus/)'
+        })
+    };
+    get requiresInit() {
+        return true; // Focus requires gut workspace to be initialized
+    }
+    async run() {
+        const { args, flags } = await this.parse(TicketFocus);
+        const ticketService = new TicketService(this.configService);
+        if (!ticketService.isConfigured()) {
+            this.error('API not configured. Set GUT_API_ENDPOINT and GUT_TENANT_ID environment variables.');
+        }
+        const spinner = ora('Getting ticket focus context...').start();
+        try {
+            // Get focus context from API
+            const focusResponse = await ticketService.focusTicket(args.ticketId);
+            spinner.succeed('Got focus context');
+            if (flags.json) {
+                this.log(JSON.stringify(focusResponse, null, 2));
+                return;
+            }
+            // Print ticket summary
+            this.log('');
+            this.log(chalk.bold(`🎯 Focusing on: ${focusResponse.ticketId}`));
+            this.log(`   ${getStatusEmoji(focusResponse.status)} Status: ${focusResponse.status}`);
+            this.log(`   📍 Phase: ${focusResponse.phase}`);
+            this.log(`   📊 Confidence: ${this.formatConfidence(focusResponse.confidence)}`);
+            this.log(`   🌿 Branch: ${focusResponse.branch}`);
+            this.log('');
+            // Determine output directory
+            const outputDir = flags.output || this.configService.getFocusDir();
+            // Download manifest
+            const manifestPath = path.join(outputDir, `${args.ticketId}.yaml`);
+            spinner.start('Downloading manifest...');
+            await ticketService.downloadManifest(focusResponse.manifestUrl, manifestPath);
+            spinner.succeed(`Manifest saved to ${manifestPath}`);
+            // Print entities
+            if (focusResponse.entities.length > 0) {
+                this.log('');
+                this.log(chalk.bold('📦 Required Entities:'));
+                for (const entity of focusResponse.entities) {
+                    this.log(`   • ${entity}`);
+                }
+            }
+            // Print acceptance criteria
+            if (focusResponse.acceptanceCriteria && focusResponse.acceptanceCriteria.length > 0) {
+                this.log('');
+                this.log(chalk.bold('✅ Acceptance Criteria:'));
+                for (const criterion of focusResponse.acceptanceCriteria) {
+                    this.log(`   ☐ ${criterion}`);
+                }
+            }
+            // Clone entities unless manifest-only
+            if (!flags['manifest-only'] && focusResponse.entities.length > 0) {
+                this.log('');
+                await this.cloneEntities(focusResponse.entities, spinner);
+                // Checkout branch
+                if (flags.checkout && focusResponse.branch) {
+                    this.log('');
+                    await this.checkoutBranch(focusResponse.entities, focusResponse.branch, spinner);
+                }
+            }
+            // Update gut focus to the entities
+            if (focusResponse.entities.length > 0) {
+                const entityNames = focusResponse.entities.map(e => {
+                    // Extract entity name from @type/name format
+                    const match = e.match(/@[^/]+\/(.+)/);
+                    return match ? match[1] : e;
+                });
+                await this.focusService.setFocus(entityNames, {
+                    mode: 'delivery'
+                });
+                this.log('');
+                this.log(chalk.green(`✓ Focus set to ${entityNames.length} entities`));
+            }
+            // Final summary
+            this.log('');
+            this.log(chalk.dim('─'.repeat(50)));
+            this.log(chalk.bold('Next steps:'));
+            this.log(`  1. Review the manifest: ${chalk.cyan(`cat ${manifestPath}`)}`);
+            this.log(`  2. Check focused entities: ${chalk.cyan('gut status')}`);
+            this.log(`  3. Start working on the ticket`);
+            if (focusResponse.status === 'blocked' || focusResponse.status === 'needs_clarity') {
+                this.log(`  4. Add hints if needed: ${chalk.cyan(`gut ticket hint ${args.ticketId} "your hint"`)}`);
+            }
+            this.log('');
+        }
+        catch (error) {
+            spinner.fail('Failed');
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(`Failed to focus on ticket: ${message}`);
+        }
+    }
+    async cloneEntities(entities, spinner) {
+        spinner.start(`Cloning ${entities.length} entities...`);
+        for (const entity of entities) {
+            // Extract entity name for gut add
+            const match = entity.match(/@([^/]+)\/(.+)/);
+            if (!match) {
+                this.log(chalk.yellow(`   ⚠️  Could not parse entity: ${entity}`));
+                continue;
+            }
+            const [, entityType, entityName] = match;
+            // Check if entity already exists in config
+            const config = this.configService.getConfig();
+            const existingEntity = config.entities.find(e => e.name === entityName || e.name === entity);
+            if (existingEntity) {
+                spinner.info(`   ${entity} already configured`);
+                continue;
+            }
+            // Use gut add to clone the entity
+            try {
+                await this.runGutAdd(entityType, entityName);
+                spinner.succeed(`   ${entity} cloned`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.log(chalk.yellow(`   ⚠️  Could not clone ${entity}: ${msg}`));
+            }
+        }
+        spinner.succeed('Entities ready');
+    }
+    async runGutAdd(entityType, entityName) {
+        return new Promise((resolve, reject) => {
+            const child = spawn('gut', ['add', entityType, entityName], {
+                stdio: 'pipe'
+            });
+            let stderr = '';
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(stderr || `Exit code ${code}`));
+                }
+            });
+            child.on('error', reject);
+        });
+    }
+    async checkoutBranch(entities, branch, spinner) {
+        spinner.start(`Checking out branch: ${branch}`);
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        for (const entity of focusedEntities) {
+            try {
+                // Check if branch exists, create if not
+                await this.gitService.checkout(entity.path, branch);
+                spinner.succeed(`   ${entity.name}: checked out ${branch}`);
+            }
+            catch (error) {
+                // Branch might not exist yet - create it
+                try {
+                    await this.gitService.createBranch(entity.path, branch);
+                    spinner.succeed(`   ${entity.name}: created and checked out ${branch}`);
+                }
+                catch (createError) {
+                    const msg = createError instanceof Error ? createError.message : String(createError);
+                    this.log(chalk.yellow(`   ⚠️  ${entity.name}: ${msg}`));
+                }
+            }
+        }
+        spinner.succeed(`Branch ${branch} ready`);
+    }
+    formatConfidence(confidence) {
+        if (confidence >= 90) {
+            return chalk.green(`${confidence}%`);
+        }
+        if (confidence >= 70) {
+            return chalk.yellow(`${confidence}%`);
+        }
+        if (confidence >= 50) {
+            return chalk.hex('#FFA500')(`${confidence}%`);
+        }
+        return chalk.red(`${confidence}%`);
+    }
+}

package/dist/commands/ticket/get.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command.js';
+export default class TicketGet extends BaseCommand {
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected get requiresInit(): boolean;
+    run(): Promise<void>;
+    private printTicketDetails;
+    private formatConfidence;
+}