workon 2.1.3 → 3.1.0

package/lib/project.js

@@ -1,68 +0,0 @@
-const File = require('phylo');
-const deepAssign = require('deep-assign');
-
-class Project {
-    constructor (name, cfg, defaults) {
-        this._defaults = defaults = defaults || {};
-        this._initialCfg = cfg = cfg || {};
-
-        if (!('name' in cfg)) {
-            cfg.name = name;
-        }
-        
-        if (!('path' in cfg)) {
-            cfg.path = name;
-        }
-        deepAssign(this, deepAssign(defaults, cfg));
-    }
-
-    set base (path) {
-        this._base = File.from(path).absolutify();
-    }
-
-    get base () {
-        return this._base;
-    }
-
-    set ide (cmd) {
-        this._ide = cmd;
-    }
-
-    get ide () {
-        return this._ide;
-    }
-
-    set events (eventCfg) {
-        this._eventCfg = eventCfg;
-    }
-
-    get events () {
-        return this._eventCfg;
-    }
-
-    set path (path) {
-        if (this._base) {
-            this._path = this._base.join(path);
-        } else {
-            this._path = File.from(path);
-        }
-        this._path = this._path.absolutify();
-    }
-
-    get path () {
-        return this._path;
-    }
-
-    set branch (branch) {
-        this._branch = branch;
-    }
-
-    get branch () {
-        return this._branch;
-    }
-}
-
-Project.$isProject = true;
-Project.prototype.$isProject = true;
-
-module.exports = Project;

package/lib/tmux.js

@@ -1,223 +0,0 @@
-const { spawn } = require('child_process');
-const { promisify } = require('util');
-const exec = promisify(require('child_process').exec);
-
-class TmuxManager {
-    constructor() {
-        this.sessionPrefix = 'workon-';
-    }
-
-    async isTmuxAvailable() {
-        try {
-            await exec('which tmux');
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    async sessionExists(sessionName) {
-        try {
-            await exec(`tmux has-session -t "${sessionName}"`);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    getSessionName(projectName) {
-        return `${this.sessionPrefix}${projectName}`;
-    }
-
-    async killSession(sessionName) {
-        try {
-            await exec(`tmux kill-session -t "${sessionName}"`);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    async createSplitSession(projectName, projectPath, claudeArgs = []) {
-        const sessionName = this.getSessionName(projectName);
-        
-        // Kill existing session if it exists
-        if (await this.sessionExists(sessionName)) {
-            await this.killSession(sessionName);
-        }
-
-        const claudeCommand = claudeArgs.length > 0 
-            ? `claude ${claudeArgs.join(' ')}`
-            : 'claude';
-
-        // Create new tmux session with claude in the first pane
-        await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
-        
-        // Split window horizontally and run shell in second pane
-        await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
-        
-        // Set focus on claude pane (left pane)
-        await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-
-        return sessionName;
-    }
-
-    async createThreePaneSession(projectName, projectPath, claudeArgs = [], npmCommand = 'npm run dev') {
-        const sessionName = this.getSessionName(projectName);
-        
-        // Kill existing session if it exists
-        if (await this.sessionExists(sessionName)) {
-            await this.killSession(sessionName);
-        }
-
-        const claudeCommand = claudeArgs.length > 0 
-            ? `claude ${claudeArgs.join(' ')}`
-            : 'claude';
-
-        // Create new tmux session with claude in the first pane (left side)
-        await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
-        
-        // Split window vertically - creates right side (50/50 split)
-        await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
-        
-        // Split the right pane horizontally - creates top-right and bottom-right (50/50 split)
-        await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
-        
-        // Set remain-on-exit to keep pane open if command fails
-        await exec(`tmux set-option -t "${sessionName}:0.2" remain-on-exit on`);
-        
-        // Resize panes to ensure npm pane is visible (give it at least 10 lines)
-        await exec(`tmux resize-pane -t "${sessionName}:0.2" -y 10`);
-        
-        // Set focus on claude pane (left pane)
-        await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-
-        return sessionName;
-    }
-
-    async createTwoPaneNpmSession(projectName, projectPath, npmCommand = 'npm run dev') {
-        const sessionName = this.getSessionName(projectName);
-        
-        // Kill existing session if it exists
-        if (await this.sessionExists(sessionName)) {
-            await this.killSession(sessionName);
-        }
-
-        // Create new tmux session with shell in the first pane (left side)
-        await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}"`);
-        
-        // Split window vertically and run npm command in right pane
-        await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`);
-        
-        // Set remain-on-exit to keep pane open if command fails
-        await exec(`tmux set-option -t "${sessionName}:0.1" remain-on-exit on`);
-        
-        // Set focus on terminal pane (left pane)
-        await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-
-        return sessionName;
-    }
-
-    async attachToSession(sessionName) {
-        // Check if we're already in a tmux session
-        if (process.env.TMUX) {
-            // If we're already in tmux, switch to the session
-            await exec(`tmux switch-client -t "${sessionName}"`);
-        } else {
-            // Check if iTerm2 integration is available
-            const isITerm = process.env.TERM_PROGRAM === 'iTerm.app' || 
-                           process.env.LC_TERMINAL === 'iTerm2' || 
-                           !!process.env.ITERM_SESSION_ID;
-            const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
-            
-            if (useiTermIntegration) {
-                // Use iTerm2 tmux integration - spawn detached to avoid blocking
-                spawn('tmux', ['-CC', 'attach-session', '-t', sessionName], {
-                    stdio: 'inherit',
-                    detached: true
-                });
-            } else {
-                // Use regular tmux - spawn detached to avoid blocking
-                spawn('tmux', ['attach-session', '-t', sessionName], {
-                    stdio: 'inherit',
-                    detached: true
-                });
-            }
-        }
-    }
-
-    buildShellCommands(projectName, projectPath, claudeArgs = []) {
-        const sessionName = this.getSessionName(projectName);
-        const claudeCommand = claudeArgs.length > 0 
-            ? `claude ${claudeArgs.join(' ')}`
-            : 'claude';
-
-        return [
-            `# Create tmux split session for ${projectName}`,
-            `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-            `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
-            `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
-            `tmux select-pane -t "${sessionName}:0.0"`,
-            process.env.TMUX 
-                ? `tmux switch-client -t "${sessionName}"`
-                : ((process.env.TERM_PROGRAM === 'iTerm.app' || process.env.LC_TERMINAL === 'iTerm2' || process.env.ITERM_SESSION_ID) && !process.env.TMUX_CC_NOT_SUPPORTED)
-                    ? `tmux -CC attach-session -t "${sessionName}"`
-                    : `tmux attach-session -t "${sessionName}"`
-        ];
-    }
-
-    buildThreePaneShellCommands(projectName, projectPath, claudeArgs = [], npmCommand = 'npm run dev') {
-        const sessionName = this.getSessionName(projectName);
-        const claudeCommand = claudeArgs.length > 0 
-            ? `claude ${claudeArgs.join(' ')}`
-            : 'claude';
-
-        return [
-            `# Create tmux three-pane session for ${projectName}`,
-            `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-            `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
-            `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
-            `tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`,
-            `tmux set-option -t "${sessionName}:0.2" remain-on-exit on`,
-            `tmux resize-pane -t "${sessionName}:0.2" -y 10`,
-            `tmux select-pane -t "${sessionName}:0.0"`,
-            process.env.TMUX 
-                ? `tmux switch-client -t "${sessionName}"`
-                : ((process.env.TERM_PROGRAM === 'iTerm.app' || process.env.LC_TERMINAL === 'iTerm2' || process.env.ITERM_SESSION_ID) && !process.env.TMUX_CC_NOT_SUPPORTED)
-                    ? `tmux -CC attach-session -t "${sessionName}"`
-                    : `tmux attach-session -t "${sessionName}"`
-        ];
-    }
-
-    buildTwoPaneNpmShellCommands(projectName, projectPath, npmCommand = 'npm run dev') {
-        const sessionName = this.getSessionName(projectName);
-
-        return [
-            `# Create tmux two-pane session with npm for ${projectName}`,
-            `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-            `tmux new-session -d -s "${sessionName}" -c "${projectPath}"`,
-            `tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`,
-            `tmux set-option -t "${sessionName}:0.1" remain-on-exit on`,
-            `tmux select-pane -t "${sessionName}:0.0"`,
-            process.env.TMUX 
-                ? `tmux switch-client -t "${sessionName}"`
-                : ((process.env.TERM_PROGRAM === 'iTerm.app' || process.env.LC_TERMINAL === 'iTerm2' || process.env.ITERM_SESSION_ID) && !process.env.TMUX_CC_NOT_SUPPORTED)
-                    ? `tmux -CC attach-session -t "${sessionName}"`
-                    : `tmux attach-session -t "${sessionName}"`
-        ];
-    }
-
-    async listWorkonSessions() {
-        try {
-            const { stdout } = await exec('tmux list-sessions -F "#{session_name}"');
-            return stdout.trim()
-                .split('\n')
-                .filter(session => session.startsWith(this.sessionPrefix))
-                .map(session => session.replace(this.sessionPrefix, ''));
-        } catch {
-            return [];
-        }
-    }
-}
-
-module.exports = TmuxManager;

package/lib/validation.js

@@ -1,120 +0,0 @@
-const File = require('phylo');
-const { spawn } = require('child_process');
-const path = require('path');
-const registry = require('../commands/registry');
-
-class ProjectValidator {
-    constructor(config) {
-        this.config = config;
-    }
-
-    validateProjectName(name, existingProjects = {}) {
-        if (!name || name.trim() === '') {
-            return 'Project name cannot be empty';
-        }
-        
-        if (name in existingProjects) {
-            return 'Project already exists';
-        }
-        
-        if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
-            return 'Project name can only contain letters, numbers, underscores, and hyphens';
-        }
-        
-        return true;
-    }
-
-    validateProjectPath(projectPath, basePath) {
-        if (!projectPath || projectPath.trim() === '') {
-            return 'Project path cannot be empty';
-        }
-        
-        const fullPath = basePath ? path.resolve(basePath, projectPath) : path.resolve(projectPath);
-        
-        try {
-            const fileObj = new File(fullPath);
-            if (!fileObj.exists) {
-                return `Directory does not exist: ${fullPath}`;
-            }
-            if (!fileObj.isDirectory) {
-                return `Path is not a directory: ${fullPath}`;
-            }
-        } catch (error) {
-            return `Invalid path: ${error.message}`;
-        }
-        
-        return true;
-    }
-
-    validateIdeCommand(ideCommand) {
-        if (!ideCommand || ideCommand.trim() === '') {
-            return 'IDE command cannot be empty';
-        }
-
-        const validIdeCommands = ['code', 'idea', 'atom', 'subl', 'vim', 'emacs'];
-        if (!validIdeCommands.includes(ideCommand)) {
-            return `Unknown IDE command. Supported: ${validIdeCommands.join(', ')}`;
-        }
-
-        return true;
-    }
-
-    async validateIdeAvailability(ideCommand) {
-        return new Promise((resolve) => {
-            const child = spawn('which', [ideCommand], { stdio: 'pipe' });
-            child.on('close', (code) => {
-                if (code === 0) {
-                    resolve(true);
-                } else {
-                    resolve(`IDE command '${ideCommand}' not found in PATH`);
-                }
-            });
-            child.on('error', () => {
-                resolve(`Could not check if '${ideCommand}' is available`);
-            });
-        });
-    }
-
-    async validateEvents(events) {
-        if (!events || typeof events !== 'object') {
-            return 'Events must be an object';
-        }
-
-        // 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(', ')}`;
-        }
-
-        // 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;
-    }
-
-
-    validateUrl(url) {
-        if (!url) return true; // Optional field
-        
-        try {
-            new URL(url);
-            return true;
-        } catch {
-            return 'Invalid URL format';
-        }
-    }
-}
-
-module.exports = ProjectValidator;

package/test-architecture.js

@@ -1,145 +0,0 @@
-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-colon-syntax.js

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-
-// Comprehensive test of the colon syntax feature
-const { execSync } = require('child_process');
-
-console.log('🧪 Testing Colon Syntax Feature\n');
-
-const tests = [
-    {
-        name: 'All commands (backward compatibility)',
-        command: 'node bin/workon test-project --shell',
-        expectShellCommands: 3 // cwd, claude, npm in tmux
-    },
-    {
-        name: 'Single command: cwd only',
-        command: 'node bin/workon test-project:cwd --shell',
-        expectOutput: 'cd "/users/israelroldan/code/test-project"'
-    },
-    {
-        name: 'Single command: claude (auto-adds cwd)',
-        command: 'node bin/workon test-project:claude --shell',
-        expectTmux: true
-    },
-    {
-        name: 'Multiple commands: cwd,npm',
-        command: 'node bin/workon test-project:cwd,npm --shell',
-        expectTmux: true
-    },
-    {
-        name: 'Project help',
-        command: 'node bin/workon test-project:help',
-        expectOutput: 'Available commands for'
-    },
-    {
-        name: 'Invalid command validation',
-        command: 'node bin/workon test-project:invalid 2>&1 || true',
-        expectOutput: 'Commands not configured'
-    }
-];
-
-let passed = 0;
-let failed = 0;
-
-for (const test of tests) {
-    try {
-        console.log(`Testing: ${test.name}`);
-        const output = execSync(test.command, { encoding: 'utf8', timeout: 10000 });
-        
-        let success = false;
-        
-        if (test.expectOutput) {
-            success = output.includes(test.expectOutput);
-        } else if (test.expectTmux) {
-            success = output.includes('tmux');
-        } else if (test.expectShellCommands) {
-            const lines = output.trim().split('\n').filter(line => line.trim() && !line.startsWith('#') && !line.startsWith('ℹ'));
-            success = lines.length >= test.expectShellCommands;
-        } else {
-            success = true; // Just check it doesn't crash
-        }
-        
-        if (success) {
-            console.log('   ✅ PASS');
-            passed++;
-        } else {
-            console.log('   ❌ FAIL');
-            console.log(`   Expected: ${test.expectOutput || test.expectTmux || test.expectShellCommands}`);
-            console.log(`   Got: ${output.substring(0, 200)}...`);
-            failed++;
-        }
-    } catch (error) {
-        console.log('   ❌ ERROR:', error.message);
-        failed++;
-    }
-    console.log('');
-}
-
-console.log(`\n📊 Results: ${passed} passed, ${failed} failed`);
-
-if (failed === 0) {
-    console.log('🎉 All tests passed! Colon syntax is working perfectly.');
-} else {
-    console.log('⚠️  Some tests failed. Please check the implementation.');
-    process.exit(1);
-}