@hyperdrive.bot/gut 0.1.8 → 0.1.10

package/dist/commands/ticket/update.js

@@ -0,0 +1,142 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BaseCommand } from '../../base-command.js';
+import { getStatusEmoji } from '../../models/ticket.model.js';
+import { TicketService } from '../../services/ticket.service.js';
+const VALID_STATUSES = [
+    'enriching',
+    'needs_clarity',
+    'ready',
+    'in_progress',
+    'testing',
+    'in_review',
+    'blocked',
+    'ready_to_merge',
+    'deploying',
+    'validating',
+    'done'
+];
+export default class TicketUpdate extends BaseCommand {
+    static args = {
+        ticketId: Args.string({
+            description: 'ticket ID to update',
+            name: 'ticketId',
+            required: true
+        })
+    };
+    static description = 'Update a ticket status or confidence';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --status in_progress',
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --status testing --confidence 85',
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --phase implementation'
+    ];
+    static flags = {
+        confidence: Flags.integer({
+            char: 'c',
+            description: 'new confidence score (0-100)'
+        }),
+        json: Flags.boolean({
+            char: 'j',
+            description: 'output as JSON'
+        }),
+        phase: Flags.string({
+            char: 'p',
+            description: 'new workflow phase',
+            options: ['enrichment', 'planning', 'implementation', 'testing', 'review', 'merge', 'deployment', 'validation']
+        }),
+        status: Flags.string({
+            char: 's',
+            description: `new ticket status (${VALID_STATUSES.join(', ')})`,
+            options: VALID_STATUSES
+        })
+    };
+    get requiresInit() {
+        return false;
+    }
+    async run() {
+        const { args, flags } = await this.parse(TicketUpdate);
+        const ticketService = new TicketService(this.configService);
+        if (!ticketService.isConfigured()) {
+            this.error('API not configured. Set GUT_API_ENDPOINT and GUT_TENANT_ID environment variables.');
+        }
+        // Validate that at least one update flag is provided
+        if (!flags.status && !flags.phase && flags.confidence === undefined) {
+            this.error('At least one of --status, --phase, or --confidence is required');
+        }
+        // Validate confidence range
+        if (flags.confidence !== undefined && (flags.confidence < 0 || flags.confidence > 100)) {
+            this.error('Confidence must be between 0 and 100');
+        }
+        // Get current ticket for comparison
+        const spinner = ora('Getting current ticket state...').start();
+        try {
+            const currentTicket = await ticketService.getTicket(args.ticketId);
+            if (!currentTicket) {
+                spinner.fail();
+                this.error(`Ticket ${args.ticketId} not found`);
+            }
+            spinner.text = 'Updating ticket...';
+            // Build update payload
+            const updates = {};
+            if (flags.status)
+                updates.status = flags.status;
+            if (flags.phase)
+                updates.phase = flags.phase;
+            if (flags.confidence !== undefined)
+                updates.confidence = flags.confidence;
+            const updatedTicket = await ticketService.updateTicket(args.ticketId, updates);
+            spinner.succeed('Ticket updated');
+            if (flags.json) {
+                this.log(JSON.stringify(updatedTicket, null, 2));
+                return;
+            }
+            this.log('');
+            this.log(chalk.bold(`📋 ${updatedTicket.ticketId}: ${updatedTicket.summary}`));
+            this.log('');
+            // Show changes
+            this.log(chalk.bold('Changes:'));
+            if (flags.status && currentTicket.status !== updatedTicket.status) {
+                this.log(`   Status: ${getStatusEmoji(currentTicket.status)} ${currentTicket.status} → ${getStatusEmoji(updatedTicket.status)} ${updatedTicket.status}`);
+            }
+            if (flags.phase && currentTicket.phase !== updatedTicket.phase) {
+                this.log(`   Phase: ${currentTicket.phase} → ${updatedTicket.phase}`);
+            }
+            if (flags.confidence !== undefined && currentTicket.confidence !== updatedTicket.confidence) {
+                this.log(`   Confidence: ${this.formatConfidence(currentTicket.confidence)} → ${this.formatConfidence(updatedTicket.confidence)}`);
+            }
+            this.log('');
+            this.log(chalk.green('✓ Update successful'));
+            this.log('');
+        }
+        catch (error) {
+            spinner.fail('Update failed');
+            const message = error instanceof Error ? error.message : String(error);
+            // Check for invalid transition error
+            if (message.includes('Invalid status transition')) {
+                this.log('');
+                this.log(chalk.red('Error: Invalid status transition'));
+                this.log('');
+                this.log('The requested status transition is not allowed.');
+                this.log('Valid transitions depend on the current status.');
+                this.log('');
+                this.log('Run `gut ticket get ' + args.ticketId + '` to see current status.');
+                this.log('');
+                this.exit(1);
+            }
+            this.error(`Failed to update ticket: ${message}`);
+        }
+    }
+    formatConfidence(confidence) {
+        if (confidence >= 90) {
+            return chalk.green(`${confidence}%`);
+        }
+        if (confidence >= 70) {
+            return chalk.yellow(`${confidence}%`);
+        }
+        if (confidence >= 50) {
+            return chalk.hex('#FFA500')(`${confidence}%`);
+        }
+        return chalk.red(`${confidence}%`);
+    }
+}

package/dist/commands/unfocus.d.ts

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

package/dist/commands/unfocus.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class Unfocus extends BaseCommand {
+    static description = 'Clear the current focus';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        await this.parse(Unfocus);
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.log(chalk.yellow('No entities are currently focused'));
+            return;
+        }
+        await this.focusService.clearFocus();
+        const entities = focusedEntities.map(e => e.name).join(', ');
+        this.log(chalk.green(`✓ Cleared focus from: ${entities}`));
+    }
+}

package/dist/commands/used-by.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../base-command.js';
+export default class UsedBy extends BaseCommand {
+    static args: {
+        entity: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private analyzeUsage;
+    private findClientDependents;
+    private findDirectDependents;
+    private findInferredDependents;
+}

package/dist/commands/used-by.js

@@ -0,0 +1,110 @@
+import { Args } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../base-command.js';
+export default class UsedBy extends BaseCommand {
+    static args = {
+        entity: Args.string({
+            description: 'Entity name to analyze usage for',
+            name: 'entity',
+            required: false,
+        }),
+    };
+    static description = 'Show what entities depend on current focus or specified entity';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> api',
+    ];
+    async run() {
+        const { args } = await this.parse(UsedBy);
+        let targetEntities = [];
+        if (args.entity) {
+            // Analyze specific entity
+            const entity = this.entityService.findEntity(args.entity);
+            if (!entity) {
+                this.error(`Entity '${args.entity}' not found`);
+            }
+            targetEntities = [entity];
+        }
+        else {
+            // Analyze current focus
+            targetEntities = await this.focusService.getFocusedEntities();
+            if (targetEntities.length === 0) {
+                this.error('No entities in focus. Use "gut focus <entity>" first or specify an entity name.');
+            }
+        }
+        this.log(chalk.bold('\n🔄 Usage Analysis'));
+        this.log(chalk.dim('─'.repeat(50)));
+        for (const entity of targetEntities) {
+            this.log(`\n${chalk.green('▸')} ${chalk.bold(entity.name)} (${entity.type})`);
+            const usage = await this.analyzeUsage(entity);
+            if (usage.direct.length > 0) {
+                this.log(`\n  ${chalk.yellow('Direct Dependents:')}`);
+                for (const dep of usage.direct) {
+                    this.log(`    ${this.getTypeEmoji(dep.type)} ${dep.name} (${dep.type})`);
+                }
+            }
+            if (usage.clients.length > 0) {
+                this.log(`\n  ${chalk.blue('Client Dependencies:')}`);
+                for (const dep of usage.clients) {
+                    this.log(`    ${this.getTypeEmoji(dep.type)} ${dep.name} (${dep.type})`);
+                }
+            }
+            if (usage.inferred.length > 0) {
+                this.log(`\n  ${chalk.dim('Inferred Usage:')}`);
+                for (const dep of usage.inferred) {
+                    this.log(`    ${this.getTypeEmoji(dep.type)} ${dep.name} (${dep.type}) ${chalk.dim('- pattern based')}`);
+                }
+            }
+            if (usage.direct.length === 0 && usage.clients.length === 0 && usage.inferred.length === 0) {
+                this.log(`    ${chalk.dim('No dependents found')}`);
+            }
+            // Show impact assessment
+            const totalDependents = usage.direct.length + usage.clients.length + usage.inferred.length;
+            if (totalDependents > 0) {
+                this.log(`\n  ${chalk.cyan('Impact Assessment:')}`);
+                this.log(`    ${chalk.dim('Total dependents:')} ${totalDependents}`);
+                const criticalDependents = usage.direct.filter(e => e.type === 'client').length;
+                if (criticalDependents > 0) {
+                    this.log(`    ${chalk.red('Critical client dependencies:')} ${criticalDependents}`);
+                }
+            }
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(chalk.dim('Usage analysis helps assess impact of changes'));
+    }
+    async analyzeUsage(entity) {
+        const allEntities = this.entityService.getAllEntities();
+        const directDependents = this.findDirectDependents(allEntities, entity.name);
+        const clientDependents = this.findClientDependents(allEntities, entity.type);
+        const inferredDependents = this.findInferredDependents(allEntities, entity, clientDependents, directDependents);
+        return {
+            clients: clientDependents.filter(e => !directDependents.includes(e)),
+            direct: directDependents,
+            inferred: inferredDependents.slice(0, 5),
+        };
+    }
+    findClientDependents(allEntities, entityType) {
+        const systemTypes = ['system', 'module', 'service'];
+        if (systemTypes.includes(entityType)) {
+            return allEntities.filter(e => e.type === 'client');
+        }
+        return [];
+    }
+    findDirectDependents(allEntities, entityName) {
+        return allEntities.filter(e => e.metadata?.relationships?.dependent_systems?.includes(entityName)
+            || e.metadata?.relationships?.similar_entities?.includes(entityName));
+    }
+    findInferredDependents(allEntities, entity, clientDependents, directDependents) {
+        const inferredDependents = [];
+        const isExcluded = (e) => clientDependents.includes(e) || directDependents.includes(e);
+        if (entity.name.includes('design') || entity.name.includes('shared') || entity.type === 'module') {
+            const potentialUsers = allEntities.filter(e => (e.type === 'client' || e.type === 'delivery') && !isExcluded(e));
+            inferredDependents.push(...potentialUsers);
+        }
+        if (entity.name.includes('api') || entity.type === 'service') {
+            const apiUsers = allEntities.filter(e => e.type === 'client' && !isExcluded(e));
+            inferredDependents.push(...apiUsers);
+        }
+        return inferredDependents;
+    }
+}

package/dist/commands/workspace.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../base-command.js';
+export default class Workspace extends BaseCommand {
+    static args: {
+        action: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'entity-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private generateContextsConfig;
+    private generateEntityMetadata;
+    private generateEntityMetadataContent;
+    private generateWorkspaceConfig;
+    private initWorkspaceStructure;
+    private readDirectoryItems;
+    private renderDirectoryItem;
+    private showDirectoryTree;
+    private showWorkspaceStructure;
+}

package/dist/commands/workspace.js

@@ -0,0 +1,372 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { BaseCommand } from '../base-command.js';
+export default class Workspace extends BaseCommand {
+    static args = {
+        action: Args.string({
+            description: 'Action to perform (init, structure, generate-metadata)',
+            name: 'action',
+            options: ['init', 'structure', 'generate-metadata'],
+            required: true,
+        }),
+    };
+    static description = 'Manage workspace structure and entity metadata';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> init',
+        '<%= config.bin %> <%= command.id %> structure',
+        '<%= config.bin %> <%= command.id %> generate-metadata',
+    ];
+    static flags = {
+        'entity-type': Flags.string({
+            char: 't',
+            description: 'entity type for metadata generation',
+            options: ['client', 'prospect', 'company', 'initiative', 'system'],
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'force overwrite existing files',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Workspace);
+        switch (args.action) {
+            case 'generate-metadata': {
+                await this.generateEntityMetadata(flags['entity-type'], flags.force);
+                break;
+            }
+            case 'init': {
+                await this.initWorkspaceStructure(flags.force);
+                break;
+            }
+            case 'structure': {
+                await this.showWorkspaceStructure();
+                break;
+            }
+            default: {
+                this.error(`Unknown action: ${args.action}`);
+            }
+        }
+    }
+    generateContextsConfig() {
+        return `# Context Definitions for AI and Focus Management
+# Generated on ${new Date().toISOString()}
+
+contexts:
+  # Example client context
+  # clients:
+  #   mindtools:
+  #     type: "client"
+  #     description: "MindTools React platform - 24M+ users"
+  #     status: "active_development"
+  #     
+  #     repositories:
+  #       primary: "entities/clients/mindtools/delivery"
+  #       private: "entities/clients/mindtools/business"
+  #       related: ["systems/api", "systems/shared/design-system"]
+  #     
+  #     focus_modes:
+  #       delivery:
+  #         include: ["delivery/repos/", "systems/shared/design-system/"]
+  #         exclude: ["business/contracts/"]
+  #         ai_persona: "senior_react_developer"
+  #         suggested_duration: "1h 30m"
+  #         
+  #       strategy:
+  #         include: ["delivery/", "business/", "insights/"]
+  #         exclude: []
+  #         ai_persona: "ceo_strategic_advisor"
+  #         suggested_duration: "2h 30m"
+
+# Focus mode definitions
+focus_modes:
+  delivery:
+    description: "Technical development and implementation"
+    typical_duration: "1-2 hours"
+    ai_persona: "senior_developer"
+    
+  strategy:
+    description: "Business strategy and planning"
+    typical_duration: "2-3 hours"
+    ai_persona: "strategic_advisor"
+    
+  audit:
+    description: "Review and compliance analysis"
+    typical_duration: "45-90 minutes"
+    ai_persona: "business_auditor"
+    
+  debug:
+    description: "Problem investigation and resolution"
+    typical_duration: "30-60 minutes"
+    ai_persona: "debugging_specialist"
+    
+  research:
+    description: "Market and technical research"
+    typical_duration: "1-2 hours"
+    ai_persona: "research_analyst"
+    
+  proposal:
+    description: "Proposal preparation and client communication"
+    typical_duration: "2-4 hours"
+    ai_persona: "business_consultant"
+`;
+    }
+    async generateEntityMetadata(entityType, force) {
+        const entities = entityType
+            ? this.entityService.getEntitiesByType(entityType)
+            : this.entityService.getAllEntities();
+        if (entities.length === 0) {
+            this.error('No entities found. Add entities first with "gut entity add"');
+        }
+        this.log(chalk.bold('\n📝 Generating Entity Metadata'));
+        this.log(chalk.dim('─'.repeat(50)));
+        for (const entity of entities) {
+            const entityPath = this.entityService.resolveEntityPath(entity);
+            const metadataPath = path.join(entityPath, '.entity.yaml');
+            if (fs.existsSync(metadataPath) && !force) {
+                this.log(`  ${chalk.dim(entity.name)} (metadata already exists)`);
+                continue;
+            }
+            // Ensure entity directory exists
+            if (!fs.existsSync(entityPath)) {
+                fs.mkdirSync(entityPath, { recursive: true });
+            }
+            const metadata = this.generateEntityMetadataContent(entity);
+            fs.writeFileSync(metadataPath, metadata);
+            this.log(`✓ Generated metadata for ${chalk.green(entity.name)}`);
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(chalk.green('✅ Entity metadata generated'));
+    }
+    generateEntityMetadataContent(entity) {
+        const now = new Date().toISOString();
+        return `# Entity Metadata for ${entity.name}
+# Generated on ${now}
+
+entity:
+  type: "${entity.type}"
+  name: "${entity.name}"
+  description: "${entity.description || `${entity.type} entity: ${entity.name}`}"
+  created: "${now}"
+  
+# Business information (for client/prospect entities)
+business:
+  # primary_contact: ""
+  # contract_value: ""
+  # team_size: 0
+  # priority: "medium"  # low, medium, high
+  # status: "active"
+
+# Relationships with other entities
+relationships:
+  # similar_entities: []
+  # dependent_systems: ["systems/api"]
+  # related_initiatives: []
+
+# Working patterns and preferences
+working_patterns:
+  # typical_focus_duration: "2h"
+  # common_paired_entities: []
+  # strategic_review_frequency: "weekly"
+  # productive_times: ["9-11am", "2-4pm"]
+
+# AI context configuration
+ai_context:
+  # persona: "senior_developer"
+  # knowledge_scope: "complete_technical_context"
+  # decision_authority: "technical_implementation"
+
+# Focus intelligence (learned from usage)
+focus_intelligence:
+  # optimal_session_duration: ""
+  # average_interruptions: 0
+  # effectiveness_metrics:
+  #   commits_per_session: 0
+  #   lines_changed_per_session: 0
+  #   issues_resolved_per_session: 0
+
+# Repository information
+repository:
+  path: "${entity.path}"
+  # remote: "${entity.repository || ''}"
+  # branch: "main"
+  # last_sync: ""
+`;
+    }
+    generateWorkspaceConfig() {
+        return `# DevSquad Context Operating System - Workspace Configuration
+# Generated on ${new Date().toISOString()}
+
+workspace:
+  version: "1.0"
+  name: "DevSquad Workspace"
+  description: "Context-aware development workspace"
+  
+  structure:
+    entities_dir: "entities"
+    systems_dir: "systems"
+    focus_dir: "focus"
+    
+  settings:
+    default_focus_mode: "delivery"
+    auto_context_generation: true
+    focus_session_tracking: true
+    
+  integrations:
+    git:
+      auto_sync: false
+      multi_repo_operations: true
+    ai:
+      context_generation: true
+      persona_switching: true
+    jira:
+      enabled: false
+      base_url: ""
+      
+# Entity type definitions
+entity_types:
+  client:
+    description: "Active client relationships"
+    default_modes: ["delivery", "strategy", "audit"]
+    
+  prospect:
+    description: "Potential client relationships"
+    default_modes: ["research", "proposal"]
+    
+  company:
+    description: "DevSquad group companies"
+    default_modes: ["strategy", "audit"]
+    
+  initiative:
+    description: "Strategic cross-entity initiatives"
+    default_modes: ["strategy", "delivery"]
+    
+  system:
+    description: "Supporting systems and infrastructure"
+    default_modes: ["delivery", "debug"]
+`;
+    }
+    async initWorkspaceStructure(force) {
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        this.log(chalk.bold('\n🏗️  Initializing Workspace Structure'));
+        this.log(chalk.dim('─'.repeat(50)));
+        // Create directory structure
+        const directories = [
+            'entities/clients',
+            'entities/prospects',
+            'entities/companies',
+            'entities/initiatives',
+            'systems/api',
+            'systems/tools',
+            'systems/shared',
+            'focus/current',
+            'focus/recent',
+            'focus/breadcrumbs',
+            'focus/stack',
+        ];
+        for (const dir of directories) {
+            const fullPath = path.join(workspaceRoot, dir);
+            if (fs.existsSync(fullPath)) {
+                this.log(`  ${chalk.dim(dir)} (already exists)`);
+            }
+            else {
+                fs.mkdirSync(fullPath, { recursive: true });
+                this.log(`✓ Created ${chalk.green(dir)}`);
+            }
+        }
+        // Create workspace configuration
+        const workspaceConfigPath = path.join(workspaceRoot, '.workspace', 'config.yaml');
+        const workspaceConfigDir = path.dirname(workspaceConfigPath);
+        if (!fs.existsSync(workspaceConfigDir)) {
+            fs.mkdirSync(workspaceConfigDir, { recursive: true });
+        }
+        if (!fs.existsSync(workspaceConfigPath) || force) {
+            const workspaceConfig = this.generateWorkspaceConfig();
+            fs.writeFileSync(workspaceConfigPath, workspaceConfig);
+            this.log(`✓ Created ${chalk.green('.workspace/config.yaml')}`);
+        }
+        else {
+            this.log(`  ${chalk.dim('.workspace/config.yaml')} (already exists)`);
+        }
+        // Create contexts configuration
+        const contextsConfigPath = path.join(workspaceRoot, '.workspace', 'contexts.yaml');
+        if (!fs.existsSync(contextsConfigPath) || force) {
+            const contextsConfig = this.generateContextsConfig();
+            fs.writeFileSync(contextsConfigPath, contextsConfig);
+            this.log(`✓ Created ${chalk.green('.workspace/contexts.yaml')}`);
+        }
+        else {
+            this.log(`  ${chalk.dim('.workspace/contexts.yaml')} (already exists)`);
+        }
+        this.log(chalk.dim('\n─'.repeat(50)));
+        this.log(chalk.green('✅ Workspace structure initialized'));
+        this.log(chalk.dim('Next steps:'));
+        this.log(chalk.dim('• Add entities: gut entity add <name> <type> <path>'));
+        this.log(chalk.dim('• Generate metadata: gut workspace generate-metadata'));
+        this.log(chalk.dim('• Set focus: gut focus client <name>'));
+    }
+    readDirectoryItems(dirPath) {
+        try {
+            return fs.readdirSync(dirPath)
+                .filter(item => !item.startsWith('.') || item === '.workspace')
+                .sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    renderDirectoryItem(itemPath, item, options) {
+        try {
+            const stats = fs.statSync(itemPath);
+            const { currentPrefix, depth, maxDepth, nextPrefix, prefix } = options;
+            if (stats.isDirectory()) {
+                this.log(`${prefix}${currentPrefix}${chalk.blue(item)}/`);
+                this.showDirectoryTree(itemPath, nextPrefix, depth + 1, maxDepth);
+            }
+            else {
+                this.log(`${prefix}${currentPrefix}${item}`);
+            }
+        }
+        catch {
+            // Skip items we can't access
+        }
+    }
+    showDirectoryTree(dirPath, prefix, depth, maxDepth) {
+        if (depth > maxDepth)
+            return;
+        const items = this.readDirectoryItems(dirPath);
+        for (const [index, item] of items.entries()) {
+            const itemPath = path.join(dirPath, item);
+            const isLast = index === items.length - 1;
+            const currentPrefix = isLast ? '└── ' : '├── ';
+            const nextPrefix = prefix + (isLast ? '    ' : '│   ');
+            this.renderDirectoryItem(itemPath, item, {
+                currentPrefix, depth, maxDepth, nextPrefix, prefix,
+            });
+        }
+    }
+    async showWorkspaceStructure() {
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        this.log(chalk.bold('\n📁 Workspace Structure'));
+        this.log(chalk.dim('─'.repeat(50)));
+        // Show directory tree
+        this.showDirectoryTree(workspaceRoot, '', 0, 2);
+        // Show entities summary
+        const entities = this.entityService.getAllEntities();
+        if (entities.length > 0) {
+            this.log(chalk.bold('\n🏢 Entities Summary'));
+            this.log(chalk.dim('─'.repeat(50)));
+            const byType = {};
+            for (const entity of entities) {
+                if (!byType[entity.type])
+                    byType[entity.type] = 0;
+                byType[entity.type]++;
+            }
+            for (const [type, count] of Object.entries(byType)) {
+                const emoji = this.getTypeEmoji(type);
+                this.log(`${emoji} ${type}: ${count}`);
+            }
+        }
+    }
+}