@hyperdrive.bot/gut 0.1.3

package/dist/commands/entity/clone.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = tslib_1.__importDefault(require("../../base-command"));
+const path = tslib_1.__importStar(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+const child_process_1 = require("child_process");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+class Clone extends base_command_1.default {
+    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: core_1.Flags.string({
+            char: 'b',
+            description: 'Branch to clone',
+            default: 'main',
+        }),
+        depth: core_1.Flags.integer({
+            char: 'd',
+            description: 'Create a shallow clone with specified depth',
+        }),
+        path: core_1.Flags.string({
+            char: 'p',
+            description: 'Custom path to clone to (relative to workspace)',
+        }),
+        force: core_1.Flags.boolean({
+            char: 'f',
+            description: 'Force clone even if directory exists',
+            default: false,
+        }),
+    };
+    static args = {
+        name: core_1.Args.string({
+            name: 'name',
+            required: true,
+            description: 'Name of the entity to clone',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Clone);
+        const { name } = args;
+        const { branch, depth, path: customPath, force } = flags;
+        const spinner = (0, ora_1.default)();
+        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 clonePath = customPath
+                ? path.resolve(this.config.root, customPath)
+                : path.resolve(this.config.root, entity.path);
+            if (fs.existsSync(clonePath)) {
+                if (!force) {
+                    this.error(`Directory already exists: ${clonePath}. Use --force to overwrite`);
+                }
+                spinner.start(`Removing existing directory: ${clonePath}`);
+                (0, child_process_1.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 {
+                (0, child_process_1.execSync)(cloneCommand, { stdio: 'pipe' });
+                spinner.succeed(`Successfully cloned ${name}`);
+            }
+            catch (error) {
+                spinner.fail(`Failed to clone ${name}`);
+                this.error(error.message);
+            }
+            if (customPath && customPath !== entity.path) {
+                entity.path = customPath;
+                await this.entityService.updateEntity(name, entity);
+                this.log(chalk_1.default.yellow(`Updated entity path to: ${customPath}`));
+            }
+            this.log(chalk_1.default.green(`✓ Entity '${name}' cloned to ${clonePath}`));
+            const gitBranch = (0, child_process_1.execSync)('git branch --show-current', {
+                cwd: clonePath,
+                encoding: 'utf-8'
+            }).trim();
+            this.log(chalk_1.default.dim(`  Branch: ${gitBranch}`));
+            this.log(chalk_1.default.dim(`  Repository: ${entity.repository}`));
+        }
+        catch (error) {
+            spinner.fail();
+            this.error(error.message);
+        }
+    }
+}
+exports.default = Clone;

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

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

package/dist/commands/entity/list.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+class ListEntities extends base_command_1.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 = {
+        type: core_1.Flags.string({
+            char: 't',
+            description: 'filter by entity type',
+            options: ['delivery', 'module', 'service', 'tool'],
+        }),
+        json: core_1.Flags.boolean({
+            description: 'output as JSON',
+        }),
+        verbose: core_1.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(', ')}`);
+            }
+        }
+    }
+}
+exports.default = ListEntities;

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

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

package/dist/commands/entity/remove.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+class RemoveEntity extends base_command_1.BaseCommand {
+    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 args = {
+        name: core_1.Args.string({
+            name: 'name',
+            required: true,
+            description: 'Entity name to remove',
+        }),
+    };
+    static flags = {
+        force: core_1.Flags.boolean({
+            char: 'f',
+            description: 'skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RemoveEntity);
+        // Check if entity exists
+        const entity = this.entityService.findEntity(args.name);
+        if (!entity) {
+            this.error(`Entity '${args.name}' not found`);
+        }
+        // Check if entity is currently focused
+        if (await this.focusService.isFocused(args.name)) {
+            this.warn(`Entity '${args.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}`);
+            // In a real implementation, we'd use inquirer or similar for prompts
+            // For now, we'll just proceed with a warning
+            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(args.name);
+        this.log(`\n✅ Removed entity '${args.name}' from configuration`);
+        this.log('Note: The actual files/directory were not deleted');
+    }
+}
+exports.default = RemoveEntity;

package/dist/commands/focus.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../base-command';
+export default class Focus extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        entityTypeOrName: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        entityName: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        clear: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        add: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        duration: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        remember: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+    private isEntityType;
+}

package/dist/commands/focus.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+class Focus extends base_command_1.BaseCommand {
+    static description = 'Set focus on one or more entities with optional type and mode';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-app',
+        '<%= config.bin %> <%= command.id %> client mindtools',
+        '<%= config.bin %> <%= command.id %> client mindtools --mode delivery',
+        '<%= config.bin %> <%= command.id %> prospect jazida --mode research',
+        '<%= config.bin %> <%= command.id %> my-app auth-service',
+        '<%= config.bin %> <%= command.id %> --clear',
+    ];
+    static args = {
+        entityTypeOrName: core_1.Args.string({
+            name: 'entityTypeOrName',
+            required: false,
+            description: 'Entity type (client/prospect/company/initiative) or entity name',
+        }),
+        entityName: core_1.Args.string({
+            name: 'entityName',
+            required: false,
+            description: 'Entity name (when first arg is entity type)',
+        }),
+    };
+    static flags = {
+        clear: core_1.Flags.boolean({
+            char: 'c',
+            description: 'clear current focus',
+            exclusive: ['add', 'mode'],
+        }),
+        add: core_1.Flags.boolean({
+            char: 'a',
+            description: 'add to current focus instead of replacing',
+        }),
+        mode: core_1.Flags.string({
+            char: 'm',
+            description: 'focus mode (delivery, strategy, audit, debug, research, proposal)',
+            options: ['delivery', 'strategy', 'audit', 'debug', 'research', 'proposal'],
+        }),
+        duration: core_1.Flags.string({
+            char: 'd',
+            description: 'focus duration (e.g., 2h, 90m)',
+        }),
+        remember: core_1.Flags.boolean({
+            char: 'r',
+            description: 'remember current focus before switching',
+        }),
+    };
+    static strict = false; // Allow multiple arguments
+    async run() {
+        const { flags, argv, args } = await this.parse(Focus);
+        // Clear focus
+        if (flags.clear) {
+            await this.focusService.clearFocus();
+            this.log('✓ Focus cleared');
+            return;
+        }
+        // Show current focus if no arguments
+        if (argv.length === 0) {
+            const focus = await this.focusService.getCurrentFocus();
+            if (!focus) {
+                this.log('No current focus');
+                this.log('\nSet focus with: gut focus <entity-name>');
+                this.log('Or: gut focus <entity-type> <entity-name>');
+                this.log('\nExamples:');
+                this.log('  gut focus client mindtools --mode delivery');
+                this.log('  gut focus prospect jazida --mode research');
+                return;
+            }
+            const entities = await this.focusService.getFocusedEntities();
+            this.log(`\n🎯 Current focus: ${await this.focusService.getFocusDescription()}`);
+            if (focus.mode) {
+                this.log(`📋 Mode: ${focus.mode}`);
+            }
+            if (entities.length > 0) {
+                this.log('\nFocused entities:');
+                for (const entity of entities) {
+                    this.log(`  ${this.getTypeEmoji(entity.type)} ${entity.name} (${entity.type}) - ${entity.path}`);
+                }
+            }
+            return;
+        }
+        try {
+            // Parse arguments - support both "entity-name" and "entity-type entity-name" formats
+            let entityNames = [];
+            let entityType = undefined;
+            if (argv.length >= 2 && this.isEntityType(String(argv[0]))) {
+                // Format: gut focus client mindtools
+                entityType = argv[0];
+                entityNames = argv.slice(1).map(String);
+            }
+            else {
+                // Format: gut focus mindtools (backward compatibility)
+                entityNames = argv.map(String);
+            }
+            if (flags.remember) {
+                // Save current focus to stack before switching
+                await this.focusService.pushFocusToStack();
+            }
+            if (flags.add) {
+                // Add to existing focus
+                await this.focusService.addToFocus(entityNames, {
+                    entityType,
+                    mode: flags.mode,
+                    duration: flags.duration,
+                });
+                this.log(`✓ Added to focus: ${entityNames.join(', ')}`);
+            }
+            else {
+                // Set new focus
+                await this.focusService.setFocus(entityNames, {
+                    entityType,
+                    mode: flags.mode,
+                    duration: flags.duration,
+                });
+                const modeText = flags.mode ? ` (${flags.mode} mode)` : '';
+                this.log(`✓ Focus set to: ${entityNames.join(', ')}${modeText}`);
+            }
+            // Show what's now focused
+            const entities = await this.focusService.getFocusedEntities();
+            if (entities.length > 1) {
+                this.log(`\nNow focused on ${entities.length} entities:`);
+                for (const entity of entities) {
+                    this.log(`  ${this.getTypeEmoji(entity.type)} ${entity.name} (${entity.type})`);
+                }
+            }
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+    }
+    isEntityType(value) {
+        const entityTypes = ['client', 'prospect', 'company', 'initiative', 'system', 'delivery', 'module', 'service', 'tool'];
+        return entityTypes.includes(value);
+    }
+}
+exports.default = Focus;

package/dist/commands/graph.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../base-command';
+export default class Graph extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'focus-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        depth: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private buildRelationshipGraph;
+    private inferRelationships;
+    private displayAsciiGraph;
+    private displayDotGraph;
+    private getRelationshipIcon;
+    private getNodeColor;
+    private getEdgeColor;
+}