@hyperdrive.bot/gut 0.1.3

package/dist/commands/related.js

@@ -0,0 +1,257 @@
+"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 fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+class Related extends base_command_1.default {
+    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 = {
+        threshold: core_1.Flags.string({
+            char: 't',
+            description: 'Minimum relation score (0-1)',
+            default: '0.2',
+        }),
+        type: core_1.Flags.string({
+            description: 'Type of relation to check',
+            options: ['all', 'dependencies', 'git', 'files'],
+            default: 'all',
+        }),
+        detailed: core_1.Flags.boolean({
+            char: 'd',
+            description: 'Show detailed relation information',
+            default: false,
+        }),
+    };
+    static args = {
+        entity: core_1.Args.string({
+            name: 'entity',
+            required: false,
+            description: 'Entity name (uses current focus if not provided)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Related);
+        const { threshold, type, detailed } = flags;
+        const thresholdNum = parseFloat(threshold);
+        const spinner = (0, ora_1.default)();
+        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_1.default.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.message);
+        }
+    }
+    async analyzeRelation(source, target, type) {
+        const relations = {
+            dependencies: [],
+            sharedFiles: [],
+            gitReferences: [],
+            score: 0,
+        };
+        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 };
+    }
+    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, 'utf-8'));
+            const targetPkg = JSON.parse(fs.readFileSync(targetPkgPath, 'utf-8'));
+            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 (error) {
+            // Ignore parsing errors
+        }
+        return relations;
+    }
+    extractDependencies(pkg) {
+        const deps = [];
+        if (pkg.dependencies) {
+            Object.entries(pkg.dependencies).forEach(([name, version]) => {
+                deps.push({ name, version: version, type: 'dependency' });
+            });
+        }
+        if (pkg.devDependencies) {
+            Object.entries(pkg.devDependencies).forEach(([name, version]) => {
+                deps.push({ name, version: version, type: 'devDependency' });
+            });
+        }
+        if (pkg.peerDependencies) {
+            Object.entries(pkg.peerDependencies).forEach(([name, version]) => {
+                deps.push({ name, version: version, type: 'peerDependency' });
+            });
+        }
+        return deps;
+    }
+    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 (error) {
+            // 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 (error) {
+            // 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');
+    }
+    async findGitReferences(source, target) {
+        const relations = [];
+        try {
+            const { execSync } = require('child_process');
+            if (fs.existsSync(path.join(source.path, '.git'))) {
+                const logs = execSync(`git log --grep="${target.name}" --oneline`, {
+                    cwd: source.path,
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                }).toString();
+                const mentions = logs.split('\n').filter((l) => l.trim()).length;
+                if (mentions > 0) {
+                    relations.push(`${mentions} git mentions`);
+                }
+            }
+        }
+        catch (error) {
+            // Ignore git errors
+        }
+        return 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);
+    }
+    printRelations(source, relations, detailed) {
+        this.log('');
+        this.log(chalk_1.default.bold(`Relations for ${source.name}:`));
+        this.log('');
+        relations.forEach((rel, index) => {
+            const scoreColor = rel.relations.score > 0.5 ? chalk_1.default.green :
+                rel.relations.score > 0.3 ? chalk_1.default.yellow :
+                    chalk_1.default.dim;
+            this.log(`${index + 1}. ${chalk_1.default.bold(rel.entity.name)} ${scoreColor(`(score: ${rel.relations.score.toFixed(2)})`)}`);
+            if (detailed) {
+                if (rel.relations.dependencies.length > 0) {
+                    this.log(chalk_1.default.dim(`   Dependencies: ${rel.relations.dependencies.join(', ')}`));
+                }
+                if (rel.relations.sharedFiles.length > 0) {
+                    this.log(chalk_1.default.dim(`   Shared: ${rel.relations.sharedFiles.join(', ')}`));
+                }
+                if (rel.relations.gitReferences.length > 0) {
+                    this.log(chalk_1.default.dim(`   Git: ${rel.relations.gitReferences.join(', ')}`));
+                }
+            }
+        });
+        this.log('');
+        this.log(chalk_1.default.dim('Tip: Use --detailed flag for more information'));
+    }
+}
+exports.default = Related;

package/dist/commands/repos.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../base-command';
+export default class Repos 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>;
+        status: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        accessible: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private displayRepos;
+    private displayRepoInfo;
+}

package/dist/commands/repos.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs = tslib_1.__importStar(require("fs"));
+class Repos extends base_command_1.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 = {
+        type: core_1.Flags.string({
+            char: 't',
+            description: 'filter by entity type',
+            options: ['client', 'prospect', 'company', 'initiative', 'system', 'delivery', 'module', 'service', 'tool'],
+        }),
+        status: core_1.Flags.boolean({
+            char: 's',
+            description: 'show git status for each repository',
+            default: false,
+        }),
+        json: core_1.Flags.boolean({
+            description: 'output as JSON',
+            default: false,
+        }),
+        accessible: core_1.Flags.boolean({
+            char: 'a',
+            description: 'show only accessible repositories (with valid paths)',
+            default: false,
+        }),
+    };
+    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 = {
+                name: entity.name,
+                type: entity.type,
+                path: entity.path,
+                absolutePath: entityPath,
+                exists: fs.existsSync(entityPath),
+                isGitRepo: false,
+                status: null,
+                metadata: entity.metadata || {}
+            };
+            if (repoInfo.exists) {
+                try {
+                    repoInfo.isGitRepo = await this.gitService.isRepository(entityPath);
+                    if (repoInfo.isGitRepo && flags.status) {
+                        repoInfo.status = await this.gitService.getStatus(entityPath);
+                    }
+                }
+                catch (error) {
+                    // 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);
+    }
+    async displayRepos(repos, showStatus) {
+        const currentFocus = await this.focusService.getCurrentFocus();
+        const focusedEntityNames = currentFocus?.entities?.map(e => e.name) || [];
+        this.log(chalk_1.default.bold('\n📁 Workspace Repositories'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        // Group by type
+        const byType = repos.reduce((acc, repo) => {
+            if (!acc[repo.type])
+                acc[repo.type] = [];
+            acc[repo.type].push(repo);
+            return acc;
+        }, {});
+        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_1.default.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_1.default.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_1.default.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}`);
+            }
+        }
+    }
+    displayRepoInfo(repo, showStatus, isFocused) {
+        const emoji = this.getTypeEmoji(repo.type);
+        const focusIndicator = isFocused ? chalk_1.default.yellow('●') : ' ';
+        const accessIndicator = repo.exists ? (repo.isGitRepo ? '📁' : '📂') : '❌';
+        let line = `  ${focusIndicator} ${emoji} ${chalk_1.default.cyan(repo.name)} ${accessIndicator}`;
+        // Add path info
+        line += ` ${chalk_1.default.dim(repo.path)}`;
+        // Add business info for clients
+        if (repo.type === 'client' && repo.metadata.business) {
+            const business = repo.metadata.business;
+            if (business.status) {
+                line += ` ${chalk_1.default.dim(`(${business.status})`)}`;
+            }
+        }
+        this.log(line);
+        // Show git status if requested
+        if (showStatus && repo.status) {
+            const status = repo.status;
+            if (status.hasChanges) {
+                if (status.changes.length > 0) {
+                    this.log(`    ${chalk_1.default.yellow('M')} ${status.changes.length} modified`);
+                }
+                if (status.untracked.length > 0) {
+                    this.log(`    ${chalk_1.default.green('A')} ${status.untracked.length} untracked`);
+                }
+            }
+            else {
+                this.log(`    ${chalk_1.default.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_1.default.blue('Remote:')} ${ahead} ${behind}`.trim());
+            }
+        }
+        // Show metadata highlights
+        if (repo.metadata.relationships) {
+            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_1.default.dim('Relationships:')} ${chalk_1.default.dim(info.join(', '))}`);
+            }
+        }
+    }
+}
+exports.default = Repos;

package/dist/commands/stack.d.ts

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

package/dist/commands/stack.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class Stack extends base_command_1.BaseCommand {
+    static description = 'Show and manage the focus stack';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --clear',
+    ];
+    static flags = {
+        clear: core_1.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 stack = this.focusService.getFocusStack();
+            if (stack.length === 0) {
+                this.log('Focus stack is already empty');
+                return;
+            }
+            // Note: We'd need to add a clearStack method to FocusService
+            this.log(`✓ Cleared ${stack.length} items from focus stack`);
+            return;
+        }
+        // Show current focus stack
+        const currentFocus = await this.focusService.getCurrentFocus();
+        const focusStack = this.focusService.getFocusStack();
+        this.log(chalk_1.default.bold('\n📚 Focus Stack'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        // Show current focus
+        if (currentFocus) {
+            const description = await this.focusService.getFocusDescription();
+            this.log(`${chalk_1.default.green('▸ Current:')} ${description}`);
+        }
+        else {
+            this.log(`${chalk_1.default.dim('▸ Current:')} No focus set`);
+        }
+        // Show stack items
+        if (focusStack.length > 0) {
+            this.log(`\n${chalk_1.default.yellow('Stack:')}`);
+            focusStack.forEach((focus, index) => {
+                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_1.default.dim(`${index + 1}.`)} ${entities}${modeText} ${chalk_1.default.dim(`- ${timeAgo}`)}`);
+            });
+            this.log(chalk_1.default.dim('\nUse "gut back" to pop from stack and return to previous focus'));
+        }
+        else {
+            this.log(`\n${chalk_1.default.dim('Stack is empty')}`);
+        }
+        // Show usage tips
+        this.log(chalk_1.default.dim('\n─'.repeat(50)));
+        this.log(chalk_1.default.dim('Tips:'));
+        this.log(chalk_1.default.dim('• Use "gut focus <entity> --remember" to push current focus to stack'));
+        this.log(chalk_1.default.dim('• Use "gut back" to return to previous focus'));
+        this.log(chalk_1.default.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';
+    }
+}
+exports.default = Stack;

package/dist/commands/status.d.ts

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