workon 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.1.0](https://github.com/israelroldan/workon/compare/v2.0.0...v2.1.0) (2025-08-07)
+
+
+### Features
+
+* Introduce colon syntax for selective command execution ([7b2193a](https://github.com/israelroldan/workon/commit/7b2193ace8cc014dfd71894e3e9f49e0fdea33b9))
+
 ## [2.0.0](https://github.com/israelroldan/workon/compare/v2.0.0-alpha.1...v2.0.0) (2025-08-07)
 
 ## [2.0.0-alpha.1](https://github.com/israelroldan/workon/compare/v1.4.1...v2.0.0-alpha.1) (2025-08-07)

package/cli/open.js

@@ -21,24 +21,42 @@ class open extends command {
         }
     }
 
-    async processProject (project) {
+    async processProject (projectParam) {
         let me = this;
         let environment = me.root().environment;
 
+        // Parse colon syntax: project:command1,command2
+        const [projectName, commandsString] = projectParam.split(':');
+        const requestedCommands = commandsString ? commandsString.split(',').map(cmd => cmd.trim()) : null;
+        
+        // Special case: project:help shows available commands for that project
+        if (commandsString === 'help') {
+            return me.showProjectHelp(projectName);
+        }
+        
+        me.log.debug(`Project: ${projectName}, Commands: ${requestedCommands ? requestedCommands.join(', ') : 'all'}`);
+
         let projects = me.config.get('projects');
         if (!projects) {
             me.config.set('projects', {});
         } else {
-            if (environment.$isProjectEnvironment && (project === 'this' || project === '.')) {
+            if (environment.$isProjectEnvironment && (projectName === 'this' || projectName === '.')) {
                 me.log.info(`Open current: ${environment.project.name}`);
             } else {
-                if (project in projects) {
-                    let cfg = projects[project];
-                    cfg.name = project;
-                    await me.switchTo(ProjectEnvironment.load(cfg, me.config.get('project_defaults')));
+                if (projectName in projects) {
+                    let cfg = projects[projectName];
+                    cfg.name = projectName;
+                    
+                    // Validate requested commands if specified
+                    if (requestedCommands) {
+                        me.validateRequestedCommands(requestedCommands, cfg, projectName);
+                    }
+                    
+                    const projectEnv = ProjectEnvironment.load(cfg, me.config.get('project_defaults'));
+                    await me.switchTo(projectEnv, requestedCommands);
                 } else {
-                    me.log.debug(`Project '${project}' not found, starting interactive mode`);
-                    return me.startInteractiveMode(project);
+                    me.log.debug(`Project '${projectName}' not found, starting interactive mode`);
+                    return me.startInteractiveMode(projectName);
                 }
             }
         }
@@ -52,16 +70,40 @@ class open extends command {
         return interactiveCmd.dispatch(new me.args.constructor([project]))
     }
 
-    async switchTo (environment) {
+    validateRequestedCommands(requestedCommands, projectConfig, projectName) {
+        const configuredEvents = Object.keys(projectConfig.events || {});
+        const invalidCommands = requestedCommands.filter(cmd => !configuredEvents.includes(cmd));
+        
+        if (invalidCommands.length > 0) {
+            const availableCommands = configuredEvents.join(', ');
+            throw new Error(
+                `Commands not configured for project '${projectName}': ${invalidCommands.join(', ')}\n` +
+                `Available commands: ${availableCommands}`
+            );
+        }
+    }
+
+    async switchTo (environment, requestedCommands = null) {
         let me = this;
         me.root().environment = environment;
         let project = environment.project;
 
-        let events = Object.keys(project.events).filter((e) => project.events[e]);
+        // Determine which events to execute
+        let events;
+        if (requestedCommands) {
+            // Use requested commands (already validated)
+            events = me.resolveCommandDependencies(requestedCommands, project);
+            me.log.debug(`Executing requested commands: ${events.join(', ')}`);
+        } else {
+            // Execute all configured events (current behavior)
+            events = Object.keys(project.events).filter((e) => project.events[e]);
+            me.log.debug(`Executing all configured commands: ${events.join(', ')}`);
+        }
+
         me.log.debug(`Shell is ${process.env.SHELL}`);
         me.log.debug(`Project path is ${project.path.path}`);
         me.log.debug(`IDE command is: ${project.ide}`);
-        me.log.debug(`Actions are: ${events}`);
+        me.log.debug(`Final events to execute: ${events.join(', ')}`);
 
         // Initialize shell commands collector if in shell mode
         let isShellMode = me.params.shell || me.root().params.shell;
@@ -69,7 +111,7 @@ class open extends command {
             me.shellCommands = [];
         }
 
-        // Intelligent layout detection
+        // Intelligent layout detection based on actual events being executed
         const hasCwd = events.includes('cwd');
         const hasClaudeEvent = events.includes('claude');
         const hasNpmEvent = events.includes('npm');
@@ -96,7 +138,7 @@ class open extends command {
                 await me.processEvent(event);
             }
         } else {
-            // Normal event processing
+            // Normal event processing - execute commands individually
             for (const event of events) {
                 await me.processEvent(event);
             }
@@ -108,6 +150,66 @@ class open extends command {
         }
     }
 
+    showProjectHelp(projectName) {
+        let me = this;
+        let projects = me.config.get('projects');
+        
+        if (!projects || !(projectName in projects)) {
+            me.log.error(`Project '${projectName}' not found`);
+            return;
+        }
+        
+        const projectConfig = projects[projectName];
+        const configuredEvents = Object.keys(projectConfig.events || {});
+        
+        console.log(`\n📋 Available commands for '${projectName}':`);
+        console.log('─'.repeat(50));
+        
+        for (const eventName of configuredEvents) {
+            const command = registry.getCommandByName(eventName);
+            if (command && command.metadata) {
+                const config = projectConfig.events[eventName];
+                let configDesc = '';
+                if (config !== true && config !== 'true') {
+                    if (typeof config === 'object') {
+                        configDesc = ` (${JSON.stringify(config)})`;
+                    } else {
+                        configDesc = ` (${config})`;
+                    }
+                }
+                console.log(`  ${eventName.padEnd(8)} - ${command.metadata.description}${configDesc}`);
+            }
+        }
+        
+        console.log('\n💡 Usage examples:');
+        console.log(`  workon ${projectName}                    # Execute all commands`);
+        console.log(`  workon ${projectName}:cwd               # Just change directory`);
+        console.log(`  workon ${projectName}:claude            # Just Claude (auto-adds cwd)`);
+        
+        if (configuredEvents.length > 1) {
+            const twoCommands = configuredEvents.slice(0, 2).join(',');
+            console.log(`  workon ${projectName}:${twoCommands.padEnd(12)} # Multiple commands`);
+        }
+        
+        console.log(`  workon ${projectName}:cwd --shell       # Output shell commands\n`);
+    }
+
+    resolveCommandDependencies(requestedCommands, project) {
+        const resolved = [...requestedCommands];
+        
+        // Auto-add cwd dependency for commands that need it
+        const needsCwd = ['claude', 'npm', 'ide'];
+        const needsCwdCommands = requestedCommands.filter(cmd => needsCwd.includes(cmd));
+        
+        if (needsCwdCommands.length > 0 && !requestedCommands.includes('cwd')) {
+            resolved.unshift('cwd'); // Add cwd at the beginning
+            this.log.debug(`Auto-added 'cwd' dependency for commands: ${needsCwdCommands.join(', ')}`);
+        }
+        
+        // Remove duplicates while preserving order
+        return [...new Set(resolved)];
+    }
+
     async handleSplitTerminal(project, isShellMode) {
         let me = this;
         const tmux = new TmuxManager();

package/demo-colon-syntax.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+console.log(`
+🎯 COLON SYNTAX FEATURE DEMONSTRATION
+=====================================
+
+The new colon syntax allows selective command execution for projects:
+
+📋 SYNTAX:
+  workon <project>              # Execute all configured commands  
+  workon <project>:<command>    # Execute single command
+  workon <project>:<cmd1,cmd2>  # Execute multiple commands
+  workon <project>:help         # Show available commands
+
+✨ KEY FEATURES:
+  
+  1. BACKWARD COMPATIBLE
+     workon my-project          # Still works exactly as before
+  
+  2. SELECTIVE EXECUTION  
+     workon my-project:cwd      # Just change directory
+     workon my-project:claude   # Just open Claude
+     
+  3. SMART DEPENDENCIES
+     workon my-project:claude   # Auto-adds 'cwd' dependency
+     workon my-project:npm      # Auto-adds 'cwd' dependency
+     
+  4. MULTIPLE COMMANDS
+     workon my-project:cwd,claude,npm    # Custom combinations
+     
+  5. PROJECT HELP
+     workon my-project:help     # Show what commands are available
+     
+  6. ERROR VALIDATION
+     workon my-project:invalid  # Clear error messages
+     
+  7. SHELL MODE SUPPORT
+     workon my-project:cwd --shell       # Works with all flags
+
+🏗️ IMPLEMENTATION HIGHLIGHTS:
+
+  • Zero switchit changes needed - uses existing parameter parsing
+  • Simple string split logic: project.split(':')  
+  • Integrates perfectly with Command-Centric Architecture
+  • Smart layout detection works with any command combination
+  • Comprehensive validation and dependency resolution
+
+🎉 BENEFITS:
+
+  • Faster startup for individual commands
+  • Flexible workflow matching  
+  • Resource efficiency
+  • Better testing and debugging
+  • Foundation for future features (aliases, profiles, etc.)
+
+This feature transforms workon from "all-or-nothing" to "pick-what-you-need"!
+`);

package/docs/adr/002-positional-command-arguments.md

@@ -1,10 +1,16 @@
 # ADR-002: Positional Command Arguments
 
-**Status:** Proposed  
-**Date:** 2025-08-06  
+**Status:** Implemented (as Colon Syntax)  
+**Date:** 2025-08-07  
 **Deciders:** Israel Roldan  
 **Related:** ADR-001 (Command-Centric Architecture)
 
+**Implementation Note:** Instead of positional arguments, we implemented a cleaner colon syntax approach:
+- `workon project` - Execute all commands
+- `workon project:cwd` - Execute single command  
+- `workon project:cwd,claude` - Execute multiple commands
+- `workon project:help` - Show available commands
+
 ## Context
 
 Currently, the workon CLI operates with a "all-or-nothing" approach where running `workon my-project` executes all configured events for that project. However, there are scenarios where users want to execute only specific commands for a project.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workon",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Work on something great!",
   "main": "index.js",
   "scripts": {

package/test-colon-syntax.js

@@ -0,0 +1,85 @@
+#!/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);
+}