@hyperdrive.bot/gut 0.1.4 → 0.1.6

package/dist/commands/audit.js

@@ -1,593 +0,0 @@
-"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"));
-const path = tslib_1.__importStar(require("path"));
-class Audit extends base_command_1.BaseCommand {
-    static description = 'Access and change audit across workspace';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --entity mindtools',
-        '<%= config.bin %> <%= command.id %> --security',
-        '<%= config.bin %> <%= command.id %> --compliance',
-    ];
-    static flags = {
-        entity: core_1.Flags.string({
-            char: 'e',
-            description: 'audit specific entity',
-        }),
-        security: core_1.Flags.boolean({
-            char: 's',
-            description: 'focus on security audit',
-            default: false,
-        }),
-        compliance: core_1.Flags.boolean({
-            char: 'c',
-            description: 'focus on compliance audit',
-            default: false,
-        }),
-        access: core_1.Flags.boolean({
-            char: 'a',
-            description: 'audit access patterns and permissions',
-            default: false,
-        }),
-        changes: core_1.Flags.boolean({
-            description: 'audit recent changes and activity',
-            default: false,
-        }),
-        json: core_1.Flags.boolean({
-            description: 'output as JSON',
-            default: false,
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(Audit);
-        let entities = [];
-        if (flags.entity) {
-            const entity = this.entityService.findEntity(flags.entity);
-            if (!entity) {
-                this.error(`Entity '${flags.entity}' not found`);
-            }
-            entities = [entity];
-        }
-        else {
-            entities = this.entityService.getAllEntities();
-        }
-        if (entities.length === 0) {
-            this.error('No entities found to audit');
-        }
-        const auditResults = await this.performAudit(entities, flags);
-        if (flags.json) {
-            this.log(JSON.stringify(auditResults, null, 2));
-            return;
-        }
-        this.displayAuditResults(auditResults, flags);
-    }
-    async performAudit(entities, flags) {
-        const results = {
-            timestamp: new Date().toISOString(),
-            scope: {
-                entities: entities.map(e => e.name),
-                audit_types: this.getAuditTypes(flags)
-            },
-            findings: [],
-            summary: {
-                total_entities: entities.length,
-                issues_found: 0,
-                security_issues: 0,
-                compliance_issues: 0,
-                access_issues: 0
-            }
-        };
-        for (const entity of entities) {
-            const entityAudit = await this.auditEntity(entity, flags);
-            results.findings.push(entityAudit);
-            // Update summary
-            results.summary.issues_found += entityAudit.issues.length;
-            results.summary.security_issues += entityAudit.security_issues.length;
-            results.summary.compliance_issues += entityAudit.compliance_issues.length;
-            results.summary.access_issues += entityAudit.access_issues.length;
-        }
-        return results;
-    }
-    async auditEntity(entity, flags) {
-        const entityPath = this.entityService.resolveEntityPath(entity);
-        const audit = {
-            entity: entity.name,
-            type: entity.type,
-            path: entity.path,
-            timestamp: new Date().toISOString(),
-            exists: fs.existsSync(entityPath),
-            issues: [],
-            security_issues: [],
-            compliance_issues: [],
-            access_issues: [],
-            metadata_audit: {},
-            git_audit: {},
-            file_audit: {}
-        };
-        if (!audit.exists) {
-            audit.issues.push({
-                type: 'missing_entity',
-                severity: 'high',
-                message: 'Entity path does not exist',
-                path: entityPath
-            });
-            return audit;
-        }
-        // Metadata audit
-        audit.metadata_audit = await this.auditMetadata(entity);
-        // Git audit
-        if (await this.gitService.isRepository(entityPath)) {
-            audit.git_audit = await this.auditGitRepository(entityPath);
-        }
-        // File structure audit
-        audit.file_audit = await this.auditFileStructure(entityPath, entity.type);
-        // Security audit
-        if (flags.security || !this.hasSpecificAuditType(flags)) {
-            audit.security_issues = await this.performSecurityAudit(entityPath, entity);
-        }
-        // Compliance audit
-        if (flags.compliance || !this.hasSpecificAuditType(flags)) {
-            audit.compliance_issues = await this.performComplianceAudit(entity);
-        }
-        // Access audit
-        if (flags.access || !this.hasSpecificAuditType(flags)) {
-            audit.access_issues = await this.performAccessAudit(entity);
-        }
-        return audit;
-    }
-    async auditMetadata(entity) {
-        const issues = [];
-        const metadata = entity.metadata || {};
-        // Check required metadata fields
-        if (entity.type === 'client') {
-            if (!metadata.business?.primary_contact) {
-                issues.push({
-                    type: 'missing_metadata',
-                    field: 'business.primary_contact',
-                    severity: 'medium',
-                    message: 'Client entity missing primary contact information'
-                });
-            }
-            if (!metadata.business?.contract_value) {
-                issues.push({
-                    type: 'missing_metadata',
-                    field: 'business.contract_value',
-                    severity: 'low',
-                    message: 'Client entity missing contract value'
-                });
-            }
-        }
-        // Check metadata file existence
-        const entityPath = this.entityService.resolveEntityPath(entity);
-        const metadataPath = path.join(entityPath, '.entity.yaml');
-        return {
-            has_metadata_file: fs.existsSync(metadataPath),
-            metadata_completeness: this.calculateMetadataCompleteness(metadata, entity.type),
-            issues: issues
-        };
-    }
-    async auditGitRepository(repoPath) {
-        const audit = {
-            is_git_repo: true,
-            issues: []
-        };
-        try {
-            // Check git status
-            const status = await this.gitService.getStatus(repoPath);
-            audit.status = status;
-            // Check for uncommitted changes
-            if (status.hasChanges) {
-                audit.issues.push({
-                    type: 'uncommitted_changes',
-                    severity: 'low',
-                    message: `Repository has ${status.changes.length} uncommitted changes`
-                });
-            }
-            // Check remote configuration
-            try {
-                const remotes = await this.gitService.exec(['remote', '-v'], { cwd: repoPath });
-                audit.has_remote = remotes.length > 0;
-                if (!audit.has_remote) {
-                    audit.issues.push({
-                        type: 'no_remote',
-                        severity: 'medium',
-                        message: 'Repository has no remote configured'
-                    });
-                }
-            }
-            catch {
-                audit.has_remote = false;
-            }
-            // Check branch information
-            try {
-                const branch = await this.gitService.exec(['branch', '--show-current'], { cwd: repoPath });
-                audit.current_branch = branch.trim();
-                if (audit.current_branch === 'master' || audit.current_branch === 'main') {
-                    // Check if working directly on main branch
-                    if (status.hasChanges) {
-                        audit.issues.push({
-                            type: 'working_on_main',
-                            severity: 'medium',
-                            message: 'Working directly on main/master branch with uncommitted changes'
-                        });
-                    }
-                }
-            }
-            catch {
-                // Ignore branch check errors
-            }
-        }
-        catch (error) {
-            audit.issues.push({
-                type: 'git_error',
-                severity: 'high',
-                message: `Git audit failed: ${error.message}`
-            });
-        }
-        return audit;
-    }
-    async auditFileStructure(entityPath, entityType) {
-        const audit = {
-            structure_score: 0,
-            issues: [],
-            recommendations: []
-        };
-        try {
-            const files = fs.readdirSync(entityPath);
-            // Check for common files based on entity type
-            const expectedFiles = this.getExpectedFiles(entityType);
-            for (const expectedFile of expectedFiles) {
-                if (!files.includes(expectedFile.name)) {
-                    audit.issues.push({
-                        type: 'missing_file',
-                        severity: expectedFile.required ? 'medium' : 'low',
-                        message: `Missing ${expectedFile.description}: ${expectedFile.name}`
-                    });
-                }
-            }
-            // Check for documentation
-            const hasReadme = files.some(f => f.toLowerCase().startsWith('readme'));
-            if (!hasReadme) {
-                audit.recommendations.push('Add README.md file for documentation');
-            }
-            // Check for configuration files
-            const hasConfig = files.some(f => f.includes('config') || f.includes('.env'));
-            audit.has_configuration = hasConfig;
-            audit.structure_score = this.calculateStructureScore(files, expectedFiles);
-        }
-        catch (error) {
-            audit.issues.push({
-                type: 'file_audit_error',
-                severity: 'high',
-                message: `File structure audit failed: ${error.message}`
-            });
-        }
-        return audit;
-    }
-    async performSecurityAudit(entityPath, entity) {
-        const issues = [];
-        // Check for sensitive files
-        const sensitivePatterns = [
-            '.env',
-            'secrets',
-            'private',
-            'credentials',
-            'password',
-            'key',
-            'token'
-        ];
-        try {
-            const files = this.getAllFiles(entityPath);
-            for (const file of files) {
-                const fileName = path.basename(file).toLowerCase();
-                for (const pattern of sensitivePatterns) {
-                    if (fileName.includes(pattern)) {
-                        issues.push({
-                            type: 'sensitive_file',
-                            severity: 'high',
-                            message: `Potentially sensitive file found: ${file}`,
-                            file: file
-                        });
-                    }
-                }
-            }
-            // Check for .gitignore
-            const gitignorePath = path.join(entityPath, '.gitignore');
-            if (!fs.existsSync(gitignorePath)) {
-                issues.push({
-                    type: 'missing_gitignore',
-                    severity: 'medium',
-                    message: 'No .gitignore file found'
-                });
-            }
-        }
-        catch (error) {
-            issues.push({
-                type: 'security_audit_error',
-                severity: 'high',
-                message: `Security audit failed: ${error.message}`
-            });
-        }
-        return issues;
-    }
-    async performComplianceAudit(entity) {
-        const issues = [];
-        const metadata = entity.metadata || {};
-        // Check business compliance for client entities
-        if (entity.type === 'client') {
-            if (!metadata.business?.status) {
-                issues.push({
-                    type: 'missing_business_status',
-                    severity: 'medium',
-                    message: 'Client entity missing business status'
-                });
-            }
-            // Check for required documentation
-            const entityPath = this.entityService.resolveEntityPath(entity);
-            const requiredDocs = ['README.md', '.entity.yaml'];
-            for (const doc of requiredDocs) {
-                const docPath = path.join(entityPath, doc);
-                if (!fs.existsSync(docPath)) {
-                    issues.push({
-                        type: 'missing_documentation',
-                        severity: 'medium',
-                        message: `Required documentation missing: ${doc}`
-                    });
-                }
-            }
-        }
-        // Check metadata completeness
-        const completeness = this.calculateMetadataCompleteness(metadata, entity.type);
-        if (completeness < 0.7) {
-            issues.push({
-                type: 'incomplete_metadata',
-                severity: 'low',
-                message: `Entity metadata only ${Math.round(completeness * 100)}% complete`
-            });
-        }
-        return issues;
-    }
-    async performAccessAudit(entity) {
-        const issues = [];
-        // Check path accessibility
-        const entityPath = this.entityService.resolveEntityPath(entity);
-        try {
-            const stats = fs.statSync(entityPath);
-            // Check if path is accessible
-            if (!stats.isDirectory()) {
-                issues.push({
-                    type: 'invalid_path',
-                    severity: 'high',
-                    message: 'Entity path is not a directory'
-                });
-            }
-            // Check permissions (basic check)
-            try {
-                fs.accessSync(entityPath, fs.constants.R_OK | fs.constants.W_OK);
-            }
-            catch {
-                issues.push({
-                    type: 'permission_issue',
-                    severity: 'high',
-                    message: 'Insufficient permissions for entity path'
-                });
-            }
-        }
-        catch (error) {
-            issues.push({
-                type: 'access_error',
-                severity: 'high',
-                message: `Cannot access entity path: ${error.message}`
-            });
-        }
-        // Check for private/business separation
-        if (entity.type === 'client') {
-            const hasPrivate = entity.path.includes('private') || entity.path.includes('business');
-            const metadata = entity.metadata || {};
-            if (metadata.business && !hasPrivate) {
-                issues.push({
-                    type: 'missing_private_separation',
-                    severity: 'medium',
-                    message: 'Client entity with business data should have private/business separation'
-                });
-            }
-        }
-        return issues;
-    }
-    displayAuditResults(results, flags) {
-        this.log(chalk_1.default.bold('\n🔍 Workspace Audit Report'));
-        this.log(chalk_1.default.dim('─'.repeat(50)));
-        this.log(`📅 Generated: ${new Date(results.timestamp).toLocaleString()}`);
-        this.log(`📊 Scope: ${results.scope.entities.length} entities`);
-        this.log(`🎯 Audit Types: ${results.scope.audit_types.join(', ')}`);
-        this.log('');
-        // Summary
-        this.log(chalk_1.default.bold('📋 Summary:'));
-        const summary = results.summary;
-        if (summary.issues_found === 0) {
-            this.log(chalk_1.default.green('✅ No issues found'));
-        }
-        else {
-            this.log(`⚠️  Total Issues: ${chalk_1.default.yellow(summary.issues_found)}`);
-            if (summary.security_issues > 0) {
-                this.log(`🔒 Security Issues: ${chalk_1.default.red(summary.security_issues)}`);
-            }
-            if (summary.compliance_issues > 0) {
-                this.log(`📋 Compliance Issues: ${chalk_1.default.yellow(summary.compliance_issues)}`);
-            }
-            if (summary.access_issues > 0) {
-                this.log(`🔐 Access Issues: ${chalk_1.default.red(summary.access_issues)}`);
-            }
-        }
-        this.log('');
-        // Detailed findings
-        for (const finding of results.findings) {
-            this.displayEntityAudit(finding);
-        }
-        // Recommendations
-        this.displayRecommendations(results);
-    }
-    displayEntityAudit(audit) {
-        const emoji = this.getTypeEmoji(audit.type);
-        const issueCount = audit.issues.length + audit.security_issues.length +
-            audit.compliance_issues.length + audit.access_issues.length;
-        const statusIcon = issueCount === 0 ? chalk_1.default.green('✅') :
-            issueCount < 3 ? chalk_1.default.yellow('⚠️') : chalk_1.default.red('❌');
-        this.log(`${emoji} ${chalk_1.default.bold(audit.entity)} ${statusIcon}`);
-        if (!audit.exists) {
-            this.log(`  ${chalk_1.default.red('❌ Entity path does not exist')}`);
-            return;
-        }
-        // Show critical issues
-        const criticalIssues = [
-            ...audit.issues,
-            ...audit.security_issues,
-            ...audit.compliance_issues,
-            ...audit.access_issues
-        ].filter(issue => issue.severity === 'high');
-        if (criticalIssues.length > 0) {
-            this.log(`  ${chalk_1.default.red('🚨 Critical Issues:')}`);
-            criticalIssues.forEach(issue => {
-                this.log(`    • ${issue.message}`);
-            });
-        }
-        // Show metadata completeness
-        if (audit.metadata_audit?.metadata_completeness !== undefined) {
-            const completeness = Math.round(audit.metadata_audit.metadata_completeness * 100);
-            const color = completeness >= 80 ? chalk_1.default.green : completeness >= 60 ? chalk_1.default.yellow : chalk_1.default.red;
-            this.log(`  📊 Metadata: ${color(`${completeness}% complete`)}`);
-        }
-        // Show git status
-        if (audit.git_audit?.is_git_repo) {
-            const gitStatus = audit.git_audit.status?.hasChanges ?
-                chalk_1.default.yellow('uncommitted changes') : chalk_1.default.green('clean');
-            this.log(`  📁 Git: ${gitStatus}`);
-        }
-        this.log('');
-    }
-    displayRecommendations(results) {
-        const allRecommendations = [];
-        // Collect recommendations from all findings
-        for (const finding of results.findings) {
-            if (finding.file_audit?.recommendations) {
-                allRecommendations.push(...finding.file_audit.recommendations);
-            }
-        }
-        if (allRecommendations.length > 0) {
-            this.log(chalk_1.default.bold('💡 Recommendations:'));
-            const uniqueRecommendations = [...new Set(allRecommendations)];
-            uniqueRecommendations.forEach(rec => {
-                this.log(`  • ${rec}`);
-            });
-        }
-    }
-    // Helper methods
-    getAuditTypes(flags) {
-        const types = [];
-        if (flags.security)
-            types.push('security');
-        if (flags.compliance)
-            types.push('compliance');
-        if (flags.access)
-            types.push('access');
-        if (flags.changes)
-            types.push('changes');
-        if (types.length === 0)
-            types.push('general');
-        return types;
-    }
-    hasSpecificAuditType(flags) {
-        return flags.security || flags.compliance || flags.access || flags.changes;
-    }
-    calculateMetadataCompleteness(metadata, entityType) {
-        const requiredFields = this.getRequiredMetadataFields(entityType);
-        let completedFields = 0;
-        for (const field of requiredFields) {
-            if (this.hasNestedField(metadata, field)) {
-                completedFields++;
-            }
-        }
-        return requiredFields.length > 0 ? completedFields / requiredFields.length : 1;
-    }
-    getRequiredMetadataFields(entityType) {
-        const fields = {
-            client: ['business.primary_contact', 'business.status', 'relationships.dependent_systems'],
-            prospect: ['business.status', 'relationships.similar_entities'],
-            company: ['business.status'],
-            initiative: ['relationships.related_initiatives'],
-            system: ['relationships.dependent_systems']
-        };
-        return fields[entityType] || [];
-    }
-    hasNestedField(obj, fieldPath) {
-        const parts = fieldPath.split('.');
-        let current = obj;
-        for (const part of parts) {
-            if (!current || typeof current !== 'object' || !(part in current)) {
-                return false;
-            }
-            current = current[part];
-        }
-        return current !== undefined && current !== null && current !== '';
-    }
-    getExpectedFiles(entityType) {
-        const common = [
-            { name: '.entity.yaml', required: true, description: 'Entity metadata' },
-            { name: 'README.md', required: false, description: 'Documentation' }
-        ];
-        const typeSpecific = {
-            client: [
-                { name: 'package.json', required: false, description: 'Project configuration' },
-                { name: '.gitignore', required: true, description: 'Git ignore rules' }
-            ],
-            system: [
-                { name: 'package.json', required: true, description: 'Project configuration' },
-                { name: '.gitignore', required: true, description: 'Git ignore rules' }
-            ]
-        };
-        return [...common, ...(typeSpecific[entityType] || [])];
-    }
-    calculateStructureScore(files, expectedFiles) {
-        let score = 0;
-        const totalExpected = expectedFiles.length;
-        for (const expected of expectedFiles) {
-            if (files.includes(expected.name)) {
-                score += expected.required ? 2 : 1;
-            }
-        }
-        return totalExpected > 0 ? score / (totalExpected * 2) : 1;
-    }
-    getAllFiles(dirPath, maxDepth = 2) {
-        const files = [];
-        const traverse = (currentPath, depth) => {
-            if (depth > maxDepth)
-                return;
-            try {
-                const items = fs.readdirSync(currentPath);
-                for (const item of items) {
-                    if (item.startsWith('.') && item !== '.entity.yaml')
-                        continue;
-                    const itemPath = path.join(currentPath, item);
-                    const stats = fs.statSync(itemPath);
-                    if (stats.isFile()) {
-                        files.push(path.relative(dirPath, itemPath));
-                    }
-                    else if (stats.isDirectory()) {
-                        traverse(itemPath, depth + 1);
-                    }
-                }
-            }
-            catch {
-                // Ignore permission errors
-            }
-        };
-        traverse(dirPath, 0);
-        return files;
-    }
-}
-exports.default = Audit;

package/dist/commands/back.d.ts

@@ -1,6 +0,0 @@
-import { BaseCommand } from '../base-command';
-export default class Back extends BaseCommand {
-    static description: string;
-    static examples: string[];
-    run(): Promise<void>;
-}

package/dist/commands/back.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const base_command_1 = require("../base-command");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-class Back extends base_command_1.BaseCommand {
-    static description = 'Navigate back to the previous focus';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-    ];
-    async run() {
-        await this.parse(Back);
-        const focusedEntities = await this.focusService.getFocusedEntities();
-        const history = await this.configService.getHistory();
-        if (history.length < 2) {
-            this.log(chalk_1.default.yellow('No previous focus available'));
-            this.log(chalk_1.default.dim('Focus history is empty or has only the current focus'));
-            return;
-        }
-        const previousEntry = history[1];
-        const currentEntities = focusedEntities.map(e => e.name).join(', ') || 'none';
-        const previousEntities = previousEntry.entities.join(', ');
-        await this.focusService.switchToPrevious();
-        this.log(chalk_1.default.green('✓ Switched to previous focus'));
-        this.log(chalk_1.default.dim(`  From: ${currentEntities}`));
-        this.log(chalk_1.default.dim(`  To:   ${previousEntities}`));
-    }
-}
-exports.default = Back;

package/dist/commands/commit.d.ts

@@ -1,11 +0,0 @@
-import { BaseCommand } from '../base-command';
-export default class Commit extends BaseCommand {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        amend: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-    };
-    run(): Promise<void>;
-}