workon 2.1.3 → 3.0.0

package/dist/cli.js

@@ -0,0 +1,2227 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in 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
+});
+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/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":
+      return;
+    case "more":
+      await startInteractive(defaultName, fromUser, ctx, true);
+      return;
+    case "init-project":
+      await initProject(defaultName, fromUser, ctx);
+      return;
+    case "init-branch":
+      await initBranch(defaultName, ctx);
+      return;
+    case "switch-project":
+      log.info("Switch to an existing project");
+      break;
+    case "switch-branch":
+      log.info("Switch to an existing branch");
+      break;
+    case "manage-projects":
+      log.info("Manage existing projects");
+      break;
+    case "manage-branches":
+      log.info("Manage existing branches");
+      break;
+  }
+}
+function getFirstQuestion(defaultName, fromUser, environment, showMain) {
+  if (!showMain && environment.$isProjectEnvironment && !fromUser) {
+    return {
+      message: environment.project.name,
+      choices: [
+        { name: "Start a branch", value: "init-branch" },
+        { name: "Switch branch", value: "switch-branch" },
+        { name: "Manage branches", value: "manage-branches" },
+        { name: "---", value: "" },
+        { name: "More...", value: "more" },
+        { name: "Exit", value: "exit" }
+      ].filter((c) => c.value !== "")
+    };
+  }
+  return {
+    message: "What do you want to do?",
+    choices: [
+      { name: "Start a new project", value: "init-project" },
+      { name: "Open an existing project", value: "switch-project" },
+      { name: "Manage projects", value: "manage-projects" },
+      { name: "---", value: "" },
+      { name: "Exit", value: "exit" }
+    ].filter((c) => c.value !== "")
+  };
+}
+async function initProject(defaultName, fromUser, ctx) {
+  const { config, log } = ctx;
+  const defaults = config.getDefaults();
+  const projects = config.getProjects();
+  let name;
+  if (fromUser) {
+    name = defaultName;
+    log.log(`Project name: ${name}`);
+  } else {
+    name = await input4({
+      message: "What is the name of the project?",
+      default: defaultName,
+      validate: (value) => {
+        if (value in projects) return "Project already exists.";
+        if (/\w+#\w+/.test(value)) {
+          const projectName = value.substring(0, value.indexOf("#"));
+          if (!(projectName in projects)) {
+            return `Project '${projectName}' does not exist. Please create it before starting a branch.`;
+          }
+        }
+        return true;
+      }
+    });
+  }
+  const isBranch = /\w+#\w+/.test(name);
+  let basePath;
+  if (isBranch) {
+    const projectName = name.substring(0, name.indexOf("#"));
+    basePath = defaults?.base ? File3.from(defaults.base).join(projects[projectName].path).absolutePath() : projects[projectName].path;
+    log.log(`Project path: ${basePath}`);
+  } else {
+    const pathAnswer = await input4({
+      message: "What is the path to the project?",
+      default: defaults?.base ? File3.from(defaults.base).join(name).path : name
+    });
+    let answerFile = File3.from(pathAnswer);
+    const defaultBase = defaults?.base ? File3.from(defaults.base) : File3.cwd();
+    if (!answerFile.isAbsolute()) {
+      answerFile = defaultBase.join(answerFile.path);
+    }
+    try {
+      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!`);
+}
+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" }
+    ];
+  }
+});
+
+// src/commands/index.ts
+import { Command as Command7 } from "commander";
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import loog from "loog";
+import omelette from "omelette";
+import File6 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"
+    });
+  }
+  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;
+  }
+};
+
+// 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;
+    }
+  }
+  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
+var BaseEnvironment = class {
+  $isProjectEnvironment = false;
+};
+var 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 });
+  }
+};
+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);
+  }
+  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/commands/open.ts
+import { Command } from "commander";
+import File4 from "phylo";
+
+// src/lib/tmux.ts
+import { exec as execCallback, spawn } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execCallback);
+var TmuxManager = class {
+  sessionPrefix = "workon-";
+  async isTmuxAvailable() {
+    try {
+      await exec("which tmux");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async sessionExists(sessionName) {
+    try {
+      await exec(`tmux has-session -t "${sessionName}"`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getSessionName(projectName) {
+    return `${this.sessionPrefix}${projectName}`;
+  }
+  async killSession(sessionName) {
+    try {
+      await exec(`tmux kill-session -t "${sessionName}"`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async createSplitSession(projectName, projectPath, claudeArgs = []) {
+    const sessionName = this.getSessionName(projectName);
+    if (await this.sessionExists(sessionName)) {
+      await this.killSession(sessionName);
+    }
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
+    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
+    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
+    return sessionName;
+  }
+  async createThreePaneSession(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    if (await this.sessionExists(sessionName)) {
+      await this.killSession(sessionName);
+    }
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
+    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
+    await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
+    await exec(`tmux set-option -t "${sessionName}:0.2" remain-on-exit on`);
+    await exec(`tmux resize-pane -t "${sessionName}:0.2" -y 10`);
+    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
+    return sessionName;
+  }
+  async createTwoPaneNpmSession(projectName, projectPath, npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    if (await this.sessionExists(sessionName)) {
+      await this.killSession(sessionName);
+    }
+    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}"`);
+    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`);
+    await exec(`tmux set-option -t "${sessionName}:0.1" remain-on-exit on`);
+    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
+    return sessionName;
+  }
+  async attachToSession(sessionName) {
+    if (process.env.TMUX) {
+      await exec(`tmux switch-client -t "${sessionName}"`);
+    } else {
+      const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || !!process.env.ITERM_SESSION_ID;
+      const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
+      if (useiTermIntegration) {
+        spawn("tmux", ["-CC", "attach-session", "-t", sessionName], {
+          stdio: "inherit",
+          detached: true
+        });
+      } else {
+        spawn("tmux", ["attach-session", "-t", sessionName], {
+          stdio: "inherit",
+          detached: true
+        });
+      }
+    }
+  }
+  buildShellCommands(projectName, projectPath, claudeArgs = []) {
+    const sessionName = this.getSessionName(projectName);
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    return [
+      `# Create tmux split session for ${projectName}`,
+      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
+      `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
+      `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
+      `tmux select-pane -t "${sessionName}:0.0"`,
+      this.getAttachCommand(sessionName)
+    ];
+  }
+  buildThreePaneShellCommands(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    return [
+      `# Create tmux three-pane session for ${projectName}`,
+      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
+      `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
+      `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
+      `tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`,
+      `tmux set-option -t "${sessionName}:0.2" remain-on-exit on`,
+      `tmux resize-pane -t "${sessionName}:0.2" -y 10`,
+      `tmux select-pane -t "${sessionName}:0.0"`,
+      this.getAttachCommand(sessionName)
+    ];
+  }
+  buildTwoPaneNpmShellCommands(projectName, projectPath, npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    return [
+      `# Create tmux two-pane session with npm for ${projectName}`,
+      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
+      `tmux new-session -d -s "${sessionName}" -c "${projectPath}"`,
+      `tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`,
+      `tmux set-option -t "${sessionName}:0.1" remain-on-exit on`,
+      `tmux select-pane -t "${sessionName}:0.0"`,
+      this.getAttachCommand(sessionName)
+    ];
+  }
+  getAttachCommand(sessionName) {
+    if (process.env.TMUX) {
+      return `tmux switch-client -t "${sessionName}"`;
+    }
+    const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || process.env.ITERM_SESSION_ID;
+    const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
+    if (useiTermIntegration) {
+      return `tmux -CC attach-session -t "${sessionName}"`;
+    }
+    return `tmux attach-session -t "${sessionName}"`;
+  }
+  async listWorkonSessions() {
+    try {
+      const { stdout } = await exec('tmux list-sessions -F "#{session_name}"');
+      return stdout.trim().split("\n").filter((session) => session.startsWith(this.sessionPrefix)).map((session) => session.replace(this.sessionPrefix, ""));
+    } catch {
+      return [];
+    }
+  }
+};
+
+// 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
+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) => {
+    if (options.debug) {
+      log.setLogLevel("debug");
+    }
+    await EventRegistry.initialize();
+    if (projectArg) {
+      await processProject(projectArg, options, ctx);
+    } else {
+      log.debug("No project name provided, starting interactive mode");
+      const { runInteractive: runInteractive2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+      const environment = await EnvironmentRecognizer.recognize(File4.cwd());
+      await runInteractive2({ config, log, environment });
+    }
+  });
+  return command;
+}
+async function processProject(projectParam, options, ctx) {
+  const { config, log } = ctx;
+  const [projectName, commandsString] = projectParam.split(":");
+  const requestedCommands = commandsString ? commandsString.split(",").map((cmd) => cmd.trim()) : null;
+  if (commandsString === "help") {
+    await showProjectHelp(projectName, ctx);
+    return;
+  }
+  log.debug(
+    `Project: ${projectName}, Commands: ${requestedCommands ? requestedCommands.join(", ") : "all"}`
+  );
+  const projects = config.getProjects();
+  const environment = await EnvironmentRecognizer.recognize(File4.cwd());
+  if (environment.$isProjectEnvironment && (projectName === "this" || projectName === ".")) {
+    log.info(`Opening current project: ${environment.project.name}`);
+    await switchTo(environment, requestedCommands, options, ctx);
+    return;
+  }
+  if (projectName in projects) {
+    const cfg = projects[projectName];
+    const projectCfg = { ...cfg, name: projectName };
+    if (requestedCommands) {
+      validateRequestedCommands(requestedCommands, projectCfg, projectName);
+    }
+    const projectEnv = ProjectEnvironment.load(projectCfg, config.getDefaults());
+    await switchTo(projectEnv, requestedCommands, options, ctx);
+  } else {
+    log.debug(`Project '${projectName}' not found, starting interactive mode`);
+    const { runInteractive: runInteractive2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+    await runInteractive2({ config, log, environment, suggestedName: projectName });
+  }
+}
+function validateRequestedCommands(requestedCommands, projectConfig, projectName) {
+  const configuredEvents = Object.keys(projectConfig.events || {});
+  const invalidCommands = requestedCommands.filter((cmd) => !configuredEvents.includes(cmd));
+  if (invalidCommands.length > 0) {
+    const availableCommands = configuredEvents.join(", ");
+    throw new Error(
+      `Commands not configured for project '${projectName}': ${invalidCommands.join(", ")}
+Available commands: ${availableCommands}`
+    );
+  }
+}
+async function switchTo(environment, requestedCommands, options, ctx) {
+  const { log } = ctx;
+  const project = environment.project;
+  let events;
+  if (requestedCommands) {
+    events = resolveCommandDependencies(requestedCommands, project);
+    log.debug(`Executing requested commands: ${events.join(", ")}`);
+  } else {
+    events = Object.keys(project.events).filter(
+      (e) => project.events[e]
+    );
+    log.debug(`Executing all configured commands: ${events.join(", ")}`);
+  }
+  log.debug(`Shell is ${process.env.SHELL}`);
+  log.debug(`Project path is ${project.path.path}`);
+  log.debug(`IDE command is: ${project.ide}`);
+  log.debug(`Final events to execute: ${events.join(", ")}`);
+  const shellCommands = [];
+  const isShellMode = options.shell || false;
+  const hasCwd = events.includes("cwd");
+  const hasClaudeEvent = events.includes("claude");
+  const hasNpmEvent = events.includes("npm");
+  const dryRun = options.dryRun || false;
+  if (hasCwd && hasClaudeEvent && hasNpmEvent) {
+    await handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx);
+  } else if (hasCwd && hasNpmEvent) {
+    await handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx);
+  } else if (hasCwd && hasClaudeEvent) {
+    await handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx);
+  } else {
+    for (const event of events) {
+      if (!dryRun) {
+        await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+      }
+    }
+  }
+  if (dryRun) {
+    log.info("Dry run - would execute events:", events.join(", "));
+  }
+  if (isShellMode && shellCommands.length > 0) {
+    console.log(shellCommands.join("\n"));
+  }
+}
+function resolveCommandDependencies(requestedCommands, project) {
+  const resolved = [...requestedCommands];
+  const needsCwd = ["claude", "npm", "ide"];
+  const needsCwdCommands = requestedCommands.filter((cmd) => needsCwd.includes(cmd));
+  if (needsCwdCommands.length > 0 && !requestedCommands.includes("cwd") && project.events.cwd) {
+    resolved.unshift("cwd");
+  }
+  return [...new Set(resolved)];
+}
+async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const { log } = ctx;
+  const tmux = new TmuxManager();
+  const claudeConfig = project.events.claude;
+  const claudeArgs = typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+  let tmuxHandled = false;
+  if (isShellMode) {
+    if (await tmux.isTmuxAvailable()) {
+      const commands = tmux.buildShellCommands(project.name, project.path.path, claudeArgs);
+      shellCommands.push(...commands);
+      tmuxHandled = true;
+    } else {
+      log.debug("Tmux not available, falling back to normal mode");
+      shellCommands.push(`cd "${project.path.path}"`);
+      const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+      shellCommands.push(claudeCommand);
+      tmuxHandled = true;
+    }
+  } else if (!dryRun) {
+    if (await tmux.isTmuxAvailable()) {
+      try {
+        const sessionName = await tmux.createSplitSession(
+          project.name,
+          project.path.path,
+          claudeArgs
+        );
+        await tmux.attachToSession(sessionName);
+        tmuxHandled = true;
+      } catch (error) {
+        log.debug(`Failed to create tmux session: ${error.message}`);
+      }
+    } else {
+      log.debug("Tmux not available, falling back to normal event processing");
+    }
+  } else {
+    log.info(`Would create split tmux session '${project.name}' with Claude`);
+    tmuxHandled = true;
+  }
+  if (!tmuxHandled && !dryRun) {
+    for (const event of events.filter((e) => ["cwd", "claude"].includes(e))) {
+      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+    }
+  }
+  if (!dryRun) {
+    for (const event of events.filter((e) => !["cwd", "claude"].includes(e))) {
+      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+    }
+  }
+}
+async function handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const { log } = ctx;
+  const tmux = new TmuxManager();
+  const claudeConfig = project.events.claude;
+  const claudeArgs = typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+  const npmConfig = project.events.npm;
+  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
+  const npmCommand = NpmEvent2.getNpmCommand(npmConfig);
+  let tmuxHandled = false;
+  if (isShellMode) {
+    if (await tmux.isTmuxAvailable()) {
+      const commands = tmux.buildThreePaneShellCommands(
+        project.name,
+        project.path.path,
+        claudeArgs,
+        npmCommand
+      );
+      shellCommands.push(...commands);
+      tmuxHandled = true;
+    } else {
+      log.debug("Tmux not available, falling back to normal mode");
+      shellCommands.push(`cd "${project.path.path}"`);
+      shellCommands.push(claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude");
+      shellCommands.push(npmCommand);
+      tmuxHandled = true;
+    }
+  } else if (!dryRun) {
+    if (await tmux.isTmuxAvailable()) {
+      try {
+        const sessionName = await tmux.createThreePaneSession(
+          project.name,
+          project.path.path,
+          claudeArgs,
+          npmCommand
+        );
+        await tmux.attachToSession(sessionName);
+        tmuxHandled = true;
+      } catch (error) {
+        log.debug(`Failed to create tmux session: ${error.message}`);
+      }
+    } else {
+      log.debug("Tmux not available, falling back to normal event processing");
+    }
+  } else {
+    log.info(`Would create three-pane tmux session '${project.name}' with Claude and NPM`);
+    tmuxHandled = true;
+  }
+  if (!tmuxHandled && !dryRun) {
+    for (const event of events.filter((e) => ["cwd", "claude", "npm"].includes(e))) {
+      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+    }
+  }
+  if (!dryRun) {
+    for (const event of events.filter((e) => !["cwd", "claude", "npm"].includes(e))) {
+      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+    }
+  }
+}
+async function handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const { log } = ctx;
+  const tmux = new TmuxManager();
+  const npmConfig = project.events.npm;
+  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
+  const npmCommand = NpmEvent2.getNpmCommand(npmConfig);
+  let tmuxHandled = false;
+  if (isShellMode) {
+    if (await tmux.isTmuxAvailable()) {
+      const commands = tmux.buildTwoPaneNpmShellCommands(
+        project.name,
+        project.path.path,
+        npmCommand
+      );
+      shellCommands.push(...commands);
+      tmuxHandled = true;
+    } else {
+      log.debug("Tmux not available, falling back to normal mode");
+      shellCommands.push(`cd "${project.path.path}"`);
+      shellCommands.push(npmCommand);
+      tmuxHandled = true;
+    }
+  } else if (!dryRun) {
+    if (await tmux.isTmuxAvailable()) {
+      try {
+        const sessionName = await tmux.createTwoPaneNpmSession(
+          project.name,
+          project.path.path,
+          npmCommand
+        );
+        await tmux.attachToSession(sessionName);
+        tmuxHandled = true;
+      } catch (error) {
+        log.debug(`Failed to create tmux session: ${error.message}`);
+      }
+    } else {
+      log.debug("Tmux not available, falling back to normal event processing");
+    }
+  } else {
+    log.info(`Would create two-pane tmux session '${project.name}' with NPM`);
+    tmuxHandled = true;
+  }
+  if (!tmuxHandled && !dryRun) {
+    for (const event of events.filter((e) => ["cwd", "npm"].includes(e))) {
+      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+    }
+  }
+  if (!dryRun) {
+    for (const event of events.filter((e) => !["cwd", "npm"].includes(e))) {
+      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+    }
+  }
+}
+async function processEvent(event, context, ctx) {
+  const { log } = ctx;
+  log.debug(`Processing event ${event}`);
+  const eventHandler = EventRegistry.getEventByName(event);
+  if (eventHandler && eventHandler.processing) {
+    await eventHandler.processing.processEvent(context);
+  } else {
+    log.debug(`No event handler found for: ${event}`);
+  }
+}
+async function showProjectHelp(projectName, ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  if (!(projectName in projects)) {
+    console.error(`Project '${projectName}' not found`);
+    return;
+  }
+  const projectConfig = projects[projectName];
+  const configuredEvents = Object.keys(projectConfig.events || {});
+  console.log(`
+Available commands for '${projectName}':`);
+  console.log("-".repeat(50));
+  for (const eventName of configuredEvents) {
+    const eventHandler = EventRegistry.getEventByName(eventName);
+    if (eventHandler) {
+      const metadata = eventHandler.metadata;
+      const config2 = projectConfig.events[eventName];
+      let configDesc = "";
+      if (config2 !== true && config2 !== "true") {
+        if (typeof config2 === "object") {
+          configDesc = ` (${JSON.stringify(config2)})`;
+        } else {
+          configDesc = ` (${config2})`;
+        }
+      }
+      console.log(`  ${eventName.padEnd(8)} - ${metadata.description}${configDesc}`);
+    }
+  }
+  console.log("\nUsage examples:");
+  console.log(`  workon ${projectName}                    # Execute all commands`);
+  console.log(`  workon ${projectName}:cwd               # Just change directory`);
+  console.log(`  workon ${projectName}:claude            # Just Claude (auto-adds cwd)`);
+  if (configuredEvents.length > 1) {
+    const twoCommands = configuredEvents.slice(0, 2).join(",");
+    console.log(`  workon ${projectName}:${twoCommands.padEnd(12)} # Multiple commands`);
+  }
+  console.log(`  workon ${projectName}:cwd --shell       # Output shell commands
+`);
+}
+
+// src/commands/config/index.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/config/list.ts
+import { Command as Command2 } from "commander";
+function flattenObject(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      Object.assign(result, flattenObject(value, newKey));
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function createListCommand(ctx) {
+  const { config, log } = ctx;
+  return new Command2("list").description("List configuration parameters").action(() => {
+    log.debug("Listing configuration");
+    console.log(`Configuration file: ${config.path}
+`);
+    const store = config.store;
+    const flattened = flattenObject(store);
+    for (const [key, value] of Object.entries(flattened)) {
+      const displayValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+      console.log(`${key}: ${displayValue}`);
+    }
+  });
+}
+
+// src/commands/config/set.ts
+import { Command as Command3 } from "commander";
+function createSetCommand(ctx) {
+  const { config, log } = ctx;
+  return new Command3("set").description("Set a configuration parameter").argument("<key>", "The configuration parameter to set").argument("<value>", "The value to set").action((key, value) => {
+    log.debug(`Setting ${key} to ${value}`);
+    let parsedValue = value;
+    try {
+      if (value === "true") {
+        parsedValue = true;
+      } else if (value === "false") {
+        parsedValue = false;
+      } else if (!isNaN(Number(value)) && value.trim() !== "") {
+        parsedValue = Number(value);
+      } else {
+        parsedValue = JSON.parse(value);
+      }
+    } catch {
+      parsedValue = value;
+    }
+    config.set(key, parsedValue);
+    console.log(
+      `Set ${key} = ${typeof parsedValue === "object" ? JSON.stringify(parsedValue) : parsedValue}`
+    );
+  });
+}
+
+// src/commands/config/unset.ts
+import { Command as Command4 } from "commander";
+function createUnsetCommand(ctx) {
+  const { config, log } = ctx;
+  return new Command4("unset").description("Remove a configuration parameter").argument("<key>", "The configuration parameter to remove").option("--silent", "Suppress console output").action((key, options) => {
+    log.debug(`Removing ${key}`);
+    if (config.has(key)) {
+      config.delete(key);
+      if (!options.silent) {
+        console.log(`Removed ${key}`);
+      }
+    } else {
+      if (!options.silent) {
+        console.log(`Key ${key} not found`);
+      }
+    }
+  });
+}
+
+// src/commands/config/index.ts
+function createConfigCommand(ctx) {
+  const command = new Command5("config").description("Manage configuration parameters");
+  command.addCommand(createListCommand(ctx));
+  command.addCommand(createSetCommand(ctx));
+  command.addCommand(createUnsetCommand(ctx));
+  command.action(() => {
+    command.commands.find((c) => c.name() === "list")?.parse();
+  });
+  return command;
+}
+
+// src/commands/manage.ts
+import { Command as Command6 } from "commander";
+import { select as select2, input as input5, confirm as confirm3, checkbox as checkbox2 } from "@inquirer/prompts";
+import File5 from "phylo";
+var IDE_CHOICES2 = [
+  { name: "Visual Studio Code", value: "vscode" },
+  { name: "Visual Studio Code (code)", value: "code" },
+  { name: "IntelliJ IDEA", value: "idea" },
+  { name: "Atom", value: "atom" },
+  { name: "Sublime Text", value: "subl" },
+  { name: "Vim", value: "vim" },
+  { name: "Emacs", value: "emacs" }
+];
+function createManageCommand(ctx) {
+  const { log } = ctx;
+  return new Command6("manage").description("Interactive project management").option("-d, --debug", "Enable debug logging").action(async (options) => {
+    if (options.debug) {
+      log.setLogLevel("debug");
+    }
+    await EventRegistry.initialize();
+    await mainMenu(ctx);
+  });
+}
+async function mainMenu(ctx) {
+  const { config } = ctx;
+  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: "Exit", value: "exit" }
+  ];
+  const action = await select2({
+    message: "What would you like to do?",
+    choices
+  });
+  switch (action) {
+    case "create":
+      await createProject(ctx);
+      break;
+    case "edit":
+      await editProject(ctx);
+      break;
+    case "delete":
+      await deleteProject(ctx);
+      break;
+    case "list":
+      await listProjects(ctx);
+      break;
+    case "exit":
+      return;
+  }
+  await mainMenu(ctx);
+}
+async function createProject(ctx) {
+  const { config, log } = ctx;
+  const defaults = config.getDefaults();
+  const projects = config.getProjects();
+  const name = await input5({
+    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 ? File5.from(defaults.base).join(name).path : name;
+  const pathInput = await input5({
+    message: "Project path:",
+    default: defaultPath,
+    validate: (value) => {
+      const path = File5.from(value);
+      try {
+        const exists = path.exists();
+        if (!exists) return `Path does not exist: ${value}`;
+        const stat = path.stat();
+        if (!stat.isDirectory()) return "Path must be a directory";
+        return true;
+      } catch {
+        return `Invalid path: ${value}`;
+      }
+    }
+  });
+  let relativePath = pathInput;
+  if (defaults?.base) {
+    const baseDir = File5.from(defaults.base);
+    const pathFile = File5.from(pathInput);
+    try {
+      relativePath = pathFile.relativize(baseDir.path).path;
+    } catch {
+      relativePath = pathInput;
+    }
+  }
+  const ide = await select2({
+    message: "Select IDE:",
+    choices: IDE_CHOICES2
+  });
+  const homepage = await input5({
+    message: "Project homepage URL (optional):",
+    default: ""
+  });
+  const availableEvents = EventRegistry.getEventsForManageUI();
+  const selectedEvents = await checkbox2({
+    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
+  };
+  if (homepage.trim()) {
+    projectConfig.homepage = homepage.trim();
+  }
+  console.log("\nProject configuration:");
+  console.log(JSON.stringify(projectConfig, null, 2));
+  const confirmed = await confirm3({
+    message: "Save this project?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(name, projectConfig);
+    log.info(`Project '${name}' created successfully!`);
+    log.info(`Use 'workon ${name}' to start working!`);
+  } else {
+    log.info("Project creation cancelled.");
+  }
+}
+async function editProject(ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const projectNames = Object.keys(projects);
+  if (projectNames.length === 0) {
+    log.info("No projects to edit.");
+    return;
+  }
+  const name = await select2({
+    message: "Select project to edit:",
+    choices: projectNames.map((n) => ({ name: n, value: n }))
+  });
+  const project = projects[name];
+  const defaults = config.getDefaults();
+  const pathInput = await input5({
+    message: "Project path:",
+    default: project.path
+  });
+  let relativePath = pathInput;
+  if (defaults?.base) {
+    const baseDir = File5.from(defaults.base);
+    const pathFile = File5.from(pathInput);
+    try {
+      if (pathFile.isAbsolute()) {
+        relativePath = pathFile.relativize(baseDir.path).path;
+      }
+    } catch {
+      relativePath = pathInput;
+    }
+  }
+  const ide = await select2({
+    message: "Select IDE:",
+    choices: IDE_CHOICES2,
+    default: project.ide || "vscode"
+  });
+  const homepage = await input5({
+    message: "Project homepage URL:",
+    default: project.homepage || ""
+  });
+  const keepEvents = await confirm3({
+    message: "Keep existing event configuration?",
+    default: true
+  });
+  let events = project.events;
+  if (!keepEvents) {
+    const availableEvents = EventRegistry.getEventsForManageUI();
+    const currentEvents = Object.keys(project.events);
+    const selectedEvents = await checkbox2({
+      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
+  };
+  if (homepage.trim()) {
+    updatedConfig.homepage = homepage.trim();
+  }
+  console.log("\nUpdated configuration:");
+  console.log(JSON.stringify(updatedConfig, null, 2));
+  const confirmed = await confirm3({
+    message: "Save changes?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(name, updatedConfig);
+    log.info(`Project '${name}' updated successfully!`);
+  } else {
+    log.info("Edit cancelled.");
+  }
+}
+async function deleteProject(ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const projectNames = Object.keys(projects);
+  if (projectNames.length === 0) {
+    log.info("No projects to delete.");
+    return;
+  }
+  const name = await select2({
+    message: "Select project to delete:",
+    choices: projectNames.map((n) => ({ name: n, value: n }))
+  });
+  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.`);
+  } else {
+    log.info("Delete cancelled.");
+  }
+}
+async function listProjects(ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const defaults = config.getDefaults();
+  console.log("\nConfigured projects:\n");
+  for (const [name, project] of Object.entries(projects)) {
+    const fullPath = defaults?.base ? File5.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"}`);
+    if (project.homepage) {
+      console.log(`    Homepage: ${project.homepage}`);
+    }
+    console.log();
+  }
+}
+
+// src/commands/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function findPackageJson() {
+  const paths = [
+    join(__dirname, "../package.json"),
+    join(__dirname, "../../package.json"),
+    join(process.cwd(), "package.json")
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+  throw new Error("Could not find package.json");
+}
+function createCli() {
+  const program2 = new Command7();
+  const packageJsonPath = findPackageJson();
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const config = new Config();
+  const log = loog({
+    prefixStyle: "ascii",
+    logLevel: "info"
+  });
+  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) => {
+    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;
+    }
+    const environment = await EnvironmentRecognizer.recognize(File6.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 }));
+  program2.addCommand(createConfigCommand({ config, log }));
+  program2.addCommand(createManageCommand({ config, log }));
+  program2.on("command:*", async (operands) => {
+    const projectName = operands[0];
+    if (projectName && !projectName.startsWith("-")) {
+      const openCmd = program2.commands.find((c) => c.name() === "open");
+      if (openCmd) {
+        const args = [
+          "open",
+          ...operands,
+          ...process.argv.slice(2).filter((a) => a.startsWith("-"))
+        ];
+        await program2.parseAsync(["node", "workon", ...args]);
+        return;
+      }
+    }
+    console.error(`Unknown command: ${operands.join(" ")}`);
+    program2.help();
+  });
+  program2.showHelpAfterError(true);
+  return program2;
+}
+function setupCompletion(config) {
+  const tree = {
+    config: ["list", "set", "unset"],
+    manage: null
+  };
+  const projects = config.getProjects();
+  if (projects) {
+    Object.keys(projects).forEach((id) => {
+      tree[id] = null;
+    });
+  }
+  const completion = omelette("workon").tree(tree);
+  completion.init();
+  return completion;
+}
+function outputShellInit(program2) {
+  const cmdNames = program2.commands.map((c) => c.name());
+  const switchFlags = [];
+  program2.options.forEach((opt) => {
+    switchFlags.push("--" + opt.long?.replace(/^--/, ""));
+    if (opt.short) {
+      switchFlags.push(opt.short);
+    }
+  });
+  const builtinFlags = ["--help", "-h", "--version", "-V", "help"];
+  const nonShellCommands = [.../* @__PURE__ */ new Set([...cmdNames, ...switchFlags, ...builtinFlags])];
+  const casePattern = nonShellCommands.join("|");
+  const shellFunction = `
+# workon shell integration
+workon() {
+    # Commands and flags that should NOT use shell mode
+    case "$1" in
+        ${casePattern})
+            command workon "$@"
+            return $?
+            ;;
+    esac
+
+    # If no arguments provided, run interactive mode directly
+    if [[ $# -eq 0 ]]; then
+        command workon "$@"
+        return $?
+    fi
+
+    # Default behavior: use shell mode for project opening
+    local output
+    output=$(command workon --shell "$@" 2>&1)
+    local exit_code=$?
+
+    if [[ $exit_code -eq 0 && -n "$output" ]]; then
+        # Execute shell commands if workon succeeded and output exists
+        eval "$output"
+    else
+        # Show any error output
+        [[ -n "$output" ]] && echo "$output" >&2
+        return $exit_code
+    fi
+}`;
+  console.log(shellFunction);
+}
+
+// src/cli.ts
+var program = createCli();
+program.parse();
+//# sourceMappingURL=cli.js.map