workon 3.1.0 → 3.2.0

package/dist/cli.js

@@ -9,27 +9,313 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/events/extensions/npm.ts
-var npm_exports = {};
-__export(npm_exports, {
-  NpmEvent: () => NpmEvent,
-  default: () => npm_default
+// src/lib/config.ts
+import Conf from "conf";
+var TRANSIENT_PROPS, Config;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    TRANSIENT_PROPS = ["pkg", "work"];
+    Config = class {
+      _transient = {};
+      _store;
+      constructor() {
+        this._store = new Conf({
+          projectName: "workon"
+        });
+      }
+      get(key, defaultValue) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          return this._transient[key] ?? defaultValue;
+        }
+        return this._store.get(key, defaultValue);
+      }
+      set(key, value) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          this._transient[key] = value;
+        } else {
+          if (value === void 0) {
+            this._store.set(key, value);
+          } else {
+            this._store.set(key, value);
+          }
+        }
+      }
+      has(key) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          return Object.prototype.hasOwnProperty.call(this._transient, key);
+        }
+        return this._store.has(key);
+      }
+      delete(key) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          delete this._transient[key];
+        } else {
+          this._store.delete(key);
+        }
+      }
+      getProjects() {
+        return this.get("projects") ?? {};
+      }
+      getProject(name) {
+        const projects = this.getProjects();
+        return projects[name];
+      }
+      setProject(name, config) {
+        const projects = this.getProjects();
+        projects[name] = config;
+        this.set("projects", projects);
+      }
+      deleteProject(name) {
+        const projects = this.getProjects();
+        delete projects[name];
+        this.set("projects", projects);
+      }
+      getDefaults() {
+        return this.get("project_defaults");
+      }
+      setDefaults(defaults) {
+        this.set("project_defaults", defaults);
+      }
+      get path() {
+        return this._store.path;
+      }
+      get store() {
+        return this._store.store;
+      }
+    };
+  }
 });
-import { spawn as spawn7 } from "child_process";
-import { input as input3, confirm as confirm2 } from "@inquirer/prompts";
-var NpmEvent, npm_default;
-var init_npm = __esm({
-  "src/events/extensions/npm.ts"() {
+
+// src/lib/project.ts
+import File from "phylo";
+import deepAssign from "deep-assign";
+var Project;
+var init_project = __esm({
+  "src/lib/project.ts"() {
     "use strict";
-    NpmEvent = class _NpmEvent {
+    Project = class {
+      name;
+      _base;
+      _path;
+      _ide;
+      _events = {};
+      _branch;
+      _homepage;
+      _defaults;
+      _initialCfg;
+      constructor(name, cfg, defaults) {
+        this._defaults = defaults ?? { base: "" };
+        this._initialCfg = { path: name, events: {}, ...cfg };
+        this.name = cfg?.name ?? name;
+        const merged = deepAssign({}, this._defaults, this._initialCfg);
+        if (merged.base) {
+          this.base = merged.base;
+        }
+        if (merged.path) {
+          this.path = merged.path;
+        }
+        if (merged.ide) {
+          this._ide = merged.ide;
+        }
+        if (merged.events) {
+          this._events = merged.events;
+        }
+        if (merged.branch) {
+          this._branch = merged.branch;
+        }
+        if (merged.homepage) {
+          this._homepage = merged.homepage;
+        }
+      }
+      set base(path) {
+        this._base = File.from(path).absolutify();
+      }
+      get base() {
+        return this._base;
+      }
+      set ide(cmd) {
+        this._ide = cmd;
+      }
+      get ide() {
+        return this._ide;
+      }
+      set events(eventCfg) {
+        this._events = eventCfg;
+      }
+      get events() {
+        return this._events;
+      }
+      set path(path) {
+        if (this._base) {
+          this._path = this._base.join(path);
+        } else {
+          this._path = File.from(path);
+        }
+        this._path = this._path.absolutify();
+      }
+      get path() {
+        if (!this._path) {
+          throw new Error("Project path not set");
+        }
+        return this._path;
+      }
+      set branch(branch) {
+        this._branch = branch;
+      }
+      get branch() {
+        return this._branch;
+      }
+      set homepage(url) {
+        this._homepage = url;
+      }
+      get homepage() {
+        return this._homepage;
+      }
+      static $isProject = true;
+      $isProject = true;
+    };
+  }
+});
+
+// src/lib/environment.ts
+import File2 from "phylo";
+import { simpleGit } from "simple-git";
+var BaseEnvironment, ProjectEnvironment, EnvironmentRecognizer;
+var init_environment = __esm({
+  "src/lib/environment.ts"() {
+    "use strict";
+    init_config();
+    init_project();
+    BaseEnvironment = class {
+      $isProjectEnvironment = false;
+    };
+    ProjectEnvironment = class _ProjectEnvironment {
+      $isProjectEnvironment = true;
+      project;
+      constructor(projectCfg) {
+        this.project = new Project(projectCfg.name, projectCfg);
+      }
+      static load(cfg, defaults) {
+        const project = new Project(cfg.name, cfg, defaults);
+        return new _ProjectEnvironment({ ...cfg, name: project.name });
+      }
+    };
+    EnvironmentRecognizer = class {
+      static config;
+      static log;
+      static projects = [];
+      static configured = false;
+      static configure(config, log) {
+        if (this.configured) {
+          return;
+        }
+        this.config = config;
+        this.log = log;
+        this.configured = true;
+      }
+      static async recognize(dir) {
+        this.ensureConfigured();
+        const theDir = File2.from(dir).canonicalize();
+        this.log.debug("Directory to recognize is: " + theDir.canonicalPath());
+        const allProjects = this.getAllProjects();
+        const matching = allProjects.filter((p) => p.path.canonicalPath() === theDir.path);
+        if (matching.length === 0) {
+          return new BaseEnvironment();
+        }
+        this.log.debug(`Found ${matching.length} matching projects`);
+        const base = matching.find((p) => !p.name.includes("#")) ?? matching[0];
+        this.log.debug("Base project is: " + base.name);
+        const gitDir = base.path.up(".git");
+        if (gitDir) {
+          try {
+            const git = simpleGit(gitDir.path);
+            const branchSummary = await git.branchLocal();
+            base.branch = branchSummary.current;
+          } catch {
+          }
+        }
+        return this.getProjectEnvironment(base, matching);
+      }
+      static getAllProjects(refresh = false) {
+        if (this.projects.length > 0 && !refresh) {
+          return this.projects;
+        }
+        const defaults = this.config.getDefaults();
+        if (!defaults?.base) {
+          this.projects = [];
+          return this.projects;
+        }
+        const baseDir = File2.from(defaults.base);
+        const projectsMap = this.config.getProjects();
+        this.projects = Object.entries(projectsMap).map(([name, project]) => ({
+          ...project,
+          name,
+          path: baseDir.join(project.path)
+        }));
+        return this.projects;
+      }
+      static getProjectEnvironment(base, _matching) {
+        const exactName = `${base.name}#${base.branch}`;
+        const exactProj = this.projects.find((p) => p.name === exactName);
+        const toProjectConfig = (p) => ({
+          name: p.name,
+          path: p.path.path,
+          // Convert PhyloFile to string path
+          ide: p.ide,
+          homepage: p.homepage,
+          events: p.events,
+          branch: p.branch,
+          exactName
+        });
+        if (exactProj) {
+          return new ProjectEnvironment({ ...toProjectConfig(exactProj), branch: base.branch });
+        }
+        return new ProjectEnvironment(toProjectConfig(base));
+      }
+      static ensureConfigured() {
+        if (!this.configured) {
+          this.config = new Config();
+          this.log = {
+            debug: () => {
+            },
+            info: () => {
+            },
+            log: () => {
+            },
+            warn: () => {
+            },
+            error: () => {
+            },
+            setLogLevel: () => {
+            }
+          };
+          this.configured = true;
+        }
+      }
+    };
+  }
+});
+
+// src/events/core/cwd.ts
+import { spawn as spawn2 } from "child_process";
+var CwdEvent;
+var init_cwd = __esm({
+  "src/events/core/cwd.ts"() {
+    "use strict";
+    CwdEvent = class {
       static get metadata() {
         return {
-          name: "npm",
-          displayName: "Run NPM command",
-          description: "Execute NPM scripts in project directory",
-          category: "development",
-          requiresTmux: true,
-          dependencies: ["npm"]
+          name: "cwd",
+          displayName: "Change directory (cwd)",
+          description: "Change current working directory to project path",
+          category: "core",
+          requiresTmux: false,
+          dependencies: []
         };
       }
       static get validation() {
@@ -38,157 +324,813 @@ var init_npm = __esm({
             if (typeof config === "boolean" || config === "true" || config === "false") {
               return true;
             }
-            if (typeof config === "string") {
-              if (config.trim().length === 0) {
-                return "npm script name cannot be empty";
-              }
-              return true;
-            }
-            if (typeof config === "object" && config !== null) {
-              const cfg = config;
-              if (typeof cfg.command !== "string" || cfg.command.trim().length === 0) {
-                return "npm.command must be a non-empty string";
-              }
-              if (cfg.watch !== void 0 && typeof cfg.watch !== "boolean") {
-                return "npm.watch must be a boolean";
-              }
-              if (cfg.auto_restart !== void 0 && typeof cfg.auto_restart !== "boolean") {
-                return "npm.auto_restart must be a boolean";
-              }
-              return true;
-            }
-            return "npm config must be a boolean, string (script name), or object";
+            return "cwd config must be a boolean (true/false)";
           }
         };
       }
       static get configuration() {
         return {
           async configureInteractive() {
-            const scriptName = await input3({
-              message: "Enter NPM script to run:",
-              default: "dev"
-            });
-            const useAdvanced = await confirm2({
-              message: "Configure advanced NPM options?",
-              default: false
-            });
-            if (!useAdvanced) {
-              return scriptName;
-            }
-            const watch = await confirm2({
-              message: "Enable watch mode?",
-              default: false
-            });
-            const autoRestart = await confirm2({
-              message: "Auto-restart on crash?",
-              default: false
-            });
-            if (!watch && !autoRestart) {
-              return scriptName;
-            }
-            return {
-              command: scriptName,
-              watch,
-              auto_restart: autoRestart
-            };
+            return true;
           },
           getDefaultConfig() {
-            return "dev";
+            return true;
           }
         };
       }
-      static getNpmCommand(config) {
-        if (typeof config === "boolean" || config === void 0) {
-          return "npm run dev";
-        }
-        if (typeof config === "string") {
-          return `npm run ${config}`;
-        }
-        return `npm run ${config.command}`;
-      }
       static get processing() {
         return {
           async processEvent(context) {
             const { project, isShellMode, shellCommands } = context;
-            const npmConfig = project.events.npm;
-            const npmCommand = _NpmEvent.getNpmCommand(npmConfig);
+            const projectPath = project.path.path;
             if (isShellMode) {
-              shellCommands.push(npmCommand);
+              shellCommands.push(`cd "${projectPath}"`);
             } else {
-              const [cmd, ...args] = npmCommand.split(" ");
-              spawn7(cmd, args, {
-                cwd: project.path.path,
+              const shell = process.env.SHELL || "/bin/bash";
+              spawn2(shell, [], {
+                cwd: projectPath,
                 stdio: "inherit"
               });
             }
           },
           generateShellCommand(context) {
-            const npmConfig = context.project.events.npm;
-            return [_NpmEvent.getNpmCommand(npmConfig)];
+            const projectPath = context.project.path.path;
+            return [`cd "${projectPath}"`];
           }
         };
       }
       static get tmux() {
+        return null;
+      }
+      static get help() {
         return {
-          getLayoutPriority() {
-            return 50;
+          usage: "cwd: true | false",
+          description: "Change the current working directory to the project path",
+          examples: [
+            { config: true, description: "Enable directory change" },
+            { config: false, description: "Disable directory change" }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/core/ide.ts
+import { spawn as spawn3 } from "child_process";
+var IdeEvent;
+var init_ide = __esm({
+  "src/events/core/ide.ts"() {
+    "use strict";
+    IdeEvent = class {
+      static get metadata() {
+        return {
+          name: "ide",
+          displayName: "Open in IDE",
+          description: "Open project in configured IDE/editor",
+          category: "core",
+          requiresTmux: false,
+          dependencies: []
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            return "ide config must be a boolean (true/false)";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            return true;
           },
-          contributeToLayout(enabledCommands) {
-            if (enabledCommands.includes("claude")) {
-              return "three-pane";
+          getDefaultConfig() {
+            return true;
+          }
+        };
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const projectPath = project.path.path;
+            const ide = project.ide || "code";
+            if (isShellMode) {
+              shellCommands.push(`${ide} "${projectPath}" &`);
+            } else {
+              spawn3(ide, [projectPath], {
+                detached: true,
+                stdio: "ignore"
+              }).unref();
             }
-            return "two-pane-npm";
+          },
+          generateShellCommand(context) {
+            const projectPath = context.project.path.path;
+            const ide = context.project.ide || "code";
+            return [`${ide} "${projectPath}" &`];
           }
         };
       }
+      static get tmux() {
+        return null;
+      }
       static get help() {
         return {
-          usage: 'npm: true | "script" | { command: string, watch?: boolean, auto_restart?: boolean }',
-          description: "Run an NPM script in the project directory",
+          usage: "ide: true | false",
+          description: "Open the project in the configured IDE",
           examples: [
-            { config: true, description: "Run npm run dev" },
-            { config: "test", description: "Run npm run test" },
-            { config: { command: "dev", watch: true }, description: "Run dev with watch mode" }
+            { config: true, description: "Enable IDE opening" },
+            { config: false, description: "Disable IDE opening" }
           ]
         };
       }
     };
-    npm_default = NpmEvent;
   }
 });
 
-// src/commands/interactive.ts
-var interactive_exports = {};
-__export(interactive_exports, {
-  runInteractive: () => runInteractive
-});
-import { select, input as input4, checkbox } from "@inquirer/prompts";
-import File3 from "phylo";
-import deepAssign2 from "deep-assign";
-async function runInteractive(ctx) {
-  const { config, log, environment, suggestedName } = ctx;
-  showLogo(config);
-  log.log("");
-  const defaultName = suggestedName ?? (environment.$isProjectEnvironment ? environment.project.name : File3.cwd().name);
-  const fromUser = !!suggestedName;
-  await startInteractive(defaultName, fromUser, ctx);
-}
-function showLogo(config) {
-  const version = config.get("pkg")?.version ?? "unknown";
-  console.log(
-    `                      8\x1B[2m${" ".repeat(Math.max(15 - version.length - 1, 1)) + "v" + version}\x1B[22m
-Yb  db  dP .d8b. 8d8b 8.dP \x1B[92m.d8b. 8d8b.\x1B[0m
- YbdPYbdP  8' .8 8P   88b  \x1B[92m8' .8 8P Y8\x1B[0m
-  YP  YP   \`Y8P' 8    8 Yb \x1B[92m\`Y8P' 8   8\x1B[0m`
-  );
-}
-async function startInteractive(defaultName, fromUser, ctx, showMain = false) {
-  const { log, environment } = ctx;
-  log.debug(`Name '${defaultName}' was${fromUser ? "" : " not"} provided by the user`);
-  const question = getFirstQuestion(defaultName, fromUser, environment, showMain);
-  const action = await select(question);
-  switch (action) {
-    case "exit":
+// src/events/core/web.ts
+import { spawn as spawn4 } from "child_process";
+import { platform } from "os";
+var WebEvent;
+var init_web = __esm({
+  "src/events/core/web.ts"() {
+    "use strict";
+    WebEvent = class _WebEvent {
+      static get metadata() {
+        return {
+          name: "web",
+          displayName: "Open homepage in browser",
+          description: "Open project homepage in web browser",
+          category: "core",
+          requiresTmux: false,
+          dependencies: []
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            return "web config must be a boolean (true/false)";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            return true;
+          },
+          getDefaultConfig() {
+            return true;
+          }
+        };
+      }
+      static getOpenCommand() {
+        const os = platform();
+        switch (os) {
+          case "darwin":
+            return "open";
+          case "win32":
+            return "start";
+          default:
+            return "xdg-open";
+        }
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const homepage = project.homepage;
+            if (!homepage) {
+              console.warn("No homepage configured for project");
+              return;
+            }
+            const openCmd = _WebEvent.getOpenCommand();
+            if (isShellMode) {
+              shellCommands.push(`${openCmd} "${homepage}" &`);
+            } else {
+              spawn4(openCmd, [homepage], {
+                detached: true,
+                stdio: "ignore"
+              }).unref();
+            }
+          },
+          generateShellCommand(context) {
+            const homepage = context.project.homepage;
+            if (!homepage) return [];
+            const openCmd = _WebEvent.getOpenCommand();
+            return [`${openCmd} "${homepage}" &`];
+          }
+        };
+      }
+      static get tmux() {
+        return null;
+      }
+      static get help() {
+        return {
+          usage: "web: true | false",
+          description: "Open the project homepage in the default browser",
+          examples: [
+            { config: true, description: "Enable browser opening" },
+            { config: false, description: "Disable browser opening" }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/extensions/claude.ts
+import { spawn as spawn5 } from "child_process";
+import { input, confirm } from "@inquirer/prompts";
+var ClaudeEvent;
+var init_claude = __esm({
+  "src/events/extensions/claude.ts"() {
+    "use strict";
+    ClaudeEvent = class _ClaudeEvent {
+      static get metadata() {
+        return {
+          name: "claude",
+          displayName: "Launch Claude Code",
+          description: "Launch Claude Code with optional flags and configuration",
+          category: "development",
+          requiresTmux: true,
+          dependencies: ["claude"]
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            if (typeof config === "object" && config !== null) {
+              const cfg = config;
+              if (cfg.flags !== void 0) {
+                if (!Array.isArray(cfg.flags)) {
+                  return "claude.flags must be an array of strings";
+                }
+                for (const flag of cfg.flags) {
+                  if (typeof flag !== "string") {
+                    return "claude.flags must contain only strings";
+                  }
+                  if (!flag.startsWith("-")) {
+                    return `Invalid flag "${flag}": flags must start with - or --`;
+                  }
+                }
+              }
+              if (cfg.split_terminal !== void 0 && typeof cfg.split_terminal !== "boolean") {
+                return "claude.split_terminal must be a boolean";
+              }
+              return true;
+            }
+            return "claude config must be a boolean or object with flags/split_terminal";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            const useAdvanced = await confirm({
+              message: "Configure advanced Claude options?",
+              default: false
+            });
+            if (!useAdvanced) {
+              return true;
+            }
+            const flagsInput = await input({
+              message: "Enter Claude flags (comma-separated, e.g., --resume, --debug):",
+              default: ""
+            });
+            const flags = flagsInput.split(",").map((f) => f.trim()).filter((f) => f.length > 0 && f.startsWith("-"));
+            const splitTerminal = await confirm({
+              message: "Use split terminal layout (Claude + shell)?",
+              default: true
+            });
+            if (flags.length === 0 && !splitTerminal) {
+              return true;
+            }
+            const config = {};
+            if (flags.length > 0) config.flags = flags;
+            if (splitTerminal) config.split_terminal = splitTerminal;
+            return config;
+          },
+          getDefaultConfig() {
+            return true;
+          }
+        };
+      }
+      static getClaudeCommand(config) {
+        if (typeof config === "boolean" || config === void 0) {
+          return "claude";
+        }
+        const flags = config.flags || [];
+        return flags.length > 0 ? `claude ${flags.join(" ")}` : "claude";
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const claudeConfig = project.events.claude;
+            const claudeCommand = _ClaudeEvent.getClaudeCommand(claudeConfig);
+            if (isShellMode) {
+              shellCommands.push(claudeCommand);
+            } else {
+              const args = claudeCommand.split(" ").slice(1);
+              spawn5("claude", args, {
+                cwd: project.path.path,
+                stdio: "inherit"
+              });
+            }
+          },
+          generateShellCommand(context) {
+            const claudeConfig = context.project.events.claude;
+            return [_ClaudeEvent.getClaudeCommand(claudeConfig)];
+          }
+        };
+      }
+      static get tmux() {
+        return {
+          getLayoutPriority() {
+            return 100;
+          },
+          contributeToLayout(enabledCommands) {
+            if (enabledCommands.includes("npm")) {
+              return "three-pane";
+            }
+            return "split";
+          }
+        };
+      }
+      static get help() {
+        return {
+          usage: "claude: true | { flags: string[], split_terminal: boolean }",
+          description: "Launch Claude Code in the project directory",
+          examples: [
+            { config: true, description: "Launch Claude with defaults" },
+            { config: { flags: ["--resume"] }, description: "Resume previous session" },
+            {
+              config: { flags: ["--model", "opus"], split_terminal: true },
+              description: "Use Opus model with split terminal"
+            }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/extensions/docker.ts
+import { spawn as spawn6 } from "child_process";
+import { input as input2 } from "@inquirer/prompts";
+var DockerEvent;
+var init_docker = __esm({
+  "src/events/extensions/docker.ts"() {
+    "use strict";
+    DockerEvent = class _DockerEvent {
+      static get metadata() {
+        return {
+          name: "docker",
+          displayName: "Docker container management",
+          description: "Start/stop Docker containers for the project",
+          category: "development",
+          requiresTmux: false,
+          dependencies: ["docker"]
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            if (typeof config === "string") {
+              return true;
+            }
+            if (typeof config === "object" && config !== null) {
+              const cfg = config;
+              if (cfg.compose_file !== void 0 && typeof cfg.compose_file !== "string") {
+                return "docker.compose_file must be a string";
+              }
+              if (cfg.services !== void 0) {
+                if (!Array.isArray(cfg.services)) {
+                  return "docker.services must be an array";
+                }
+                for (const service of cfg.services) {
+                  if (typeof service !== "string") {
+                    return "docker.services must contain only strings";
+                  }
+                }
+              }
+              return true;
+            }
+            return "docker config must be a boolean, string (compose file), or object";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            const composeFile = await input2({
+              message: "Enter docker-compose file path:",
+              default: "docker-compose.yml"
+            });
+            const servicesInput = await input2({
+              message: "Enter services to start (comma-separated, leave empty for all):",
+              default: ""
+            });
+            const services = servicesInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+            if (composeFile === "docker-compose.yml" && services.length === 0) {
+              return { compose_file: "docker-compose.yml" };
+            }
+            if (services.length === 0) {
+              return composeFile;
+            }
+            return {
+              compose_file: composeFile,
+              services
+            };
+          },
+          getDefaultConfig() {
+            return { compose_file: "docker-compose.yml" };
+          }
+        };
+      }
+      static getDockerCommand(config) {
+        if (typeof config === "boolean" || config === void 0) {
+          return "docker-compose up -d";
+        }
+        if (typeof config === "string") {
+          return `docker-compose -f ${config} up -d`;
+        }
+        const composeFile = config.compose_file || "docker-compose.yml";
+        const services = config.services?.join(" ") || "";
+        return `docker-compose -f ${composeFile} up -d ${services}`.trim();
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const dockerConfig = project.events.docker;
+            const dockerCommand = _DockerEvent.getDockerCommand(
+              dockerConfig
+            );
+            if (isShellMode) {
+              shellCommands.push(dockerCommand);
+            } else {
+              const [cmd, ...args] = dockerCommand.split(" ");
+              spawn6(cmd, args, {
+                cwd: project.path.path,
+                stdio: "inherit"
+              });
+            }
+          },
+          generateShellCommand(context) {
+            const dockerConfig = context.project.events.docker;
+            return [_DockerEvent.getDockerCommand(dockerConfig)];
+          }
+        };
+      }
+      static get tmux() {
+        return null;
+      }
+      static get help() {
+        return {
+          usage: 'docker: true | "compose-file.yml" | { compose_file: string, services?: string[] }',
+          description: "Start Docker containers for the project",
+          examples: [
+            { config: true, description: "Use default docker-compose.yml" },
+            { config: "docker-compose.dev.yml", description: "Use custom compose file" },
+            {
+              config: { compose_file: "docker-compose.yml", services: ["web", "db"] },
+              description: "Start specific services"
+            }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/extensions/npm.ts
+var npm_exports = {};
+__export(npm_exports, {
+  NpmEvent: () => NpmEvent,
+  default: () => npm_default
+});
+import { spawn as spawn7 } from "child_process";
+import { input as input3, confirm as confirm2 } from "@inquirer/prompts";
+var NpmEvent, npm_default;
+var init_npm = __esm({
+  "src/events/extensions/npm.ts"() {
+    "use strict";
+    NpmEvent = class _NpmEvent {
+      static get metadata() {
+        return {
+          name: "npm",
+          displayName: "Run NPM command",
+          description: "Execute NPM scripts in project directory",
+          category: "development",
+          requiresTmux: true,
+          dependencies: ["npm"]
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            if (typeof config === "string") {
+              if (config.trim().length === 0) {
+                return "npm script name cannot be empty";
+              }
+              return true;
+            }
+            if (typeof config === "object" && config !== null) {
+              const cfg = config;
+              if (typeof cfg.command !== "string" || cfg.command.trim().length === 0) {
+                return "npm.command must be a non-empty string";
+              }
+              if (cfg.watch !== void 0 && typeof cfg.watch !== "boolean") {
+                return "npm.watch must be a boolean";
+              }
+              if (cfg.auto_restart !== void 0 && typeof cfg.auto_restart !== "boolean") {
+                return "npm.auto_restart must be a boolean";
+              }
+              return true;
+            }
+            return "npm config must be a boolean, string (script name), or object";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            const scriptName = await input3({
+              message: "Enter NPM script to run:",
+              default: "dev"
+            });
+            const useAdvanced = await confirm2({
+              message: "Configure advanced NPM options?",
+              default: false
+            });
+            if (!useAdvanced) {
+              return scriptName;
+            }
+            const watch = await confirm2({
+              message: "Enable watch mode?",
+              default: false
+            });
+            const autoRestart = await confirm2({
+              message: "Auto-restart on crash?",
+              default: false
+            });
+            if (!watch && !autoRestart) {
+              return scriptName;
+            }
+            return {
+              command: scriptName,
+              watch,
+              auto_restart: autoRestart
+            };
+          },
+          getDefaultConfig() {
+            return "dev";
+          }
+        };
+      }
+      static getNpmCommand(config) {
+        if (typeof config === "boolean" || config === void 0) {
+          return "npm run dev";
+        }
+        if (typeof config === "string") {
+          return `npm run ${config}`;
+        }
+        return `npm run ${config.command}`;
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const npmConfig = project.events.npm;
+            const npmCommand = _NpmEvent.getNpmCommand(npmConfig);
+            if (isShellMode) {
+              shellCommands.push(npmCommand);
+            } else {
+              const [cmd, ...args] = npmCommand.split(" ");
+              spawn7(cmd, args, {
+                cwd: project.path.path,
+                stdio: "inherit"
+              });
+            }
+          },
+          generateShellCommand(context) {
+            const npmConfig = context.project.events.npm;
+            return [_NpmEvent.getNpmCommand(npmConfig)];
+          }
+        };
+      }
+      static get tmux() {
+        return {
+          getLayoutPriority() {
+            return 50;
+          },
+          contributeToLayout(enabledCommands) {
+            if (enabledCommands.includes("claude")) {
+              return "three-pane";
+            }
+            return "two-pane-npm";
+          }
+        };
+      }
+      static get help() {
+        return {
+          usage: 'npm: true | "script" | { command: string, watch?: boolean, auto_restart?: boolean }',
+          description: "Run an NPM script in the project directory",
+          examples: [
+            { config: true, description: "Run npm run dev" },
+            { config: "test", description: "Run npm run test" },
+            { config: { command: "dev", watch: true }, description: "Run dev with watch mode" }
+          ]
+        };
+      }
+    };
+    npm_default = NpmEvent;
+  }
+});
+
+// src/events/registry.ts
+var ALL_EVENTS, EventRegistryClass, EventRegistry;
+var init_registry = __esm({
+  "src/events/registry.ts"() {
+    "use strict";
+    init_cwd();
+    init_ide();
+    init_web();
+    init_claude();
+    init_docker();
+    init_npm();
+    ALL_EVENTS = [CwdEvent, IdeEvent, WebEvent, ClaudeEvent, DockerEvent, NpmEvent];
+    EventRegistryClass = class {
+      _events = /* @__PURE__ */ new Map();
+      _initialized = false;
+      /**
+       * Initialize the registry by registering all events
+       */
+      async initialize() {
+        if (this._initialized) return;
+        this.registerEvents();
+        this._initialized = true;
+      }
+      /**
+       * Register all event classes
+       */
+      registerEvents() {
+        for (const EventClass of ALL_EVENTS) {
+          if (this.isValidEvent(EventClass)) {
+            const metadata = EventClass.metadata;
+            this._events.set(metadata.name, EventClass);
+          }
+        }
+      }
+      /**
+       * Validate if a class is a proper event
+       */
+      isValidEvent(EventClass) {
+        try {
+          if (typeof EventClass !== "function") return false;
+          const metadata = EventClass.metadata;
+          return metadata !== void 0 && typeof metadata.name === "string" && typeof metadata.displayName === "string" && typeof EventClass.validation === "object" && typeof EventClass.configuration === "object" && typeof EventClass.processing === "object";
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Get all valid event names from registered events
+       */
+      getValidEventNames() {
+        this.ensureInitialized();
+        return Array.from(this._events.keys());
+      }
+      /**
+       * Get event by name
+       */
+      getEventByName(name) {
+        this.ensureInitialized();
+        return this._events.get(name) ?? null;
+      }
+      /**
+       * Get all events for management UI
+       */
+      getEventsForManageUI() {
+        this.ensureInitialized();
+        const events = [];
+        for (const [name, EventClass] of this._events) {
+          const metadata = EventClass.metadata;
+          events.push({
+            name: metadata.displayName,
+            value: name,
+            description: metadata.description
+          });
+        }
+        return events.sort((a, b) => a.name.localeCompare(b.name));
+      }
+      /**
+       * Get events that support tmux integration
+       */
+      getTmuxEnabledEvents() {
+        this.ensureInitialized();
+        const tmuxEvents = [];
+        for (const [name, EventClass] of this._events) {
+          const tmux = EventClass.tmux;
+          if (tmux) {
+            tmuxEvents.push({
+              name,
+              event: EventClass,
+              priority: tmux.getLayoutPriority ? tmux.getLayoutPriority() : 0
+            });
+          }
+        }
+        return tmuxEvents.sort((a, b) => b.priority - a.priority);
+      }
+      /**
+       * Get all available events with their metadata
+       */
+      getAllEvents() {
+        this.ensureInitialized();
+        const events = [];
+        for (const [name, EventClass] of this._events) {
+          const typedClass = EventClass;
+          events.push({
+            name,
+            metadata: typedClass.metadata,
+            hasValidation: !!typedClass.validation,
+            hasConfiguration: !!typedClass.configuration,
+            hasProcessing: !!typedClass.processing,
+            hasTmux: !!typedClass.tmux,
+            hasHelp: !!typedClass.help
+          });
+        }
+        return events;
+      }
+      /**
+       * Ensure registry is initialized
+       */
+      ensureInitialized() {
+        if (!this._initialized) {
+          throw new Error("EventRegistry must be initialized before use. Call initialize() first.");
+        }
+      }
+      /**
+       * Clear the registry (useful for testing)
+       */
+      clear() {
+        this._events.clear();
+        this._initialized = false;
+      }
+    };
+    EventRegistry = new EventRegistryClass();
+  }
+});
+
+// src/commands/interactive.ts
+var interactive_exports = {};
+__export(interactive_exports, {
+  runInteractive: () => runInteractive
+});
+import { select, input as input4, checkbox, confirm as confirm3 } from "@inquirer/prompts";
+import File3 from "phylo";
+import deepAssign2 from "deep-assign";
+async function runInteractive(ctx) {
+  const { config, log, environment, suggestedName } = ctx;
+  showLogo(config);
+  log.log("");
+  const defaultName = suggestedName ?? (environment.$isProjectEnvironment ? environment.project.name : File3.cwd().name);
+  const fromUser = !!suggestedName;
+  await startInteractive(defaultName, fromUser, ctx);
+}
+function showLogo(config) {
+  const version = config.get("pkg")?.version ?? "unknown";
+  console.log(
+    `                      8\x1B[2m${" ".repeat(Math.max(15 - version.length - 1, 1)) + "v" + version}\x1B[22m
+Yb  db  dP .d8b. 8d8b 8.dP \x1B[92m.d8b. 8d8b.\x1B[0m
+ YbdPYbdP  8' .8 8P   88b  \x1B[92m8' .8 8P Y8\x1B[0m
+  YP  YP   \`Y8P' 8    8 Yb \x1B[92m\`Y8P' 8   8\x1B[0m`
+  );
+}
+async function startInteractive(defaultName, fromUser, ctx, showMain = false) {
+  const { log, environment } = ctx;
+  log.debug(`Name '${defaultName}' was${fromUser ? "" : " not"} provided by the user`);
+  const question = getFirstQuestion(defaultName, fromUser, environment, showMain);
+  const action = await select(question);
+  switch (action) {
+    case "exit":
       return;
     case "more":
       await startInteractive(defaultName, fromUser, ctx, true);
@@ -200,17 +1142,17 @@ async function startInteractive(defaultName, fromUser, ctx, showMain = false) {
       await initBranch(defaultName, ctx);
       return;
     case "switch-project":
-      log.info("Switch to an existing project");
-      break;
+      await switchProject(ctx);
+      return;
     case "switch-branch":
-      log.info("Switch to an existing branch");
-      break;
+      await switchBranch(defaultName, ctx);
+      return;
     case "manage-projects":
-      log.info("Manage existing projects");
-      break;
+      await manageProjects(ctx);
+      return;
     case "manage-branches":
-      log.info("Manage existing branches");
-      break;
+      await manageBranches(defaultName, ctx);
+      return;
   }
 }
 function getFirstQuestion(defaultName, fromUser, environment, showMain) {
@@ -279,358 +1221,523 @@ async function initProject(defaultName, fromUser, ctx) {
       answerFile = defaultBase.join(answerFile.path);
     }
     try {
-      const canonical = answerFile.canonicalize();
-      if (canonical) {
-        answerFile = canonical;
-      } else {
-        answerFile = answerFile.absolutify();
+      const canonical = answerFile.canonicalize();
+      if (canonical) {
+        answerFile = canonical;
+      } else {
+        answerFile = answerFile.absolutify();
+      }
+    } catch {
+      answerFile = answerFile.absolutify();
+    }
+    basePath = answerFile.relativize(defaultBase.path).path;
+  }
+  const ide = await select({
+    message: "What is the IDE?",
+    choices: IDE_CHOICES
+  });
+  const selectedEvents = await checkbox({
+    message: "Which events should take place when opening?",
+    choices: [
+      { name: "Change terminal cwd to project path", value: "cwd", checked: true },
+      { name: "Open project in IDE", value: "ide", checked: true }
+    ]
+  });
+  const events = {
+    cwd: selectedEvents.includes("cwd"),
+    ide: selectedEvents.includes("ide")
+  };
+  const projectConfig = {
+    path: basePath,
+    ide,
+    events
+  };
+  projects[name] = projectConfig;
+  config.set("projects", projects);
+  log.info("Your project has been initialized.");
+  log.info(`Use 'workon ${name}' to start working!`);
+}
+async function initBranch(defaultName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branch = await input4({
+    message: "What is the name of the branch?",
+    validate: (value) => {
+      if (/\w+#\w+/.test(value)) return `Branch name can't contain the "#" sign`;
+      if (`${defaultName}#${value}` in projects) return "Branch already exists.";
+      return true;
+    }
+  });
+  const branchName = `${defaultName}#${branch}`;
+  const baseProject = projects[defaultName];
+  const branchConfig = deepAssign2({}, baseProject, { branch });
+  delete branchConfig.name;
+  projects[branchName] = branchConfig;
+  config.set("projects", projects);
+  log.info("Your branch configuration has been initialized.");
+  log.info(`Use 'workon ${branchName}' to start working!`);
+}
+async function switchProject(ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const baseProjects = Object.keys(projects).filter((name) => !name.includes("#"));
+  if (baseProjects.length === 0) {
+    log.info('No projects configured yet. Use "Start a new project" to create one.');
+    return;
+  }
+  const projectName = await select({
+    message: "Select a project to open:",
+    choices: baseProjects.map((name) => ({
+      name: `${name} (${projects[name].path})`,
+      value: name
+    }))
+  });
+  await openProject(projectName, ctx);
+}
+async function switchBranch(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  if (branches.length === 0) {
+    log.info(`No branch configurations found for '${projectName}'.`);
+    log.info('Use "Start a branch" to create one.');
+    return;
+  }
+  const branchConfig = await select({
+    message: "Select a branch configuration:",
+    choices: branches.map((name) => ({
+      name: name.substring(branchPrefix.length),
+      value: name
+    }))
+  });
+  await openProject(branchConfig, ctx);
+}
+async function manageProjects(ctx) {
+  const { config } = ctx;
+  await EventRegistry.initialize();
+  const projects = config.getProjects();
+  const hasProjects = Object.keys(projects).length > 0;
+  const choices = [
+    { name: "Create new project", value: "create" },
+    ...hasProjects ? [
+      { name: "Edit project", value: "edit" },
+      { name: "Delete project", value: "delete" },
+      { name: "List projects", value: "list" }
+    ] : [],
+    { name: "Back", value: "back" }
+  ];
+  const action = await select({
+    message: "Manage projects:",
+    choices
+  });
+  switch (action) {
+    case "create":
+      await createProjectManage(ctx);
+      break;
+    case "edit":
+      await editProjectManage(ctx);
+      break;
+    case "delete":
+      await deleteProjectManage(ctx);
+      break;
+    case "list":
+      listProjectsManage(ctx);
+      break;
+    case "back":
+      return;
+  }
+  await manageProjects(ctx);
+}
+async function manageBranches(projectName, ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  const choices = [
+    { name: "Create new branch config", value: "create" },
+    ...branches.length > 0 ? [
+      { name: "Edit branch config", value: "edit" },
+      { name: "Delete branch config", value: "delete" },
+      { name: "List branch configs", value: "list" }
+    ] : [],
+    { name: "Back", value: "back" }
+  ];
+  const action = await select({
+    message: `Manage branches for '${projectName}':`,
+    choices
+  });
+  switch (action) {
+    case "create":
+      await initBranch(projectName, ctx);
+      break;
+    case "edit":
+      await editBranchManage(projectName, ctx);
+      break;
+    case "delete":
+      await deleteBranchManage(projectName, ctx);
+      break;
+    case "list":
+      listBranchesManage(projectName, ctx);
+      break;
+    case "back":
+      return;
+  }
+  await manageBranches(projectName, ctx);
+}
+async function openProject(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  if (!(projectName in projects)) {
+    log.error(`Project '${projectName}' not found.`);
+    return;
+  }
+  await EventRegistry.initialize();
+  const projectConfig = projects[projectName];
+  const projectCfg = { ...projectConfig, name: projectName };
+  const projectEnv = ProjectEnvironment.load(projectCfg, config.getDefaults());
+  log.info(`Opening project '${projectName}'...`);
+  const events = Object.keys(projectConfig.events).filter(
+    (e) => projectConfig.events[e]
+  );
+  for (const event of events) {
+    const eventHandler = EventRegistry.getEventByName(event);
+    if (eventHandler && eventHandler.processing) {
+      await eventHandler.processing.processEvent({
+        project: projectEnv.project,
+        isShellMode: false,
+        shellCommands: []
+      });
+    }
+  }
+}
+async function createProjectManage(ctx) {
+  const { config, log } = ctx;
+  const defaults = config.getDefaults();
+  const projects = config.getProjects();
+  const name = await input4({
+    message: "Project name:",
+    validate: (value) => {
+      if (!value.trim()) return "Name is required";
+      if (!/^[\w-]+$/.test(value))
+        return "Name can only contain letters, numbers, underscores, and hyphens";
+      if (value in projects) return "Project already exists";
+      return true;
+    }
+  });
+  const defaultPath = defaults?.base ? File3.from(defaults.base).join(name).path : name;
+  const pathInput = await input4({
+    message: "Project path:",
+    default: defaultPath
+  });
+  let relativePath = pathInput;
+  if (defaults?.base) {
+    const baseDir = File3.from(defaults.base);
+    const pathFile = File3.from(pathInput);
+    try {
+      if (pathFile.isAbsolute()) {
+        relativePath = pathFile.relativize(baseDir.path).path;
+      }
+    } catch {
+      relativePath = pathInput;
+    }
+  }
+  const ide = await select({
+    message: "Select IDE:",
+    choices: IDE_CHOICES
+  });
+  const availableEvents = EventRegistry.getEventsForManageUI();
+  const selectedEvents = await checkbox({
+    message: "Select events to enable:",
+    choices: availableEvents.map((e) => ({
+      name: `${e.name} - ${e.description}`,
+      value: e.value,
+      checked: e.value === "cwd" || e.value === "ide"
+    }))
+  });
+  const events = {};
+  for (const eventName of selectedEvents) {
+    const eventHandler = EventRegistry.getEventByName(eventName);
+    if (eventHandler) {
+      const eventConfig = await eventHandler.configuration.configureInteractive();
+      events[eventName] = eventConfig;
+    }
+  }
+  const projectConfig = {
+    path: relativePath,
+    ide,
+    events
+  };
+  const confirmed = await confirm3({
+    message: "Save this project?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(name, projectConfig);
+    log.info(`Project '${name}' created successfully!`);
+  }
+}
+async function editProjectManage(ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const defaults = config.getDefaults();
+  const baseProjects = Object.keys(projects).filter((name2) => !name2.includes("#"));
+  if (baseProjects.length === 0) {
+    log.info("No projects to edit.");
+    return;
+  }
+  const name = await select({
+    message: "Select project to edit:",
+    choices: baseProjects.map((n) => ({ name: n, value: n }))
+  });
+  const project = projects[name];
+  const pathInput = await input4({
+    message: "Project path:",
+    default: project.path
+  });
+  let relativePath = pathInput;
+  if (defaults?.base) {
+    const baseDir = File3.from(defaults.base);
+    const pathFile = File3.from(pathInput);
+    try {
+      if (pathFile.isAbsolute()) {
+        relativePath = pathFile.relativize(baseDir.path).path;
       }
     } catch {
-      answerFile = answerFile.absolutify();
+      relativePath = pathInput;
     }
-    basePath = answerFile.relativize(defaultBase.path).path;
   }
   const ide = await select({
-    message: "What is the IDE?",
-    choices: IDE_CHOICES
+    message: "Select IDE:",
+    choices: IDE_CHOICES,
+    default: project.ide || "vscode"
   });
-  const selectedEvents = await checkbox({
-    message: "Which events should take place when opening?",
-    choices: [
-      { name: "Change terminal cwd to project path", value: "cwd", checked: true },
-      { name: "Open project in IDE", value: "ide", checked: true }
-    ]
+  const keepEvents = await confirm3({
+    message: "Keep existing event configuration?",
+    default: true
   });
-  const events = {
-    cwd: selectedEvents.includes("cwd"),
-    ide: selectedEvents.includes("ide")
-  };
-  const projectConfig = {
-    path: basePath,
+  let events = project.events;
+  if (!keepEvents) {
+    const availableEvents = EventRegistry.getEventsForManageUI();
+    const currentEvents = Object.keys(project.events);
+    const selectedEvents = await checkbox({
+      message: "Select events to enable:",
+      choices: availableEvents.map((e) => ({
+        name: `${e.name} - ${e.description}`,
+        value: e.value,
+        checked: currentEvents.includes(e.value)
+      }))
+    });
+    events = {};
+    for (const eventName of selectedEvents) {
+      if (project.events[eventName]) {
+        events[eventName] = project.events[eventName];
+      } else {
+        const eventHandler = EventRegistry.getEventByName(eventName);
+        if (eventHandler) {
+          const eventConfig = await eventHandler.configuration.configureInteractive();
+          events[eventName] = eventConfig;
+        }
+      }
+    }
+  }
+  const updatedConfig = {
+    path: relativePath,
     ide,
     events
   };
-  projects[name] = projectConfig;
-  config.set("projects", projects);
-  log.info("Your project has been initialized.");
-  log.info(`Use 'workon ${name}' to start working!`);
+  const confirmed = await confirm3({
+    message: "Save changes?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(name, updatedConfig);
+    log.info(`Project '${name}' updated successfully!`);
+  }
 }
-async function initBranch(defaultName, ctx) {
+async function deleteProjectManage(ctx) {
   const { config, log } = ctx;
   const projects = config.getProjects();
-  const branch = await input4({
-    message: "What is the name of the branch?",
-    validate: (value) => {
-      if (/\w+#\w+/.test(value)) return `Branch name can't contain the "#" sign`;
-      if (`${defaultName}#${value}` in projects) return "Branch already exists.";
-      return true;
-    }
-  });
-  const branchName = `${defaultName}#${branch}`;
-  const baseProject = projects[defaultName];
-  const branchConfig = deepAssign2({}, baseProject, { branch });
-  delete branchConfig.name;
-  projects[branchName] = branchConfig;
-  config.set("projects", projects);
-  log.info("Your branch configuration has been initialized.");
-  log.info(`Use 'workon ${branchName}' to start working!`);
-}
-var IDE_CHOICES;
-var init_interactive = __esm({
-  "src/commands/interactive.ts"() {
-    "use strict";
-    IDE_CHOICES = [
-      { name: "Visual Studio Code", value: "vscode" },
-      { name: "IntelliJ IDEA", value: "idea" },
-      { name: "Atom", value: "atom" }
-    ];
+  const baseProjects = Object.keys(projects).filter((name2) => !name2.includes("#"));
+  if (baseProjects.length === 0) {
+    log.info("No projects to delete.");
+    return;
   }
-});
-
-// src/commands/index.ts
-import { Command as Command8 } from "commander";
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import loog from "loog";
-import omelette from "omelette";
-import File7 from "phylo";
-
-// src/lib/config.ts
-import Conf from "conf";
-var TRANSIENT_PROPS = ["pkg", "work"];
-var Config = class {
-  _transient = {};
-  _store;
-  constructor() {
-    this._store = new Conf({
-      projectName: "workon"
+  const name = await select({
+    message: "Select project to delete:",
+    choices: baseProjects.map((n) => ({ name: n, value: n }))
+  });
+  const branchPrefix = `${name}#`;
+  const branches = Object.keys(projects).filter((n) => n.startsWith(branchPrefix));
+  if (branches.length > 0) {
+    log.warn(`This project has ${branches.length} branch configuration(s).`);
+    const deleteAll = await confirm3({
+      message: "Delete all branch configurations as well?",
+      default: false
     });
-  }
-  get(key, defaultValue) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      return this._transient[key] ?? defaultValue;
-    }
-    return this._store.get(key, defaultValue);
-  }
-  set(key, value) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      this._transient[key] = value;
-    } else {
-      if (value === void 0) {
-        this._store.set(key, value);
-      } else {
-        this._store.set(key, value);
+    if (deleteAll) {
+      for (const branch of branches) {
+        config.deleteProject(branch);
       }
     }
   }
-  has(key) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      return Object.prototype.hasOwnProperty.call(this._transient, key);
-    }
-    return this._store.has(key);
-  }
-  delete(key) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      delete this._transient[key];
-    } else {
-      this._store.delete(key);
-    }
-  }
-  getProjects() {
-    return this.get("projects") ?? {};
-  }
-  getProject(name) {
-    const projects = this.getProjects();
-    return projects[name];
-  }
-  setProject(name, config) {
-    const projects = this.getProjects();
-    projects[name] = config;
-    this.set("projects", projects);
-  }
-  deleteProject(name) {
-    const projects = this.getProjects();
-    delete projects[name];
-    this.set("projects", projects);
-  }
-  getDefaults() {
-    return this.get("project_defaults");
-  }
-  setDefaults(defaults) {
-    this.set("project_defaults", defaults);
-  }
-  get path() {
-    return this._store.path;
-  }
-  get store() {
-    return this._store.store;
+  const confirmed = await confirm3({
+    message: `Are you sure you want to delete '${name}'?`,
+    default: false
+  });
+  if (confirmed) {
+    config.deleteProject(name);
+    log.info(`Project '${name}' deleted.`);
   }
-};
-
-// src/lib/environment.ts
-import File2 from "phylo";
-import { simpleGit } from "simple-git";
-
-// src/lib/project.ts
-import File from "phylo";
-import deepAssign from "deep-assign";
-var Project = class {
-  name;
-  _base;
-  _path;
-  _ide;
-  _events = {};
-  _branch;
-  _homepage;
-  _defaults;
-  _initialCfg;
-  constructor(name, cfg, defaults) {
-    this._defaults = defaults ?? { base: "" };
-    this._initialCfg = { path: name, events: {}, ...cfg };
-    this.name = cfg?.name ?? name;
-    const merged = deepAssign({}, this._defaults, this._initialCfg);
-    if (merged.base) {
-      this.base = merged.base;
-    }
-    if (merged.path) {
-      this.path = merged.path;
-    }
-    if (merged.ide) {
-      this._ide = merged.ide;
-    }
-    if (merged.events) {
-      this._events = merged.events;
-    }
-    if (merged.branch) {
-      this._branch = merged.branch;
-    }
-    if (merged.homepage) {
-      this._homepage = merged.homepage;
+}
+function listProjectsManage(ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const defaults = config.getDefaults();
+  console.log("\nConfigured projects:\n");
+  const baseProjects = Object.keys(projects).filter((name) => !name.includes("#"));
+  for (const name of baseProjects) {
+    const project = projects[name];
+    const fullPath = defaults?.base ? File3.from(defaults.base).join(project.path).path : project.path;
+    console.log(`  ${name}`);
+    console.log(`    Path: ${fullPath}`);
+    console.log(`    IDE: ${project.ide || "not set"}`);
+    console.log(`    Events: ${Object.keys(project.events).join(", ") || "none"}`);
+    const branchPrefix = `${name}#`;
+    const branches = Object.keys(projects).filter((n) => n.startsWith(branchPrefix));
+    if (branches.length > 0) {
+      console.log(`    Branches: ${branches.length}`);
     }
+    console.log();
   }
-  set base(path) {
-    this._base = File.from(path).absolutify();
-  }
-  get base() {
-    return this._base;
-  }
-  set ide(cmd) {
-    this._ide = cmd;
-  }
-  get ide() {
-    return this._ide;
-  }
-  set events(eventCfg) {
-    this._events = eventCfg;
-  }
-  get events() {
-    return this._events;
-  }
-  set path(path) {
-    if (this._base) {
-      this._path = this._base.join(path);
-    } else {
-      this._path = File.from(path);
-    }
-    this._path = this._path.absolutify();
+}
+async function editBranchManage(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  if (branches.length === 0) {
+    log.info("No branch configurations to edit.");
+    return;
   }
-  get path() {
-    if (!this._path) {
-      throw new Error("Project path not set");
+  const branchName = await select({
+    message: "Select branch configuration to edit:",
+    choices: branches.map((n) => ({
+      name: n.substring(branchPrefix.length),
+      value: n
+    }))
+  });
+  const branch = projects[branchName];
+  const keepEvents = await confirm3({
+    message: "Keep existing event configuration?",
+    default: true
+  });
+  let events = branch.events;
+  if (!keepEvents) {
+    const availableEvents = EventRegistry.getEventsForManageUI();
+    const currentEvents = Object.keys(branch.events);
+    const selectedEvents = await checkbox({
+      message: "Select events to enable:",
+      choices: availableEvents.map((e) => ({
+        name: `${e.name} - ${e.description}`,
+        value: e.value,
+        checked: currentEvents.includes(e.value)
+      }))
+    });
+    events = {};
+    for (const eventName of selectedEvents) {
+      if (branch.events[eventName]) {
+        events[eventName] = branch.events[eventName];
+      } else {
+        const eventHandler = EventRegistry.getEventByName(eventName);
+        if (eventHandler) {
+          const eventConfig = await eventHandler.configuration.configureInteractive();
+          events[eventName] = eventConfig;
+        }
+      }
     }
-    return this._path;
-  }
-  set branch(branch) {
-    this._branch = branch;
-  }
-  get branch() {
-    return this._branch;
   }
-  set homepage(url) {
-    this._homepage = url;
-  }
-  get homepage() {
-    return this._homepage;
-  }
-  static $isProject = true;
-  $isProject = true;
-};
-
-// src/lib/environment.ts
-var BaseEnvironment = class {
-  $isProjectEnvironment = false;
-};
-var ProjectEnvironment = class _ProjectEnvironment {
-  $isProjectEnvironment = true;
-  project;
-  constructor(projectCfg) {
-    this.project = new Project(projectCfg.name, projectCfg);
+  const updatedConfig = {
+    ...branch,
+    events
+  };
+  const confirmed = await confirm3({
+    message: "Save changes?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(branchName, updatedConfig);
+    log.info(`Branch configuration '${branchName}' updated successfully!`);
   }
-  static load(cfg, defaults) {
-    const project = new Project(cfg.name, cfg, defaults);
-    return new _ProjectEnvironment({ ...cfg, name: project.name });
+}
+async function deleteBranchManage(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  if (branches.length === 0) {
+    log.info("No branch configurations to delete.");
+    return;
   }
-};
-var EnvironmentRecognizer = class {
-  static config;
-  static log;
-  static projects = [];
-  static configured = false;
-  static configure(config, log) {
-    if (this.configured) {
-      return;
-    }
-    this.config = config;
-    this.log = log;
-    this.configured = true;
-  }
-  static async recognize(dir) {
-    this.ensureConfigured();
-    const theDir = File2.from(dir).canonicalize();
-    this.log.debug("Directory to recognize is: " + theDir.canonicalPath());
-    const allProjects = this.getAllProjects();
-    const matching = allProjects.filter((p) => p.path.canonicalPath() === theDir.path);
-    if (matching.length === 0) {
-      return new BaseEnvironment();
-    }
-    this.log.debug(`Found ${matching.length} matching projects`);
-    const base = matching.find((p) => !p.name.includes("#")) ?? matching[0];
-    this.log.debug("Base project is: " + base.name);
-    const gitDir = base.path.up(".git");
-    if (gitDir) {
-      try {
-        const git = simpleGit(gitDir.path);
-        const branchSummary = await git.branchLocal();
-        base.branch = branchSummary.current;
-      } catch {
-      }
-    }
-    return this.getProjectEnvironment(base, matching);
+  const branchName = await select({
+    message: "Select branch configuration to delete:",
+    choices: branches.map((n) => ({
+      name: n.substring(branchPrefix.length),
+      value: n
+    }))
+  });
+  const confirmed = await confirm3({
+    message: `Are you sure you want to delete '${branchName}'?`,
+    default: false
+  });
+  if (confirmed) {
+    config.deleteProject(branchName);
+    log.info(`Branch configuration '${branchName}' deleted.`);
   }
-  static getAllProjects(refresh = false) {
-    if (this.projects.length > 0 && !refresh) {
-      return this.projects;
-    }
-    const defaults = this.config.getDefaults();
-    if (!defaults?.base) {
-      this.projects = [];
-      return this.projects;
-    }
-    const baseDir = File2.from(defaults.base);
-    const projectsMap = this.config.getProjects();
-    this.projects = Object.entries(projectsMap).map(([name, project]) => ({
-      ...project,
-      name,
-      path: baseDir.join(project.path)
-    }));
-    return this.projects;
-  }
-  static getProjectEnvironment(base, _matching) {
-    const exactName = `${base.name}#${base.branch}`;
-    const exactProj = this.projects.find((p) => p.name === exactName);
-    const toProjectConfig = (p) => ({
-      name: p.name,
-      path: p.path.path,
-      // Convert PhyloFile to string path
-      ide: p.ide,
-      homepage: p.homepage,
-      events: p.events,
-      branch: p.branch,
-      exactName
-    });
-    if (exactProj) {
-      return new ProjectEnvironment({ ...toProjectConfig(exactProj), branch: base.branch });
-    }
-    return new ProjectEnvironment(toProjectConfig(base));
-  }
-  static ensureConfigured() {
-    if (!this.configured) {
-      this.config = new Config();
-      this.log = {
-        debug: () => {
-        },
-        info: () => {
-        },
-        log: () => {
-        },
-        warn: () => {
-        },
-        error: () => {
-        },
-        setLogLevel: () => {
-        }
-      };
-      this.configured = true;
-    }
+}
+function listBranchesManage(projectName, ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  console.log(`
+Branch configurations for '${projectName}':
+`);
+  for (const branchName of branches) {
+    const branch = projects[branchName];
+    const shortName = branchName.substring(branchPrefix.length);
+    console.log(`  ${shortName}`);
+    console.log(`    Events: ${Object.keys(branch.events).join(", ") || "none"}`);
+    console.log();
   }
-};
+}
+var IDE_CHOICES;
+var init_interactive = __esm({
+  "src/commands/interactive.ts"() {
+    "use strict";
+    init_environment();
+    init_registry();
+    IDE_CHOICES = [
+      { name: "Visual Studio Code", value: "vscode" },
+      { name: "IntelliJ IDEA", value: "idea" },
+      { name: "Atom", value: "atom" }
+    ];
+  }
+});
+
+// src/commands/index.ts
+init_config();
+init_environment();
+import { Command as Command8 } from "commander";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import loog from "loog";
+import omelette from "omelette";
+import File7 from "phylo";
 
 // src/commands/open.ts
+init_environment();
 import { Command } from "commander";
 import File4 from "phylo";
 
@@ -782,616 +1889,8 @@ var TmuxManager = class {
   }
 };
 
-// src/events/core/cwd.ts
-import { spawn as spawn2 } from "child_process";
-var CwdEvent = class {
-  static get metadata() {
-    return {
-      name: "cwd",
-      displayName: "Change directory (cwd)",
-      description: "Change current working directory to project path",
-      category: "core",
-      requiresTmux: false,
-      dependencies: []
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        return "cwd config must be a boolean (true/false)";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        return true;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const projectPath = project.path.path;
-        if (isShellMode) {
-          shellCommands.push(`cd "${projectPath}"`);
-        } else {
-          const shell = process.env.SHELL || "/bin/bash";
-          spawn2(shell, [], {
-            cwd: projectPath,
-            stdio: "inherit"
-          });
-        }
-      },
-      generateShellCommand(context) {
-        const projectPath = context.project.path.path;
-        return [`cd "${projectPath}"`];
-      }
-    };
-  }
-  static get tmux() {
-    return null;
-  }
-  static get help() {
-    return {
-      usage: "cwd: true | false",
-      description: "Change the current working directory to the project path",
-      examples: [
-        { config: true, description: "Enable directory change" },
-        { config: false, description: "Disable directory change" }
-      ]
-    };
-  }
-};
-
-// src/events/core/ide.ts
-import { spawn as spawn3 } from "child_process";
-var IdeEvent = class {
-  static get metadata() {
-    return {
-      name: "ide",
-      displayName: "Open in IDE",
-      description: "Open project in configured IDE/editor",
-      category: "core",
-      requiresTmux: false,
-      dependencies: []
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        return "ide config must be a boolean (true/false)";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        return true;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const projectPath = project.path.path;
-        const ide = project.ide || "code";
-        if (isShellMode) {
-          shellCommands.push(`${ide} "${projectPath}" &`);
-        } else {
-          spawn3(ide, [projectPath], {
-            detached: true,
-            stdio: "ignore"
-          }).unref();
-        }
-      },
-      generateShellCommand(context) {
-        const projectPath = context.project.path.path;
-        const ide = context.project.ide || "code";
-        return [`${ide} "${projectPath}" &`];
-      }
-    };
-  }
-  static get tmux() {
-    return null;
-  }
-  static get help() {
-    return {
-      usage: "ide: true | false",
-      description: "Open the project in the configured IDE",
-      examples: [
-        { config: true, description: "Enable IDE opening" },
-        { config: false, description: "Disable IDE opening" }
-      ]
-    };
-  }
-};
-
-// src/events/core/web.ts
-import { spawn as spawn4 } from "child_process";
-import { platform } from "os";
-var WebEvent = class _WebEvent {
-  static get metadata() {
-    return {
-      name: "web",
-      displayName: "Open homepage in browser",
-      description: "Open project homepage in web browser",
-      category: "core",
-      requiresTmux: false,
-      dependencies: []
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        return "web config must be a boolean (true/false)";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        return true;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static getOpenCommand() {
-    const os = platform();
-    switch (os) {
-      case "darwin":
-        return "open";
-      case "win32":
-        return "start";
-      default:
-        return "xdg-open";
-    }
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const homepage = project.homepage;
-        if (!homepage) {
-          console.warn("No homepage configured for project");
-          return;
-        }
-        const openCmd = _WebEvent.getOpenCommand();
-        if (isShellMode) {
-          shellCommands.push(`${openCmd} "${homepage}" &`);
-        } else {
-          spawn4(openCmd, [homepage], {
-            detached: true,
-            stdio: "ignore"
-          }).unref();
-        }
-      },
-      generateShellCommand(context) {
-        const homepage = context.project.homepage;
-        if (!homepage) return [];
-        const openCmd = _WebEvent.getOpenCommand();
-        return [`${openCmd} "${homepage}" &`];
-      }
-    };
-  }
-  static get tmux() {
-    return null;
-  }
-  static get help() {
-    return {
-      usage: "web: true | false",
-      description: "Open the project homepage in the default browser",
-      examples: [
-        { config: true, description: "Enable browser opening" },
-        { config: false, description: "Disable browser opening" }
-      ]
-    };
-  }
-};
-
-// src/events/extensions/claude.ts
-import { spawn as spawn5 } from "child_process";
-import { input, confirm } from "@inquirer/prompts";
-var ClaudeEvent = class _ClaudeEvent {
-  static get metadata() {
-    return {
-      name: "claude",
-      displayName: "Launch Claude Code",
-      description: "Launch Claude Code with optional flags and configuration",
-      category: "development",
-      requiresTmux: true,
-      dependencies: ["claude"]
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        if (typeof config === "object" && config !== null) {
-          const cfg = config;
-          if (cfg.flags !== void 0) {
-            if (!Array.isArray(cfg.flags)) {
-              return "claude.flags must be an array of strings";
-            }
-            for (const flag of cfg.flags) {
-              if (typeof flag !== "string") {
-                return "claude.flags must contain only strings";
-              }
-              if (!flag.startsWith("-")) {
-                return `Invalid flag "${flag}": flags must start with - or --`;
-              }
-            }
-          }
-          if (cfg.split_terminal !== void 0 && typeof cfg.split_terminal !== "boolean") {
-            return "claude.split_terminal must be a boolean";
-          }
-          return true;
-        }
-        return "claude config must be a boolean or object with flags/split_terminal";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        const useAdvanced = await confirm({
-          message: "Configure advanced Claude options?",
-          default: false
-        });
-        if (!useAdvanced) {
-          return true;
-        }
-        const flagsInput = await input({
-          message: "Enter Claude flags (comma-separated, e.g., --resume, --debug):",
-          default: ""
-        });
-        const flags = flagsInput.split(",").map((f) => f.trim()).filter((f) => f.length > 0 && f.startsWith("-"));
-        const splitTerminal = await confirm({
-          message: "Use split terminal layout (Claude + shell)?",
-          default: true
-        });
-        if (flags.length === 0 && !splitTerminal) {
-          return true;
-        }
-        const config = {};
-        if (flags.length > 0) config.flags = flags;
-        if (splitTerminal) config.split_terminal = splitTerminal;
-        return config;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static getClaudeCommand(config) {
-    if (typeof config === "boolean" || config === void 0) {
-      return "claude";
-    }
-    const flags = config.flags || [];
-    return flags.length > 0 ? `claude ${flags.join(" ")}` : "claude";
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const claudeConfig = project.events.claude;
-        const claudeCommand = _ClaudeEvent.getClaudeCommand(claudeConfig);
-        if (isShellMode) {
-          shellCommands.push(claudeCommand);
-        } else {
-          const args = claudeCommand.split(" ").slice(1);
-          spawn5("claude", args, {
-            cwd: project.path.path,
-            stdio: "inherit"
-          });
-        }
-      },
-      generateShellCommand(context) {
-        const claudeConfig = context.project.events.claude;
-        return [_ClaudeEvent.getClaudeCommand(claudeConfig)];
-      }
-    };
-  }
-  static get tmux() {
-    return {
-      getLayoutPriority() {
-        return 100;
-      },
-      contributeToLayout(enabledCommands) {
-        if (enabledCommands.includes("npm")) {
-          return "three-pane";
-        }
-        return "split";
-      }
-    };
-  }
-  static get help() {
-    return {
-      usage: "claude: true | { flags: string[], split_terminal: boolean }",
-      description: "Launch Claude Code in the project directory",
-      examples: [
-        { config: true, description: "Launch Claude with defaults" },
-        { config: { flags: ["--resume"] }, description: "Resume previous session" },
-        {
-          config: { flags: ["--model", "opus"], split_terminal: true },
-          description: "Use Opus model with split terminal"
-        }
-      ]
-    };
-  }
-};
-
-// src/events/extensions/docker.ts
-import { spawn as spawn6 } from "child_process";
-import { input as input2 } from "@inquirer/prompts";
-var DockerEvent = class _DockerEvent {
-  static get metadata() {
-    return {
-      name: "docker",
-      displayName: "Docker container management",
-      description: "Start/stop Docker containers for the project",
-      category: "development",
-      requiresTmux: false,
-      dependencies: ["docker"]
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        if (typeof config === "string") {
-          return true;
-        }
-        if (typeof config === "object" && config !== null) {
-          const cfg = config;
-          if (cfg.compose_file !== void 0 && typeof cfg.compose_file !== "string") {
-            return "docker.compose_file must be a string";
-          }
-          if (cfg.services !== void 0) {
-            if (!Array.isArray(cfg.services)) {
-              return "docker.services must be an array";
-            }
-            for (const service of cfg.services) {
-              if (typeof service !== "string") {
-                return "docker.services must contain only strings";
-              }
-            }
-          }
-          return true;
-        }
-        return "docker config must be a boolean, string (compose file), or object";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        const composeFile = await input2({
-          message: "Enter docker-compose file path:",
-          default: "docker-compose.yml"
-        });
-        const servicesInput = await input2({
-          message: "Enter services to start (comma-separated, leave empty for all):",
-          default: ""
-        });
-        const services = servicesInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-        if (composeFile === "docker-compose.yml" && services.length === 0) {
-          return { compose_file: "docker-compose.yml" };
-        }
-        if (services.length === 0) {
-          return composeFile;
-        }
-        return {
-          compose_file: composeFile,
-          services
-        };
-      },
-      getDefaultConfig() {
-        return { compose_file: "docker-compose.yml" };
-      }
-    };
-  }
-  static getDockerCommand(config) {
-    if (typeof config === "boolean" || config === void 0) {
-      return "docker-compose up -d";
-    }
-    if (typeof config === "string") {
-      return `docker-compose -f ${config} up -d`;
-    }
-    const composeFile = config.compose_file || "docker-compose.yml";
-    const services = config.services?.join(" ") || "";
-    return `docker-compose -f ${composeFile} up -d ${services}`.trim();
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const dockerConfig = project.events.docker;
-        const dockerCommand = _DockerEvent.getDockerCommand(
-          dockerConfig
-        );
-        if (isShellMode) {
-          shellCommands.push(dockerCommand);
-        } else {
-          const [cmd, ...args] = dockerCommand.split(" ");
-          spawn6(cmd, args, {
-            cwd: project.path.path,
-            stdio: "inherit"
-          });
-        }
-      },
-      generateShellCommand(context) {
-        const dockerConfig = context.project.events.docker;
-        return [_DockerEvent.getDockerCommand(dockerConfig)];
-      }
-    };
-  }
-  static get tmux() {
-    return null;
-  }
-  static get help() {
-    return {
-      usage: 'docker: true | "compose-file.yml" | { compose_file: string, services?: string[] }',
-      description: "Start Docker containers for the project",
-      examples: [
-        { config: true, description: "Use default docker-compose.yml" },
-        { config: "docker-compose.dev.yml", description: "Use custom compose file" },
-        {
-          config: { compose_file: "docker-compose.yml", services: ["web", "db"] },
-          description: "Start specific services"
-        }
-      ]
-    };
-  }
-};
-
-// src/events/registry.ts
-init_npm();
-var ALL_EVENTS = [CwdEvent, IdeEvent, WebEvent, ClaudeEvent, DockerEvent, NpmEvent];
-var EventRegistryClass = class {
-  _events = /* @__PURE__ */ new Map();
-  _initialized = false;
-  /**
-   * Initialize the registry by registering all events
-   */
-  async initialize() {
-    if (this._initialized) return;
-    this.registerEvents();
-    this._initialized = true;
-  }
-  /**
-   * Register all event classes
-   */
-  registerEvents() {
-    for (const EventClass of ALL_EVENTS) {
-      if (this.isValidEvent(EventClass)) {
-        const metadata = EventClass.metadata;
-        this._events.set(metadata.name, EventClass);
-      }
-    }
-  }
-  /**
-   * Validate if a class is a proper event
-   */
-  isValidEvent(EventClass) {
-    try {
-      if (typeof EventClass !== "function") return false;
-      const metadata = EventClass.metadata;
-      return metadata !== void 0 && typeof metadata.name === "string" && typeof metadata.displayName === "string" && typeof EventClass.validation === "object" && typeof EventClass.configuration === "object" && typeof EventClass.processing === "object";
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get all valid event names from registered events
-   */
-  getValidEventNames() {
-    this.ensureInitialized();
-    return Array.from(this._events.keys());
-  }
-  /**
-   * Get event by name
-   */
-  getEventByName(name) {
-    this.ensureInitialized();
-    return this._events.get(name) ?? null;
-  }
-  /**
-   * Get all events for management UI
-   */
-  getEventsForManageUI() {
-    this.ensureInitialized();
-    const events = [];
-    for (const [name, EventClass] of this._events) {
-      const metadata = EventClass.metadata;
-      events.push({
-        name: metadata.displayName,
-        value: name,
-        description: metadata.description
-      });
-    }
-    return events.sort((a, b) => a.name.localeCompare(b.name));
-  }
-  /**
-   * Get events that support tmux integration
-   */
-  getTmuxEnabledEvents() {
-    this.ensureInitialized();
-    const tmuxEvents = [];
-    for (const [name, EventClass] of this._events) {
-      const tmux = EventClass.tmux;
-      if (tmux) {
-        tmuxEvents.push({
-          name,
-          event: EventClass,
-          priority: tmux.getLayoutPriority ? tmux.getLayoutPriority() : 0
-        });
-      }
-    }
-    return tmuxEvents.sort((a, b) => b.priority - a.priority);
-  }
-  /**
-   * Get all available events with their metadata
-   */
-  getAllEvents() {
-    this.ensureInitialized();
-    const events = [];
-    for (const [name, EventClass] of this._events) {
-      const typedClass = EventClass;
-      events.push({
-        name,
-        metadata: typedClass.metadata,
-        hasValidation: !!typedClass.validation,
-        hasConfiguration: !!typedClass.configuration,
-        hasProcessing: !!typedClass.processing,
-        hasTmux: !!typedClass.tmux,
-        hasHelp: !!typedClass.help
-      });
-    }
-    return events;
-  }
-  /**
-   * Ensure registry is initialized
-   */
-  ensureInitialized() {
-    if (!this._initialized) {
-      throw new Error("EventRegistry must be initialized before use. Call initialize() first.");
-    }
-  }
-  /**
-   * Clear the registry (useful for testing)
-   */
-  clear() {
-    this._events.clear();
-    this._initialized = false;
-  }
-};
-var EventRegistry = new EventRegistryClass();
-
 // src/commands/open.ts
+init_registry();
 function createOpenCommand(ctx) {
   const { config, log } = ctx;
   const command = new Command("open").description("Open a project by passing its project id").argument("[project]", "The id of the project to open (supports project:command syntax)").option("-d, --debug", "Enable debug logging").option("-n, --dry-run", "Show what would happen without executing").option("--shell", "Output shell commands instead of spawning processes").action(async (projectArg, options) => {
@@ -1806,8 +2305,9 @@ function createConfigCommand(ctx) {
 }
 
 // src/commands/manage.ts
+init_registry();
 import { Command as Command6 } from "commander";
-import { select as select2, input as input5, confirm as confirm3, checkbox as checkbox2 } from "@inquirer/prompts";
+import { select as select2, input as input5, confirm as confirm4, checkbox as checkbox2 } from "@inquirer/prompts";
 import File5 from "phylo";
 var IDE_CHOICES2 = [
   { name: "Visual Studio Code", value: "vscode" },
@@ -1939,7 +2439,7 @@ async function createProject(ctx) {
   }
   console.log("\nProject configuration:");
   console.log(JSON.stringify(projectConfig, null, 2));
-  const confirmed = await confirm3({
+  const confirmed = await confirm4({
     message: "Save this project?",
     default: true
   });
@@ -1990,7 +2490,7 @@ async function editProject(ctx) {
     message: "Project homepage URL:",
     default: project.homepage || ""
   });
-  const keepEvents = await confirm3({
+  const keepEvents = await confirm4({
     message: "Keep existing event configuration?",
     default: true
   });
@@ -2029,7 +2529,7 @@ async function editProject(ctx) {
   }
   console.log("\nUpdated configuration:");
   console.log(JSON.stringify(updatedConfig, null, 2));
-  const confirmed = await confirm3({
+  const confirmed = await confirm4({
     message: "Save changes?",
     default: true
   });
@@ -2052,7 +2552,7 @@ async function deleteProject(ctx) {
     message: "Select project to delete:",
     choices: projectNames.map((n) => ({ name: n, value: n }))
   });
-  const confirmed = await confirm3({
+  const confirmed = await confirm4({
     message: `Are you sure you want to delete '${name}'?`,
     default: false
   });
@@ -2086,7 +2586,7 @@ import { Command as Command7 } from "commander";
 import { existsSync, readFileSync } from "fs";
 import { basename, resolve } from "path";
 import File6 from "phylo";
-import { confirm as confirm4 } from "@inquirer/prompts";
+import { confirm as confirm5 } from "@inquirer/prompts";
 function createAddCommand(ctx) {
   const { log } = ctx;
   return new Command7("add").description("Add a project from a directory path").argument("[path]", "Path to the project directory (defaults to current directory)", ".").option("-d, --debug", "Enable debug logging").option("-n, --name <name>", "Override the detected project name").option(
@@ -2130,7 +2630,7 @@ async function addProject(pathArg, options, ctx) {
     process.exit(1);
   }
   if (projectName in projects && !options.force) {
-    const overwrite = await confirm4({
+    const overwrite = await confirm5({
       message: `Project '${projectName}' already exists. Overwrite?`,
       default: false
     });
@@ -2245,32 +2745,41 @@ function createCli() {
   config.set("pkg", packageJson);
   EnvironmentRecognizer.configure(config, log);
   const completion = setupCompletion(config);
-  program2.name("workon").description("Work on something great!").version(packageJson.version).option("-d, --debug", "Enable debug logging").option("--completion", "Setup shell tab completion").option("--shell", "Output shell commands for evaluation").option("--init", "Generate shell integration function").hook("preAction", (thisCommand) => {
+  program2.name("workon").description("Work on something great!").version(packageJson.version).argument("[project]", "Project name to open (supports project:command syntax)").option("-d, --debug", "Enable debug logging").option("--completion", "Setup shell tab completion").option("--shell", "Output shell commands for evaluation").option("--init", "Generate shell integration function").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     if (opts.debug) {
       log.setLogLevel("debug");
     }
-  }).action(async (options) => {
-    if (options.debug) {
-      log.setLogLevel("debug");
-    }
-    if (options.completion) {
-      log.debug("Setting up command-line completion");
-      completion.setupShellInitFile();
-      return;
-    }
-    if (options.init) {
-      log.debug("Generating shell integration function");
-      outputShellInit(program2);
-      return;
+  }).action(
+    async (project, options) => {
+      if (options.debug) {
+        log.setLogLevel("debug");
+      }
+      if (options.completion) {
+        log.debug("Setting up command-line completion");
+        completion.setupShellInitFile();
+        return;
+      }
+      if (options.init) {
+        log.debug("Generating shell integration function");
+        outputShellInit(program2);
+        return;
+      }
+      if (project) {
+        const args = ["open", project];
+        if (options.shell) args.push("--shell");
+        if (options.debug) args.push("--debug");
+        await program2.parseAsync(["node", "workon", ...args]);
+        return;
+      }
+      const environment = await EnvironmentRecognizer.recognize(File7.cwd());
+      program2.setOptionValue("_environment", environment);
+      program2.setOptionValue("_config", config);
+      program2.setOptionValue("_log", log);
+      const { runInteractive: runInteractive2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+      await runInteractive2({ config, log, environment });
     }
-    const environment = await EnvironmentRecognizer.recognize(File7.cwd());
-    program2.setOptionValue("_environment", environment);
-    program2.setOptionValue("_config", config);
-    program2.setOptionValue("_log", log);
-    const { runInteractive: runInteractive2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
-    await runInteractive2({ config, log, environment });
-  });
+  );
   program2.setOptionValue("_config", config);
   program2.setOptionValue("_log", log);
   program2.addCommand(createOpenCommand({ config, log }));