workon 1.2.1 → 1.3.0

package/.history/.gitignore_20250806202718

@@ -0,0 +1,30 @@
+# ---> Node
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directory
+# https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git
+node_modules
+

package/.history/.gitignore_20250806231444

@@ -0,0 +1,32 @@
+# ---> Node
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directory
+# https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git
+node_modules
+
+.history
+.specstory

package/.history/.gitignore_20250806231450

@@ -0,0 +1,32 @@
+# ---> Node
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directory
+# https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git
+node_modules
+
+.history
+.specstory

package/.history/lib/tmux_20250806233103.js

@@ -0,0 +1,109 @@
+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 -CC has-session -t "${sessionName}"`);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    getSessionName(projectName) {
+        return `${this.sessionPrefix}${projectName}`;
+    }
+
+    async killSession(sessionName) {
+        try {
+            await exec(`tmux -CC 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 -CC new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
+        
+        // Split window horizontally and run shell in second pane
+        await exec(`tmux -CC split-window -h -t "${sessionName}" -c "${projectPath}"`);
+        
+        // Set focus on claude pane (left pane)
+        await exec(`tmux -CC 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 -CC 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 -CC has-session -t "${sessionName}" 2>/dev/null && tmux -CC kill-session -t "${sessionName}"`,
+            `tmux -CC new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
+            `tmux -CC split-window -h -t "${sessionName}" -c "${projectPath}"`,
+            `tmux -CC select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux -CC switch-client -t "${sessionName}"`
+                : `tmux -CC attach-session -t "${sessionName}"`
+        ];
+    }
+
+    async listWorkonSessions() {
+        try {
+            const { stdout } = await exec('tmux -CC 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_20250806233219.js

@@ -0,0 +1,109 @@
+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 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', ['', '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  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_20250806233223.js

@@ -0,0 +1,109 @@
+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 -CC has-session -t "${sessionName}"`);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    getSessionName(projectName) {
+        return `${this.sessionPrefix}${projectName}`;
+    }
+
+    async killSession(sessionName) {
+        try {
+            await exec(`tmux -CC 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 -CC new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
+        
+        // Split window horizontally and run shell in second pane
+        await exec(`tmux -CC split-window -h -t "${sessionName}" -c "${projectPath}"`);
+        
+        // Set focus on claude pane (left pane)
+        await exec(`tmux -CC 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 -CC 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 -CC has-session -t "${sessionName}" 2>/dev/null && tmux -CC kill-session -t "${sessionName}"`,
+            `tmux -CC new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
+            `tmux -CC split-window -h -t "${sessionName}" -c "${projectPath}"`,
+            `tmux -CC select-pane -t "${sessionName}:0.0"`,
+            process.env.TMUX 
+                ? `tmux -CC switch-client -t "${sessionName}"`
+                : `tmux -CC attach-session -t "${sessionName}"`
+        ];
+    }
+
+    async listWorkonSessions() {
+        try {
+            const { stdout } = await exec('tmux -CC 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_20250806233230.js

@@ -0,0 +1,109 @@
+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 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 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_20250806233231.js

@@ -0,0 +1,109 @@
+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 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 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,17 @@
 
 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.
 
+<a name="1.3.0"></a>
+# [1.3.0](https://github.com/israelroldan/workon/compare/v1.2.1...v1.3.0) (2025-08-06)
+
+
+### Features
+
+* Add split terminal support for 'claude' event (tmux based) ([c700afc](https://github.com/israelroldan/workon/commit/c700afc))
+* Enhance 'claude' event configuration and validation ([12387e4](https://github.com/israelroldan/workon/commit/12387e4))
+
+
+
 <a name="1.2.1"></a>
 ## [1.2.1](https://github.com/israelroldan/workon/compare/v1.2.0...v1.2.1) (2025-08-06)
 

package/cli/manage.js

@@ -134,11 +134,17 @@ class manage extends command {
 
         const answers = await inquirer.prompt(questions);
 
-        // Convert events array to object
+        // Convert events array to object and configure advanced options
         const events = {};
-        answers.events.forEach(event => {
-            events[event] = 'true';
-        });
+        for (const event of answers.events) {
+            if (event === 'claude') {
+                // Ask for Claude-specific configuration
+                const claudeConfig = await me.configureClaudeEvent();
+                events[event] = claudeConfig;
+            } else {
+                events[event] = 'true';
+            }
+        }
 
         const projectConfig = {
             path: answers.path,
@@ -248,11 +254,32 @@ class manage extends command {
 
         const answers = await inquirer.prompt(questions);
 
-        // Convert events array to object
+        // Convert events array to object and configure advanced options
         const events = {};
-        answers.events.forEach(event => {
-            events[event] = 'true';
-        });
+        for (const event of answers.events) {
+            if (event === 'claude') {
+                // If claude was previously configured with advanced options, preserve or update them
+                const existingClaudeConfig = project.events && project.events.claude;
+                if (existingClaudeConfig && typeof existingClaudeConfig === 'object') {
+                    const keepConfig = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'keep',
+                        message: 'Keep existing Claude configuration?',
+                        default: true
+                    }]);
+                    
+                    if (keepConfig.keep) {
+                        events[event] = existingClaudeConfig;
+                    } else {
+                        events[event] = await me.configureClaudeEvent();
+                    }
+                } else {
+                    events[event] = await me.configureClaudeEvent();
+                }
+            } else {
+                events[event] = 'true';
+            }
+        }
 
         const updatedProject = {
             path: answers.path,
@@ -371,6 +398,59 @@ class manage extends command {
             return me.startManagement();
         }
     }
+
+    async configureClaudeEvent() {
+        let me = this;
+        
+        me.log.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 config = {};
+
+        if (advancedAnswers.flags && advancedAnswers.flags.length > 0) {
+            config.flags = advancedAnswers.flags;
+        }
+
+        if (advancedAnswers.split_terminal) {
+            config.split_terminal = true;
+        }
+
+        return config;
+    }
 }
 
 manage.define({

package/cli/open.js

@@ -3,6 +3,7 @@ const Project = require('../lib/project');
 const { ProjectEnvironment } = require('../lib/environment');
 const spawn = require('child_process').spawn;
 const File = require('phylo');
+const TmuxManager = require('../lib/tmux');
 
 class open extends command {
     execute (params) {
@@ -15,7 +16,7 @@ class open extends command {
         }
     }
 
-    processProject (project) {
+    async processProject (project) {
         let me = this;
         let environment = me.root().environment;
 
@@ -29,7 +30,7 @@ class open extends command {
                 if (project in projects) {
                     let cfg = projects[project];
                     cfg.name = project;
-                    me.switchTo(ProjectEnvironment.load(cfg, me.config.get('project_defaults')));
+                    await me.switchTo(ProjectEnvironment.load(cfg, me.config.get('project_defaults')));
                 } else {
                     me.log.debug(`Project '${project}' not found, starting interactive mode`);
                     return me.startInteractiveMode(project);
@@ -46,7 +47,7 @@ class open extends command {
         return interactiveCmd.dispatch(new me.args.constructor([project]))
     }
 
-    switchTo (environment) {
+    async switchTo (environment) {
         let me = this;
         me.root().environment = environment;
         let project = environment.project;
@@ -63,7 +64,21 @@ class open extends command {
             me.shellCommands = [];
         }
 
-        events.forEach(me.processEvent.bind(me));
+        // Check for split terminal scenario
+        const hasCwd = events.includes('cwd');
+        const hasClaudeEvent = events.includes('claude');
+        const claudeConfig = project.events.claude;
+        const shouldUseSplitTerminal = hasCwd && hasClaudeEvent && 
+            claudeConfig && typeof claudeConfig === 'object' && claudeConfig.split_terminal;
+
+        if (shouldUseSplitTerminal) {
+            await me.handleSplitTerminal(project, isShellMode);
+            // Process other events except cwd and claude
+            events.filter(e => e !== 'cwd' && e !== 'claude').forEach(me.processEvent.bind(me));
+        } else {
+            // Normal event processing
+            events.forEach(me.processEvent.bind(me));
+        }
 
         // Output collected shell commands if in shell mode
         if (isShellMode && me.shellCommands.length > 0) {
@@ -71,6 +86,55 @@ class open extends command {
         }
     }
 
+    async handleSplitTerminal(project, isShellMode) {
+        let me = this;
+        const tmux = new TmuxManager();
+        const claudeConfig = project.events.claude;
+        const claudeArgs = (claudeConfig && claudeConfig.flags) ? claudeConfig.flags : [];
+        
+        if (isShellMode) {
+            // Check if tmux is available
+            if (await tmux.isTmuxAvailable()) {
+                const commands = tmux.buildShellCommands(
+                    project.name, 
+                    project.path.path, 
+                    claudeArgs
+                );
+                me.shellCommands.push(...commands);
+            } else {
+                // Fall back to normal behavior if tmux is not available
+                me.log.debug('Tmux not available, falling back to normal mode');
+                me.shellCommands.push(`cd "${project.path.path}"`);
+                const claudeCommand = claudeArgs.length > 0 
+                    ? `claude ${claudeArgs.join(' ')}`
+                    : 'claude';
+                me.shellCommands.push(claudeCommand);
+            }
+        } else {
+            // Direct execution mode
+            if (await tmux.isTmuxAvailable()) {
+                try {
+                    const sessionName = await tmux.createSplitSession(
+                        project.name, 
+                        project.path.path, 
+                        claudeArgs
+                    );
+                    await tmux.attachToSession(sessionName);
+                } catch (error) {
+                    me.log.debug(`Failed to create tmux session: ${error.message}`);
+                    // Fall back to normal behavior
+                    me.processEvent('cwd');
+                    me.processEvent('claude');
+                }
+            } else {
+                me.log.debug('Tmux not available, falling back to normal mode');
+                // Fall back to normal behavior
+                me.processEvent('cwd');
+                me.processEvent('claude');
+            }
+        }
+    }
+
     processEvent (event) {
         let me = this;
         let environment = me.root().environment;
@@ -126,10 +190,24 @@ class open extends command {
                     }
                 break;
                 case 'claude':
+                    let claudeArgs = [];
+                    let claudeConfig = project.events.claude;
+                    
+                    // Handle advanced Claude configuration
+                    if (claudeConfig && typeof claudeConfig === 'object') {
+                        if (claudeConfig.flags && Array.isArray(claudeConfig.flags)) {
+                            claudeArgs = claudeArgs.concat(claudeConfig.flags);
+                        }
+                        // Additional config options can be handled here in the future
+                    }
+                    
                     if (isShellMode) {
-                        me.shellCommands.push(`claude`);
+                        let claudeCommand = claudeArgs.length > 0 
+                            ? `claude ${claudeArgs.join(' ')}`
+                            : 'claude';
+                        me.shellCommands.push(claudeCommand);
                     } else {
-                        spawn('claude', [], {
+                        spawn('claude', claudeArgs, {
                             cwd: environment.project.path.path,
                             stdio: 'inherit'
                         });

package/docs/ideas.md

@@ -34,13 +34,51 @@ Create an interactive mode for editing project configurations through guided pro
 
 ## Enhanced Events
 
-### Advanced claude Event Options
-Extend the claude event with more configuration options:
+### Advanced claude Event Options ✅ IMPLEMENTED
+The claude event now supports advanced configuration options:
+```json
+"claude": {
+  "flags": ["--resume", "--debug"]
+}
+```
+
+**Available through:** `workon manage` → Configure advanced Claude options
+
+### Split Terminal with Claude + CWD
+When both `claude` and `cwd` events are enabled, automatically create a split terminal layout:
+- **Left pane**: Claude Code running in project directory
+- **Right pane**: Shell terminal in project directory  
+
+**Implementation approach:**
+- Use tmux to create split session
+- Detect when both events are present
+- Create session: `tmux new-session -d -s "workon-{project}"`
+- Split horizontally: `tmux split-window -h`
+- Run claude in left pane, shell in right pane
+- Attach to session
+
+**Configuration:**
+```json
+"claude": {
+  "flags": ["--resume"],
+  "split_terminal": true
+}
+```
+
+**Benefits:**
+- Claude and terminal side-by-side for optimal workflow
+- Easy switching between AI assistance and command execution
+- Persistent session that can be reattached
+
+### Future claude Event Enhancements
+Additional options that could be implemented:
 ```json
 "claude": {
-  "mode": "interactive",
   "flags": ["--resume"],
-  "project_context": true
+  "mode": "interactive", 
+  "project_context": true,
+  "working_directory": "src/",
+  "tmux_layout": "even-horizontal"
 }
 ```
 

package/lib/tmux.js

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

@@ -86,6 +86,43 @@ class ProjectValidator {
             return `Invalid events: ${invalidEvents.join(', ')}. Valid events: ${validEvents.join(', ')}`;
         }
 
+        // Validate claude event configuration if present
+        if (events.claude && typeof events.claude === 'object') {
+            const claudeValidation = this.validateClaudeConfig(events.claude);
+            if (claudeValidation !== true) {
+                return claudeValidation;
+            }
+        }
+
+        return true;
+    }
+
+    validateClaudeConfig(config) {
+        if (typeof config !== 'object') {
+            return 'Claude configuration must be an object';
+        }
+
+        // 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;
     }
 

package/package.json

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

package/.history/package_20250806214300.json

@@ -1,42 +0,0 @@
-{
-  "name": "workon",
-  "version": "1.1.0",
-  "description": "Work on something great!",
-  "main": "index.js",
-  "scripts": {
-    "release": "standard-version"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/israelroldan/workon.git"
-  },
-  "keywords": [
-    "productivity"
-  ],
-  "author": "Israel Roldan (me@isro.me)",
-  "license": "MIT",
-  "devDependencies": {
-    "cz-conventional-changelog": "^2.0.0",
-    "standard-version": "^4.2.0"
-  },
-  "config": {
-    "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
-    }
-  },
-  "dependencies": {
-    "conf": "^1.1.2",
-    "deep-assign": "^2.0.0",
-    "flat": "^2.0.1",
-    "inquirer": "^3.1.1",
-    "loog": "^1.4.0",
-    "omelette": "^0.4.4",
-    "openurl2": "^1.0.1",
-    "phylo": "^1.0.0-beta.7",
-    "simple-git": "^1.73.0",
-    "switchit": "^1.0.7"
-  },
-  "bin": {
-    "workon": "bin/workon"
-  }
-}

package/.history/package_20250806215528.json

@@ -1,43 +0,0 @@
-{
-  "name": "workon",
-  "version": "1.1.0",
-  "description": "Work on something great!",
-  "main": "index.js",
-  "scripts": {
-    "release": "standard-version"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/israelroldan/workon.git"
-  },
-  "keywords": [
-    "productivity"
-  ],
-  "author": "Israel Roldan (me@isro.me)",
-  "license": "MIT",
-  "devDependencies": {
-    "cz-conventional-changelog": "^2.0.0",
-    "standard-version": "^4.2.0"
-  },
-  "config": {
-    "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
-    }
-  },
-  "dependencies": {
-    "conf": "^1.1.2",
-    "deep-assign": "^2.0.0",
-    "flat": "^2.0.1",
-    "inquirer": "^3.1.1",
-    "loog": "^1.4.0",
-    "omelette": "^0.4.4",
-    "openurl2": "^1.0.1",
-    "phylo": "^1.0.0-beta.7",
-    "simple-git": "^1.73.0",
-    "switchit": "^1.0.7"
-  },
-  "bin": {
-    "workon": "bin/workon",
-    "wo": "bin/workon"
-  }
-}