@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/commands/entity/clone-all.js

@@ -0,0 +1,127 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+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 CloneAll extends BaseCommand {
+    static description = 'Clone all configured entities from their repositories';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --parallel',
+        '<%= config.bin %> <%= command.id %> --branch develop',
+        '<%= config.bin %> <%= command.id %> --skip-existing',
+    ];
+    static flags = {
+        branch: Flags.string({
+            char: 'b',
+            default: 'main',
+            description: 'Branch to clone for all entities',
+        }),
+        depth: Flags.integer({
+            char: 'd',
+            description: 'Create shallow clones with specified depth',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force clone even if directories exist',
+        }),
+        parallel: Flags.boolean({
+            char: 'p',
+            default: false,
+            description: 'Clone entities in parallel',
+        }),
+        'skip-existing': Flags.boolean({
+            default: false,
+            description: 'Skip entities that already exist',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CloneAll);
+        const { branch, depth, force, parallel, 'skip-existing': skipExisting } = flags;
+        const entities = await this.entityService.listEntities();
+        const entitiesToClone = entities.filter(e => e.repository);
+        if (entitiesToClone.length === 0) {
+            this.log(chalk.yellow('No entities with repositories configured'));
+            return;
+        }
+        this.log(chalk.blue(`Found ${entitiesToClone.length} entities to clone`));
+        const results = [];
+        await (parallel ? this.cloneInParallel(entitiesToClone, branch, depth, skipExisting, force, results) : this.cloneSequentially(entitiesToClone, branch, depth, skipExisting, force, results));
+        this.printSummary(results);
+    }
+    async cloneEntity(entity, branch, depth, skipExisting, force) {
+        const spinner = ora(`Cloning ${entity.name}`).start();
+        try {
+            const workspaceRoot = this.configService.getWorkspaceRoot();
+            const clonePath = path.resolve(workspaceRoot, entity.path);
+            if (fs.existsSync(clonePath)) {
+                if (skipExisting) {
+                    spinner.info(`Skipped ${entity.name} (already exists)`);
+                    return { entity, message: 'Skipped (exists)', success: true };
+                }
+                if (!force) {
+                    spinner.fail(`${entity.name} already exists (use --force to overwrite)`);
+                    return { entity, message: 'Already exists', success: false };
+                }
+                fs.rmSync(clonePath, { force: true, recursive: true });
+            }
+            const parentDir = path.dirname(clonePath);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            let cloneCommand = 'git clone';
+            if (branch && branch !== 'main') {
+                cloneCommand += ` -b ${branch}`;
+            }
+            if (depth) {
+                cloneCommand += ` --depth ${depth}`;
+            }
+            cloneCommand += ` ${entity.repository || entity.repo} ${clonePath}`;
+            execSync(cloneCommand, { stdio: 'pipe' });
+            const gitBranch = execSync('git branch --show-current', {
+                cwd: clonePath,
+                encoding: 'utf8',
+            }).trim();
+            spinner.succeed(`Cloned ${entity.name} (${gitBranch})`);
+            return { entity, message: `Cloned (${gitBranch})`, success: true };
+        }
+        catch (error) {
+            spinner.fail(`Failed to clone ${entity.name}`);
+            return { entity, message: error instanceof Error ? error.message : String(error), success: false };
+        }
+    }
+    async cloneInParallel(entities, branch, depth, skipExisting, force, results) {
+        const promises = entities.map(entity => this.cloneEntity(entity, branch, depth, skipExisting, force));
+        const parallelResults = await Promise.all(promises);
+        results.push(...parallelResults);
+    }
+    async cloneSequentially(entities, branch, depth, skipExisting, force, results) {
+        for (const entity of entities) {
+            const result = await this.cloneEntity(entity, branch, depth, skipExisting, force);
+            results.push(result);
+        }
+    }
+    printSummary(results) {
+        const successful = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+        this.log('');
+        this.log(chalk.bold('Clone Summary:'));
+        this.log(chalk.green(`  ✓ Successful: ${successful.length}`));
+        if (failed.length > 0) {
+            this.log(chalk.red(`  ✗ Failed: ${failed.length}`));
+            this.log('');
+            this.log(chalk.red('Failed entities:'));
+            for (const r of failed) {
+                this.log(chalk.red(`  - ${r.entity.name}: ${r.message}`));
+            }
+        }
+        this.log('');
+        this.log(chalk.dim('Entity locations:'));
+        for (const r of successful) {
+            this.log(chalk.dim(`  ${r.entity.name}: ${r.entity.path}`));
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Clone extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        depth: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/entity/clone.js

@@ -0,0 +1,106 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+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 Clone extends BaseCommand {
+    static args = {
+        name: Args.string({
+            description: 'Name of the entity to clone',
+            name: 'name',
+            required: true,
+        }),
+    };
+    static description = 'Clone a specific entity from its repository';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-app',
+        '<%= config.bin %> <%= command.id %> my-app --branch develop',
+        '<%= config.bin %> <%= command.id %> my-app --depth 1',
+    ];
+    static flags = {
+        branch: Flags.string({
+            char: 'b',
+            default: 'main',
+            description: 'Branch to clone',
+        }),
+        depth: Flags.integer({
+            char: 'd',
+            description: 'Create a shallow clone with specified depth',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force clone even if directory exists',
+        }),
+        path: Flags.string({
+            char: 'p',
+            description: 'Custom path to clone to (relative to workspace)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Clone);
+        const { name } = args;
+        const { branch, depth, force, path: customPath } = flags;
+        const spinner = ora();
+        try {
+            const entity = await this.entityService.getEntity(name);
+            if (!entity) {
+                this.error(`Entity '${name}' not found`);
+            }
+            if (!entity.repository) {
+                this.error(`Entity '${name}' has no repository configured`);
+            }
+            const workspaceRoot = this.configService.getWorkspaceRoot();
+            const clonePath = customPath
+                ? path.resolve(workspaceRoot, customPath)
+                : path.resolve(workspaceRoot, entity.path);
+            if (fs.existsSync(clonePath)) {
+                if (!force) {
+                    this.error(`Directory already exists: ${clonePath}. Use --force to overwrite`);
+                }
+                spinner.start(`Removing existing directory: ${clonePath}`);
+                execSync(`rm -rf ${clonePath}`, { stdio: 'pipe' });
+                spinner.succeed('Removed existing directory');
+            }
+            const parentDir = path.dirname(clonePath);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            let cloneCommand = 'git clone';
+            if (branch && branch !== 'main') {
+                cloneCommand += ` -b ${branch}`;
+            }
+            if (depth) {
+                cloneCommand += ` --depth ${depth}`;
+            }
+            cloneCommand += ` ${entity.repository} ${clonePath}`;
+            spinner.start(`Cloning ${name} from ${entity.repository}`);
+            try {
+                execSync(cloneCommand, { stdio: 'pipe' });
+                spinner.succeed(`Successfully cloned ${name}`);
+            }
+            catch (error) {
+                spinner.fail(`Failed to clone ${name}`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            if (customPath && customPath !== entity.path) {
+                entity.path = customPath;
+                await this.entityService.updateEntity(name, entity);
+                this.log(chalk.yellow(`Updated entity path to: ${customPath}`));
+            }
+            this.log(chalk.green(`✓ Entity '${name}' cloned to ${clonePath}`));
+            const gitBranch = execSync('git branch --show-current', {
+                cwd: clonePath,
+                encoding: 'utf8',
+            }).trim();
+            this.log(chalk.dim(`  Branch: ${gitBranch}`));
+            this.log(chalk.dim(`  Repository: ${entity.repository}`));
+        }
+        catch (error) {
+            spinner.fail();
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

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

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

package/dist/commands/entity/list.js

@@ -0,0 +1,80 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { ENTITY_TYPES } from '../../models/entity.model.js';
+export default class ListEntities extends BaseCommand {
+    static description = 'List all configured entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --type delivery',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'output as JSON',
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'filter by entity type',
+            options: [...ENTITY_TYPES],
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            description: 'show detailed information',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ListEntities);
+        let entities = this.entityService.getAllEntities();
+        // Filter by type if specified
+        if (flags.type) {
+            entities = entities.filter(e => e.type === flags.type);
+        }
+        // JSON output
+        if (flags.json) {
+            this.log(JSON.stringify(entities, null, 2));
+            return;
+        }
+        // Regular output
+        if (entities.length === 0) {
+            if (flags.type) {
+                this.log(`No ${flags.type} entities configured`);
+            }
+            else {
+                this.log('No entities configured');
+                this.log('\nAdd entities with: gut entity add <type> <name> --path <path>');
+            }
+            return;
+        }
+        this.log(`\n${entities.length} entities configured:`);
+        if (flags.verbose) {
+            // Detailed view
+            for (const entity of entities) {
+                this.log(`\n${this.getTypeEmoji(entity.type)} ${entity.name}`);
+                this.log(`   Type: ${entity.type}`);
+                this.log(`   Path: ${entity.path}`);
+                if (entity.remote) {
+                    this.log(`   Remote: ${entity.remote}`);
+                }
+                if (entity.repo) {
+                    this.log(`   Repo: ${entity.repo}`);
+                }
+                if (entity.description) {
+                    this.log(`   Description: ${entity.description}`);
+                }
+                // Check if focused
+                if (await this.focusService.isFocused(entity.name)) {
+                    this.log('   Status: 🎯 FOCUSED');
+                }
+            }
+        }
+        else {
+            // Simple view
+            this.printEntityList(entities);
+            // Show focused entities
+            const focusedEntities = await this.focusService.getFocusedEntities();
+            if (focusedEntities.length > 0) {
+                this.log(`\n🎯 Current focus: ${focusedEntities.map(e => e.name).join(', ')}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command.js';
+export default class RemoveEntity extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/entity/remove.js

@@ -0,0 +1,54 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+export default class RemoveEntity extends BaseCommand {
+    static args = {
+        name: Args.string({
+            description: 'Entity name to remove',
+            name: 'name',
+            required: true,
+        }),
+    };
+    static description = 'Remove an entity from the workspace configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-app',
+        '<%= config.bin %> <%= command.id %> my-app --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            description: 'skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RemoveEntity);
+        const { name } = args;
+        // Check if entity exists
+        const entity = this.entityService.findEntity(name);
+        if (!entity) {
+            this.error(`Entity '${name}' not found`);
+        }
+        // Check if entity is currently focused
+        if (await this.focusService.isFocused(name)) {
+            this.warn(`Entity '${name}' is currently focused`);
+            if (!flags.force) {
+                this.error('Cannot remove focused entity. Unfocus first with "gut unfocus" or use --force');
+            }
+            // Clear focus if forcing
+            await this.focusService.clearFocus();
+            this.log('Cleared focus');
+        }
+        // Confirmation prompt if not forcing
+        if (!flags.force) {
+            this.log('\nAbout to remove entity:');
+            this.log(`  Name: ${entity.name}`);
+            this.log(`  Type: ${entity.type}`);
+            this.log(`  Path: ${entity.path}`);
+            this.warn('\nThis will only remove the entity from gut configuration.');
+            this.warn('The actual files/directory will NOT be deleted.');
+        }
+        // Remove entity
+        this.entityService.removeEntity(name);
+        this.log(`\n✅ Removed entity '${name}' from configuration`);
+        this.log('Note: The actual files/directory were not deleted');
+    }
+}

package/dist/commands/extract.d.ts

@@ -0,0 +1,35 @@
+import { BaseCommand } from '../base-command.js';
+export default class Extract extends BaseCommand {
+    static args: {
+        folderPath: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'gitlab-token': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'gitlab-url': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'keep-temp': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'project-path': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'target-path': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'temp-dir': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected get requiresInit(): boolean;
+    catch(error: Error & {
+        args?: Array<{
+            name: string;
+        }>;
+        code?: string;
+    }): Promise<void>;
+    run(): Promise<void>;
+    private checkExistingProject;
+    private cloneNewRepository;
+    private cloneToTemp;
+    private collectConfiguration;
+    private createGitLabProject;
+    private ensureGroupPath;
+    private filterAllBranches;
+    private getAllBranches;
+    private pushToNewRepository;
+}