@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/commands/graph.js

@@ -0,0 +1,273 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Graph extends BaseCommand {
+    static description = 'Visualize repository relationships and dependencies';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --format ascii',
+        '<%= config.bin %> <%= command.id %> --focus-only',
+    ];
+    static flags = {
+        depth: Flags.integer({
+            char: 'd',
+            default: 2,
+            description: 'maximum depth of relationships to show',
+        }),
+        'focus-only': Flags.boolean({
+            default: false,
+            description: 'show only focused entities and their relationships',
+        }),
+        format: Flags.string({
+            char: 'f',
+            default: 'ascii',
+            description: 'output format',
+            options: ['ascii', 'dot', 'json'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Graph);
+        const entities = flags['focus-only']
+            ? await this.focusService.getFocusedEntities()
+            : this.entityService.getAllEntities();
+        if (entities.length === 0) {
+            this.error('No entities found. Add entities first or set focus.');
+        }
+        this.log(chalk.bold('\n🕸️  Repository Relationship Graph'));
+        this.log(chalk.dim('─'.repeat(50)));
+        const graph = await this.buildRelationshipGraph(entities, flags.depth);
+        switch (flags.format) {
+            case 'ascii': {
+                this.displayAsciiGraph(graph);
+                break;
+            }
+            case 'dot': {
+                this.displayDotGraph(graph);
+                break;
+            }
+            case 'json': {
+                this.log(JSON.stringify(graph, null, 2));
+                break;
+            }
+        }
+    }
+    async buildRelationshipGraph(entities, _maxDepth) {
+        const nodes = new Map();
+        const edges = [];
+        // Build nodes
+        for (const entity of entities) {
+            nodes.set(entity.name, {
+                metadata: entity.metadata || {},
+                name: entity.name,
+                path: entity.path,
+                type: entity.type,
+            });
+        }
+        // Build edges from metadata relationships
+        for (const entity of entities) {
+            const { metadata } = entity;
+            if (!metadata?.relationships)
+                continue;
+            // Direct dependencies
+            if (metadata.relationships.dependent_systems) {
+                for (const dep of metadata.relationships.dependent_systems) {
+                    edges.push({
+                        from: entity.name,
+                        to: dep,
+                        type: 'depends_on',
+                        weight: 1,
+                    });
+                }
+            }
+            // Similar entities
+            if (metadata.relationships.similar_entities) {
+                for (const similar of metadata.relationships.similar_entities) {
+                    edges.push({
+                        from: entity.name,
+                        to: similar,
+                        type: 'similar_to',
+                        weight: 0.5,
+                    });
+                }
+            }
+            // Related initiatives
+            if (metadata.relationships.related_initiatives) {
+                for (const initiative of metadata.relationships.related_initiatives) {
+                    edges.push({
+                        from: entity.name,
+                        to: initiative,
+                        type: 'part_of',
+                        weight: 0.7,
+                    });
+                }
+            }
+        }
+        // Infer additional relationships
+        this.inferRelationships([...nodes.values()], edges);
+        return {
+            edges,
+            nodes: [...nodes.values()],
+        };
+    }
+    displayAsciiGraph(graph) {
+        const { edges, nodes } = graph;
+        // Group nodes by type
+        const byType = {};
+        for (const node of nodes) {
+            if (!byType[node.type])
+                byType[node.type] = [];
+            byType[node.type].push(node);
+        }
+        // Display nodes by type
+        const typeOrder = ['client', 'prospect', 'company', 'initiative', 'system'];
+        for (const type of typeOrder) {
+            if (!byType[type])
+                continue;
+            this.log(`\n${chalk.bold(type.toUpperCase())}:`);
+            for (const node of byType[type]) {
+                const emoji = this.getTypeEmoji(node.type);
+                this.log(`  ${emoji} ${chalk.cyan(node.name)}`);
+                // Show outgoing relationships
+                const outgoing = edges.filter((e) => e.from === node.name);
+                for (const edge of outgoing) {
+                    const relationshipIcon = this.getRelationshipIcon(edge.type);
+                    const targetNode = nodes.find((n) => n.name === edge.to);
+                    const targetEmoji = targetNode ? this.getTypeEmoji(targetNode.type) : '📁';
+                    this.log(`    ${relationshipIcon} ${targetEmoji} ${edge.to} ${chalk.dim(`(${edge.type})`)}`);
+                }
+            }
+        }
+        // Show relationship summary
+        this.log(chalk.bold('\n📊 Relationship Summary:'));
+        const relationshipCounts = {};
+        for (const edge of edges) {
+            relationshipCounts[edge.type] = (relationshipCounts[edge.type] || 0) + 1;
+        }
+        for (const [type, count] of Object.entries(relationshipCounts)) {
+            this.log(`  ${this.getRelationshipIcon(type)} ${type}: ${count}`);
+        }
+    }
+    displayDotGraph(graph) {
+        const { edges, nodes } = graph;
+        this.log('digraph EntityGraph {');
+        this.log('  rankdir=TB;');
+        this.log('  node [shape=box, style=rounded];');
+        this.log('');
+        // Nodes
+        for (const node of nodes) {
+            const color = this.getNodeColor(node.type);
+            this.log(`  "${node.name}" [label="${node.name}\\n(${node.type})", fillcolor="${color}", style=filled];`);
+        }
+        this.log('');
+        // Edges
+        for (const edge of edges) {
+            const style = edge.type.includes('likely') ? 'dashed' : 'solid';
+            const color = this.getEdgeColor(edge.type);
+            this.log(`  "${edge.from}" -> "${edge.to}" [label="${edge.type}", style=${style}, color="${color}"];`);
+        }
+        this.log('}');
+    }
+    getEdgeColor(type) {
+        switch (type) {
+            case 'depends_on': {
+                return 'red';
+            }
+            case 'likely_depends_on': {
+                return 'orange';
+            }
+            case 'part_of': {
+                return 'green';
+            }
+            case 'similar_to': {
+                return 'blue';
+            }
+            case 'uses_shared': {
+                return 'purple';
+            }
+            default: {
+                return 'black';
+            }
+        }
+    }
+    getNodeColor(type) {
+        switch (type) {
+            case 'client': {
+                return 'lightblue';
+            }
+            case 'company': {
+                return 'lightgreen';
+            }
+            case 'initiative': {
+                return 'lightcoral';
+            }
+            case 'prospect': {
+                return 'lightyellow';
+            }
+            case 'system': {
+                return 'lightgray';
+            }
+            default: {
+                return 'white';
+            }
+        }
+    }
+    getRelationshipIcon(type) {
+        switch (type) {
+            case 'depends_on': {
+                return '🔗';
+            }
+            case 'likely_depends_on': {
+                return '🔗';
+            }
+            case 'part_of': {
+                return '📋';
+            }
+            case 'similar_to': {
+                return '🔄';
+            }
+            case 'uses_shared': {
+                return '📚';
+            }
+            default: {
+                return '→';
+            }
+        }
+    }
+    inferRelationships(nodes, edges) {
+        // Infer system dependencies
+        const systems = nodes.filter(n => n.type === 'system');
+        const clients = nodes.filter(n => n.type === 'client');
+        // All clients likely depend on systems
+        for (const client of clients) {
+            for (const system of systems) {
+                // Don't add if relationship already exists
+                const exists = edges.some(e => e.from === client.name && e.to === system.name);
+                if (!exists) {
+                    edges.push({
+                        from: client.name,
+                        to: system.name,
+                        type: 'likely_depends_on',
+                        weight: 0.3,
+                    });
+                }
+            }
+        }
+        // Infer shared dependencies
+        const sharedSystems = systems.filter(s => s.name.includes('shared') || s.name.includes('common'));
+        for (const shared of sharedSystems) {
+            for (const entity of nodes) {
+                if (entity.type === 'client' || entity.type === 'delivery') {
+                    const exists = edges.some(e => e.from === entity.name && e.to === shared.name);
+                    if (!exists) {
+                        edges.push({
+                            from: entity.name,
+                            to: shared.name,
+                            type: 'uses_shared',
+                            weight: 0.4,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../base-command.js';
+export default class Init extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected get requiresInit(): boolean;
+    run(): Promise<void>;
+}

package/dist/commands/init.js

@@ -0,0 +1,75 @@
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { BaseCommand } from '../base-command.js';
+export default class Init extends BaseCommand {
+    static description = 'Initialize a gut workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            description: 'force initialization even if already initialized',
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            default: process.cwd(),
+            description: 'workspace root directory',
+        }),
+    };
+    get requiresInit() {
+        return false; // This command doesn't require initialization
+    }
+    async run() {
+        const { flags } = await this.parse(Init);
+        // Check if already initialized
+        if (this.configService.isInitialized() && !flags.force) {
+            this.log('Workspace already initialized. Use --force to reinitialize.');
+            return;
+        }
+        this.log('🚀 Initializing gut workspace...\n');
+        // Create .gut directory
+        const gutDir = this.configService.getGutDir();
+        if (!fs.existsSync(gutDir)) {
+            fs.mkdirSync(gutDir, { recursive: true });
+            this.log('✓ Created .gut directory');
+        }
+        // Discover entities
+        this.log('\n🔍 Discovering entities...');
+        const discovered = this.entityService.discoverEntities();
+        if (discovered.length > 0) {
+            this.log(`Found ${discovered.length} potential entities:`);
+            this.printEntityList(discovered);
+        }
+        // Save configuration with discovered entities (or empty list)
+        const config = {
+            entities: discovered,
+            initialized: true,
+            workspace: flags.workspace,
+        };
+        this.configService.saveConfig(config);
+        if (discovered.length > 0) {
+            this.log('\n✓ Configuration saved');
+        }
+        else {
+            this.log('No entities discovered. You can add them manually with "gut entity add"');
+        }
+        // Add .gut to .gitignore if it exists
+        const gitignorePath = path.join(flags.workspace, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            const gitignore = fs.readFileSync(gitignorePath, 'utf8');
+            if (!gitignore.includes('.gut')) {
+                fs.appendFileSync(gitignorePath, '\n# Gut workspace files\n.gut/\n');
+                this.log('✓ Added .gut to .gitignore');
+            }
+        }
+        this.log('\n✅ Workspace initialized successfully!');
+        this.log('\nNext steps:');
+        this.log('  • Review discovered entities: gut entity list');
+        this.log('  • Add more entities: gut entity add <type> <name> --path <path>');
+        this.log('  • Set focus: gut focus <entity>');
+        this.log('  • Get help: gut help');
+    }
+}

package/dist/commands/insights.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../base-command.js';
+export default class Insights extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        detailed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'include-ignored': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private analyzeEntity;
+    private calculateWorkspaceStats;
+    private countFiles;
+    private formatSize;
+    private getLanguageFromExt;
+    private isTextFile;
+    private parseRelativeDate;
+    private printJSON;
+    private printSummary;
+    private printTable;
+}