workon 1.0.0-alpha.1 → 1.1.0

package/.cursorindexingignore

@@ -0,0 +1,3 @@
+
+# Don't index SpecStory auto-save files, but allow explicit context inclusion via @ references
+.specstory/**

package/.vscode/terminals.json

@@ -0,0 +1,11 @@
+{
+  "autorun": true,
+  "artificialDelay": 1000,
+  "terminals": [
+    {
+      "name": "Persistent",
+      "focus": true,
+      "command": "cc"
+    }
+  ]
+}

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 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.1.0"></a>
+# [1.1.0](https://github.com/israelroldan/workon/compare/v1.0.0...v1.1.0) (2025-08-06)
+
+
+### Bug Fixes
+
+* Update package.json format for npm publish ([6c5e9e0](https://github.com/israelroldan/workon/commit/6c5e9e0))
+
+
+### Features
+
+* Enhance CLI with new 'claude' command support ([70b3f96](https://github.com/israelroldan/workon/commit/70b3f96))
+* Improve shell integration for workon command ([f5b6ff0](https://github.com/israelroldan/workon/commit/f5b6ff0))
+
+
+
 <a name="1.0.0-alpha.1"></a>
 # [1.0.0-alpha.1](https://code.palu.io/israel/workon/compare/v1.0.0-alpha.0...v1.0.0-alpha.1) (2017-06-26)
 

package/CLAUDE.md

@@ -0,0 +1,100 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`workon` is a Node.js CLI tool for managing development projects and environments. It helps developers quickly switch between projects, configure IDEs, and manage git branches through an interactive interface.
+
+## Development Commands
+
+### Release Management
+```bash
+npm run release              # Create a new release using standard-version
+```
+
+### Installation and Usage
+```bash
+npm install                  # Install dependencies
+node bin/workon             # Run the CLI tool directly
+npm link                    # Install globally for development
+```
+
+## Architecture
+
+### Core Components
+
+**CLI Entry Point (`bin/workon`)**
+- Main executable that initializes logging and runs the CLI
+- Supports `--debug` flag for detailed logging
+
+**Command System (`cli/`)**
+- `cli/index.js`: Main CLI class extending switchit's container pattern
+- `cli/interactive.js`: Interactive mode for project setup and management
+- `cli/open.js`: Project opening and environment switching
+- `cli/config/`: Configuration management commands
+
+**Project Management (`lib/`)**
+- `lib/project.js`: Project class with path, IDE, events, and branch properties
+- `lib/environment/`: Environment recognition and project detection
+- `lib/config.js`: Configuration storage using the `conf` package
+
+### Key Architectural Patterns
+
+**Environment Recognition**
+- Automatically detects if current directory is a configured project
+- Matches project paths against configuration
+- Integrates with git to detect current branch
+- Supports branch-specific project configurations (e.g., `project#branch`)
+
+**Configuration System**
+- Uses `conf` package for persistent storage
+- Separates transient properties (`pkg`, `work`) from persistent config
+- Stores project definitions and defaults
+- Configuration lives in user's config directory
+
+**Interactive Flow**
+- Context-aware prompts based on current environment
+- Different options when inside vs outside project directories
+- Supports creating new projects, branches, and managing existing ones
+
+**Event System**
+- Projects can define events that trigger when opening:
+  - `cwd`: Change terminal directory to project path
+  - `ide`: Open project in configured IDE (VS Code, IntelliJ, Atom)
+  - `web`: Open project homepage in browser
+- Events are processed when switching to a project
+
+### Project Configuration Structure
+
+Projects are stored with these properties:
+- `name`: Project identifier
+- `path`: Relative path from base directory
+- `ide`: IDE command (`vscode`, `idea`, `atom`)
+- `events`: Object defining which events to trigger
+- `branch`: Git branch (for branch-specific configs)
+
+### Dependencies
+
+**Core Dependencies**
+- `switchit`: CLI framework for commands and arguments
+- `inquirer`: Interactive command-line prompts
+- `conf`: Configuration storage
+- `phylo`: File system utilities
+- `simple-git`: Git integration
+- `loog`: Logging system
+
+**Utility Dependencies**
+- `deep-assign`: Object merging
+- `flat`: Object flattening
+- `omelette`: Shell completion
+- `openurl2`: Browser opening
+
+## Development Notes
+
+- The tool uses a class-based architecture with command inheritance
+- Configuration is automatically managed and persisted
+- Environment detection works by matching canonical paths
+- Interactive mode provides different UX based on context
+- Shell completion is supported via omelette
+- Git integration detects current branch for branch-specific configs

package/README.md

@@ -1,2 +1,215 @@
 # workon
 
+> Work on something great! 🚀
+
+A productivity CLI tool that helps developers quickly switch between projects with automatic environment setup. No more manually navigating to project directories, opening IDEs, or remembering project-specific commands.
+
+## Features
+
+✨ **Smart Project Switching** - Switch between projects in your current shell (no nested processes!)  
+🔧 **IDE Integration** - Automatically open projects in VS Code, IntelliJ IDEA, or Atom  
+🌐 **Web Integration** - Launch project websites and documentation  
+🌳 **Git Branch Support** - Different configurations for different branches  
+📁 **Auto Directory Change** - Seamlessly `cd` into project directories  
+⚡ **Interactive Setup** - Guided project configuration  
+🔄 **Backward Compatible** - Legacy nested shell mode still available
+
+## Installation
+
+### Option 1: Global Installation (Recommended)
+
+```bash
+# Install globally
+npm install -g workon
+
+# Set up shell integration (one time setup)
+echo 'eval "$(workon --init)"' >> ~/.zshrc    # for zsh
+echo 'eval "$(workon --init)"' >> ~/.bashrc   # for bash
+
+# Reload your shell
+source ~/.zshrc  # or ~/.bashrc
+```
+
+### Option 2: Using npx (No Global Install)
+
+```bash
+# Set up shell integration
+echo 'eval "$(npx workon --init)"' >> ~/.zshrc    # for zsh  
+echo 'eval "$(npx workon --init)"' >> ~/.bashrc   # for bash
+
+# Reload your shell
+source ~/.zshrc  # or ~/.bashrc
+```
+
+### Verify Installation
+
+```bash
+workon --help
+```
+
+## Quick Start
+
+1. **Create your first project:**
+   ```bash
+   workon  # Start interactive mode
+   ```
+
+2. **Switch to a project:**
+   ```bash
+   workon myproject  # Automatically cd + open IDE
+   ```
+
+3. **List available projects:**
+   ```bash
+   workon config list
+   ```
+
+## Project Configuration
+
+Projects are configured with:
+
+- **Path**: Where your project lives
+- **IDE**: Which editor to open (`code`, `idea`, `atom`)  
+- **Events**: What happens when switching to the project
+  - `cwd`: Change directory to project path
+  - `ide`: Open project in configured IDE
+  - `web`: Open project homepage/docs
+
+### Interactive Project Setup
+
+Run `workon` to start the interactive setup wizard:
+
+```bash
+$ workon
+                      8                v1.0.0-alpha.1
+Yb  db  dP .d8b. 8d8b 8.dP .d8b. 8d8b.
+ YbdPYbdP  8' .8 8P   88b  8' .8 8P Y8
+  YP  YP   `Y8P' 8    8 Yb `Y8P' 8   8
+
+? What do you want to do?
+❯ Start a new project
+  Open an existing project  
+  Manage projects
+  Exit
+```
+
+### Manual Configuration
+
+```bash
+# Set base directory for all projects
+workon config set project_defaults.base ~/code
+
+# Add a project
+workon config set projects.myapp.path myapp
+workon config set projects.myapp.ide code
+workon config set projects.myapp.events.cwd true
+workon config set projects.myapp.events.ide true
+```
+
+## Usage Examples
+
+### Basic Project Switching
+```bash
+# Switch to project (changes directory + opens IDE)
+workon myproject
+
+# Shell mode - outputs commands instead of executing
+workon myproject --shell
+# Output: cd "/path/to/myproject"
+#         code "/path/to/myproject" &
+```
+
+### Branch-Specific Configuration
+```bash
+# Configure different settings for a git branch
+workon myproject#feature-branch
+```
+
+### Legacy Mode (Nested Shells)
+```bash
+# Use the old behavior if needed (spawns new shell)
+workon myproject --no-shell  # (this is the default)
+```
+
+### Configuration Management
+```bash
+# List all configuration
+workon config list
+
+# Set a value
+workon config set key value
+
+# Remove a value  
+workon config unset key
+```
+
+## Shell Integration Details
+
+The modern shell integration works by:
+
+1. **Setup**: `workon --init` outputs a shell function
+2. **Usage**: When you run `workon myproject`, the function:
+   - Calls `workon myproject --shell` to get commands
+   - Uses `eval` to execute them in your current shell
+3. **Result**: No nested shells, seamless directory changes
+
+### Manual Shell Integration
+
+If you prefer not to modify your shell config:
+
+```bash
+# Get commands and execute manually
+eval "$(workon myproject --shell)"
+
+# Or see what commands would run
+workon myproject --shell
+```
+
+## Advanced Usage
+
+### Environment Detection
+
+`workon` automatically detects when you're in a configured project directory and shows relevant options.
+
+### Shell Completion
+
+Set up tab completion:
+
+```bash
+workon --setup-completion
+```
+
+### Debug Mode
+
+Troubleshoot with debug output:
+
+```bash
+workon myproject --debug
+```
+
+## Configuration Storage
+
+Configuration is stored using the [`conf`](https://github.com/sindresorhus/conf) package in your system's config directory:
+
+- **macOS**: `~/Library/Preferences/workon/`
+- **Linux**: `~/.config/workon/`  
+- **Windows**: `%APPDATA%/workon/`
+
+## Migration from Legacy Mode
+
+If you've been using the nested shell mode, the new shell integration provides the same functionality without the shell nesting issues. Both modes continue to work:
+
+- **Legacy**: `workon myproject` (spawns new shell)
+- **Modern**: `workon myproject` (with shell integration setup)
+
+## Contributing
+
+This project uses [standard-version](https://github.com/conventional-changelog/standard-version) for releases.
+
+```bash
+npm run release
+```
+
+## License
+
+MIT © [Israel Roldan](https://github.com/israelroldan)

package/bin/workon

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-const isDebug = /-{1,2}de?b?u?g?\b/.test(process.argv[2]);
-const log = require('loog')({
+const isDebug = !!process.argv.find(param => /-{1,2}de?b?u?g?\b/.test(param));
+const console = require('loog')({
     prefixStyle: 'ascii',
     logLevel: isDebug ? 'debug' : 'info'
 });
 
 const workon = require('../cli');
-new workon(log).run().catch(e => { 
-    log.error(isDebug ? e.stack : (e.message ? e.message : e));
+new workon(console).run().catch(e => {
+    console.error(isDebug ? e.stack : (e.message ? e.message : e));
     process.exit(1);
 });

package/cli/config/index.js

@@ -7,6 +7,7 @@ const unset = require('./unset');
 class config extends container {}
 
 config.define({
+    help: 'manage configuration parameters',
     commands: {
         '': 'list',
         list,

package/cli/config/list.js

@@ -19,6 +19,8 @@ class list extends command {
     }
 }
 
-list.define({});
+list.define({
+    help: 'List configuration parameters'
+});
 
 module.exports = list;

package/cli/config/set.js

@@ -3,11 +3,17 @@ const { command } = require('../base');
 class set extends command {
     execute (params) {
         let me = this;
-
-        me.log.info('set config here');
+        me.config.set(params.key, params.value);
     }
 }
 
-set.define({});
+set.define({
+    help: {
+        '': 'Set a configuration parameter',
+        key: 'The configuration parameter to set',
+        value: 'The value to set'
+    },
+    parameters: '{key} {value}'
+});
 
 module.exports = set;

package/cli/config/unset.js

@@ -3,11 +3,24 @@ const { command } = require('../base');
 class unset extends command {
     execute (params) {
         let me = this;
-
-        me.log.info('unset config here');
+        if (!params.silent && !me.config.has(params.key)) {
+            throw new Error(`Unknown config ${params.key}`);
+        }
+        me.config.delete(params.key);
+        if (!params.silent) {
+            me.log.info(`Entry ${params.key} was removed from the configuration`);
+        }
     }
 }
 
-unset.define({});
+unset.define({
+    help: {
+        '': 'Remove a configuration parameter',
+        silent: 'Suppress console output',
+        key: 'The configuration parameter to remove'
+    },
+    switches: '[silent:boolean=false]',
+    parameters: '{key}'
+});
 
 module.exports = unset;

package/cli/index.js

@@ -1,8 +1,8 @@
-const File = require('phylo');
 const {container} = require('./base');
-const Config = require('../lib/config')
-const omelette = require('omelette');
 
+const File = require('phylo');
+
+const Config = require('../lib/config');
 const {EnvironmentRecognizer} = require('../lib/environment');
 
 const config = require('./config');
@@ -16,8 +16,13 @@ class workon extends container {
         me.log = log || require('loog')({
             prefixStyle: 'ascii'
         });
+    }
+
+    run () {
+        let me = this;
         me.initialize();
         me.prepareCompletion();
+        return super.run();
     }
 
     initialize () {
@@ -39,58 +44,112 @@ class workon extends container {
                 'list', 'set', 'reset'
             ]
         };
-        let projects = Object.keys(me.config.get('projects')).forEach((id) => {
-            tree[id] = null;
-        })
-        me.completion = omelette('workon').tree(tree);
+        let projects = me.config.get('projects');
+        if (projects) {
+            Object.keys(projects).forEach((id) => {
+                tree[id] = null;
+            });
+        }
+        me.completion = require('omelette')('workon').tree(tree);
         me.completion.init();
     }
 
     execute (params, args) {
         let me = this;
-        me.log.debug('');
-        
+
         if (params.debug) {
             me.log.setLogLevel('debug');
         }
-        if (params.version) {
-            me.log.info(`workon v${me.config.get('pkg').version}`);
-            return true;
-        } else if (params.help) {
-            me.log.info('Show help');
-            return true;
-        } else if (params.setup) {
+
+        if (params['setup-completion']) {
             me.log.debug('Configuring command-line completion');
             me.completion.setupShellInitFile();
             return true;
+        } else if (params.init) {
+            me.log.debug('Generating shell integration function');
+            me.outputShellInit();
+            return true;
         } else {
+            let prom = Promise.resolve();
             if (!me.environment) {
-                return EnvironmentRecognizer.recognize(File.cwd())
+                prom = EnvironmentRecognizer.recognize(File.cwd())
                     .then((environment) => {
                         me.environment = environment;
-                        return super.execute(params, args).catch((err) => {
-                            if (args._args.length == 0) {
-                                let interactiveCmd = me.commands.lookup('interactive').create(me);
-                                return interactiveCmd.run([])
-                            } else {
-                                let cmdNames = me.constructor.getAspects().commands.filter((c)=>!!c).map((c)=>c.name);
-                                let firstCmd = args._args.filter((a)=>!/^-/.test(a))[0];
-                                if (!~cmdNames.indexOf(firstCmd)) {
-                                    let openCmd = me.commands.lookup('open').create(me);
-                                    return openCmd.run(args._args);
-                                } else {
-                                    throw err;
-                                }
-                            }
-                        });
                     });
             }
+            return prom.then(() => super.execute(params, args).catch((err) => me.maybeOpen(err, args)));
         }
     }
 
-    logo () {
-        let version = this.config.get('pkg').version;
-        return `                      8\u001b[2m${' '.repeat(Math.max(15-version.length-1, 1))+'v'+version}\u001b[22m\nYb  db  dP .d8b. 8d8b 8.dP \u001b[92m.d8b. 8d8b.\u001b[0m\n YbdPYbdP  8' .8 8P   88b  \u001b[92m8' .8 8P Y8\u001b[0m\n  YP  YP   \`Y8P' 8    8 Yb \u001b[92m\`Y8P' 8   8\u001b[0m`;
+    outputShellInit () {
+        let me = this;
+        
+        // Get list of available commands from switchit
+        let cmdNames = me.constructor.getAspects().commands.filter((c) => !!c).map((c) => c.name);
+        
+        // Get list of available switches from switchit
+        let switches = me.constructor.getAspects().switches || [];
+        let switchFlags = [];
+        switches.forEach(sw => {
+            switchFlags.push('--' + sw.name);
+            if (sw.char) {
+                switchFlags.push('-' + sw.char);
+            }
+        });
+        
+        // Add built-in switchit flags (help and version are automatically added by switchit)
+        let builtinFlags = ['--help', '-h', '--version', '-v', 'help'];
+        
+        // Combine all non-shell commands and flags, removing duplicates
+        let nonShellCommands = [...new Set(cmdNames.concat(switchFlags).concat(builtinFlags))];
+        let casePattern = nonShellCommands.join('|');
+        
+        // Generate shell function that wraps workon calls
+        let shellFunction = `
+# workon shell integration
+workon() {
+    # Commands that should NOT use shell mode
+    case "$1" in
+        ${casePattern})
+            command workon "$@"
+            return $?
+            ;;
+    esac
+    
+    # Default behavior: use shell mode for project opening
+    local output
+    output=$(command workon --shell "$@" 2>&1)
+    local exit_code=$?
+    
+    if [[ $exit_code -eq 0 && -n "$output" ]]; then
+        # Execute shell commands if workon succeeded and output exists
+        eval "$output"
+    else
+        # Show any error output
+        [[ -n "$output" ]] && echo "$output" >&2
+        return $exit_code
+    fi
+}`;
+        console.log(shellFunction);
+    }
+
+    maybeOpen (err, args) {
+        let me = this;
+        let cmdNames = me.constructor.getAspects().commands.filter((c) => !!c).map((c) => c.name);
+        let firstCmd = args._args.filter((a) => !/^-/.test(a))[0];
+        if (!~cmdNames.indexOf(firstCmd)) {
+            // ex. "workon projectName"
+            let openCmd = me.commands.lookup('open').create(me);
+            // Copy shell parameter to the open command
+            if (me.params.shell) {
+                openCmd.params = openCmd.params || {};
+                openCmd.params.shell = true;
+            }
+            return openCmd.run(args._args);
+        } else {
+            // ex. "workon config asdf"
+            throw err;
+        }
     }
 }
 
@@ -98,14 +157,17 @@ workon.define({
     help: {
         '': 'Work on something great!',
         debug: 'Provide debug logging output',
-        help: 'Show help',
-        version: 'Show version',
-        'setup-completion': 'Configure command line tab completion (see help for details)'
+        'setup-completion': 'Configure command line tab completion (see help for details)',
+        shell: 'Output shell commands instead of spawning processes',
+        init: 'Generate shell integration function for seamless directory switching'
     },
-    switches: '[debug:boolean=false] [version:boolean=false] [help:boolean=false] [setup-completion:boolean=false]',
+    switches: '[d#debug:boolean=false] [setup-completion:boolean=false] [shell:boolean=false] [init:boolean=false]',
     commands: {
         '': 'open',
-        interactive,
+        interactive: {
+            type: interactive,
+            private: true
+        },
         open,
         config
     }

package/cli/interactive.js

@@ -4,21 +4,21 @@ const File = require('phylo');
 const Prompt = require('inquirer/lib/prompts/input');
 const deepAssign = require('deep-assign');
 
-class init extends command {
+class interactive extends command {
     execute (params) {
         let me = this;
         me.log.debug();
-        me.log.log(me.root().logo());
+        me.showLogo();
         me.log.log();
         let name;
         let fromUser = false;
         if (!params.identifier || params.identifier === 'undefined') {
-            me.log.debug('Name was not provided, autodetecting');
+            me.log.debug('Name was not provided, auto-detecting');
             if (me.root().project) {
                 me.log.debug('Name derived form current project');
                 name = me.root().project;
             } else {
-                me.log.debug('Name derived from current working directory')
+                me.log.debug('Name derived from current working directory');
                 name = File.cwd().name;
             }
         } else {
@@ -28,6 +28,16 @@ class init extends command {
         return me.startInteractive(name, fromUser);
     }
 
+    showLogo () {
+        let me = this;
+        let version = me.config.get('pkg').version;
+
+        if (!this._hasShownLogo) {
+            this.log.log(`                      8\u001b[2m${' '.repeat(Math.max(15-version.length-1, 1))+'v'+version}\u001b[22m\nYb  db  dP .d8b. 8d8b 8.dP \u001b[92m.d8b. 8d8b.\u001b[0m\n YbdPYbdP  8' .8 8P   88b  \u001b[92m8' .8 8P Y8\u001b[0m\n  YP  YP   \`Y8P' 8    8 Yb \u001b[92m\`Y8P' 8   8\u001b[0m`);
+            this._hasShownLogo = true;
+        }
+    }
+
     startInteractive (defaultName, fromUser, showMain = false) {
         let me = this;
         let environment = me.root().environment;
@@ -268,7 +278,7 @@ class init extends command {
     }
 }
 
-init.define({
+interactive.define({
     parameters: {
         identifier: {
             type: 'string',
@@ -277,4 +287,4 @@ init.define({
     }
 });
 
-module.exports = init;
+module.exports = interactive;

package/cli/open.js

@@ -5,22 +5,17 @@ const spawn = require('child_process').spawn;
 const File = require('phylo');
 
 class open extends command {
-    execute (params, args) {
+    execute (params) {
         let me = this;
-        let defaults = me.config.get('project_defaults');
-        let baseDir = File.from(defaults.base);
-        let projects = me.config.get('projects');
-        let cwp = null;
-        switch (params.identifier) {
-            case undefined:
-                me.log.debug(`No project name provided, starting interactive mode`);
-                return me.startInteractiveMode();
-            default:
-                return me.processProjectIdentifier(params.identifier);
+        if (params.project) {
+            return me.processProject(params.project);
+        } else {
+            me.log.debug(`No project name provided, starting interactive mode`);
+            return me.startInteractiveMode();
         }
     }
 
-    processProjectIdentifier (identifier) {
+    processProject (project) {
         let me = this;
         let environment = me.root().environment;
 
@@ -28,27 +23,27 @@ class open extends command {
         if (!projects) {
             me.config.set('projects', {});
         } else {
-            if (environment.$isProjectEnvironment && (identifier === 'this' || identifier === '.')) {
+            if (environment.$isProjectEnvironment && (project === 'this' || project === '.')) {
                 me.log.info(`Open current: ${environment.project.name}`);
             } else {
-                if (identifier in projects) {   
-                    let cfg = projects[identifier];
-                    cfg.name = identifier;
+                if (project in projects) {
+                    let cfg = projects[project];
+                    cfg.name = project;
                     me.switchTo(ProjectEnvironment.load(cfg, me.config.get('project_defaults')));
                 } else {
-                    me.log.debug(`Project '${identifier}' not found, starting interactive mode`);
-                    return me.startInteractiveMode(identifier);
+                    me.log.debug(`Project '${project}' not found, starting interactive mode`);
+                    return me.startInteractiveMode(project);
                 }
             }
         }
     }
 
-    startInteractiveMode (identifier) {
+    startInteractiveMode (project) {
         let me = this;
         let root = me.root();
         
         let interactiveCmd = root.commands.lookup('interactive').create(root);
-        return interactiveCmd.dispatch(new me.args.constructor([identifier]))
+        return interactiveCmd.dispatch(new me.args.constructor([project]))
     }
 
     switchTo (environment) {
@@ -62,7 +57,18 @@ class open extends command {
         me.log.debug(`IDE command is: ${project.ide}`);
         me.log.debug(`Actions are: ${events}`);
 
+        // Initialize shell commands collector if in shell mode
+        let isShellMode = me.params.shell || me.root().params.shell;
+        if (isShellMode) {
+            me.shellCommands = [];
+        }
+
         events.forEach(me.processEvent.bind(me));
+
+        // Output collected shell commands if in shell mode
+        if (isShellMode && me.shellCommands.length > 0) {
+            console.log(me.shellCommands.join('\n'));
+        }
     }
 
     processEvent (event) {
@@ -80,21 +86,56 @@ class open extends command {
         if (event in scripts) {
             me.log.debug(`Found script with event name, unfortunately scripts are not yet supported.`);
         }
-        switch (event) {
-            case 'ide':
-                spawn(project.ide, [project.path.path]);
-            break;
-            case 'cwd':
-                spawn(process.env.SHELL, ['-i'], {
-                    cwd: environment.project.path.path,
-                    stdio: 'inherit'
-                });
-            break;
-            case 'web':
-                if (homepage) {
-                    require("openurl2").open(homepage);
-                }
-            break;
+        if (!me.params['dry-run']) {
+            // Check if we're in shell mode
+            let isShellMode = me.params.shell || me.root().params.shell;
+            me.log.debug(`Shell mode is: ${isShellMode}`);
+            
+            switch (event) {
+                case 'ide':
+                    if (isShellMode) {
+                        me.shellCommands.push(`${project.ide} "${project.path.path}" &`);
+                    } else {
+                        spawn(project.ide, [project.path.path]);
+                    }
+                break;
+                case 'cwd':
+                    if (isShellMode) {
+                        me.shellCommands.push(`cd "${environment.project.path.path}"`);
+                    } else {
+                        spawn(process.env.SHELL, ['-i'], {
+                            cwd: environment.project.path.path,
+                            stdio: 'inherit'
+                        });
+                    }
+                break;
+                case 'web':
+                    if (homepage) {
+                        if (isShellMode) {
+                            // Different approaches based on OS
+                            let openCmd;
+                            switch (process.platform) {
+                                case 'darwin': openCmd = 'open'; break;
+                                case 'win32': openCmd = 'start'; break;
+                                default: openCmd = 'xdg-open'; break;
+                            }
+                            me.shellCommands.push(`${openCmd} "${homepage}" &`);
+                        } else {
+                            require("openurl2").open(homepage);
+                        }
+                    }
+                break;
+                case 'claude':
+                    if (isShellMode) {
+                        me.shellCommands.push(`claude &`);
+                    } else {
+                        spawn('claude', [], {
+                            cwd: environment.project.path.path,
+                            stdio: 'inherit'
+                        });
+                    }
+                break;
+            }
         }
         if (`before${capitalEvt}` in scripts) {
             me.log.debug(`Found 'after' script, unfortunately scripts are not yet supported.`);
@@ -103,8 +144,13 @@ class open extends command {
 }
 
 open.define({
-    switches: '[debug:boolean=false]',
-    parameters: '[identifier:string]'
+    help: {
+        '': 'open a project by passing its project id',
+        project: 'The id of the project to open',
+        shell: 'Output shell commands instead of spawning processes'
+    },
+    switches: '[d#debug:boolean=false] [n#dry-run:boolean=false] [shell:boolean=false]',
+    parameters: '[p#project:string]'
 });
 
 module.exports = open;

package/docs/ideas.md

@@ -0,0 +1,49 @@
+# Ideas for workon
+
+This document contains ideas for future enhancements to the workon project.
+
+## Interactive Project Management
+
+### Project Configuration Editor
+Create an interactive mode for editing project configurations through guided prompts instead of manual file editing.
+
+**Features:**
+- Interactive project creation wizard with step-by-step guidance
+- Edit existing project properties (name, path, IDE, events) through prompts
+- Validate project paths and IDE commands during configuration
+- Preview configuration changes before saving
+- Bulk operations for managing multiple projects
+
+**Implementation considerations:**
+- Extend existing inquirer-based interactive system
+- Add new command like `workon config` or `workon manage --interactive`
+- Provide different flows for:
+  - Creating new projects
+  - Editing existing projects
+  - Bulk project management
+- Include validation for:
+  - Directory paths existence
+  - IDE command availability
+  - Event configuration correctness
+
+**Benefits:**
+- Lower barrier to entry for new users
+- Reduced configuration errors through validation
+- More discoverable project management features
+- Better UX compared to manual JSON editing
+
+## Enhanced Events
+
+### Advanced claude Event Options
+Extend the claude event with more configuration options:
+```json
+"claude": {
+  "mode": "interactive",
+  "flags": ["--resume"],
+  "project_context": true
+}
+```
+
+## Future Ideas
+
+*Add more ideas here as they come up...*

package/lib/environment/index.js

@@ -64,14 +64,21 @@ class EnvironmentRecognizer {
         let allProjects = me.projects;
         if (!allProjects || refresh) {
             let defaults = me.config.get('project_defaults');
+            if (!defaults || !defaults.base) {
+                allProjects = [];
+                me.projects = allProjects;
+                return allProjects;
+            }
             let baseDir = File.from(defaults.base);
             let projectsMap = me.config.get('projects');
             allProjects = [];
-            for (let name in projectsMap) {
-                let project = projectsMap[name];
-                project.name = name;
-                project.path = baseDir.join(project.path);
-                allProjects.push(project);
+            if (projectsMap) {
+                for (let name in projectsMap) {
+                    let project = projectsMap[name];
+                    project.name = name;
+                    project.path = baseDir.join(project.path);
+                    allProjects.push(project);
+                }
             }
             me.projects = allProjects;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workon",
-  "version": "1.0.0-alpha.1",
+  "version": "1.1.0",
   "description": "Work on something great!",
   "main": "index.js",
   "scripts": {
@@ -8,7 +8,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@code.palu.io:israel/workon.git"
+    "url": "git+ssh://git@github.com/israelroldan/workon.git"
   },
   "keywords": [
     "productivity"
@@ -36,5 +36,7 @@
     "simple-git": "^1.73.0",
     "switchit": "^1.0.7"
   },
-  "bin": "bin/workon"
+  "bin": {
+    "workon": "bin/workon"
+  }
 }

package/.npmignore

@@ -1 +0,0 @@
-bin/workon-debug