@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/commands/insights.js

@@ -0,0 +1,465 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+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 Insights extends BaseCommand {
+    static description = 'Display analytics and insights about the workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --detailed',
+        '<%= config.bin %> <%= command.id %> --format json',
+    ];
+    static flags = {
+        detailed: Flags.boolean({
+            char: 'd',
+            default: false,
+            description: 'Show detailed statistics for each entity',
+        }),
+        format: Flags.string({
+            char: 'f',
+            default: 'table',
+            description: 'Output format',
+            options: ['table', 'json', 'summary'],
+        }),
+        'include-ignored': Flags.boolean({
+            default: false,
+            description: 'Include gitignored files in statistics',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Insights);
+        const { detailed, format, 'include-ignored': includeIgnored } = flags;
+        const spinner = ora('Analyzing workspace').start();
+        try {
+            const entities = await this.entityService.listEntities();
+            if (entities.length === 0) {
+                spinner.fail('No entities found in workspace');
+                this.log(chalk.yellow('Initialize your workspace with: gut init'));
+                return;
+            }
+            const entityStats = [];
+            for (const entity of entities) {
+                const stats = await this.analyzeEntity(entity, includeIgnored);
+                entityStats.push({ entity, stats });
+            }
+            const workspaceStats = this.calculateWorkspaceStats(entityStats);
+            spinner.succeed('Analysis complete');
+            switch (format) {
+                case 'json': {
+                    this.printJSON(workspaceStats, entityStats);
+                    break;
+                }
+                case 'summary': {
+                    this.printSummary(workspaceStats);
+                    break;
+                }
+                default: {
+                    this.printTable(workspaceStats, entityStats, detailed);
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail();
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async analyzeEntity(entity, includeIgnored) {
+        const stats = {
+            branches: 0,
+            contributors: 0,
+            files: 0,
+            languages: new Map(),
+            lastCommit: 'N/A',
+            lines: 0,
+            size: '0B',
+            uncommitted: 0,
+        };
+        const entityPath = path.resolve(entity.path);
+        if (!fs.existsSync(entityPath)) {
+            return stats;
+        }
+        // Count files and lines
+        const fileStats = this.countFiles(entityPath, includeIgnored);
+        stats.files = fileStats.files;
+        stats.lines = fileStats.lines;
+        stats.size = this.formatSize(fileStats.size);
+        stats.languages = fileStats.languages;
+        // Git statistics
+        if (fs.existsSync(path.join(entityPath, '.git'))) {
+            try {
+                // Last commit
+                const lastCommit = execSync('git log -1 --format=%ar', {
+                    cwd: entityPath,
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).trim();
+                stats.lastCommit = lastCommit;
+                // Contributors
+                const contributors = execSync('git shortlog -sn', {
+                    cwd: entityPath,
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).split('\n').filter(l => l.trim()).length;
+                stats.contributors = contributors;
+                // Branches
+                const branches = execSync('git branch -a', {
+                    cwd: entityPath,
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).split('\n').filter(l => l.trim()).length;
+                stats.branches = branches;
+                // Uncommitted changes
+                const status = execSync('git status --porcelain', {
+                    cwd: entityPath,
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).split('\n').filter(l => l.trim()).length;
+                stats.uncommitted = status;
+            }
+            catch {
+                // Ignore git errors
+            }
+        }
+        return stats;
+    }
+    calculateWorkspaceStats(entityStats) {
+        let totalFiles = 0;
+        let totalLines = 0;
+        let totalSize = 0;
+        const allLanguages = new Map();
+        let mostActive = '';
+        let mostActiveCommit = new Date(0);
+        let leastActive = '';
+        let leastActiveCommit = new Date();
+        let largestEntity = '';
+        let largestSize = 0;
+        let smallestEntity = '';
+        let smallestSize = Infinity;
+        for (const { entity, stats } of entityStats) {
+            totalFiles += stats.files;
+            totalLines += stats.lines;
+            // Parse size back to bytes for total
+            const sizeMatch = stats.size.match(/(\d+\.?\d*)([BKMG])/);
+            if (sizeMatch) {
+                const value = Number.parseFloat(sizeMatch[1]);
+                const unit = sizeMatch[2];
+                const multipliers = {
+                    B: 1, G: 1024 * 1024 * 1024, K: 1024, M: 1024 * 1024,
+                };
+                totalSize += value * multipliers[unit];
+            }
+            // Merge languages
+            for (const [lang, count] of stats.languages.entries()) {
+                allLanguages.set(lang, (allLanguages.get(lang) || 0) + count);
+            }
+            // Track most/least active
+            if (stats.lastCommit !== 'N/A') {
+                const commitDate = this.parseRelativeDate(stats.lastCommit);
+                if (commitDate > mostActiveCommit) {
+                    mostActiveCommit = commitDate;
+                    mostActive = entity.name;
+                }
+                if (commitDate < leastActiveCommit) {
+                    leastActiveCommit = commitDate;
+                    leastActive = entity.name;
+                }
+            }
+            // Track largest/smallest
+            const entitySize = stats.files;
+            if (entitySize > largestSize) {
+                largestSize = entitySize;
+                largestEntity = entity.name;
+            }
+            if (entitySize < smallestSize && entitySize > 0) {
+                smallestSize = entitySize;
+                smallestEntity = entity.name;
+            }
+        }
+        return {
+            languages: allLanguages,
+            largestEntity,
+            leastActive,
+            mostActive,
+            smallestEntity,
+            totalEntities: entityStats.length,
+            totalFiles,
+            totalLines,
+            totalSize: this.formatSize(totalSize),
+        };
+    }
+    countFiles(dir, includeIgnored) {
+        const result = {
+            files: 0,
+            languages: new Map(),
+            lines: 0,
+            size: 0,
+        };
+        const shouldIgnore = (file) => {
+            if (includeIgnored)
+                return false;
+            const ignoredPatterns = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage'];
+            return ignoredPatterns.some(pattern => file.includes(pattern));
+        };
+        const walkDir = (currentDir) => {
+            try {
+                const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentDir, entry.name);
+                    if (shouldIgnore(fullPath))
+                        continue;
+                    if (entry.isDirectory()) {
+                        walkDir(fullPath);
+                    }
+                    else if (entry.isFile()) {
+                        result.files++;
+                        const stats = fs.statSync(fullPath);
+                        result.size += stats.size;
+                        const ext = path.extname(fullPath).toLowerCase();
+                        const lang = this.getLanguageFromExt(ext);
+                        if (lang) {
+                            result.languages.set(lang, (result.languages.get(lang) || 0) + 1);
+                        }
+                        // Count lines for text files
+                        if (this.isTextFile(fullPath)) {
+                            try {
+                                const content = fs.readFileSync(fullPath, 'utf8');
+                                result.lines += content.split('\n').length;
+                            }
+                            catch {
+                                // Ignore read errors
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore permission errors
+            }
+        };
+        walkDir(dir);
+        return result;
+    }
+    formatSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(1)}${units[unitIndex]}`;
+    }
+    getLanguageFromExt(ext) {
+        const langMap = {
+            '.bash': 'Shell',
+            '.c': 'C',
+            '.cpp': 'C++',
+            '.cs': 'C#',
+            '.css': 'CSS',
+            '.dart': 'Dart',
+            '.go': 'Go',
+            '.html': 'HTML',
+            '.java': 'Java',
+            '.js': 'JavaScript',
+            '.json': 'JSON',
+            '.jsx': 'JavaScript',
+            '.kt': 'Kotlin',
+            '.less': 'Less',
+            '.m': 'Objective-C',
+            '.md': 'Markdown',
+            '.php': 'PHP',
+            '.py': 'Python',
+            '.r': 'R',
+            '.rb': 'Ruby',
+            '.rs': 'Rust',
+            '.sass': 'Sass',
+            '.scala': 'Scala',
+            '.scss': 'SCSS',
+            '.sh': 'Shell',
+            '.sql': 'SQL',
+            '.svelte': 'Svelte',
+            '.swift': 'Swift',
+            '.ts': 'TypeScript',
+            '.tsx': 'TypeScript',
+            '.vue': 'Vue',
+            '.xml': 'XML',
+            '.yaml': 'YAML',
+            '.yml': 'YAML',
+        };
+        return langMap[ext] || null;
+    }
+    isTextFile(filePath) {
+        const textExts = [
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx',
+            '.json',
+            '.md',
+            '.txt',
+            '.yml',
+            '.yaml',
+            '.xml',
+            '.html',
+            '.css',
+            '.scss',
+            '.sass',
+            '.py',
+            '.rb',
+            '.go',
+            '.rs',
+            '.java',
+            '.c',
+            '.cpp',
+            '.h',
+            '.php',
+            '.sql',
+            '.sh',
+            '.bash',
+            '.env',
+            '.gitignore',
+        ];
+        const ext = path.extname(filePath).toLowerCase();
+        return textExts.includes(ext);
+    }
+    parseRelativeDate(relativeDate) {
+        const now = new Date();
+        const match = relativeDate.match(/(\d+)\s+(\w+)\s+ago/);
+        if (!match)
+            return now;
+        const value = Number.parseInt(match[1], 10);
+        const unit = match[2];
+        const date = new Date(now);
+        switch (unit) {
+            case 'day':
+            case 'days': {
+                date.setDate(date.getDate() - value);
+                break;
+            }
+            case 'hour':
+            case 'hours': {
+                date.setHours(date.getHours() - value);
+                break;
+            }
+            case 'minute':
+            case 'minutes': {
+                date.setMinutes(date.getMinutes() - value);
+                break;
+            }
+            case 'month':
+            case 'months': {
+                date.setMonth(date.getMonth() - value);
+                break;
+            }
+            case 'second':
+            case 'seconds': {
+                date.setSeconds(date.getSeconds() - value);
+                break;
+            }
+            case 'week':
+            case 'weeks': {
+                date.setDate(date.getDate() - (value * 7));
+                break;
+            }
+            case 'year':
+            case 'years': {
+                date.setFullYear(date.getFullYear() - value);
+                break;
+            }
+        }
+        return date;
+    }
+    printJSON(workspaceStats, entityStats) {
+        const output = {
+            entities: entityStats.map(({ entity, stats }) => ({
+                name: entity.name,
+                path: entity.path,
+                stats: {
+                    ...stats,
+                    languages: Object.fromEntries(stats.languages),
+                },
+                type: entity.type,
+            })),
+            workspace: {
+                ...workspaceStats,
+                languages: Object.fromEntries(workspaceStats.languages),
+            },
+        };
+        this.log(JSON.stringify(output, null, 2));
+    }
+    printSummary(workspaceStats) {
+        this.log('');
+        this.log(chalk.bold.blue('Workspace Summary'));
+        this.log(chalk.dim('─'.repeat(40)));
+        this.log(`Entities: ${workspaceStats.totalEntities}`);
+        this.log(`Files: ${workspaceStats.totalFiles.toLocaleString()}`);
+        this.log(`Lines: ${workspaceStats.totalLines.toLocaleString()}`);
+        this.log(`Size: ${workspaceStats.totalSize}`);
+        if (workspaceStats.languages.size > 0) {
+            const topLang = [...workspaceStats.languages.entries()]
+                .sort((a, b) => b[1] - a[1])[0];
+            this.log(`Primary Language: ${topLang[0]}`);
+        }
+        this.log(`Most Active: ${workspaceStats.mostActive || 'N/A'}`);
+        this.log(`Largest: ${workspaceStats.largestEntity || 'N/A'}`);
+    }
+    printTable(workspaceStats, entityStats, detailed) {
+        // Workspace summary
+        this.log('');
+        this.log(chalk.bold.blue('📊 Workspace Insights'));
+        this.log('');
+        const summaryTable = new Table({
+            head: [chalk.cyan('Metric'), chalk.cyan('Value')],
+            style: { border: [], head: [] },
+        });
+        summaryTable.push(['Total Entities', workspaceStats.totalEntities.toString()], ['Total Files', workspaceStats.totalFiles.toLocaleString()], ['Total Lines', workspaceStats.totalLines.toLocaleString()], ['Total Size', workspaceStats.totalSize], ['Most Active', workspaceStats.mostActive || 'N/A'], ['Largest Entity', workspaceStats.largestEntity || 'N/A']);
+        this.log(summaryTable.toString());
+        // Language distribution
+        if (workspaceStats.languages.size > 0) {
+            this.log('');
+            this.log(chalk.bold('Language Distribution:'));
+            const sortedLangs = [...workspaceStats.languages.entries()]
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 5);
+            for (const [lang, count] of sortedLangs) {
+                const percentage = ((count / workspaceStats.totalFiles) * 100).toFixed(1);
+                const bar = '█'.repeat(Math.floor(Number.parseFloat(percentage) / 2));
+                this.log(`  ${lang.padEnd(12)} ${bar} ${percentage}%`);
+            }
+        }
+        // Entity details
+        if (detailed) {
+            this.log('');
+            this.log(chalk.bold('Entity Details:'));
+            const entityTable = new Table({
+                head: [
+                    chalk.cyan('Entity'),
+                    chalk.cyan('Files'),
+                    chalk.cyan('Lines'),
+                    chalk.cyan('Size'),
+                    chalk.cyan('Last Commit'),
+                    chalk.cyan('Changes'),
+                ],
+                style: { border: [], head: [] },
+            });
+            for (const { entity, stats } of entityStats) {
+                entityTable.push([
+                    entity.name,
+                    stats.files.toString(),
+                    stats.lines.toLocaleString(),
+                    stats.size,
+                    stats.lastCommit,
+                    stats.uncommitted > 0 ? chalk.yellow(stats.uncommitted.toString()) : '0',
+                ]);
+            }
+            this.log(entityTable.toString());
+        }
+        this.log('');
+        this.log(chalk.dim('Tip: Use --detailed flag for per-entity statistics'));
+    }
+}

package/dist/commands/patterns.d.ts

@@ -0,0 +1,40 @@
+import { BaseCommand } from '../base-command.js';
+export default class Patterns extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        entity: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        mode: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private analyzeCollaborationPatterns;
+    private analyzeCrossEntityPatterns;
+    private analyzeEntityPatterns;
+    private analyzeFilePatterns;
+    private analyzeModePatterns;
+    private analyzePatterns;
+    private analyzeRelationshipPatterns;
+    private analyzeTypePatterns;
+    private calculateTypicalDuration;
+    private displayEntityPatterns;
+    private displayModePatterns;
+    private displayPatterns;
+    private displayProductivityPatterns;
+    private displayTemporalPatterns;
+    private displayTypePatterns;
+    private findDependencyChains;
+    private findSharedSystems;
+    private findSimilarClusters;
+    private findWorkflowSimilarities;
+    private generateProductivityPatterns;
+    private generateTemporalPatterns;
+    private getCommonModes;
+    private getCommonTools;
+    private getOptimalDuration;
+    private getSuccessIndicators;
+    private getSuccessMetrics;
+    private getTransitionPatterns;
+    private getTypicalActivities;
+}