workon 1.4.0 → 2.0.0

package/cli/open.js

@@ -4,10 +4,15 @@ const { ProjectEnvironment } = require('../lib/environment');
 const spawn = require('child_process').spawn;
 const File = require('phylo');
 const TmuxManager = require('../lib/tmux');
+const registry = require('../commands/registry');
 
 class open extends command {
-    execute (params) {
+    async execute (params) {
         let me = this;
+        
+        // Initialize command registry
+        await registry.initialize();
+        
         if (params.project) {
             return me.processProject(params.project);
         } else {
@@ -73,20 +78,28 @@ class open extends command {
             // Three-pane layout: Claude + Terminal + NPM
             await me.handleThreePaneLayout(project, isShellMode);
             // Process other events except cwd, claude, and npm
-            events.filter(e => !['cwd', 'claude', 'npm'].includes(e)).forEach(me.processEvent.bind(me));
+            for (const event of events.filter(e => !['cwd', 'claude', 'npm'].includes(e))) {
+                await me.processEvent(event);
+            }
         } else if (hasCwd && hasNpmEvent) {
             // Two-pane layout: Terminal + NPM (no Claude)
             await me.handleTwoPaneNpmLayout(project, isShellMode);
             // Process other events except cwd and npm
-            events.filter(e => !['cwd', 'npm'].includes(e)).forEach(me.processEvent.bind(me));
+            for (const event of events.filter(e => !['cwd', 'npm'].includes(e))) {
+                await me.processEvent(event);
+            }
         } else if (hasCwd && hasClaudeEvent) {
             // Two-pane layout: Claude + Terminal (existing split terminal)
             await me.handleSplitTerminal(project, isShellMode);
             // Process other events except cwd and claude
-            events.filter(e => !['cwd', 'claude'].includes(e)).forEach(me.processEvent.bind(me));
+            for (const event of events.filter(e => !['cwd', 'claude'].includes(e))) {
+                await me.processEvent(event);
+            }
         } else {
             // Normal event processing
-            events.forEach(me.processEvent.bind(me));
+            for (const event of events) {
+                await me.processEvent(event);
+            }
         }
 
         // Output collected shell commands if in shell mode
@@ -132,14 +145,14 @@ class open extends command {
                 } catch (error) {
                     me.log.debug(`Failed to create tmux session: ${error.message}`);
                     // Fall back to normal behavior
-                    me.processEvent('cwd');
-                    me.processEvent('claude');
+                    await me.processEvent('cwd');
+                    await me.processEvent('claude');
                 }
             } else {
                 me.log.debug('Tmux not available, falling back to normal mode');
                 // Fall back to normal behavior
-                me.processEvent('cwd');
-                me.processEvent('claude');
+                await me.processEvent('cwd');
+                await me.processEvent('claude');
             }
         }
     }
@@ -150,7 +163,8 @@ class open extends command {
         const claudeConfig = project.events.claude;
         const claudeArgs = (claudeConfig && claudeConfig.flags) ? claudeConfig.flags : [];
         const npmConfig = project.events.npm;
-        const npmCommand = me.getNpmCommand(npmConfig);
+        const NpmCommand = registry.getCommandByName('npm');
+        const npmCommand = NpmCommand ? NpmCommand._getNpmCommand(npmConfig) : 'npm run dev';
         
         if (isShellMode) {
             // Check if tmux is available
@@ -186,16 +200,16 @@ class open extends command {
                 } catch (error) {
                     me.log.debug(`Failed to create tmux session: ${error.message}`);
                     // Fall back to normal behavior
-                    me.processEvent('cwd');
-                    me.processEvent('claude');
-                    me.processEvent('npm');
+                    await me.processEvent('cwd');
+                    await me.processEvent('claude');
+                    await me.processEvent('npm');
                 }
             } else {
                 me.log.debug('Tmux not available, falling back to normal mode');
                 // Fall back to normal behavior
-                me.processEvent('cwd');
-                me.processEvent('claude');
-                me.processEvent('npm');
+                await me.processEvent('cwd');
+                await me.processEvent('claude');
+                await me.processEvent('npm');
             }
         }
     }
@@ -204,7 +218,8 @@ class open extends command {
         let me = this;
         const tmux = new TmuxManager();
         const npmConfig = project.events.npm;
-        const npmCommand = me.getNpmCommand(npmConfig);
+        const NpmCommand = registry.getCommandByName('npm');
+        const npmCommand = NpmCommand ? NpmCommand._getNpmCommand(npmConfig) : 'npm run dev';
         
         if (isShellMode) {
             // Check if tmux is available
@@ -234,34 +249,24 @@ class open extends command {
                 } catch (error) {
                     me.log.debug(`Failed to create tmux session: ${error.message}`);
                     // Fall back to normal behavior
-                    me.processEvent('cwd');
-                    me.processEvent('npm');
+                    await me.processEvent('cwd');
+                    await me.processEvent('npm');
                 }
             } else {
                 me.log.debug('Tmux not available, falling back to normal mode');
                 // Fall back to normal behavior
-                me.processEvent('cwd');
-                me.processEvent('npm');
+                await me.processEvent('cwd');
+                await me.processEvent('npm');
             }
         }
     }
 
-    getNpmCommand(npmConfig) {
-        if (typeof npmConfig === 'string') {
-            return `npm run ${npmConfig}`;
-        } else if (npmConfig && typeof npmConfig === 'object' && npmConfig.command) {
-            return `npm run ${npmConfig.command}`;
-        } else {
-            return 'npm run dev';
-        }
-    }
 
-    processEvent (event) {
+    async processEvent (event) {
         let me = this;
         let environment = me.root().environment;
         let project = environment.project;
         let scripts = project.scripts || {};
-        let homepage = project.homepage;
         let capitalEvt = `${event[0].toUpperCase()}${event.substring(1)}`;
 
         me.log.debug(`Processing event ${event}`);
@@ -276,79 +281,19 @@ class open extends command {
             let isShellMode = me.params.shell || me.root().params.shell;
             me.log.debug(`Shell mode is: ${isShellMode}`);
             
-            switch (event) {
-                case 'ide':
-                    if (isShellMode) {
-                        me.shellCommands.push(`${project.ide} "${project.path.path}" &`);
-                    } else {
-                        spawn(project.ide, [project.path.path]);
-                    }
-                break;
-                case 'cwd':
-                    if (isShellMode) {
-                        me.shellCommands.push(`cd "${environment.project.path.path}"`);
-                    } else {
-                        spawn(process.env.SHELL, ['-i'], {
-                            cwd: environment.project.path.path,
-                            stdio: 'inherit'
-                        });
-                    }
-                break;
-                case 'web':
-                    if (homepage) {
-                        if (isShellMode) {
-                            // Different approaches based on OS
-                            let openCmd;
-                            switch (process.platform) {
-                                case 'darwin': openCmd = 'open'; break;
-                                case 'win32': openCmd = 'start'; break;
-                                default: openCmd = 'xdg-open'; break;
-                            }
-                            me.shellCommands.push(`${openCmd} "${homepage}" &`);
-                        } else {
-                            require("openurl2").open(homepage);
-                        }
-                    }
-                break;
-                case 'claude':
-                    let claudeArgs = [];
-                    let claudeConfig = project.events.claude;
-                    
-                    // Handle advanced Claude configuration
-                    if (claudeConfig && typeof claudeConfig === 'object') {
-                        if (claudeConfig.flags && Array.isArray(claudeConfig.flags)) {
-                            claudeArgs = claudeArgs.concat(claudeConfig.flags);
-                        }
-                        // Additional config options can be handled here in the future
-                    }
-                    
-                    if (isShellMode) {
-                        let claudeCommand = claudeArgs.length > 0 
-                            ? `claude ${claudeArgs.join(' ')}`
-                            : 'claude';
-                        me.shellCommands.push(claudeCommand);
-                    } else {
-                        spawn('claude', claudeArgs, {
-                            cwd: environment.project.path.path,
-                            stdio: 'inherit'
-                        });
-                    }
-                break;
-                case 'npm':
-                    let npmCommand = me.getNpmCommand(project.events.npm);
-                    
-                    if (isShellMode) {
-                        me.shellCommands.push(npmCommand);
-                    } else {
-                        spawn('npm', ['run', npmCommand.replace('npm run ', '')], {
-                            cwd: environment.project.path.path,
-                            stdio: 'inherit'
-                        });
-                    }
-                break;
+            // Use CommandRegistry to process the event
+            const command = registry.getCommandByName(event);
+            if (command && command.processing) {
+                await command.processing.processEvent({
+                    project,
+                    isShellMode,
+                    shellCommands: me.shellCommands || []
+                });
+            } else {
+                me.log.debug(`No command handler found for event: ${event}`);
             }
         }
-        if (`before${capitalEvt}` in scripts) {
+        if (`after${capitalEvt}` in scripts) {
             me.log.debug(`Found 'after' script, unfortunately scripts are not yet supported.`);
         }
     }

package/commands/base.js

@@ -0,0 +1,105 @@
+/**
+ * Base command interface that all commands must implement
+ * Provides standardized structure for command-centric architecture
+ */
+class BaseCommand {
+    /**
+     * Command metadata - must be implemented by each command
+     * @returns {Object} metadata object with name, displayName, description, etc.
+     */
+    static get metadata() {
+        throw new Error('Command must implement static metadata getter');
+    }
+
+    /**
+     * Validation rules for command configuration
+     * @returns {Object} validation methods
+     */
+    static get validation() {
+        return {
+            /**
+             * Validate command-specific configuration
+             * @param {*} config - Configuration to validate
+             * @returns {true|string} true if valid, error message if invalid
+             */
+            validateConfig(config) {
+                return true; // Default: accept any config
+            }
+        };
+    }
+
+    /**
+     * Interactive configuration setup
+     * @returns {Object} configuration methods
+     */
+    static get configuration() {
+        return {
+            /**
+             * Interactive setup prompts for the command
+             * @returns {*} Configuration object or primitive value
+             */
+            async configureInteractive() {
+                return 'true'; // Default: simple boolean enable
+            },
+
+            /**
+             * Get default configuration for the command
+             * @returns {*} Default configuration
+             */
+            getDefaultConfig() {
+                return 'true';
+            }
+        };
+    }
+
+    /**
+     * Event processing logic
+     * @returns {Object} processing methods
+     */
+    static get processing() {
+        return {
+            /**
+             * Process the command event
+             * @param {Object} context - Processing context
+             * @param {Object} context.project - Project configuration
+             * @param {boolean} context.isShellMode - Whether in shell mode
+             * @param {string[]} context.shellCommands - Array to collect shell commands
+             * @returns {Promise<void>}
+             */
+            async processEvent(context) {
+                throw new Error('Command must implement processEvent method');
+            },
+
+            /**
+             * Generate shell command for the event
+             * @param {Object} context - Processing context
+             * @returns {string[]} Array of shell commands
+             */
+            generateShellCommand(context) {
+                return [];
+            }
+        };
+    }
+
+    /**
+     * Tmux integration (optional)
+     * @returns {Object|null} tmux methods or null if not supported
+     */
+    static get tmux() {
+        return null; // Default: no tmux integration
+    }
+
+    /**
+     * Help and documentation
+     * @returns {Object} help information
+     */
+    static get help() {
+        return {
+            usage: `${this.metadata.name}: <configuration>`,
+            description: this.metadata.description,
+            examples: []
+        };
+    }
+}
+
+module.exports = BaseCommand;

package/commands/core/cwd/index.js

@@ -0,0 +1,86 @@
+const BaseCommand = require('../../base');
+const spawn = require('child_process').spawn;
+
+/**
+ * CWD (Change Working Directory) Command
+ * Changes the current working directory to the project path
+ */
+class CwdCommand extends BaseCommand {
+    static get metadata() {
+        return {
+            name: 'cwd',
+            displayName: 'Change directory (cwd)',
+            description: 'Change current working directory to project path',
+            category: 'core',
+            requiresTmux: false,
+            dependencies: []
+        };
+    }
+
+    static get validation() {
+        return {
+            validateConfig(config) {
+                // CWD command accepts boolean or string 'true'
+                if (config === true || config === 'true' || config === false || config === 'false') {
+                    return true;
+                }
+                return 'CWD configuration must be a boolean or string "true"/"false"';
+            }
+        };
+    }
+
+    static get configuration() {
+        return {
+            async configureInteractive() {
+                // CWD is typically just enabled/disabled, no advanced config needed
+                return 'true';
+            },
+
+            getDefaultConfig() {
+                return 'true';
+            }
+        };
+    }
+
+    static get processing() {
+        return {
+            async processEvent(context) {
+                const { project, isShellMode, shellCommands } = context;
+                
+                if (isShellMode) {
+                    shellCommands.push(`cd "${project.path.path}"`);
+                } else {
+                    // In non-shell mode, spawn a new shell in the project directory
+                    spawn(process.env.SHELL, ['-i'], {
+                        cwd: project.path.path,
+                        stdio: 'inherit'
+                    });
+                }
+            },
+
+            generateShellCommand(context) {
+                const { project } = context;
+                return [`cd "${project.path.path}"`];
+            }
+        };
+    }
+
+    static get help() {
+        return {
+            usage: 'cwd: true',
+            description: 'Changes the current working directory to the project path',
+            examples: [
+                { 
+                    config: 'cwd: true', 
+                    description: 'Enable directory change when opening project' 
+                },
+                { 
+                    config: 'cwd: false', 
+                    description: 'Disable directory change (stay in current directory)' 
+                }
+            ]
+        };
+    }
+}
+
+module.exports = CwdCommand;

package/commands/core/ide/index.js

@@ -0,0 +1,84 @@
+const BaseCommand = require('../../base');
+const spawn = require('child_process').spawn;
+
+/**
+ * IDE Command
+ * Opens the project in the configured IDE/editor
+ */
+class IdeCommand extends BaseCommand {
+    static get metadata() {
+        return {
+            name: 'ide',
+            displayName: 'Open in IDE',
+            description: 'Open project in configured IDE/editor',
+            category: 'core',
+            requiresTmux: false,
+            dependencies: []
+        };
+    }
+
+    static get validation() {
+        return {
+            validateConfig(config) {
+                // IDE command accepts boolean or string 'true'
+                if (config === true || config === 'true' || config === false || config === 'false') {
+                    return true;
+                }
+                return 'IDE configuration must be a boolean or string "true"/"false"';
+            }
+        };
+    }
+
+    static get configuration() {
+        return {
+            async configureInteractive() {
+                // IDE configuration is handled at the project level (project.ide)
+                // This event just enables/disables opening the IDE
+                return 'true';
+            },
+
+            getDefaultConfig() {
+                return 'true';
+            }
+        };
+    }
+
+    static get processing() {
+        return {
+            async processEvent(context) {
+                const { project, isShellMode, shellCommands } = context;
+                
+                if (isShellMode) {
+                    shellCommands.push(`${project.ide} "${project.path.path}" &`);
+                } else {
+                    // In non-shell mode, spawn the IDE directly
+                    spawn(project.ide, [project.path.path]);
+                }
+            },
+
+            generateShellCommand(context) {
+                const { project } = context;
+                return [`${project.ide} "${project.path.path}" &`];
+            }
+        };
+    }
+
+    static get help() {
+        return {
+            usage: 'ide: true',
+            description: 'Opens the project in the configured IDE/editor',
+            examples: [
+                { 
+                    config: 'ide: true', 
+                    description: 'Enable opening project in IDE when switching to project' 
+                },
+                { 
+                    config: 'ide: false', 
+                    description: 'Disable automatic IDE opening' 
+                }
+            ]
+        };
+    }
+}
+
+module.exports = IdeCommand;

package/commands/core/web/index.js

@@ -0,0 +1,109 @@
+const BaseCommand = require('../../base');
+
+/**
+ * Web Command
+ * Opens the project homepage in a web browser
+ */
+class WebCommand extends BaseCommand {
+    static get metadata() {
+        return {
+            name: 'web',
+            displayName: 'Open homepage in browser',
+            description: 'Open project homepage in web browser',
+            category: 'core',
+            requiresTmux: false,
+            dependencies: []
+        };
+    }
+
+    static get validation() {
+        return {
+            validateConfig(config) {
+                // Web command accepts boolean or string 'true'
+                if (config === true || config === 'true' || config === false || config === 'false') {
+                    return true;
+                }
+                return 'Web configuration must be a boolean or string "true"/"false"';
+            }
+        };
+    }
+
+    static get configuration() {
+        return {
+            async configureInteractive() {
+                // Web event just enables/disables opening the homepage
+                // The actual homepage URL is configured at the project level
+                return 'true';
+            },
+
+            getDefaultConfig() {
+                return 'true';
+            }
+        };
+    }
+
+    static get processing() {
+        return {
+            async processEvent(context) {
+                const { project, isShellMode, shellCommands } = context;
+                const homepage = project.homepage;
+                
+                if (!homepage) {
+                    // No homepage configured, skip
+                    return;
+                }
+                
+                if (isShellMode) {
+                    // Different approaches based on OS
+                    let openCmd;
+                    switch (process.platform) {
+                        case 'darwin': openCmd = 'open'; break;
+                        case 'win32': openCmd = 'start'; break;
+                        default: openCmd = 'xdg-open'; break;
+                    }
+                    shellCommands.push(`${openCmd} "${homepage}" &`);
+                } else {
+                    // In non-shell mode, use openurl2
+                    require("openurl2").open(homepage);
+                }
+            },
+
+            generateShellCommand(context) {
+                const { project } = context;
+                const homepage = project.homepage;
+                
+                if (!homepage) {
+                    return [];
+                }
+                
+                let openCmd;
+                switch (process.platform) {
+                    case 'darwin': openCmd = 'open'; break;
+                    case 'win32': openCmd = 'start'; break;
+                    default: openCmd = 'xdg-open'; break;
+                }
+                
+                return [`${openCmd} "${homepage}" &`];
+            }
+        };
+    }
+
+    static get help() {
+        return {
+            usage: 'web: true',
+            description: 'Opens the project homepage in the default web browser',
+            examples: [
+                { 
+                    config: 'web: true', 
+                    description: 'Enable opening project homepage when switching to project' 
+                },
+                { 
+                    config: 'web: false', 
+                    description: 'Disable automatic homepage opening' 
+                }
+            ]
+        };
+    }
+}
+
+module.exports = WebCommand;