workon 2.1.3 → 3.1.0

package/dist/index.js

@@ -0,0 +1,1173 @@
+// 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/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/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/lib/environment.ts
+import File2 from "phylo";
+import { simpleGit } from "simple-git";
+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/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/extensions/npm.ts
+import { spawn as spawn7 } from "child_process";
+import { input as input3, confirm as confirm2 } from "@inquirer/prompts";
+var 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" }
+      ]
+    };
+  }
+};
+
+// src/events/registry.ts
+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();
+export {
+  BaseEnvironment,
+  Config,
+  EnvironmentRecognizer,
+  EventRegistry,
+  Project,
+  ProjectEnvironment,
+  TmuxManager
+};
+//# sourceMappingURL=index.js.map