workon 1.3.0 → 2.0.0

package/lib/validation.js

@@ -1,6 +1,7 @@
 const File = require('phylo');
 const { spawn } = require('child_process');
 const path = require('path');
+const registry = require('../commands/registry');
 
 class ProjectValidator {
     constructor(config) {
@@ -74,57 +75,35 @@ class ProjectValidator {
         });
     }
 
-    validateEvents(events) {
+    async validateEvents(events) {
         if (!events || typeof events !== 'object') {
             return 'Events must be an object';
         }
 
-        const validEvents = ['cwd', 'ide', 'web', 'claude'];
+        // Initialize registry if not already done
+        await registry.initialize();
+        
+        const validEvents = registry.getValidEventNames();
         const invalidEvents = Object.keys(events).filter(event => !validEvents.includes(event));
         
         if (invalidEvents.length > 0) {
             return `Invalid events: ${invalidEvents.join(', ')}. Valid events: ${validEvents.join(', ')}`;
         }
 
-        // Validate claude event configuration if present
-        if (events.claude && typeof events.claude === 'object') {
-            const claudeValidation = this.validateClaudeConfig(events.claude);
-            if (claudeValidation !== true) {
-                return claudeValidation;
+        // Delegate to command-specific validation
+        for (const [eventName, config] of Object.entries(events)) {
+            const command = registry.getCommandByName(eventName);
+            if (command && command.validation) {
+                const result = command.validation.validateConfig(config);
+                if (result !== true) {
+                    return `${eventName}: ${result}`;
+                }
             }
         }
 
         return true;
     }
 
-    validateClaudeConfig(config) {
-        if (typeof config !== 'object') {
-            return 'Claude configuration must be an object';
-        }
-
-        // Validate flags if present
-        if (config.flags) {
-            if (!Array.isArray(config.flags)) {
-                return 'Claude flags must be an array';
-            }
-            
-            // Basic flag validation - ensure they start with - or --
-            const invalidFlags = config.flags.filter(flag => 
-                typeof flag !== 'string' || (!flag.startsWith('-') && !flag.startsWith('--'))
-            );
-            
-            if (invalidFlags.length > 0) {
-                return `Invalid Claude flags: ${invalidFlags.join(', ')}. Flags must start with - or --`;
-            }
-        }
-
-        // Validate split_terminal if present
-        if (config.split_terminal !== undefined && typeof config.split_terminal !== 'boolean') {
-            return 'Claude split_terminal must be a boolean';
-        }
-
-        return true;
-    }
 
     validateUrl(url) {
         if (!url) return true; // Optional field

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workon",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "Work on something great!",
   "main": "index.js",
   "scripts": {
@@ -17,7 +17,7 @@
   "license": "MIT",
   "devDependencies": {
     "cz-conventional-changelog": "^2.0.0",
-    "standard-version": "^4.2.0"
+    "standard-version": "^9.5.0"
   },
   "config": {
     "commitizen": {

package/test-architecture.js

@@ -0,0 +1,145 @@
+const registry = require('./commands/registry');
+const ProjectValidator = require('./lib/validation');
+
+async function comprehensiveTest() {
+    console.log('🧪 Testing Command-Centric Architecture\n');
+    
+    try {
+        // Test 1: Registry initialization
+        console.log('1. Testing registry initialization...');
+        await registry.initialize();
+        console.log('   ✅ Registry initialized successfully');
+        
+        // Test 2: Command discovery
+        console.log('\n2. Testing command discovery...');
+        const commands = registry.getValidEventNames();
+        const expectedCommands = ['cwd', 'ide', 'web', 'claude', 'npm'];
+        const hasAllCommands = expectedCommands.every(cmd => commands.includes(cmd));
+        console.log(`   📋 Discovered commands: ${commands.join(', ')}`);
+        console.log(`   ${hasAllCommands ? '✅' : '❌'} All expected commands found`);
+        
+        // Test 3: Command metadata
+        console.log('\n3. Testing command metadata...');
+        for (const cmdName of expectedCommands) {
+            const command = registry.getCommandByName(cmdName);
+            if (command && command.metadata) {
+                console.log(`   ✅ ${cmdName}: ${command.metadata.displayName}`);
+            } else {
+                console.log(`   ❌ ${cmdName}: Missing metadata`);
+            }
+        }
+        
+        // Test 4: Validation system
+        console.log('\n4. Testing validation system...');
+        const validator = new ProjectValidator({});
+        
+        // Test valid configurations
+        const validConfigs = [
+            { cwd: true, ide: true },
+            { claude: { flags: ['--debug'] } },
+            { npm: 'dev' },
+            { npm: { command: 'test', watch: true } }
+        ];
+        
+        for (const config of validConfigs) {
+            const result = await validator.validateEvents(config);
+            console.log(`   ${result === true ? '✅' : '❌'} Valid config: ${JSON.stringify(config)}`);
+            if (result !== true) console.log(`      Error: ${result}`);
+        }
+        
+        // Test invalid configurations
+        const invalidConfigs = [
+            { invalid: true },
+            { claude: { flags: 'invalid' } },
+            { npm: { command: 123 } }
+        ];
+        
+        for (const config of invalidConfigs) {
+            const result = await validator.validateEvents(config);
+            console.log(`   ${result !== true ? '✅' : '❌'} Invalid config rejected: ${JSON.stringify(config)}`);
+            if (result !== true) console.log(`      Error: ${result}`);
+        }
+        
+        // Test 5: Command configuration
+        console.log('\n5. Testing command configuration...');
+        const claudeCommand = registry.getCommandByName('claude');
+        if (claudeCommand) {
+            const defaultConfig = claudeCommand.configuration.getDefaultConfig();
+            console.log(`   ✅ Claude default config: ${defaultConfig}`);
+        }
+        
+        const npmCommand = registry.getCommandByName('npm');
+        if (npmCommand) {
+            const defaultConfig = npmCommand.configuration.getDefaultConfig();
+            console.log(`   ✅ NPM default config: ${defaultConfig}`);
+        }
+        
+        // Test 6: Tmux integration
+        console.log('\n6. Testing tmux integration...');
+        const tmuxCommands = registry.getTmuxEnabledCommands();
+        console.log(`   📋 Tmux-enabled commands: ${tmuxCommands.map(c => `${c.name}(${c.priority})`).join(', ')}`);
+        console.log(`   ${tmuxCommands.length > 0 ? '✅' : '❌'} Tmux commands found`);
+        
+        // Test 7: Management UI data
+        console.log('\n7. Testing management UI data...');
+        const manageCommands = registry.getCommandsForManageUI();
+        console.log(`   📋 Management UI commands: ${manageCommands.length}`);
+        for (const cmd of manageCommands) {
+            console.log(`   - ${cmd.name} (${cmd.value})`);
+        }
+        console.log(`   ${manageCommands.length === expectedCommands.length ? '✅' : '❌'} All commands available for management`);
+        
+        // Test 8: Command processing simulation
+        console.log('\n8. Testing command processing...');
+        const mockProject = {
+            name: 'test-project',
+            path: { path: '/test/path' },
+            ide: 'code',
+            homepage: 'https://example.com',
+            events: {
+                cwd: true,
+                ide: true,
+                claude: { flags: ['--debug'] },
+                npm: 'dev'
+            }
+        };
+        
+        const shellCommands = [];
+        const context = {
+            project: mockProject,
+            isShellMode: true,
+            shellCommands
+        };
+        
+        for (const eventName of ['cwd', 'ide', 'claude', 'npm']) {
+            const command = registry.getCommandByName(eventName);
+            if (command && command.processing) {
+                try {
+                    await command.processing.processEvent(context);
+                    console.log(`   ✅ ${eventName} command processed`);
+                } catch (error) {
+                    console.log(`   ❌ ${eventName} command failed: ${error.message}`);
+                }
+            }
+        }
+        
+        console.log(`   📋 Generated shell commands: ${shellCommands.length}`);
+        shellCommands.forEach((cmd, i) => console.log(`   ${i + 1}. ${cmd}`));
+        
+        console.log('\n🎉 All tests completed successfully!');
+        console.log('\n📊 Architecture Benefits Achieved:');
+        console.log('   ✅ Commands are self-contained');
+        console.log('   ✅ Validation is delegated to commands');
+        console.log('   ✅ Configuration is handled by commands');
+        console.log('   ✅ No hardcoded command lists');
+        console.log('   ✅ Auto-discovery works');
+        console.log('   ✅ Adding new commands requires touching only command directory');
+        
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+        console.error(error.stack);
+        process.exit(1);
+    }
+}
+
+comprehensiveTest();

package/test-registry.js

@@ -0,0 +1,57 @@
+const registry = require('./commands/registry');
+
+async function testRegistry() {
+    console.log('Testing Command Registry...\n');
+    
+    try {
+        await registry.initialize();
+        console.log('✅ Registry initialized successfully\n');
+        
+        // Test getting valid event names
+        const eventNames = registry.getValidEventNames();
+        console.log('Valid event names:', eventNames);
+        
+        // Test getting commands for manage UI
+        const manageCommands = registry.getCommandsForManageUI();
+        console.log('\nCommands for manage UI:');
+        manageCommands.forEach(cmd => {
+            console.log(`  - ${cmd.name} (${cmd.value}): ${cmd.description}`);
+        });
+        
+        // Test getting specific commands
+        console.log('\nTesting specific commands:');
+        const cwdCommand = registry.getCommandByName('cwd');
+        if (cwdCommand) {
+            console.log('✅ CWD command found');
+            console.log('   Metadata:', cwdCommand.metadata);
+        }
+        
+        const claudeCommand = registry.getCommandByName('claude');
+        if (claudeCommand) {
+            console.log('✅ Claude command found');
+            console.log('   Metadata:', claudeCommand.metadata);
+        }
+        
+        // Test tmux commands
+        const tmuxCommands = registry.getTmuxEnabledCommands();
+        console.log('\nTmux-enabled commands:');
+        tmuxCommands.forEach(cmd => {
+            console.log(`  - ${cmd.name} (priority: ${cmd.priority})`);
+        });
+        
+        // Test validation
+        console.log('\nTesting validation:');
+        if (cwdCommand) {
+            console.log('CWD validation (true):', cwdCommand.validation.validateConfig(true));
+            console.log('CWD validation (invalid):', cwdCommand.validation.validateConfig(123));
+        }
+        
+        console.log('\n✅ All tests passed!');
+        
+    } catch (error) {
+        console.error('❌ Error testing registry:', error.message);
+        console.error(error.stack);
+    }
+}
+
+testRegistry();