@hyperdrive.bot/gut 0.1.8 → 0.1.10

package/dist/commands/quick-setup.js

@@ -0,0 +1,417 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import path from 'node:path';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class QuickSetup extends BaseCommand {
+    static description = 'Automated workspace setup based on common patterns';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --auto',
+        '<%= config.bin %> <%= command.id %> --profile monorepo',
+        '<%= config.bin %> <%= command.id %> --scan-depth 3',
+    ];
+    static flags = {
+        auto: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Auto-detect and configure without prompts',
+        }),
+        'clone-missing': Flags.boolean({
+            default: false,
+            description: 'Clone missing repositories if found',
+        }),
+        profile: Flags.string({
+            char: 'p',
+            description: 'Use specific setup profile',
+            options: ['monorepo', 'microservices', 'fullstack', 'library'],
+        }),
+        'scan-depth': Flags.integer({
+            default: 2,
+            description: 'Directory depth to scan for entities',
+        }),
+    };
+    profiles = [
+        {
+            description: 'Monorepo with packages or apps',
+            name: 'monorepo',
+            patterns: {
+                client: ['clients/*/package.json', 'entities/clients/*/package.json'],
+                company: ['companies/*/package.json', 'entities/companies/*/package.json'],
+                delivery: ['packages/*/package.json', 'apps/*/package.json'],
+                initiative: ['initiatives/*/package.json', 'entities/initiatives/*/package.json'],
+                module: ['packages/*/package.json', 'libs/*/package.json'],
+                prospect: ['prospects/*/package.json', 'entities/prospects/*/package.json'],
+                service: ['services/*/package.json', 'apis/*/package.json'],
+                system: ['systems/*/package.json', 'shared/*/package.json'],
+                tool: ['tools/*/package.json', 'scripts/*/package.json'],
+            },
+            repositories: {
+                pattern: /package\.json/,
+                transform(match) {
+                    const pkg = JSON.parse(fs.readFileSync(match, 'utf8'));
+                    return pkg.repository?.url || pkg.repository || '';
+                },
+            },
+        },
+        {
+            description: 'Microservices architecture',
+            name: 'microservices',
+            patterns: {
+                client: ['clients/*/package.json'],
+                company: ['companies/*/package.json'],
+                delivery: ['frontend/package.json', 'web/package.json', 'mobile/package.json'],
+                initiative: ['initiatives/*/package.json'],
+                module: ['shared/*/package.json', 'common/*/package.json'],
+                prospect: ['prospects/*/package.json'],
+                service: ['services/*/package.json', 'services/*/pom.xml', 'services/*/go.mod'],
+                system: ['shared/*/package.json', 'common/*/package.json'],
+                tool: ['infrastructure/*/package.json', 'deployment/*/'],
+            },
+        },
+        {
+            description: 'Full-stack application',
+            name: 'fullstack',
+            patterns: {
+                client: ['clients/*/package.json'],
+                company: ['companies/*/package.json'],
+                delivery: ['frontend/package.json', 'client/package.json', 'web/package.json'],
+                initiative: ['initiatives/*/package.json'],
+                module: ['shared/package.json', 'common/package.json'],
+                prospect: ['prospects/*/package.json'],
+                service: ['backend/package.json', 'server/package.json', 'api/package.json'],
+                system: ['shared/package.json', 'common/package.json'],
+                tool: ['scripts/package.json', 'tools/package.json'],
+            },
+        },
+        {
+            description: 'Library or package development',
+            name: 'library',
+            patterns: {
+                client: [],
+                company: [],
+                delivery: ['examples/*/package.json', 'demo/*/package.json'],
+                initiative: [],
+                module: ['src/package.json', 'lib/package.json', 'package.json'],
+                prospect: [],
+                service: [],
+                system: ['package.json'],
+                tool: ['scripts/package.json', 'tools/package.json'],
+            },
+        },
+    ];
+    async run() {
+        const { flags } = await this.parse(QuickSetup);
+        const { auto, 'clone-missing': cloneMissing, profile, 'scan-depth': scanDepth } = flags;
+        const spinner = ora();
+        try {
+            // Check if workspace is already initialized
+            const config = await this.configService.loadConfig();
+            if (config.entities && Object.keys(config.entities).length > 0) {
+                const { proceed } = await inquirer.prompt([{
+                        default: false,
+                        message: 'Workspace already has entities configured. Continue setup?',
+                        name: 'proceed',
+                        type: 'confirm',
+                    }]);
+                if (!proceed) {
+                    this.log(chalk.yellow('Setup cancelled'));
+                    return;
+                }
+            }
+            spinner.start('Scanning workspace structure');
+            // Detect workspace structure
+            const detectedEntities = await this.scanWorkspace(scanDepth);
+            spinner.succeed(`Found ${detectedEntities.length} potential entities`);
+            // Select or detect profile
+            let selectedProfile;
+            if (profile) {
+                selectedProfile = this.profiles.find(p => p.name === profile);
+                if (!selectedProfile) {
+                    this.error(`Profile '${profile}' not found`);
+                }
+            }
+            else if (auto) {
+                selectedProfile = this.detectProfile(detectedEntities);
+                this.log(chalk.blue(`Auto-detected profile: ${selectedProfile.name}`));
+            }
+            else {
+                const { selectedProfileName } = await inquirer.prompt([{
+                        choices: this.profiles.map(p => ({
+                            name: `${p.name} - ${p.description}`,
+                            value: p.name,
+                        })),
+                        message: 'Select workspace profile:',
+                        name: 'selectedProfileName',
+                        type: 'list',
+                    }]);
+                selectedProfile = this.profiles.find(p => p.name === selectedProfileName);
+            }
+            // Categorize entities
+            const categorizedEntities = this.categorizeEntities(detectedEntities, selectedProfile);
+            // Show and confirm entities
+            if (!auto) {
+                this.printDetectedEntities(categorizedEntities);
+                const { confirmSetup } = await inquirer.prompt([{
+                        default: true,
+                        message: 'Proceed with this configuration?',
+                        name: 'confirmSetup',
+                        type: 'confirm',
+                    }]);
+                if (!confirmSetup) {
+                    this.log(chalk.yellow('Setup cancelled'));
+                    return;
+                }
+            }
+            // Initialize workspace if needed
+            if (!config.workspace) {
+                spinner.start('Initializing workspace');
+                await this.configService.initWorkspace(process.cwd());
+                spinner.succeed('Workspace initialized');
+            }
+            // Add entities
+            spinner.start('Adding entities to configuration');
+            let addedCount = 0;
+            let skippedCount = 0;
+            for (const [type, entities] of Object.entries(categorizedEntities)) {
+                for (const entity of entities) {
+                    if (!entity.name || !entity.path) {
+                        continue;
+                    }
+                    const existing = await this.entityService.getEntity(entity.name);
+                    if (existing) {
+                        skippedCount++;
+                        continue;
+                    }
+                    await this.entityService.addEntity(entity.name, type, entity.path, entity.repository);
+                    addedCount++;
+                }
+            }
+            spinner.succeed(`Added ${addedCount} entities (${skippedCount} skipped)`);
+            // Clone missing repositories if requested
+            if (cloneMissing) {
+                const missingEntities = await this.findMissingEntities();
+                if (missingEntities.length > 0) {
+                    spinner.start(`Cloning ${missingEntities.length} missing repositories`);
+                    for (const entity of missingEntities) {
+                        if (entity.repository) {
+                            try {
+                                execSync(`git clone ${entity.repository} ${entity.path}`, {
+                                    stdio: 'pipe',
+                                });
+                            }
+                            catch {
+                                // Continue on error
+                            }
+                        }
+                    }
+                    spinner.succeed('Cloning complete');
+                }
+            }
+            // Set initial focus
+            if (addedCount > 0) {
+                const allEntities = await this.entityService.listEntities();
+                const mainEntity = allEntities.find(e => e.name.includes('main') || e.name.includes('core') || e.name.includes('app')) || allEntities[0];
+                if (mainEntity) {
+                    await this.focusService.setFocus([mainEntity.name]);
+                    this.log(chalk.green(`✓ Initial focus set to: ${mainEntity.name}`));
+                }
+            }
+            // Print summary
+            this.printSetupSummary(addedCount, skippedCount);
+            // Show next steps
+            this.printNextSteps();
+        }
+        catch (error) {
+            spinner.fail();
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    categorizeEntities(entities, profile) {
+        const categorized = {
+            client: [],
+            company: [],
+            delivery: [],
+            initiative: [],
+            module: [],
+            prospect: [],
+            service: [],
+            system: [],
+            tool: [],
+        };
+        for (const entity of entities) {
+            let matched = false;
+            // Try to match against profile patterns
+            for (const [type, patterns] of Object.entries(profile.patterns)) {
+                for (const pattern of patterns) {
+                    const glob = pattern.replaceAll('*', '[^/]+');
+                    const regex = new RegExp(`^${glob}$`);
+                    if (regex.test(entity.path + '/package.json')) {
+                        categorized[type].push(entity);
+                        matched = true;
+                        break;
+                    }
+                }
+                if (matched)
+                    break;
+            }
+            // If no match, categorize based on path/name
+            if (!matched) {
+                const pathLower = (entity.path || '').toLowerCase();
+                if (pathLower.includes('frontend') || pathLower.includes('client')
+                    || pathLower.includes('web') || pathLower.includes('app')) {
+                    categorized.delivery.push(entity);
+                }
+                else if (pathLower.includes('service') || pathLower.includes('api')
+                    || pathLower.includes('backend') || pathLower.includes('server')) {
+                    categorized.service.push(entity);
+                }
+                else if (pathLower.includes('lib') || pathLower.includes('shared')
+                    || pathLower.includes('common') || pathLower.includes('core')) {
+                    categorized.module.push(entity);
+                }
+                else if (pathLower.includes('tool') || pathLower.includes('script')
+                    || pathLower.includes('util') || pathLower.includes('infra')) {
+                    categorized.tool.push(entity);
+                }
+                else {
+                    // Default to module
+                    categorized.module.push(entity);
+                }
+            }
+        }
+        return categorized;
+    }
+    detectProfile(entities) {
+        const pathPatterns = entities.map(e => e.path || '');
+        // Check for monorepo patterns
+        const hasPackages = pathPatterns.some(p => p.startsWith('packages/'));
+        const hasApps = pathPatterns.some(p => p.startsWith('apps/'));
+        if (hasPackages || hasApps) {
+            return this.profiles[0]; // monorepo
+        }
+        // Check for microservices patterns
+        const hasServices = pathPatterns.some(p => p.startsWith('services/'));
+        if (hasServices) {
+            return this.profiles[1]; // microservices
+        }
+        // Check for fullstack patterns
+        const hasFrontend = pathPatterns.some(p => p.includes('frontend') || p.includes('client') || p.includes('web'));
+        const hasBackend = pathPatterns.some(p => p.includes('backend') || p.includes('server') || p.includes('api'));
+        if (hasFrontend && hasBackend) {
+            return this.profiles[2]; // fullstack
+        }
+        // Default to library
+        return this.profiles[3];
+    }
+    async findMissingEntities() {
+        const entities = await this.entityService.listEntities();
+        return entities.filter(e => !fs.existsSync(e.path));
+    }
+    printDetectedEntities(categorized) {
+        this.log('');
+        this.log(chalk.bold('Detected Entities:'));
+        this.log('');
+        for (const [type, entities] of Object.entries(categorized)) {
+            if (entities.length === 0)
+                continue;
+            this.log(chalk.cyan(`  ${type}:`));
+            for (const e of entities) {
+                const repo = e.repository ? chalk.dim(` (${e.repository})`) : '';
+                this.log(`    - ${e.name} ${chalk.dim(`[${e.path}]`)}${repo}`);
+            }
+        }
+    }
+    printNextSteps() {
+        this.log('');
+        this.log(chalk.bold('Next Steps:'));
+        this.log('');
+        this.log('  1. List all entities:');
+        this.log(chalk.dim('     gut entity list'));
+        this.log('');
+        this.log('  2. Set focus on specific entities:');
+        this.log(chalk.dim('     gut focus [entity-name]'));
+        this.log('');
+        this.log('  3. Check status across focused entities:');
+        this.log(chalk.dim('     gut status'));
+        this.log('');
+        this.log('  4. View workspace insights:');
+        this.log(chalk.dim('     gut insights'));
+        this.log('');
+        this.log('  5. Clone missing repositories:');
+        this.log(chalk.dim('     gut entity clone-all'));
+    }
+    printSetupSummary(added, skipped) {
+        this.log('');
+        this.log(chalk.bold.green('✓ Setup Complete!'));
+        this.log('');
+        this.log(chalk.dim('Summary:'));
+        this.log(`  • Entities added: ${added}`);
+        this.log(`  • Entities skipped: ${skipped}`);
+        this.log(`  • Total entities: ${added + skipped}`);
+    }
+    async scanWorkspace(maxDepth) {
+        const entities = [];
+        const seen = new Set();
+        const scan = (dir, depth) => {
+            if (depth > maxDepth)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const { name } = entry;
+                    if (name.startsWith('.') || name === 'node_modules' || name === 'dist' || name === 'build') {
+                        continue;
+                    }
+                    const fullPath = path.join(dir, name);
+                    const relativePath = path.relative(process.cwd(), fullPath);
+                    // Check for entity indicators
+                    const indicators = [
+                        'package.json',
+                        'pom.xml',
+                        'go.mod',
+                        'Cargo.toml',
+                        'requirements.txt',
+                        'Gemfile',
+                        'build.gradle',
+                    ];
+                    const hasIndicator = indicators.some(ind => fs.existsSync(path.join(fullPath, ind)));
+                    if (hasIndicator && !seen.has(relativePath)) {
+                        seen.add(relativePath);
+                        // Try to determine name and repository
+                        let entityName = name;
+                        let repository;
+                        const pkgPath = path.join(fullPath, 'package.json');
+                        if (fs.existsSync(pkgPath)) {
+                            try {
+                                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                                entityName = pkg.name || name;
+                                repository = pkg.repository?.url || pkg.repository;
+                            }
+                            catch {
+                                // Use directory name
+                            }
+                        }
+                        entities.push({
+                            name: entityName,
+                            path: relativePath,
+                            repository,
+                        });
+                    }
+                    // Recurse
+                    scan(fullPath, depth + 1);
+                }
+            }
+            catch {
+                // Ignore permission errors
+            }
+        };
+        scan(process.cwd(), 0);
+        return entities;
+    }
+}

package/dist/commands/recent.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../base-command.js';
+export default class Recent extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/recent.js

@@ -0,0 +1,51 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Recent extends BaseCommand {
+    static description = 'Show recent focus history';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --limit 10',
+    ];
+    static flags = {
+        limit: Flags.integer({
+            char: 'l',
+            default: 5,
+            description: 'Number of recent items to show',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Recent);
+        const { configService } = this;
+        const history = configService.getHistory();
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        const currentFocusNames = focusedEntities.map(e => e.name);
+        if (history.length === 0) {
+            this.log(chalk.yellow('No focus history available'));
+            return;
+        }
+        this.log(chalk.bold('\n📜 Recent Focus History'));
+        this.log(chalk.dim('─'.repeat(50)));
+        const limit = Math.min(flags.limit, history.length);
+        for (let i = 0; i < limit; i++) {
+            const entry = history[i];
+            const isCurrent = i === 0
+                && currentFocusNames.length === entry.entities.length
+                && currentFocusNames.every(e => entry.entities.includes(e));
+            const marker = isCurrent ? chalk.green('▸') : chalk.dim('•');
+            const label = isCurrent ? chalk.green(' (current)') : '';
+            const timestamp = new Date(entry.timestamp).toLocaleString();
+            this.log(`\n${marker} ${chalk.bold(entry.entities.join(', '))}${label}`);
+            this.log(`  ${chalk.dim('Time:')} ${timestamp}`);
+            if (i === 0 && isCurrent) {
+                this.log(`  ${chalk.dim('Status:')} ${chalk.green('Active')}`);
+            }
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(`${chalk.dim('Total history entries:')} ${history.length}`);
+        if (history.length > limit) {
+            this.log(chalk.dim(`Showing ${limit} of ${history.length} entries`));
+        }
+        this.log(chalk.dim('\nTip: Use "gut back" to switch to previous focus'));
+    }
+}

package/dist/commands/related.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../base-command.js';
+export default class Related extends BaseCommand {
+    static args: {
+        entity: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        detailed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        threshold: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private analyzeRelation;
+    private calculateScore;
+    private extractDependencies;
+    private findDependencyRelations;
+    private findGitReferences;
+    private findSharedFiles;
+    private getFileList;
+    private isSimilarFile;
+    private printRelations;
+}