workon 1.3.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 {
@@ -64,20 +69,37 @@ class open extends command {
             me.shellCommands = [];
         }
 
-        // Check for split terminal scenario
+        // Intelligent layout detection
         const hasCwd = events.includes('cwd');
         const hasClaudeEvent = events.includes('claude');
-        const claudeConfig = project.events.claude;
-        const shouldUseSplitTerminal = hasCwd && hasClaudeEvent && 
-            claudeConfig && typeof claudeConfig === 'object' && claudeConfig.split_terminal;
-
-        if (shouldUseSplitTerminal) {
+        const hasNpmEvent = events.includes('npm');
+        
+        if (hasCwd && hasClaudeEvent && hasNpmEvent) {
+            // Three-pane layout: Claude + Terminal + NPM
+            await me.handleThreePaneLayout(project, isShellMode);
+            // Process other events except cwd, claude, and npm
+            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
+            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 => e !== 'cwd' && e !== 'claude').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
@@ -123,24 +145,128 @@ 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
+                await me.processEvent('cwd');
+                await me.processEvent('claude');
+            }
+        }
+    }
+
+    async handleThreePaneLayout(project, isShellMode) {
+        let me = this;
+        const tmux = new TmuxManager();
+        const claudeConfig = project.events.claude;
+        const claudeArgs = (claudeConfig && claudeConfig.flags) ? claudeConfig.flags : [];
+        const npmConfig = project.events.npm;
+        const NpmCommand = registry.getCommandByName('npm');
+        const npmCommand = NpmCommand ? NpmCommand._getNpmCommand(npmConfig) : 'npm run dev';
+        
+        if (isShellMode) {
+            // Check if tmux is available
+            if (await tmux.isTmuxAvailable()) {
+                const commands = tmux.buildThreePaneShellCommands(
+                    project.name, 
+                    project.path.path, 
+                    claudeArgs,
+                    npmCommand
+                );
+                me.shellCommands.push(...commands);
+            } else {
+                // Fall back to normal behavior if tmux is not available
+                me.log.debug('Tmux not available, falling back to normal mode');
+                me.shellCommands.push(`cd "${project.path.path}"`);
+                const claudeCommand = claudeArgs.length > 0 
+                    ? `claude ${claudeArgs.join(' ')}`
+                    : 'claude';
+                me.shellCommands.push(claudeCommand);
+                me.shellCommands.push(npmCommand);
+            }
+        } else {
+            // Direct execution mode
+            if (await tmux.isTmuxAvailable()) {
+                try {
+                    const sessionName = await tmux.createThreePaneSession(
+                        project.name, 
+                        project.path.path, 
+                        claudeArgs,
+                        npmCommand
+                    );
+                    await tmux.attachToSession(sessionName);
+                } catch (error) {
+                    me.log.debug(`Failed to create tmux session: ${error.message}`);
+                    // Fall back to normal behavior
+                    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');
+                await me.processEvent('cwd');
+                await me.processEvent('claude');
+                await me.processEvent('npm');
             }
         }
     }
 
-    processEvent (event) {
+    async handleTwoPaneNpmLayout(project, isShellMode) {
+        let me = this;
+        const tmux = new TmuxManager();
+        const npmConfig = project.events.npm;
+        const NpmCommand = registry.getCommandByName('npm');
+        const npmCommand = NpmCommand ? NpmCommand._getNpmCommand(npmConfig) : 'npm run dev';
+        
+        if (isShellMode) {
+            // Check if tmux is available
+            if (await tmux.isTmuxAvailable()) {
+                const commands = tmux.buildTwoPaneNpmShellCommands(
+                    project.name, 
+                    project.path.path, 
+                    npmCommand
+                );
+                me.shellCommands.push(...commands);
+            } else {
+                // Fall back to normal behavior if tmux is not available
+                me.log.debug('Tmux not available, falling back to normal mode');
+                me.shellCommands.push(`cd "${project.path.path}"`);
+                me.shellCommands.push(npmCommand);
+            }
+        } else {
+            // Direct execution mode
+            if (await tmux.isTmuxAvailable()) {
+                try {
+                    const sessionName = await tmux.createTwoPaneNpmSession(
+                        project.name, 
+                        project.path.path, 
+                        npmCommand
+                    );
+                    await tmux.attachToSession(sessionName);
+                } catch (error) {
+                    me.log.debug(`Failed to create tmux session: ${error.message}`);
+                    // Fall back to normal behavior
+                    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
+                await me.processEvent('cwd');
+                await me.processEvent('npm');
+            }
+        }
+    }
+
+
+    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}`);
@@ -155,67 +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;
+            // 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;