@hyperdrive.bot/gut 0.1.8 → 0.1.10

package/dist/base-command.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+import { Entity, EntityType } from './models/entity.model.js';
+import { ConfigService } from './services/config.service.js';
+import { EntityService } from './services/entity.service.js';
+import { FocusService } from './services/focus.service.js';
+import { GitService } from './services/git.service.js';
+import { TicketService } from './services/ticket.service.js';
+export declare abstract class BaseCommand extends Command {
+    protected configService: ConfigService;
+    protected entityService: EntityService;
+    protected focusService: FocusService;
+    protected gitService: GitService;
+    protected ticketService: TicketService;
+    protected get requiresInit(): boolean;
+    protected formatPath(path: string): string;
+    protected getStatusIcon(hasChanges: boolean): string;
+    protected getTypeEmoji(type: EntityType | string): string;
+    init(): Promise<void>;
+    protected printEntityList(entities: Entity[]): void;
+    protected withFocus<T>(callback: (entities: Entity[]) => Promise<T>): Promise<T>;
+    protected withSpinner<T>(text: string, callback: () => Promise<T>): Promise<T>;
+}

package/dist/base-command.js

@@ -0,0 +1,99 @@
+import { Command } from '@oclif/core';
+import { ConfigService } from './services/config.service.js';
+import { EntityService } from './services/entity.service.js';
+import { FocusService } from './services/focus.service.js';
+import { GitService } from './services/git.service.js';
+import { TicketService } from './services/ticket.service.js';
+const ENTITY_TYPE_EMOJI = {
+    client: '🏢',
+    company: '🏛️',
+    delivery: '📦',
+    initiative: '🚀',
+    module: '📚',
+    prospect: '🎯',
+    service: '🔧',
+    system: '⚙️',
+    tool: '🛠️',
+};
+const DEFAULT_ENTITY_EMOJI = '📁';
+export class BaseCommand extends Command {
+    configService;
+    entityService;
+    focusService;
+    gitService;
+    ticketService;
+    get requiresInit() {
+        // Override in commands that don't require initialization
+        return true;
+    }
+    formatPath(path) {
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        if (path.startsWith(workspaceRoot)) {
+            return path.slice(Math.max(0, workspaceRoot.length + 1));
+        }
+        return path;
+    }
+    getStatusIcon(hasChanges) {
+        return hasChanges ? '●' : '✓';
+    }
+    getTypeEmoji(type) {
+        return ENTITY_TYPE_EMOJI[type] ?? DEFAULT_ENTITY_EMOJI;
+    }
+    async init() {
+        await super.init();
+        // Initialize services
+        this.configService = new ConfigService();
+        this.entityService = new EntityService(this.configService);
+        this.focusService = new FocusService(this.configService);
+        this.gitService = new GitService();
+        this.ticketService = new TicketService(this.configService);
+        // Check workspace initialization for commands that require it
+        if (this.requiresInit && !this.configService.isInitialized()) {
+            this.error('Workspace not initialized. Run "gut init" first.');
+        }
+    }
+    printEntityList(entities) {
+        if (entities.length === 0) {
+            this.log('No entities configured');
+            return;
+        }
+        // Group by type
+        const byType = {};
+        for (const entity of entities) {
+            if (!byType[entity.type]) {
+                byType[entity.type] = [];
+            }
+            byType[entity.type].push(entity);
+        }
+        // Display grouped
+        for (const [type, typeEntities] of Object.entries(byType)) {
+            this.log(`\n${this.getTypeEmoji(type)} ${type.charAt(0).toUpperCase() + type.slice(1)} entities:`);
+            for (const entity of typeEntities) {
+                this.log(`  • ${entity.name} (${entity.path})`);
+                if (entity.description) {
+                    this.log(`    ${entity.description}`);
+                }
+            }
+        }
+    }
+    async withFocus(callback) {
+        const entities = await this.focusService.getFocusedEntities();
+        if (entities.length === 0) {
+            this.error('No entities focused. Use "gut focus <entity>" first.');
+        }
+        return callback(entities);
+    }
+    async withSpinner(text, callback) {
+        // Note: oclif doesn't have built-in spinner, we'll use ora later
+        this.log(text);
+        try {
+            const result = await callback();
+            this.log('✓ Done');
+            return result;
+        }
+        catch (error) {
+            this.log('✗ Failed');
+            throw error;
+        }
+    }
+}

package/dist/commands/add.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../base-command.js';
+export default class Add extends BaseCommand {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        patch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private buildGitAddArgs;
+}

package/dist/commands/add.js

@@ -0,0 +1,70 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BaseCommand } from '../base-command.js';
+export default class Add extends BaseCommand {
+    static args = {
+        path: Args.string({
+            default: '.',
+            description: 'Path(s) to stage',
+            required: false,
+        }),
+    };
+    static description = 'Stage changes in focused entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> .',
+        '<%= config.bin %> <%= command.id %> src/',
+        '<%= config.bin %> <%= command.id %> --all',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'A',
+            default: false,
+            description: 'Stage all changes (equivalent to git add -A)',
+        }),
+        patch: Flags.boolean({
+            char: 'p',
+            default: false,
+            description: 'Interactive staging',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Add);
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.error('No entities are focused. Use "gut focus <entity>" first.');
+        }
+        this.log(chalk.bold('\n📝 Staging changes in focused entities\n'));
+        for (const entity of focusedEntities) {
+            const spinner = ora(`Staging in ${chalk.cyan(entity.name)}`).start();
+            try {
+                const gitAddArgs = this.buildGitAddArgs(flags, args.path);
+                await this.gitService.add(entity.path, gitAddArgs);
+                // Get status to check what was staged
+                const status = await this.gitService.getStatus(entity.path);
+                const staged = status.changes.length;
+                if (staged > 0) {
+                    spinner.succeed(chalk.green(`✓ ${entity.name}: ${staged} file(s) staged`));
+                }
+                else {
+                    spinner.info(chalk.yellow(`${entity.name}: No changes to stage`));
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                spinner.fail(chalk.red(`✗ ${entity.name}: ${message}`));
+            }
+        }
+        this.log(chalk.dim('\nTip: Use "gut commit" to commit staged changes'));
+    }
+    buildGitAddArgs(flags, path) {
+        if (flags.all) {
+            return ['-A'];
+        }
+        if (flags.patch) {
+            return ['-p', path];
+        }
+        return [path];
+    }
+}

package/dist/commands/affected.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../base-command.js';
+export default class Affected extends BaseCommand {
+    static args: {
+        entity: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'include-docs': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'include-tests': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        since: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private analyzeAffected;
+    private checkAPIChanges;
+    private checkConfigChanges;
+    private checkDependencies;
+    private checkSchemaChanges;
+    private getChangedFiles;
+    private getEntityFiles;
+    private printAffected;
+}

package/dist/commands/affected.js

@@ -0,0 +1,323 @@
+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 Affected extends BaseCommand {
+    static args = {
+        entity: Args.string({
+            description: 'Entity to analyze (uses current focus if not provided)',
+            name: 'entity',
+            required: false,
+        }),
+    };
+    static description = 'Detect entities potentially affected by changes in current focus';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> my-app',
+        '<%= config.bin %> <%= command.id %> --since HEAD~5',
+        '<%= config.bin %> <%= command.id %> --include-tests',
+    ];
+    static flags = {
+        'include-docs': Flags.boolean({
+            default: false,
+            description: 'Include documentation changes in analysis',
+        }),
+        'include-tests': Flags.boolean({
+            default: false,
+            description: 'Include test file changes in analysis',
+        }),
+        since: Flags.string({
+            char: 's',
+            default: 'HEAD~1',
+            description: 'Git reference to compare against',
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Show detailed analysis',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Affected);
+        const { 'include-docs': includeDocs, 'include-tests': includeTests, since, verbose } = flags;
+        const spinner = ora();
+        try {
+            let sourceEntities = [];
+            if (args.entity) {
+                const entity = await this.entityService.getEntity(args.entity);
+                if (!entity) {
+                    this.error(`Entity '${args.entity}' not found`);
+                }
+                sourceEntities = [entity];
+            }
+            else {
+                const focus = await this.focusService.getCurrentFocus();
+                if (!focus || !focus.entities || focus.entities.length === 0) {
+                    this.error('No entity specified and no current focus');
+                }
+                const entities = await Promise.all(focus.entities.map((e) => this.entityService.getEntity(e.name)));
+                sourceEntities = entities.filter(e => e !== null);
+            }
+            spinner.start('Analyzing changes and dependencies');
+            const changedFiles = await this.getChangedFiles(sourceEntities, since, includeTests, includeDocs);
+            if (changedFiles.length === 0) {
+                spinner.succeed('No changes detected');
+                this.log(chalk.yellow('No file changes found since ' + since));
+                return;
+            }
+            const allEntities = await this.entityService.listEntities();
+            const otherEntities = allEntities.filter(e => !sourceEntities.some(se => se.name === e.name));
+            const affected = await this.analyzeAffected(sourceEntities, otherEntities, changedFiles);
+            spinner.succeed(`Analysis complete: ${affected.length} entities potentially affected`);
+            if (affected.length === 0) {
+                this.log(chalk.green('No other entities appear to be affected by the changes'));
+                return;
+            }
+            this.printAffected(affected, changedFiles, verbose);
+        }
+        catch (error) {
+            spinner.fail();
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+    async analyzeAffected(sourceEntities, targetEntities, changedFiles) {
+        const affected = [];
+        for (const target of targetEntities) {
+            const reasons = [];
+            let confidence = 'low';
+            // Check direct dependencies
+            const depReason = await this.checkDependencies(sourceEntities, target);
+            if (depReason) {
+                reasons.push(depReason);
+                confidence = 'high';
+            }
+            // Check for API changes
+            const apiChanges = this.checkAPIChanges(changedFiles, target);
+            if (apiChanges) {
+                reasons.push(apiChanges);
+                if (confidence === 'low')
+                    confidence = 'medium';
+            }
+            // Check for shared configuration
+            const configChanges = this.checkConfigChanges(changedFiles, target);
+            if (configChanges) {
+                reasons.push(configChanges);
+                if (confidence === 'low')
+                    confidence = 'medium';
+            }
+            // Check for database/schema changes
+            const schemaChanges = this.checkSchemaChanges(changedFiles, target);
+            if (schemaChanges) {
+                reasons.push(schemaChanges);
+                confidence = 'high';
+            }
+            if (reasons.length > 0) {
+                affected.push({ confidence, entity: target, reason: reasons });
+            }
+        }
+        // Sort by confidence
+        affected.sort((a, b) => {
+            const confidenceOrder = { high: 3, low: 1, medium: 2 };
+            return confidenceOrder[b.confidence] - confidenceOrder[a.confidence];
+        });
+        return affected;
+    }
+    checkAPIChanges(changedFiles, target) {
+        const apiPatterns = [
+            /api\//i,
+            /routes\//i,
+            /controllers\//i,
+            /services\//i,
+            /endpoints\//i,
+            /graphql\//i,
+        ];
+        const apiFiles = changedFiles.filter(f => apiPatterns.some(pattern => pattern.test(f)));
+        if (apiFiles.length > 0) {
+            // Check if target might consume these APIs
+            const targetFiles = this.getEntityFiles(target.path);
+            const hasApiConsumption = targetFiles.some(f => f.includes('api') || f.includes('client') || f.includes('service'));
+            if (hasApiConsumption) {
+                return `API changes detected (${apiFiles.length} files)`;
+            }
+        }
+        return null;
+    }
+    checkConfigChanges(changedFiles, _target) {
+        const configPatterns = [
+            /config\./i,
+            /\.env/,
+            /settings\./i,
+            /constants\./i,
+        ];
+        const configFiles = changedFiles.filter(f => configPatterns.some(pattern => pattern.test(path.basename(f))));
+        if (configFiles.length > 0) {
+            return `Configuration changes detected (${configFiles.length} files)`;
+        }
+        return null;
+    }
+    async checkDependencies(sources, target) {
+        const targetPkgPath = path.join(target.path, 'package.json');
+        if (!fs.existsSync(targetPkgPath)) {
+            return null;
+        }
+        try {
+            const targetPkg = JSON.parse(fs.readFileSync(targetPkgPath, 'utf8'));
+            const dependencies = {
+                ...targetPkg.dependencies,
+                ...targetPkg.devDependencies,
+                ...targetPkg.peerDependencies,
+            };
+            for (const source of sources) {
+                const sourcePkgPath = path.join(source.path, 'package.json');
+                if (fs.existsSync(sourcePkgPath)) {
+                    const sourcePkg = JSON.parse(fs.readFileSync(sourcePkgPath, 'utf8'));
+                    if (sourcePkg.name && dependencies[sourcePkg.name]) {
+                        return `Depends on ${sourcePkg.name}`;
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore parsing errors
+        }
+        return null;
+    }
+    checkSchemaChanges(changedFiles, target) {
+        const schemaPatterns = [
+            /schema\./i,
+            /migration/i,
+            /\.sql$/,
+            /models?\//i,
+            /entities\//i,
+        ];
+        const schemaFiles = changedFiles.filter(f => schemaPatterns.some(pattern => pattern.test(f)));
+        if (schemaFiles.length > 0) {
+            // Check if target uses database
+            const targetFiles = this.getEntityFiles(target.path);
+            const hasDatabase = targetFiles.some(f => f.includes('model') || f.includes('entity') || f.includes('schema') || f.includes('database'));
+            if (hasDatabase) {
+                return `Database/Schema changes detected (${schemaFiles.length} files)`;
+            }
+        }
+        return null;
+    }
+    async getChangedFiles(entities, since, includeTests, includeDocs) {
+        const changedFiles = [];
+        for (const entity of entities) {
+            const entityPath = path.resolve(entity.path);
+            if (!fs.existsSync(path.join(entityPath, '.git'))) {
+                continue;
+            }
+            try {
+                const diff = execSync(`git diff ${since} --name-only`, {
+                    cwd: entityPath,
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).toString();
+                const files = diff.split('\n')
+                    .filter(f => f.trim())
+                    .filter(f => {
+                    if (!includeTests && (f.includes('test') || f.includes('spec'))) {
+                        return false;
+                    }
+                    if (!includeDocs && (f.endsWith('.md') || f.includes('docs/'))) {
+                        return false;
+                    }
+                    return true;
+                })
+                    .map(f => path.join(entityPath, f));
+                changedFiles.push(...files);
+            }
+            catch {
+                // Ignore git errors
+            }
+        }
+        return [...new Set(changedFiles)];
+    }
+    getEntityFiles(entityPath) {
+        const files = [];
+        if (!fs.existsSync(entityPath))
+            return files;
+        const walkDir = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name === 'node_modules' || entry.name === '.git')
+                        continue;
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        walkDir(fullPath);
+                    }
+                    else {
+                        files.push(path.relative(entityPath, fullPath));
+                    }
+                }
+            }
+            catch {
+                // Ignore permission errors
+            }
+        };
+        walkDir(entityPath);
+        return files;
+    }
+    printAffected(affected, changedFiles, verbose) {
+        this.log('');
+        this.log(chalk.bold(`Changed files: ${changedFiles.length}`));
+        if (verbose) {
+            this.log(chalk.dim('Changed:'));
+            for (const f of changedFiles.slice(0, 5)) {
+                this.log(chalk.dim(`  - ${path.basename(f)}`));
+            }
+            if (changedFiles.length > 5) {
+                this.log(chalk.dim(`  ... and ${changedFiles.length - 5} more`));
+            }
+        }
+        this.log('');
+        this.log(chalk.bold('Potentially affected entities:'));
+        this.log('');
+        const groupedByConfidence = {
+            high: affected.filter(a => a.confidence === 'high'),
+            low: affected.filter(a => a.confidence === 'low'),
+            medium: affected.filter(a => a.confidence === 'medium'),
+        };
+        if (groupedByConfidence.high.length > 0) {
+            this.log(chalk.red.bold('High confidence:'));
+            for (const a of groupedByConfidence.high) {
+                this.log(`  ${chalk.red('●')} ${chalk.bold(a.entity.name)}`);
+                for (const r of a.reason) {
+                    this.log(chalk.dim(`    - ${r}`));
+                }
+            }
+            this.log('');
+        }
+        if (groupedByConfidence.medium.length > 0) {
+            this.log(chalk.yellow.bold('Medium confidence:'));
+            for (const a of groupedByConfidence.medium) {
+                this.log(`  ${chalk.yellow('●')} ${chalk.bold(a.entity.name)}`);
+                if (verbose) {
+                    for (const r of a.reason) {
+                        this.log(chalk.dim(`    - ${r}`));
+                    }
+                }
+            }
+            this.log('');
+        }
+        if (groupedByConfidence.low.length > 0) {
+            this.log(chalk.dim('Low confidence:'));
+            for (const a of groupedByConfidence.low) {
+                this.log(`  ${chalk.gray('●')} ${a.entity.name}`);
+                if (verbose) {
+                    for (const r of a.reason) {
+                        this.log(chalk.dim(`    - ${r}`));
+                    }
+                }
+            }
+        }
+        this.log('');
+        this.log(chalk.dim('Tip: Use --verbose flag for detailed analysis'));
+    }
+}

package/dist/commands/audit.d.ts

@@ -0,0 +1,33 @@
+import { BaseCommand } from '../base-command.js';
+export default class Audit extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        access: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        changes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        compliance: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        entity: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        security: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private auditEntity;
+    private auditFileStructure;
+    private auditGitRepository;
+    private auditMetadata;
+    private calculateMetadataCompleteness;
+    private calculateStructureScore;
+    private displayAuditResults;
+    private displayEntityAudit;
+    private displayRecommendations;
+    private getAllFiles;
+    private getAuditTypes;
+    private getExpectedFiles;
+    private getRequiredMetadataFields;
+    private hasNestedField;
+    private hasSpecificAuditType;
+    private performAccessAudit;
+    private performAudit;
+    private performComplianceAudit;
+    private performSecurityAudit;
+}