@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/commands/extract.js

@@ -0,0 +1,483 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class Extract extends BaseCommand {
+    static args = {
+        folderPath: Args.string({
+            description: 'Path to the folder to extract from the current repository',
+            name: 'folderPath',
+            required: true,
+        }),
+    };
+    static description = 'Extract a folder from the current repository into its own repository with full git history';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> packages/my-package --gitlab-token <token> --project-path my-group/my-package',
+        '<%= config.bin %> <%= command.id %> src/components --gitlab-token <token> --project-path my-group/frontend/components --target-path .',
+        '<%= config.bin %> <%= command.id %> libs/shared --gitlab-token <token> --project-path company/backend/libs/shared-utils',
+    ];
+    static flags = {
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what would be done without actually doing it',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force extraction even if target directory exists',
+        }),
+        'gitlab-token': Flags.string({
+            description: 'GitLab personal access token for creating projects',
+            required: false,
+        }),
+        'gitlab-url': Flags.string({
+            default: 'https://gitlab.com',
+            description: 'GitLab instance URL',
+        }),
+        'keep-temp': Flags.boolean({
+            default: false,
+            description: 'Keep temporary directory after extraction',
+        }),
+        'project-path': Flags.string({
+            description: 'GitLab project path (group/project-name)',
+            required: false,
+        }),
+        'target-path': Flags.string({
+            default: '.',
+            description: 'Target path in the new repository (default: same as source folder)',
+        }),
+        'temp-dir': Flags.string({
+            description: 'Custom temporary directory path',
+        }),
+    };
+    get requiresInit() {
+        return false; // This command can work outside of gut workspace
+    }
+    async catch(error) {
+        if (error.code === 'OCLIF_REQUIRED_ARG_ERROR' ||
+            (error.args && error.args.some((arg) => arg.name === 'folderPath'))) {
+            this.error(`Please specify a folder path to extract.
+
+Usage: gut extract <folder-path>
+
+Examples:
+  gut extract packages/my-package
+  gut extract src/components
+  gut extract libs/shared
+
+GitLab project paths support nested groups:
+  my-group/my-project
+  company/frontend/components
+  organization/team/backend/services
+
+Use --help for more information.`);
+        }
+        throw error;
+    }
+    async run() {
+        const { args, flags } = await this.parse(Extract);
+        const { folderPath } = args;
+        const { 'dry-run': dryRun, force, 'gitlab-token': gitlabToken, 'gitlab-url': gitlabUrl, 'keep-temp': keepTemp, 'project-path': projectPath, 'target-path': targetPath, 'temp-dir': customTempDir, } = flags;
+        const spinner = ora();
+        try {
+            // Validate we're in a git repository
+            if (!await this.gitService.isRepository(process.cwd())) {
+                this.error('Current directory is not a git repository. Please run this command from within a git repository.');
+            }
+            // Validate folder path is provided
+            if (!folderPath || folderPath.trim() === '') {
+                this.error('Please specify a folder path to extract. Example: gut extract packages/my-package');
+            }
+            // Validate folder exists
+            const sourcePath = path.resolve(folderPath);
+            if (!fs.existsSync(sourcePath)) {
+                this.error(`Folder does not exist: ${sourcePath}\nPlease check the path and try again.`);
+            }
+            // Validate it's actually a directory
+            if (!fs.statSync(sourcePath).isDirectory()) {
+                this.error(`Path is not a directory: ${sourcePath}\nPlease specify a folder path.`);
+            }
+            // Get user inputs if not provided
+            const config = await this.collectConfiguration({
+                gitlabToken,
+                gitlabUrl,
+                projectPath,
+            });
+            // Check if GitLab project exists first
+            const existingProject = await this.checkExistingProject(config, spinner);
+            if (existingProject) {
+                this.log(chalk.green('✓ GitLab project already exists - skipping extraction'));
+                this.log(chalk.dim(`  Repository URL: ${existingProject.web_url}`));
+                this.log(chalk.dim(`  SSH URL: ${existingProject.ssh_url_to_repo}`));
+                return;
+            }
+            if (dryRun) {
+                this.log(chalk.yellow('DRY RUN - No actual changes will be made'));
+                this.log(`Would extract: ${sourcePath}`);
+                this.log(`Target repository: ${config.projectPath}`);
+                this.log(`GitLab URL: ${config.gitlabUrl}`);
+                this.log(`Target path in new repo: ${targetPath}`);
+                this.log('Would create new GitLab project');
+                return;
+            }
+            // Create temporary directory
+            const tempDir = customTempDir || path.join(os.tmpdir(), `gut-extract-${Date.now()}`);
+            spinner.start('Setting up temporary workspace...');
+            fs.mkdirSync(tempDir, { recursive: true });
+            spinner.succeed('Temporary workspace created');
+            try {
+                // Step 1: Clone current repository to temp
+                await this.cloneToTemp(tempDir, spinner);
+                // Step 2: Get all branches and filter each one
+                const branches = await this.getAllBranches(tempDir, spinner);
+                await this.filterAllBranches(tempDir, folderPath, targetPath, branches, spinner);
+                // Step 3: Create GitLab project
+                const projectInfo = await this.createGitLabProject(config, spinner);
+                // Step 4: Add remote and push all branches
+                await this.pushToNewRepository(tempDir, projectInfo.ssh_url_to_repo, branches, spinner);
+                // Step 5: Clone new repository to final location
+                await this.cloneNewRepository(projectInfo, folderPath, force, spinner);
+                this.log(chalk.green('✓ Successfully extracted folder to new repository!'));
+                this.log(chalk.dim(`  Repository URL: ${projectInfo.web_url}`));
+                this.log(chalk.dim(`  SSH URL: ${projectInfo.ssh_url_to_repo}`));
+            }
+            finally {
+                // Cleanup temp directory unless requested to keep
+                if (!keepTemp) {
+                    spinner.start('Cleaning up temporary files...');
+                    execSync(`rm -rf "${tempDir}"`, { stdio: 'pipe' });
+                    spinner.succeed('Cleanup completed');
+                }
+                else {
+                    this.log(chalk.yellow(`Temporary directory preserved at: ${tempDir}`));
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail();
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async checkExistingProject(config, spinner) {
+        spinner.start('Checking if GitLab project exists...');
+        try {
+            const checkResponse = await fetch(`${config.gitlabUrl}/api/v4/projects/${encodeURIComponent(config.projectPath)}`, {
+                headers: {
+                    'PRIVATE-TOKEN': config.gitlabToken,
+                },
+            });
+            if (checkResponse.ok) {
+                const existingProject = await checkResponse.json();
+                spinner.succeed(`GitLab project already exists: ${existingProject.web_url}`);
+                return existingProject;
+            }
+            spinner.succeed('GitLab project does not exist - will create new one');
+            return null;
+        }
+        catch (error) {
+            spinner.warn(`Could not check project existence: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async cloneNewRepository(projectInfo, originalFolderPath, force, spinner) {
+        const folderName = path.basename(originalFolderPath);
+        const targetPath = path.resolve(folderName);
+        if (fs.existsSync(targetPath)) {
+            if (!force) {
+                this.error(`Directory ${targetPath} already exists. Use --force to overwrite.`);
+            }
+            spinner.start(`Removing existing directory: ${targetPath}`);
+            execSync(`rm -rf "${targetPath}"`, { stdio: 'pipe' });
+            spinner.succeed('Existing directory removed');
+        }
+        spinner.start('Cloning new repository...');
+        execSync(`git clone "${projectInfo.ssh_url_to_repo}" "${targetPath}"`, { stdio: 'pipe' });
+        spinner.succeed(`New repository cloned to: ${targetPath}`);
+        // Force pull to ensure all branches are available locally
+        spinner.start('Updating local repository...');
+        execSync('git fetch --all', { cwd: targetPath, stdio: 'pipe' });
+        spinner.succeed('Repository updated');
+    }
+    async cloneToTemp(tempDir, spinner) {
+        spinner.start('Cloning current repository...');
+        const currentRepo = path.basename(process.cwd());
+        const tempRepoPath = path.join(tempDir, currentRepo);
+        const remoteUrl = await this.gitService.getRemoteUrl(process.cwd());
+        if (!remoteUrl) {
+            // If no remote, create a local clone
+            execSync(`cp -R . "${tempRepoPath}"`, { stdio: 'pipe' });
+        }
+        else {
+            execSync(`git clone "${remoteUrl}" "${tempRepoPath}"`, { stdio: 'pipe' });
+        }
+        spinner.succeed('Repository cloned to temporary location');
+    }
+    async collectConfiguration(provided) {
+        const config = { ...provided };
+        if (!config.gitlabToken) {
+            // Try to get from environment variable first
+            config.gitlabToken = process.env.GITLAB_TOKEN || process.env.GL_TOKEN;
+            if (!config.gitlabToken) {
+                this.error('GitLab token is required. Provide via --gitlab-token flag or GITLAB_TOKEN environment variable.');
+            }
+        }
+        if (!config.projectPath) {
+            this.error('GitLab project path is required. Provide via --project-path flag (e.g., my-group/my-project).');
+        }
+        return config;
+    }
+    async createGitLabProject(config, spinner) {
+        const pathParts = config.projectPath.split('/');
+        const projectName = pathParts.at(-1);
+        const groupPath = pathParts.slice(0, -1);
+        if (groupPath.length === 0) {
+            throw new Error('Project path must include at least one group (e.g., my-group/my-project)');
+        }
+        // Ensure all nested groups exist
+        const finalGroupId = await this.ensureGroupPath(config, groupPath, spinner);
+        // Create the project
+        spinner.start(`Creating GitLab project: ${projectName}`);
+        const createResponse = await fetch(`${config.gitlabUrl}/api/v4/projects`, {
+            body: JSON.stringify({
+                initialize_with_readme: false,
+                name: projectName,
+                namespace_id: finalGroupId,
+                path: projectName,
+                visibility: 'private',
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+                'PRIVATE-TOKEN': config.gitlabToken,
+            },
+            method: 'POST',
+        });
+        if (!createResponse.ok) {
+            const errorText = await createResponse.text();
+            let errorData;
+            try {
+                errorData = JSON.parse(errorText);
+            }
+            catch {
+                throw new Error(`Failed to create GitLab project: ${errorText}`);
+            }
+            if (errorData.message && typeof errorData.message === 'object' && errorData.message.path?.includes('already been taken')) {
+                // Project was created concurrently, try to fetch it
+                const retryResponse = await fetch(`${config.gitlabUrl}/api/v4/projects/${encodeURIComponent(config.projectPath)}`, {
+                    headers: {
+                        'PRIVATE-TOKEN': config.gitlabToken,
+                    },
+                });
+                if (retryResponse.ok) {
+                    const existingProject = await retryResponse.json();
+                    spinner.succeed(`Using GitLab project (created concurrently): ${existingProject.web_url}`);
+                    return existingProject;
+                }
+            }
+            throw new Error(`Failed to create GitLab project: ${typeof errorData.message === 'string' ? errorData.message : errorText}`);
+        }
+        const project = await createResponse.json();
+        spinner.succeed(`GitLab project created: ${project.web_url}`);
+        return project;
+    }
+    async ensureGroupPath(config, groupPath, spinner) {
+        let currentParentId = null;
+        let currentPath = '';
+        for (const groupName of groupPath) {
+            currentPath = currentPath ? `${currentPath}/${groupName}` : groupName;
+            spinner.start(`Checking group: ${currentPath}`);
+            // Try to find existing group
+            const groupResponse = await fetch(`${config.gitlabUrl}/api/v4/groups/${encodeURIComponent(currentPath)}`, {
+                headers: {
+                    'PRIVATE-TOKEN': config.gitlabToken,
+                },
+            });
+            if (groupResponse.ok) {
+                // Group exists
+                const group = await groupResponse.json();
+                currentParentId = group.id;
+                spinner.succeed(`Found existing group: ${currentPath}`);
+            }
+            else if (groupResponse.status === 404) {
+                // Group doesn't exist, create it
+                spinner.start(`Creating group: ${groupName}`);
+                const createGroupBody = {
+                    name: groupName,
+                    path: groupName,
+                    visibility: 'private',
+                };
+                if (currentParentId !== null) {
+                    createGroupBody.parent_id = currentParentId;
+                }
+                const createResponse = await fetch(`${config.gitlabUrl}/api/v4/groups`, {
+                    body: JSON.stringify(createGroupBody),
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'PRIVATE-TOKEN': config.gitlabToken,
+                    },
+                    method: 'POST',
+                });
+                if (!createResponse.ok) {
+                    const errorText = await createResponse.text();
+                    let errorData;
+                    try {
+                        errorData = JSON.parse(errorText);
+                    }
+                    catch {
+                        throw new Error(`Failed to create group '${groupName}': ${errorText}`);
+                    }
+                    if (errorData.message && typeof errorData.message === 'object' && errorData.message.path?.includes('already been taken')) {
+                        // Group was created by another process, try to fetch it
+                        const retryResponse = await fetch(`${config.gitlabUrl}/api/v4/groups/${encodeURIComponent(currentPath)}`, {
+                            headers: {
+                                'PRIVATE-TOKEN': config.gitlabToken,
+                            },
+                        });
+                        if (retryResponse.ok) {
+                            const group = await retryResponse.json();
+                            currentParentId = group.id;
+                            spinner.succeed(`Found group (created concurrently): ${currentPath}`);
+                            continue;
+                        }
+                    }
+                    throw new Error(`Failed to create group '${groupName}': ${typeof errorData.message === 'string' ? errorData.message : errorText}`);
+                }
+                const newGroup = await createResponse.json();
+                currentParentId = newGroup.id;
+                spinner.succeed(`Created group: ${currentPath}`);
+            }
+            else {
+                // Other error
+                const errorText = await groupResponse.text();
+                throw new Error(`Failed to access group '${currentPath}': ${errorText}`);
+            }
+        }
+        if (currentParentId === null) {
+            throw new Error('Failed to resolve final group ID');
+        }
+        return currentParentId;
+    }
+    async filterAllBranches(tempDir, folderPath, targetPath, branches, spinner) {
+        const repoPath = path.join(tempDir, path.basename(process.cwd()));
+        // Ensure we have the correct relative path for git filtering
+        let relativeFolderPath;
+        if (path.isAbsolute(folderPath)) {
+            relativeFolderPath = path.relative(process.cwd(), folderPath);
+        }
+        else {
+            relativeFolderPath = folderPath;
+        }
+        // Normalize path separators for git commands
+        relativeFolderPath = relativeFolderPath.replaceAll('\\', '/');
+        this.log(chalk.dim(`Filtering path: ${relativeFolderPath} -> ${targetPath}`));
+        // Use git filter-repo (modern replacement for filter-branch)
+        // filter-repo processes all branches at once, which is more efficient
+        spinner.start('Filtering all branches...');
+        try {
+            if (targetPath === '.') {
+                // Extract to root - use subdirectory filter approach
+                execSync(`git filter-repo --subdirectory-filter "${relativeFolderPath}" --force`, {
+                    cwd: repoPath,
+                    stdio: 'pipe',
+                });
+            }
+            else {
+                // Extract and rename path
+                execSync(`git filter-repo --path "${relativeFolderPath}" --path-rename "${relativeFolderPath}:${targetPath}" --force`, {
+                    cwd: repoPath,
+                    stdio: 'pipe',
+                });
+            }
+            spinner.succeed('All branches filtered using git filter-repo');
+        }
+        catch {
+            // Fallback to filter-branch if filter-repo is not available
+            spinner.warn('git filter-repo not available, using git filter-branch (slower)');
+            for (const branch of branches) {
+                spinner.start(`Processing branch: ${branch}`);
+                try {
+                    // Checkout branch
+                    execSync(`git checkout -B ${branch} origin/${branch}`, {
+                        cwd: repoPath,
+                        stdio: 'pipe',
+                    });
+                    if (targetPath === '.') {
+                        // Extract folder contents to root
+                        execSync(`git filter-branch --prune-empty --subdirectory-filter "${relativeFolderPath}" --force`, {
+                            cwd: repoPath,
+                            stdio: 'pipe',
+                        });
+                    }
+                    else {
+                        // Extract and move to target path
+                        execSync(`git filter-branch --prune-empty --tree-filter 'if [ -d "${relativeFolderPath}" ]; then mkdir -p "${targetPath}"; mv "${relativeFolderPath}"/* "${targetPath}/" 2>/dev/null || true; rm -rf "${relativeFolderPath}"; fi' --force`, {
+                            cwd: repoPath,
+                            stdio: 'pipe',
+                        });
+                    }
+                    spinner.succeed(`Processed branch: ${branch}`);
+                }
+                catch (error) {
+                    spinner.warn(`Skipped branch ${branch}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    }
+    async getAllBranches(tempDir, spinner) {
+        spinner.start('Discovering all branches...');
+        const repoPath = path.join(tempDir, path.basename(process.cwd()));
+        // Get all remote branches
+        const remoteBranches = execSync('git branch -r', {
+            cwd: repoPath,
+            encoding: 'utf8',
+        }).split('\n')
+            .map(branch => branch.trim())
+            .filter(branch => branch && !branch.includes('HEAD'))
+            .map(branch => branch.replace('origin/', ''));
+        // Get local branches
+        const localBranches = execSync('git branch', {
+            cwd: repoPath,
+            encoding: 'utf8',
+        }).split('\n')
+            .map(branch => branch.trim().replace('* ', ''))
+            .filter(branch => branch);
+        // Combine and deduplicate
+        const allBranches = [...new Set([...localBranches, ...remoteBranches])];
+        // Ensure master/main is processed first
+        const priorityBranches = ['master', 'main'];
+        const sortedBranches = [];
+        for (const priority of priorityBranches) {
+            if (allBranches.includes(priority)) {
+                sortedBranches.push(priority);
+            }
+        }
+        // Add remaining branches
+        for (const branch of allBranches) {
+            if (!priorityBranches.includes(branch)) {
+                sortedBranches.push(branch);
+            }
+        }
+        spinner.succeed(`Found ${sortedBranches.length} branches to process (master/main first)`);
+        return sortedBranches;
+    }
+    async pushToNewRepository(tempDir, repositoryUrl, branches, spinner) {
+        const repoPath = path.join(tempDir, path.basename(process.cwd()));
+        spinner.start('Adding new remote...');
+        execSync(`git remote add new-origin "${repositoryUrl}"`, { cwd: repoPath, stdio: 'pipe' });
+        spinner.succeed('Remote added');
+        for (const branch of branches) {
+            spinner.start(`Pushing branch: ${branch}`);
+            try {
+                execSync(`git checkout ${branch}`, { cwd: repoPath, stdio: 'pipe' });
+                execSync(`git push new-origin ${branch}`, { cwd: repoPath, stdio: 'pipe' });
+                spinner.succeed(`Pushed branch: ${branch}`);
+            }
+            catch (error) {
+                spinner.warn(`Failed to push branch ${branch}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/focus.d.ts

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

package/dist/commands/focus.js

@@ -0,0 +1,137 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../base-command.js';
+import { ENTITY_TYPES } from '../models/entity.model.js';
+export default class Focus extends BaseCommand {
+    static args = {
+        entityName: Args.string({
+            description: 'Entity name (when first arg is entity type)',
+            name: 'entityName',
+            required: false,
+        }),
+        entityTypeOrName: Args.string({
+            description: 'Entity type (client/prospect/company/initiative) or entity name',
+            name: 'entityTypeOrName',
+            required: false,
+        }),
+    };
+    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 flags = {
+        add: Flags.boolean({
+            char: 'a',
+            description: 'add to current focus instead of replacing',
+        }),
+        clear: Flags.boolean({
+            char: 'c',
+            description: 'clear current focus',
+            exclusive: ['add', 'mode'],
+        }),
+        duration: Flags.string({
+            char: 'd',
+            description: 'focus duration (e.g., 2h, 90m)',
+        }),
+        mode: Flags.string({
+            char: 'm',
+            description: 'focus mode (delivery, strategy, audit, debug, research, proposal)',
+            options: ['delivery', 'strategy', 'audit', 'debug', 'research', 'proposal'],
+        }),
+        remember: Flags.boolean({
+            char: 'r',
+            description: 'remember current focus before switching',
+        }),
+    };
+    static strict = false; // Allow multiple arguments
+    async run() {
+        const { argv, flags } = 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;
+            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, {
+                    duration: flags.duration,
+                    entityType,
+                    mode: flags.mode,
+                });
+                this.log(`✓ Added to focus: ${entityNames.join(', ')}`);
+            }
+            else {
+                // Set new focus
+                await this.focusService.setFocus(entityNames, {
+                    duration: flags.duration,
+                    entityType,
+                    mode: flags.mode,
+                });
+                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) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+    isEntityType(value) {
+        return ENTITY_TYPES.includes(value);
+    }
+}

package/dist/commands/graph.d.ts

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