workon 2.1.2 → 3.0.0

package/commands/core/web/index.js

@@ -1,109 +0,0 @@
-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;

package/commands/extensions/claude/index.js

@@ -1,211 +0,0 @@
-const BaseCommand = require('../../base');
-const inquirer = require('inquirer');
-const spawn = require('child_process').spawn;
-
-/**
- * Claude Command
- * Launches Claude Code with optional configuration
- */
-class ClaudeCommand extends BaseCommand {
-    static get metadata() {
-        return {
-            name: 'claude',
-            displayName: 'Launch Claude Code',
-            description: 'Launch Claude Code with optional flags and configuration',
-            category: 'development',
-            requiresTmux: true,
-            dependencies: ['claude']
-        };
-    }
-
-    static get validation() {
-        return {
-            validateConfig(config) {
-                if (config === true || config === 'true' || config === false || config === 'false') {
-                    return true;
-                }
-                
-                if (typeof config === 'object' && config !== null) {
-                    // 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;
-                }
-                
-                return 'Claude configuration must be a boolean, string "true"/"false", or configuration object';
-            }
-        };
-    }
-
-    static get configuration() {
-        return {
-            async configureInteractive() {
-                console.log('\n⚙️  Configure Claude Event\n');
-                
-                const claudeQuestions = [
-                    {
-                        type: 'confirm',
-                        name: 'useAdvanced',
-                        message: 'Configure advanced Claude options?',
-                        default: false
-                    }
-                ];
-
-                const claudeAnswer = await inquirer.prompt(claudeQuestions);
-                
-                if (!claudeAnswer.useAdvanced) {
-                    return 'true';
-                }
-
-                const advancedQuestions = [
-                    {
-                        type: 'input',
-                        name: 'flags',
-                        message: 'Claude flags (comma-separated, e.g. --resume,--debug):',
-                        filter: (input) => {
-                            if (!input.trim()) return [];
-                            return input.split(',').map(flag => flag.trim()).filter(flag => flag);
-                        }
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'split_terminal',
-                        message: 'Enable split terminal (Claude + shell side-by-side with tmux)?',
-                        default: false
-                    }
-                ];
-
-                const advancedAnswers = await inquirer.prompt(advancedQuestions);
-                
-                const configObj = {};
-
-                if (advancedAnswers.flags && advancedAnswers.flags.length > 0) {
-                    configObj.flags = advancedAnswers.flags;
-                }
-
-                if (advancedAnswers.split_terminal) {
-                    configObj.split_terminal = true;
-                }
-
-                return Object.keys(configObj).length > 0 ? configObj : 'true';
-            },
-
-            getDefaultConfig() {
-                return 'true';
-            }
-        };
-    }
-
-    static get processing() {
-        return {
-            async processEvent(context) {
-                const { project, isShellMode, shellCommands } = context;
-                const claudeConfig = project.events.claude;
-                
-                let claudeArgs = [];
-                
-                // Handle advanced Claude configuration
-                if (claudeConfig && typeof claudeConfig === 'object') {
-                    if (claudeConfig.flags && Array.isArray(claudeConfig.flags)) {
-                        claudeArgs = claudeArgs.concat(claudeConfig.flags);
-                    }
-                }
-                
-                if (isShellMode) {
-                    let claudeCommand = claudeArgs.length > 0 
-                        ? `claude ${claudeArgs.join(' ')}`
-                        : 'claude';
-                    shellCommands.push(claudeCommand);
-                } else {
-                    spawn('claude', claudeArgs, {
-                        cwd: project.path.path,
-                        stdio: 'inherit'
-                    });
-                }
-            },
-
-            generateShellCommand(context) {
-                const { project } = context;
-                const claudeConfig = project.events.claude;
-                
-                let claudeArgs = [];
-                
-                // Handle advanced Claude configuration
-                if (claudeConfig && typeof claudeConfig === 'object') {
-                    if (claudeConfig.flags && Array.isArray(claudeConfig.flags)) {
-                        claudeArgs = claudeArgs.concat(claudeConfig.flags);
-                    }
-                }
-                
-                const claudeCommand = claudeArgs.length > 0 
-                    ? `claude ${claudeArgs.join(' ')}`
-                    : 'claude';
-                    
-                return [claudeCommand];
-            }
-        };
-    }
-
-    static get tmux() {
-        return {
-            getLayoutPriority() {
-                return 100; // High priority for Claude
-            },
-
-            contributeToLayout(enabledCommands) {
-                // Claude prefers split terminal layouts
-                const hasCwd = enabledCommands.some(cmd => cmd.name === 'cwd');
-                const hasNpm = enabledCommands.some(cmd => cmd.name === 'npm');
-                
-                if (hasCwd && hasNpm) {
-                    return 'three-pane'; // Claude + Terminal + NPM
-                } else if (hasCwd) {
-                    return 'split-terminal'; // Claude + Terminal
-                } else {
-                    return 'single'; // Just Claude
-                }
-            }
-        };
-    }
-
-    static get help() {
-        return {
-            usage: 'claude: <configuration>',
-            description: 'Launch Claude Code with optional flags and configuration',
-            examples: [
-                { 
-                    config: 'claude: true', 
-                    description: 'Launch Claude Code with default settings' 
-                },
-                { 
-                    config: 'claude: { flags: ["--resume", "--debug"] }', 
-                    description: 'Launch Claude with specific flags' 
-                },
-                { 
-                    config: 'claude: { split_terminal: true }', 
-                    description: 'Launch Claude in split terminal with tmux' 
-                }
-            ]
-        };
-    }
-}
-
-module.exports = ClaudeCommand;

package/commands/extensions/docker/index.js

@@ -1,167 +0,0 @@
-const BaseCommand = require('../../base');
-const inquirer = require('inquirer');
-const spawn = require('child_process').spawn;
-
-/**
- * Docker Command
- * Manages Docker containers for the project
- * 
- * This demonstrates how easy it is to add a new command to the system!
- * Just create this file and the system automatically discovers it.
- */
-class DockerCommand extends BaseCommand {
-    static get metadata() {
-        return {
-            name: 'docker',
-            displayName: 'Docker container management',
-            description: 'Start/stop Docker containers for the project',
-            category: 'development',
-            requiresTmux: false,
-            dependencies: ['docker']
-        };
-    }
-
-    static get validation() {
-        return {
-            validateConfig(config) {
-                if (config === true || config === 'true' || config === false || config === 'false') {
-                    return true;
-                }
-                
-                if (typeof config === 'string' && config.trim() !== '') {
-                    return true; // Docker compose file path
-                }
-                
-                if (typeof config === 'object' && config !== null) {
-                    if (config.compose_file && typeof config.compose_file !== 'string') {
-                        return 'Docker compose_file must be a string';
-                    }
-                    if (config.services && !Array.isArray(config.services)) {
-                        return 'Docker services must be an array';
-                    }
-                    return true;
-                }
-                
-                return 'Docker configuration must be a boolean, string, or configuration object';
-            }
-        };
-    }
-
-    static get configuration() {
-        return {
-            async configureInteractive() {
-                console.log('\n🐳 Configure Docker Event\n');
-                
-                const dockerQuestions = [
-                    {
-                        type: 'input',
-                        name: 'compose_file',
-                        message: 'Docker Compose file path (relative to project):',
-                        default: 'docker-compose.yml'
-                    },
-                    {
-                        type: 'input',
-                        name: 'services',
-                        message: 'Services to start (comma-separated, or leave empty for all):',
-                        filter: (input) => {
-                            if (!input.trim()) return [];
-                            return input.split(',').map(s => s.trim()).filter(s => s);
-                        }
-                    }
-                ];
-
-                const answers = await inquirer.prompt(dockerQuestions);
-                
-                const config = {
-                    compose_file: answers.compose_file
-                };
-
-                if (answers.services.length > 0) {
-                    config.services = answers.services;
-                }
-
-                return config;
-            },
-
-            getDefaultConfig() {
-                return { compose_file: 'docker-compose.yml' };
-            }
-        };
-    }
-
-    static get processing() {
-        return {
-            async processEvent(context) {
-                const { project, isShellMode, shellCommands } = context;
-                const dockerConfig = project.events.docker;
-                
-                let composeFile = 'docker-compose.yml';
-                let services = [];
-                
-                if (typeof dockerConfig === 'string') {
-                    composeFile = dockerConfig;
-                } else if (dockerConfig && typeof dockerConfig === 'object') {
-                    composeFile = dockerConfig.compose_file || composeFile;
-                    services = dockerConfig.services || [];
-                }
-                
-                const servicesArg = services.length > 0 ? services.join(' ') : '';
-                const dockerCommand = `docker-compose -f ${composeFile} up -d ${servicesArg}`.trim();
-                
-                if (isShellMode) {
-                    shellCommands.push(dockerCommand);
-                } else {
-                    const args = ['-f', composeFile, 'up', '-d'];
-                    if (services.length > 0) {
-                        args.push(...services);
-                    }
-                    spawn('docker-compose', args, {
-                        cwd: project.path.path,
-                        stdio: 'inherit'
-                    });
-                }
-            },
-
-            generateShellCommand(context) {
-                const { project } = context;
-                const dockerConfig = project.events.docker;
-                
-                let composeFile = 'docker-compose.yml';
-                let services = [];
-                
-                if (typeof dockerConfig === 'string') {
-                    composeFile = dockerConfig;
-                } else if (dockerConfig && typeof dockerConfig === 'object') {
-                    composeFile = dockerConfig.compose_file || composeFile;
-                    services = dockerConfig.services || [];
-                }
-                
-                const servicesArg = services.length > 0 ? services.join(' ') : '';
-                return [`docker-compose -f ${composeFile} up -d ${servicesArg}`.trim()];
-            }
-        };
-    }
-
-    static get help() {
-        return {
-            usage: 'docker: <compose-file> | <configuration>',
-            description: 'Start Docker containers using docker-compose',
-            examples: [
-                { 
-                    config: 'docker: true', 
-                    description: 'Start containers using default docker-compose.yml' 
-                },
-                { 
-                    config: 'docker: "docker-compose.dev.yml"', 
-                    description: 'Use specific compose file' 
-                },
-                { 
-                    config: 'docker: { compose_file: "docker-compose.yml", services: ["web", "db"] }', 
-                    description: 'Start only specific services' 
-                }
-            ]
-        };
-    }
-}
-
-module.exports = DockerCommand;

package/commands/extensions/npm/index.js

@@ -1,208 +0,0 @@
-const BaseCommand = require('../../base');
-const inquirer = require('inquirer');
-const spawn = require('child_process').spawn;
-
-/**
- * NPM Command
- * Executes NPM scripts in the project directory
- */
-class NpmCommand extends BaseCommand {
-    static get metadata() {
-        return {
-            name: 'npm',
-            displayName: 'Run NPM command',
-            description: 'Execute NPM scripts in project directory',
-            category: 'development',
-            requiresTmux: true,
-            dependencies: ['npm']
-        };
-    }
-
-    static get validation() {
-        return {
-            validateConfig(config) {
-                if (config === true || config === 'true' || config === false || config === 'false') {
-                    return true;
-                }
-                
-                if (typeof config === 'string' && config.trim() !== '') {
-                    return true; // Simple string command
-                }
-                
-                if (typeof config === 'object' && config !== null) {
-                    // Validate command if present
-                    if (config.command) {
-                        if (typeof config.command !== 'string' || config.command.trim() === '') {
-                            return 'NPM command must be a non-empty string';
-                        }
-                    }
-
-                    // Validate watch if present
-                    if (config.watch !== undefined && typeof config.watch !== 'boolean') {
-                        return 'NPM watch must be a boolean';
-                    }
-
-                    // Validate auto_restart if present
-                    if (config.auto_restart !== undefined && typeof config.auto_restart !== 'boolean') {
-                        return 'NPM auto_restart must be a boolean';
-                    }
-                    
-                    return true;
-                }
-                
-                return 'NPM configuration must be a boolean, string command, or configuration object';
-            }
-        };
-    }
-
-    static get configuration() {
-        return {
-            async configureInteractive() {
-                console.log('\n📦 Configure NPM Event\n');
-                
-                const npmQuestions = [
-                    {
-                        type: 'input',
-                        name: 'command',
-                        message: 'NPM script to run (e.g., dev, start, test):',
-                        default: 'dev',
-                        validate: (value) => {
-                            if (!value.trim()) {
-                                return 'NPM command cannot be empty';
-                            }
-                            return true;
-                        }
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'useAdvanced',
-                        message: 'Configure advanced NPM options?',
-                        default: false
-                    }
-                ];
-
-                const basicAnswers = await inquirer.prompt(npmQuestions);
-                
-                if (!basicAnswers.useAdvanced) {
-                    return basicAnswers.command;
-                }
-
-                const advancedQuestions = [
-                    {
-                        type: 'confirm',
-                        name: 'watch',
-                        message: 'Enable watch mode (if supported by command)?',
-                        default: true
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'auto_restart',
-                        message: 'Auto-restart on crashes?',
-                        default: false
-                    }
-                ];
-
-                const advancedAnswers = await inquirer.prompt(advancedQuestions);
-                
-                const configObj = {
-                    command: basicAnswers.command
-                };
-
-                if (advancedAnswers.watch) {
-                    configObj.watch = true;
-                }
-
-                if (advancedAnswers.auto_restart) {
-                    configObj.auto_restart = true;
-                }
-
-                return configObj;
-            },
-
-            getDefaultConfig() {
-                return 'dev';
-            }
-        };
-    }
-
-    static get processing() {
-        return {
-            async processEvent(context) {
-                const { project, isShellMode, shellCommands } = context;
-                const npmConfig = project.events.npm;
-                const npmCommand = NpmCommand._getNpmCommand(npmConfig);
-                
-                if (isShellMode) {
-                    shellCommands.push(npmCommand);
-                } else {
-                    const scriptName = npmCommand.replace('npm run ', '');
-                    spawn('npm', ['run', scriptName], {
-                        cwd: project.path.path,
-                        stdio: 'inherit'
-                    });
-                }
-            },
-
-            generateShellCommand(context) {
-                const { project } = context;
-                const npmConfig = project.events.npm;
-                return [NpmCommand._getNpmCommand(npmConfig)];
-            }
-        };
-    }
-
-    static _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';
-        }
-    }
-
-    static get tmux() {
-        return {
-            getLayoutPriority() {
-                return 50; // Medium priority for NPM
-            },
-
-            contributeToLayout(enabledCommands) {
-                // NPM works well in multi-pane layouts
-                const hasCwd = enabledCommands.some(cmd => cmd.name === 'cwd');
-                const hasClaude = enabledCommands.some(cmd => cmd.name === 'claude');
-                
-                if (hasCwd && hasClaude) {
-                    return 'three-pane'; // Claude + Terminal + NPM
-                } else if (hasCwd) {
-                    return 'two-pane-npm'; // Terminal + NPM
-                } else {
-                    return 'single'; // Just NPM
-                }
-            }
-        };
-    }
-
-    static get help() {
-        return {
-            usage: 'npm: <script-name> | <configuration>',
-            description: 'Execute NPM scripts in the project directory',
-            examples: [
-                { 
-                    config: 'npm: "dev"', 
-                    description: 'Run npm run dev' 
-                },
-                { 
-                    config: 'npm: { command: "test", watch: true }', 
-                    description: 'Run tests in watch mode' 
-                },
-                { 
-                    config: 'npm: { command: "start", auto_restart: true }', 
-                    description: 'Run start script with auto-restart on crashes' 
-                }
-            ]
-        };
-    }
-}
-
-module.exports = NpmCommand;