workon 2.0.0 → 2.1.1

package/.history/lib/tmux_20250807120751.js

@@ -0,0 +1,190 @@
+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
+        await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
+        
+        // Split the right pane horizontally - creates top-right and bottom-right
+        await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
+        
+        // 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 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 {
+            // If not in tmux, attach to the session
+            spawn('tmux', ['-CC', 'attach-session', '-t', sessionName], {
+                stdio: 'inherit'
+            });
+        }
+    }
+
+    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}"`
+                : `tmux -CC 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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -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/.history/lib/tmux_20250807120757.js

@@ -0,0 +1,190 @@
+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
+        await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
+        
+        // Split the right pane horizontally - creates top-right and bottom-right
+        await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
+        
+        // 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 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 {
+            // If not in tmux, attach to the session
+            spawn('tmux', ['-CC', 'attach-session', '-t', sessionName], {
+                stdio: 'inherit'
+            });
+        }
+    }
+
+    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}"`
+                : `tmux -CC 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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -t "${sessionName}"`
+                : `tmux -CC 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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -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/.history/lib/tmux_20250807120802.js

@@ -0,0 +1,190 @@
+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
+        await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
+        
+        // Split the right pane horizontally - creates top-right and bottom-right
+        await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
+        
+        // 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 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 {
+            // If not in tmux, attach to the session
+            spawn('tmux', ['-CC', 'attach-session', '-t', sessionName], {
+                stdio: 'inherit'
+            });
+        }
+    }
+
+    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}"`
+                : `tmux -CC 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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -t "${sessionName}"`
+                : `tmux -CC 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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -t "${sessionName}"`
+                : `tmux -CC 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/.history/lib/tmux_20250807120808.js

@@ -0,0 +1,190 @@
+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
+        await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
+        
+        // Split the right pane horizontally - creates top-right and bottom-right
+        await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
+        
+        // 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 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 {
+            // If not in tmux, attach to the session
+            spawn('tmux', ['-CC', 'attach-session', '-t', sessionName], {
+                stdio: 'inherit'
+            });
+        }
+    }
+
+    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}"`
+                : `tmux -CC 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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -t "${sessionName}"`
+                : `tmux -CC 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 select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux switch-client -t "${sessionName}"`
+                : `tmux -CC 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/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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.1](https://github.com/israelroldan/workon/compare/v2.1.0...v2.1.1) (2025-08-07)
+
+
+### Bug Fixes
+
+* Update tmux attach command to use -CC flag for compatibility with iTerm ([2d3d7c7](https://github.com/israelroldan/workon/commit/2d3d7c73fb164f1718908d276f91b8fba004f42d))
+
+## [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/lib/tmux.js

@@ -136,7 +136,7 @@ class TmuxManager {
             `tmux select-pane -t "${sessionName}:0.0"`,
             process.env.TMUX 
                 ? `tmux switch-client -t "${sessionName}"`
-                : `tmux attach-session -t "${sessionName}"`
+                : `tmux -CC attach-session -t "${sessionName}"`
         ];
     }
 
@@ -155,7 +155,7 @@ class TmuxManager {
             `tmux select-pane -t "${sessionName}:0.0"`,
             process.env.TMUX 
                 ? `tmux switch-client -t "${sessionName}"`
-                : `tmux attach-session -t "${sessionName}"`
+                : `tmux -CC attach-session -t "${sessionName}"`
         ];
     }
 
@@ -170,7 +170,7 @@ class TmuxManager {
             `tmux select-pane -t "${sessionName}:0.0"`,
             process.env.TMUX 
                 ? `tmux switch-client -t "${sessionName}"`
-                : `tmux attach-session -t "${sessionName}"`
+                : `tmux -CC attach-session -t "${sessionName}"`
         ];
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workon",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "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);
+}