@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/commands/related.js

@@ -0,0 +1,255 @@
+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 Related extends BaseCommand {
+    static args = {
+        entity: Args.string({
+            description: 'Entity name (uses current focus if not provided)',
+            name: 'entity',
+            required: false,
+        }),
+    };
+    static description = 'Find entities related to a specific entity or current focus';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-app',
+        '<%= config.bin %> <%= command.id %> --threshold 0.3',
+        '<%= config.bin %> <%= command.id %> --type dependencies',
+    ];
+    static flags = {
+        detailed: Flags.boolean({
+            char: 'd',
+            default: false,
+            description: 'Show detailed relation information',
+        }),
+        threshold: Flags.string({
+            char: 't',
+            default: '0.2',
+            description: 'Minimum relation score (0-1)',
+        }),
+        type: Flags.string({
+            default: 'all',
+            description: 'Type of relation to check',
+            options: ['all', 'dependencies', 'git', 'files'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Related);
+        const { detailed, threshold, type } = flags;
+        const thresholdNum = Number.parseFloat(threshold);
+        const spinner = ora();
+        try {
+            let targetEntity;
+            if (args.entity) {
+                targetEntity = await this.entityService.getEntity(args.entity);
+                if (!targetEntity) {
+                    this.error(`Entity '${args.entity}' not found`);
+                }
+            }
+            else {
+                const focus = await this.focusService.getCurrentFocus();
+                if (!focus || !focus.entities || focus.entities.length === 0) {
+                    this.error('No entity specified and no current focus');
+                }
+                targetEntity = await this.entityService.getEntity(focus.entities[0].name);
+            }
+            if (!targetEntity) {
+                this.error('Could not determine target entity');
+            }
+            spinner.start(`Analyzing relations for ${targetEntity.name}`);
+            const allEntities = await this.entityService.listEntities();
+            const otherEntities = allEntities.filter(e => e.name !== targetEntity.name);
+            const relations = [];
+            for (const entity of otherEntities) {
+                const relation = await this.analyzeRelation(targetEntity, entity, type);
+                if (relation.relations.score >= thresholdNum) {
+                    relations.push(relation);
+                }
+            }
+            spinner.succeed(`Found ${relations.length} related entities`);
+            if (relations.length === 0) {
+                this.log(chalk.yellow('No related entities found with the specified threshold'));
+                return;
+            }
+            relations.sort((a, b) => b.relations.score - a.relations.score);
+            this.printRelations(targetEntity, relations, detailed);
+        }
+        catch (error) {
+            spinner.fail();
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async analyzeRelation(source, target, type) {
+        const relations = {
+            dependencies: [],
+            gitReferences: [],
+            score: 0,
+            sharedFiles: [],
+        };
+        if (type === 'all' || type === 'dependencies') {
+            relations.dependencies = await this.findDependencyRelations(source, target);
+        }
+        if (type === 'all' || type === 'files') {
+            relations.sharedFiles = await this.findSharedFiles(source, target);
+        }
+        if (type === 'all' || type === 'git') {
+            relations.gitReferences = await this.findGitReferences(source, target);
+        }
+        relations.score = this.calculateScore(relations);
+        return { entity: target, relations };
+    }
+    calculateScore(relations) {
+        let score = 0;
+        score += relations.dependencies.length * 0.4;
+        score += Math.min(relations.sharedFiles.length * 0.05, 0.3);
+        score += Math.min(relations.gitReferences.length * 0.1, 0.3);
+        return Math.min(score, 1);
+    }
+    extractDependencies(pkg) {
+        const deps = [];
+        if (pkg.dependencies) {
+            for (const [name, version] of Object.entries(pkg.dependencies)) {
+                deps.push({ name, type: 'dependency', version: version });
+            }
+        }
+        if (pkg.devDependencies) {
+            for (const [name, version] of Object.entries(pkg.devDependencies)) {
+                deps.push({ name, type: 'devDependency', version: version });
+            }
+        }
+        if (pkg.peerDependencies) {
+            for (const [name, version] of Object.entries(pkg.peerDependencies)) {
+                deps.push({ name, type: 'peerDependency', version: version });
+            }
+        }
+        return deps;
+    }
+    async findDependencyRelations(source, target) {
+        const relations = [];
+        const sourcePkgPath = path.join(source.path, 'package.json');
+        const targetPkgPath = path.join(target.path, 'package.json');
+        if (!fs.existsSync(sourcePkgPath) || !fs.existsSync(targetPkgPath)) {
+            return relations;
+        }
+        try {
+            const sourcePkg = JSON.parse(fs.readFileSync(sourcePkgPath, 'utf8'));
+            const targetPkg = JSON.parse(fs.readFileSync(targetPkgPath, 'utf8'));
+            const sourceDeps = this.extractDependencies(sourcePkg);
+            const targetName = targetPkg.name;
+            if (targetName && sourceDeps.some(d => d.name === targetName)) {
+                relations.push(`depends on ${targetName}`);
+            }
+            const targetDeps = this.extractDependencies(targetPkg);
+            const sourceName = sourcePkg.name;
+            if (sourceName && targetDeps.some(d => d.name === sourceName)) {
+                relations.push(`dependency of ${targetName}`);
+            }
+            const sharedDeps = sourceDeps.filter(sd => targetDeps.some(td => td.name === sd.name));
+            if (sharedDeps.length > 0) {
+                relations.push(`${sharedDeps.length} shared dependencies`);
+            }
+        }
+        catch {
+            // Ignore parsing errors
+        }
+        return relations;
+    }
+    async findGitReferences(source, target) {
+        const relations = [];
+        try {
+            if (fs.existsSync(path.join(source.path, '.git'))) {
+                const logs = execSync(`git log --grep="${target.name}" --oneline`, {
+                    cwd: source.path,
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).toString();
+                const mentions = logs.split('\n').filter((l) => l.trim()).length;
+                if (mentions > 0) {
+                    relations.push(`${mentions} git mentions`);
+                }
+            }
+        }
+        catch {
+            // Ignore git errors
+        }
+        return relations;
+    }
+    async findSharedFiles(source, target) {
+        const relations = [];
+        try {
+            const sourceFiles = this.getFileList(source.path);
+            const targetFiles = this.getFileList(target.path);
+            const sharedPatterns = sourceFiles.filter(sf => targetFiles.some(tf => this.isSimilarFile(sf, tf)));
+            if (sharedPatterns.length > 0) {
+                relations.push(`${sharedPatterns.length} similar files`);
+            }
+        }
+        catch {
+            // Ignore file system errors
+        }
+        return relations;
+    }
+    getFileList(dir, baseDir = dir) {
+        const files = [];
+        if (!fs.existsSync(dir))
+            return files;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.name === 'node_modules' || entry.name === '.git')
+                    continue;
+                if (entry.isDirectory()) {
+                    files.push(...this.getFileList(fullPath, baseDir));
+                }
+                else {
+                    const relativePath = path.relative(baseDir, fullPath);
+                    files.push(relativePath);
+                }
+            }
+        }
+        catch {
+            // Ignore permission errors
+        }
+        return files;
+    }
+    isSimilarFile(file1, file2) {
+        const base1 = path.basename(file1);
+        const base2 = path.basename(file2);
+        return base1 === base2
+            && (base1.includes('config')
+                || base1.includes('test')
+                || base1.includes('spec')
+                || base1 === 'README.md'
+                || base1 === 'package.json');
+    }
+    printRelations(source, relations, detailed) {
+        this.log('');
+        this.log(chalk.bold(`Relations for ${source.name}:`));
+        this.log('');
+        for (const [index, rel] of relations.entries()) {
+            const scoreColor = rel.relations.score > 0.5
+                ? chalk.green
+                : (rel.relations.score > 0.3
+                    ? chalk.yellow
+                    : chalk.dim);
+            this.log(`${index + 1}. ${chalk.bold(rel.entity.name)} ${scoreColor(`(score: ${rel.relations.score.toFixed(2)})`)}`);
+            if (detailed) {
+                if (rel.relations.dependencies.length > 0) {
+                    this.log(chalk.dim(`   Dependencies: ${rel.relations.dependencies.join(', ')}`));
+                }
+                if (rel.relations.sharedFiles.length > 0) {
+                    this.log(chalk.dim(`   Shared: ${rel.relations.sharedFiles.join(', ')}`));
+                }
+                if (rel.relations.gitReferences.length > 0) {
+                    this.log(chalk.dim(`   Git: ${rel.relations.gitReferences.join(', ')}`));
+                }
+            }
+        }
+        this.log('');
+        this.log(chalk.dim('Tip: Use --detailed flag for more information'));
+    }
+}

package/dist/commands/repos.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../base-command.js';
+export default class Repos extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accessible: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        status: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private buildRepoInfoLine;
+    private displayGitStatus;
+    private displayRelationships;
+    private displayRepoInfo;
+    private displayRepos;
+}

package/dist/commands/repos.js

@@ -0,0 +1,184 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import * as fs from 'node:fs';
+import { BaseCommand } from '../base-command.js';
+export default class Repos extends BaseCommand {
+    static description = 'List accessible repositories in the workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --type client',
+        '<%= config.bin %> <%= command.id %> --status',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        accessible: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'show only accessible repositories (with valid paths)',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'output as JSON',
+        }),
+        status: Flags.boolean({
+            char: 's',
+            default: false,
+            description: 'show git status for each repository',
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'filter by entity type',
+            options: ['client', 'prospect', 'company', 'initiative', 'system', 'delivery', 'module', 'service', 'tool'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Repos);
+        let entities = this.entityService.getAllEntities();
+        // Filter by type if specified
+        if (flags.type) {
+            entities = entities.filter(e => e.type === flags.type);
+        }
+        // Filter by accessibility if specified
+        if (flags.accessible) {
+            entities = entities.filter(e => {
+                const entityPath = this.entityService.resolveEntityPath(e);
+                return fs.existsSync(entityPath);
+            });
+        }
+        if (entities.length === 0) {
+            this.error('No repositories found matching criteria');
+        }
+        // Collect repository information
+        const repos = [];
+        for (const entity of entities) {
+            const entityPath = this.entityService.resolveEntityPath(entity);
+            const repoInfo = {
+                absolutePath: entityPath,
+                exists: fs.existsSync(entityPath),
+                isGitRepo: false,
+                metadata: entity.metadata || {},
+                name: entity.name,
+                path: entity.path,
+                status: null,
+                type: entity.type,
+            };
+            if (repoInfo.exists) {
+                try {
+                    repoInfo.isGitRepo = await this.gitService.isRepository(entityPath);
+                    if (repoInfo.isGitRepo && flags.status) {
+                        repoInfo.status = await this.gitService.getStatus(entityPath);
+                    }
+                }
+                catch {
+                    // Ignore git errors for non-git directories
+                }
+            }
+            repos.push(repoInfo);
+        }
+        // Output results
+        if (flags.json) {
+            this.log(JSON.stringify(repos, null, 2));
+            return;
+        }
+        await this.displayRepos(repos, flags.status);
+    }
+    buildRepoInfoLine(repo, isFocused) {
+        const emoji = this.getTypeEmoji(repo.type);
+        const focusIndicator = isFocused ? chalk.yellow('●') : ' ';
+        const accessIndicator = repo.exists ? (repo.isGitRepo ? '📁' : '📂') : '❌';
+        let line = `  ${focusIndicator} ${emoji} ${chalk.cyan(repo.name)} ${accessIndicator}`;
+        line += ` ${chalk.dim(repo.path)}`;
+        if (repo.type === 'client' && repo.metadata.business?.status) {
+            line += ` ${chalk.dim(`(${repo.metadata.business.status})`)}`;
+        }
+        return line;
+    }
+    displayGitStatus(status) {
+        if (status.hasChanges) {
+            if (status.changes.length > 0) {
+                this.log(`    ${chalk.yellow('M')} ${status.changes.length} modified`);
+            }
+            if (status.untracked.length > 0) {
+                this.log(`    ${chalk.green('A')} ${status.untracked.length} untracked`);
+            }
+        }
+        else {
+            this.log(`    ${chalk.dim('Clean')}`);
+        }
+        if (status.ahead > 0 || status.behind > 0) {
+            const ahead = status.ahead > 0 ? `↑${status.ahead}` : '';
+            const behind = status.behind > 0 ? `↓${status.behind}` : '';
+            this.log(`    ${chalk.blue('Remote:')} ${ahead} ${behind}`.trim());
+        }
+    }
+    displayRelationships(repo) {
+        if (!repo.metadata.relationships) {
+            return;
+        }
+        const rel = repo.metadata.relationships;
+        const deps = rel.dependent_systems?.length || 0;
+        const similar = rel.similar_entities?.length || 0;
+        if (deps > 0 || similar > 0) {
+            const info = [];
+            if (deps > 0)
+                info.push(`${deps} deps`);
+            if (similar > 0)
+                info.push(`${similar} similar`);
+            this.log(`    ${chalk.dim('Relationships:')} ${chalk.dim(info.join(', '))}`);
+        }
+    }
+    displayRepoInfo(repo, showStatus, isFocused) {
+        const line = this.buildRepoInfoLine(repo, isFocused);
+        this.log(line);
+        if (showStatus && repo.status) {
+            this.displayGitStatus(repo.status);
+        }
+        this.displayRelationships(repo);
+    }
+    async displayRepos(repos, showStatus) {
+        const currentFocus = await this.focusService.getCurrentFocus();
+        const focusedEntityNames = currentFocus?.entities?.map(e => e.name) || [];
+        this.log(chalk.bold('\n📁 Workspace Repositories'));
+        this.log(chalk.dim('─'.repeat(50)));
+        // Group by type
+        const byType = {};
+        for (const repo of repos) {
+            if (!byType[repo.type])
+                byType[repo.type] = [];
+            byType[repo.type].push(repo);
+        }
+        const typeOrder = ['client', 'prospect', 'company', 'initiative', 'system', 'delivery', 'module', 'service', 'tool'];
+        for (const type of typeOrder) {
+            if (!byType[type] || byType[type].length === 0)
+                continue;
+            this.log(`\n${chalk.bold(type.toUpperCase())}:`);
+            for (const repo of byType[type]) {
+                this.displayRepoInfo(repo, showStatus, focusedEntityNames.includes(repo.name));
+            }
+        }
+        // Summary
+        const totalRepos = repos.length;
+        const gitRepos = repos.filter(r => r.isGitRepo).length;
+        const accessibleRepos = repos.filter(r => r.exists).length;
+        const focusedRepos = repos.filter(r => focusedEntityNames.includes(r.name)).length;
+        this.log(chalk.bold('\n📊 Repository Summary:'));
+        this.log(`  Total entities: ${totalRepos}`);
+        this.log(`  Accessible: ${accessibleRepos}`);
+        this.log(`  Git repositories: ${gitRepos}`);
+        if (focusedRepos > 0) {
+            this.log(`  Currently focused: ${focusedRepos}`);
+        }
+        // Show access patterns
+        if (repos.some(r => r.metadata.business)) {
+            this.log(chalk.bold('\n🔐 Access Information:'));
+            const clientRepos = repos.filter(r => r.type === 'client');
+            const privateRepos = repos.filter(r => r.path.includes('private') || r.path.includes('business'));
+            if (clientRepos.length > 0) {
+                this.log(`  Client repositories: ${clientRepos.length}`);
+            }
+            if (privateRepos.length > 0) {
+                this.log(`  Private/Business: ${privateRepos.length}`);
+            }
+        }
+    }
+}

package/dist/commands/stack.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../base-command.js';
+export default class Stack extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        clear: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private formatTimeAgo;
+}

package/dist/commands/stack.js

@@ -0,0 +1,78 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Stack extends BaseCommand {
+    static description = 'Show and manage the focus stack';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --clear',
+    ];
+    static flags = {
+        clear: Flags.boolean({
+            char: 'c',
+            description: 'clear the focus stack',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Stack);
+        if (flags.clear) {
+            // Clear the focus stack
+            const clearedCount = this.focusService.clearFocusStack();
+            if (clearedCount === 0) {
+                this.log('Focus stack is already empty');
+                return;
+            }
+            this.log(`✓ Cleared ${clearedCount} items from focus stack`);
+            return;
+        }
+        // Show current focus stack
+        const currentFocus = await this.focusService.getCurrentFocus();
+        const focusStack = this.focusService.getFocusStack();
+        this.log(chalk.bold('\n📚 Focus Stack'));
+        this.log(chalk.dim('─'.repeat(50)));
+        // Show current focus
+        if (currentFocus) {
+            const description = await this.focusService.getFocusDescription();
+            this.log(`${chalk.green('▸ Current:')} ${description}`);
+        }
+        else {
+            this.log(`${chalk.dim('▸ Current:')} No focus set`);
+        }
+        // Show stack items
+        if (focusStack.length > 0) {
+            this.log(`\n${chalk.yellow('Stack:')}`);
+            for (const [index, focus] of focusStack.entries()) {
+                const entities = focus.entities?.map(e => e.name).join(', ') || focus.name;
+                const modeText = focus.mode ? ` (${focus.mode})` : '';
+                const timeAgo = this.formatTimeAgo(focus.timestamp || 0);
+                this.log(`  ${chalk.dim(`${index + 1}.`)} ${entities}${modeText} ${chalk.dim(`- ${timeAgo}`)}`);
+            }
+            this.log(chalk.dim('\nUse "gut back" to pop from stack and return to previous focus'));
+        }
+        else {
+            this.log(`\n${chalk.dim('Stack is empty')}`);
+        }
+        // Show usage tips
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(chalk.dim('Tips:'));
+        this.log(chalk.dim('• Use "gut focus <entity> --remember" to push current focus to stack'));
+        this.log(chalk.dim('• Use "gut back" to return to previous focus'));
+        this.log(chalk.dim('• Use "gut stack --clear" to clear the stack'));
+    }
+    formatTimeAgo(timestamp) {
+        if (!timestamp)
+            return 'unknown';
+        const now = Date.now();
+        const diff = now - timestamp;
+        const minutes = Math.floor(diff / (1000 * 60));
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0)
+            return `${days}d ago`;
+        if (hours > 0)
+            return `${hours}h ago`;
+        if (minutes > 0)
+            return `${minutes}m ago`;
+        return 'just now';
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../base-command.js';
+export default class Status extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private displayEnhancedStatus;
+    private displayEntityStatus;
+}