@oh-my-pi/cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -17,203 +17,826 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
-    constructor(exitCode, code, message) {
-      super(message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-      this.code = code;
-      this.exitCode = exitCode;
-      this.nestedError = undefined;
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
     }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
   }
-
-  class InvalidArgumentError extends CommanderError {
-    constructor(message) {
-      super(1, "commander.invalidArgument", message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
     }
-  }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
+  });
+  return styles;
+}
+var ANSI_BACKGROUND_OFFSET = 10, wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`, wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm(() => {
+  styles = {
+    modifier: {
+      reset: [0, 0],
+      bold: [1, 22],
+      dim: [2, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      overline: [53, 55],
+      inverse: [7, 27],
+      hidden: [8, 28],
+      strikethrough: [9, 29]
+    },
+    color: {
+      black: [30, 39],
+      red: [31, 39],
+      green: [32, 39],
+      yellow: [33, 39],
+      blue: [34, 39],
+      magenta: [35, 39],
+      cyan: [36, 39],
+      white: [37, 39],
+      blackBright: [90, 39],
+      gray: [90, 39],
+      grey: [90, 39],
+      redBright: [91, 39],
+      greenBright: [92, 39],
+      yellowBright: [93, 39],
+      blueBright: [94, 39],
+      magentaBright: [95, 39],
+      cyanBright: [96, 39],
+      whiteBright: [97, 39]
+    },
+    bgColor: {
+      bgBlack: [40, 49],
+      bgRed: [41, 49],
+      bgGreen: [42, 49],
+      bgYellow: [43, 49],
+      bgBlue: [44, 49],
+      bgMagenta: [45, 49],
+      bgCyan: [46, 49],
+      bgWhite: [47, 49],
+      bgBlackBright: [100, 49],
+      bgGray: [100, 49],
+      bgGrey: [100, 49],
+      bgRedBright: [101, 49],
+      bgGreenBright: [102, 49],
+      bgYellowBright: [103, 49],
+      bgBlueBright: [104, 49],
+      bgMagentaBright: [105, 49],
+      bgCyanBright: [106, 49],
+      bgWhiteBright: [107, 49]
+    }
+  };
+  modifierNames = Object.keys(styles.modifier);
+  foregroundColorNames = Object.keys(styles.color);
+  backgroundColorNames = Object.keys(styles.bgColor);
+  colorNames = [...foregroundColorNames, ...backgroundColorNames];
+  ansiStyles = assembleStyles();
+  ansi_styles_default = ansiStyles;
 });
 
-// node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Argument {
-    constructor(name, description) {
-      this.description = description || "";
-      this.variadic = false;
-      this.parseArg = undefined;
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.argChoices = undefined;
-      switch (name[0]) {
-        case "<":
-          this.required = true;
-          this._name = name.slice(1, -1);
-          break;
-        case "[":
-          this.required = false;
-          this._name = name.slice(1, -1);
-          break;
-        default:
-          this.required = true;
-          this._name = name;
-          break;
-      }
-      if (this._name.length > 3 && this._name.slice(-3) === "...") {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
-    }
-    name() {
-      return this._name;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
+// node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
     }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
+    if (env.FORCE_COLOR === "false") {
+      return 0;
     }
-    argRequired() {
-      this.required = true;
-      return this;
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
     }
-    argOptional() {
-      this.required = false;
-      return this;
+    if (hasFlag("color=256")) {
+      return 2;
     }
   }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
   }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
-});
-
-// node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
-
-  class Help {
-    constructor() {
-      this.helpWidth = undefined;
-      this.sortSubcommands = false;
-      this.sortOptions = false;
-      this.showGlobalOptions = false;
-    }
-    visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      const helpCommand = cmd._getHelpCommand();
-      if (helpCommand && !helpCommand._hidden) {
-        visibleCommands.push(helpCommand);
-      }
-      if (this.sortSubcommands) {
-        visibleCommands.sort((a, b) => {
-          return a.name().localeCompare(b.name());
-        });
-      }
-      return visibleCommands;
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
-    compareOptions(a, b) {
-      const getSortKey = (option) => {
-        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-      };
-      return getSortKey(a).localeCompare(getSortKey(b));
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+      return 3;
     }
-    visibleOptions(cmd) {
-      const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      const helpOption = cmd._getHelpOption();
-      if (helpOption && !helpOption.hidden) {
-        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
-        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
-        if (!removeShort && !removeLong) {
-          visibleOptions.push(helpOption);
-        } else if (helpOption.long && !removeLong) {
-          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
-        } else if (helpOption.short && !removeShort) {
-          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
-        }
-      }
-      if (this.sortOptions) {
-        visibleOptions.sort(this.compareOptions);
-      }
-      return visibleOptions;
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      return 1;
     }
-    visibleGlobalOptions(cmd) {
-      if (!this.showGlobalOptions)
-        return [];
-      const globalOptions = [];
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-        globalOptions.push(...visibleOptions);
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
       }
-      if (this.sortOptions) {
-        globalOptions.sort(this.compareOptions);
+      case "Apple_Terminal": {
+        return 2;
       }
-      return globalOptions;
     }
-    visibleArguments(cmd) {
-      if (cmd._argsDescription) {
-        cmd.registeredArguments.forEach((argument) => {
-          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
-        });
-      }
-      if (cmd.registeredArguments.find((argument) => argument.description)) {
-        return cmd.registeredArguments;
-      }
-      return [];
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm(() => {
+  ({ env } = process2);
+  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    flagForceColor = 0;
+  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    flagForceColor = 1;
+  }
+  supportsColor = {
+    stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+    stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+  };
+  supports_color_default = supportsColor;
+});
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+function createChalk(options) {
+  return chalkFactory(options);
+}
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+}, chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+}, getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
     }
-    subcommandTerm(cmd) {
-      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
     }
-    optionTerm(option) {
-      return option.flags;
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+}, usedModels, proto, createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+}, createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+}, applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === undefined) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
     }
-    argumentTerm(argument) {
-      return argument.name();
+  }
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+}, chalk, chalkStderr, source_default;
+var init_source = __esm(() => {
+  init_ansi_styles();
+  init_supports_color();
+  ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+  GENERATOR = Symbol("GENERATOR");
+  STYLER = Symbol("STYLER");
+  IS_EMPTY = Symbol("IS_EMPTY");
+  levelMapping = [
+    "ansi",
+    "ansi",
+    "ansi256",
+    "ansi16m"
+  ];
+  styles2 = Object.create(null);
+  Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+  for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+    styles2[styleName] = {
+      get() {
+        const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+        Object.defineProperty(this, styleName, { value: builder });
+        return builder;
+      }
+    };
+  }
+  styles2.visible = {
+    get() {
+      const builder = createBuilder(this, this[STYLER], true);
+      Object.defineProperty(this, "visible", { value: builder });
+      return builder;
     }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, helper.subcommandTerm(command).length);
-      }, 0);
+  };
+  usedModels = ["rgb", "hex", "ansi256"];
+  for (const model of usedModels) {
+    styles2[model] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+          return createBuilder(this, styler, this[IS_EMPTY]);
+        };
+      }
+    };
+    const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+    styles2[bgModel] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+          return createBuilder(this, styler, this[IS_EMPTY]);
+        };
+      }
+    };
+  }
+  proto = Object.defineProperties(() => {}, {
+    ...styles2,
+    level: {
+      enumerable: true,
+      get() {
+        return this[GENERATOR].level;
+      },
+      set(level) {
+        this[GENERATOR].level = level;
+      }
     }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
-      }, 0);
+  });
+  Object.defineProperties(createChalk.prototype, styles2);
+  chalk = createChalk();
+  chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+  source_default = chalk;
+});
+
+// src/paths.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2, resolve } from "path";
+function findProjectRoot() {
+  let dir = process.cwd();
+  const root = resolve("/");
+  while (dir !== root) {
+    if (existsSync2(join2(dir, ".pi", "plugins.json"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function hasProjectPlugins() {
+  return findProjectRoot() !== null;
+}
+function resolveScope(options) {
+  if (options.global) {
+    return true;
+  }
+  if (options.local) {
+    return false;
+  }
+  return !hasProjectPlugins();
+}
+var PI_CONFIG_DIR, PLUGINS_DIR, NODE_MODULES_DIR, GLOBAL_PACKAGE_JSON, GLOBAL_LOCK_FILE, LEGACY_MANIFEST_PATH, PROJECT_PI_DIR = ".pi", PROJECT_PLUGINS_JSON, PROJECT_PACKAGE_JSON, PROJECT_PLUGINS_LOCK, PROJECT_NODE_MODULES;
+var init_paths = __esm(() => {
+  PI_CONFIG_DIR = join2(homedir(), ".pi");
+  PLUGINS_DIR = join2(PI_CONFIG_DIR, "plugins");
+  NODE_MODULES_DIR = join2(PLUGINS_DIR, "node_modules");
+  GLOBAL_PACKAGE_JSON = join2(PLUGINS_DIR, "package.json");
+  GLOBAL_LOCK_FILE = join2(PLUGINS_DIR, "package-lock.json");
+  LEGACY_MANIFEST_PATH = join2(PLUGINS_DIR, "manifest.json");
+  PROJECT_PLUGINS_JSON = join2(PROJECT_PI_DIR, "plugins.json");
+  PROJECT_PACKAGE_JSON = join2(PROJECT_PI_DIR, "package.json");
+  PROJECT_PLUGINS_LOCK = join2(PROJECT_PI_DIR, "plugins-lock.json");
+  PROJECT_NODE_MODULES = join2(PROJECT_PI_DIR, "node_modules");
+});
+
+// src/lockfile.ts
+var exports_lockfile = {};
+__export(exports_lockfile, {
+  validateOrRegenerateLockFile: () => validateOrRegenerateLockFile,
+  updateLockFile: () => updateLockFile,
+  saveLockFile: () => saveLockFile,
+  loadLockFile: () => loadLockFile,
+  getLockedVersion: () => getLockedVersion,
+  createLockFile: () => createLockFile,
+  LOCKFILE_VERSION: () => LOCKFILE_VERSION
+});
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile2, writeFile as writeFile4 } from "fs/promises";
+async function loadLockFile(global = true) {
+  const path = global ? GLOBAL_LOCK_FILE : PROJECT_PLUGINS_LOCK;
+  try {
+    if (!existsSync7(path))
+      return null;
+    const data = await readFile2(path, "utf-8");
+    const parsed = JSON.parse(data);
+    if (typeof parsed.lockfileVersion !== "number" || typeof parsed.packages !== "object") {
+      console.log(source_default.yellow(`Warning: ${path} has invalid schema, ignoring`));
+      return null;
+    }
+    if (parsed.lockfileVersion > LOCKFILE_VERSION) {
+      console.log(source_default.yellow(`Warning: ${path} was created by a newer version of omp (lockfile v${parsed.lockfileVersion}), ignoring`));
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    if (err.name === "SyntaxError") {
+      console.log(source_default.yellow(`Warning: ${path} is corrupted (invalid JSON), ignoring`));
+    }
+    return null;
+  }
+}
+async function saveLockFile(lockFile, global = true) {
+  const path = global ? GLOBAL_LOCK_FILE : PROJECT_PLUGINS_LOCK;
+  await writeFile4(path, JSON.stringify(lockFile, null, 2));
+}
+function createLockFile() {
+  return {
+    lockfileVersion: LOCKFILE_VERSION,
+    packages: {}
+  };
+}
+async function validateOrRegenerateLockFile(global = true) {
+  const existing = await loadLockFile(global);
+  if (existing) {
+    return existing;
+  }
+  const path = global ? GLOBAL_LOCK_FILE : PROJECT_PLUGINS_LOCK;
+  if (existsSync7(path)) {
+    console.log(source_default.yellow(`Regenerating corrupted lock file: ${path}`));
+  }
+  return createLockFile();
+}
+async function getLockedVersion(packageName, global = true) {
+  const lockFile = await loadLockFile(global);
+  if (!lockFile)
+    return null;
+  const entry = lockFile.packages[packageName];
+  return entry?.version ?? null;
+}
+async function updateLockFile(packageName, version, global = true) {
+  let lockFile = await loadLockFile(global);
+  if (!lockFile) {
+    lockFile = createLockFile();
+  }
+  lockFile.packages[packageName] = {
+    version
+  };
+  await saveLockFile(lockFile, global);
+}
+var LOCKFILE_VERSION = 1;
+var init_lockfile = __esm(() => {
+  init_paths();
+  init_source();
+});
+
+// node_modules/commander/lib/error.js
+var require_error = __commonJS((exports) => {
+  class CommanderError extends Error {
+    constructor(exitCode, code, message) {
+      super(message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
+      this.code = code;
+      this.exitCode = exitCode;
+      this.nestedError = undefined;
+    }
+  }
+
+  class InvalidArgumentError extends CommanderError {
+    constructor(message) {
+      super(1, "commander.invalidArgument", message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
+    }
+  }
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+});
+
+// node_modules/commander/lib/argument.js
+var require_argument = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
+
+  class Argument {
+    constructor(name, description) {
+      this.description = description || "";
+      this.variadic = false;
+      this.parseArg = undefined;
+      this.defaultValue = undefined;
+      this.defaultValueDescription = undefined;
+      this.argChoices = undefined;
+      switch (name[0]) {
+        case "<":
+          this.required = true;
+          this._name = name.slice(1, -1);
+          break;
+        case "[":
+          this.required = false;
+          this._name = name.slice(1, -1);
+          break;
+        default:
+          this.required = true;
+          this._name = name;
+          break;
+      }
+      if (this._name.length > 3 && this._name.slice(-3) === "...") {
+        this.variadic = true;
+        this._name = this._name.slice(0, -3);
+      }
+    }
+    name() {
+      return this._name;
+    }
+    _concatValue(value, previous) {
+      if (previous === this.defaultValue || !Array.isArray(previous)) {
+        return [value];
+      }
+      return previous.concat(value);
+    }
+    default(value, description) {
+      this.defaultValue = value;
+      this.defaultValueDescription = description;
+      return this;
+    }
+    argParser(fn) {
+      this.parseArg = fn;
+      return this;
+    }
+    choices(values) {
+      this.argChoices = values.slice();
+      this.parseArg = (arg, previous) => {
+        if (!this.argChoices.includes(arg)) {
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+        }
+        if (this.variadic) {
+          return this._concatValue(arg, previous);
+        }
+        return arg;
+      };
+      return this;
+    }
+    argRequired() {
+      this.required = true;
+      return this;
+    }
+    argOptional() {
+      this.required = false;
+      return this;
+    }
+  }
+  function humanReadableArgName(arg) {
+    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
+    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+  }
+  exports.Argument = Argument;
+  exports.humanReadableArgName = humanReadableArgName;
+});
+
+// node_modules/commander/lib/help.js
+var require_help = __commonJS((exports) => {
+  var { humanReadableArgName } = require_argument();
+
+  class Help {
+    constructor() {
+      this.helpWidth = undefined;
+      this.sortSubcommands = false;
+      this.sortOptions = false;
+      this.showGlobalOptions = false;
+    }
+    visibleCommands(cmd) {
+      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+      const helpCommand = cmd._getHelpCommand();
+      if (helpCommand && !helpCommand._hidden) {
+        visibleCommands.push(helpCommand);
+      }
+      if (this.sortSubcommands) {
+        visibleCommands.sort((a, b) => {
+          return a.name().localeCompare(b.name());
+        });
+      }
+      return visibleCommands;
+    }
+    compareOptions(a, b) {
+      const getSortKey = (option) => {
+        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+      };
+      return getSortKey(a).localeCompare(getSortKey(b));
+    }
+    visibleOptions(cmd) {
+      const visibleOptions = cmd.options.filter((option) => !option.hidden);
+      const helpOption = cmd._getHelpOption();
+      if (helpOption && !helpOption.hidden) {
+        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+        if (!removeShort && !removeLong) {
+          visibleOptions.push(helpOption);
+        } else if (helpOption.long && !removeLong) {
+          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+        } else if (helpOption.short && !removeShort) {
+          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
+        }
+      }
+      if (this.sortOptions) {
+        visibleOptions.sort(this.compareOptions);
+      }
+      return visibleOptions;
+    }
+    visibleGlobalOptions(cmd) {
+      if (!this.showGlobalOptions)
+        return [];
+      const globalOptions = [];
+      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
+        globalOptions.push(...visibleOptions);
+      }
+      if (this.sortOptions) {
+        globalOptions.sort(this.compareOptions);
+      }
+      return globalOptions;
+    }
+    visibleArguments(cmd) {
+      if (cmd._argsDescription) {
+        cmd.registeredArguments.forEach((argument) => {
+          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+        });
+      }
+      if (cmd.registeredArguments.find((argument) => argument.description)) {
+        return cmd.registeredArguments;
+      }
+      return [];
+    }
+    subcommandTerm(cmd) {
+      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
+      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
+    }
+    optionTerm(option) {
+      return option.flags;
+    }
+    argumentTerm(argument) {
+      return argument.name();
+    }
+    longestSubcommandTermLength(cmd, helper) {
+      return helper.visibleCommands(cmd).reduce((max, command) => {
+        return Math.max(max, helper.subcommandTerm(command).length);
+      }, 0);
+    }
+    longestOptionTermLength(cmd, helper) {
+      return helper.visibleOptions(cmd).reduce((max, option) => {
+        return Math.max(max, helper.optionTerm(option).length);
+      }, 0);
     }
     longestGlobalOptionTermLength(cmd, helper) {
       return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
@@ -601,7 +1224,7 @@ var require_command = __commonJS((exports) => {
   var childProcess = __require("child_process");
   var path = __require("path");
   var fs = __require("fs");
-  var process2 = __require("process");
+  var process3 = __require("process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
   var { Help } = require_help();
@@ -643,10 +1266,10 @@ var require_command = __commonJS((exports) => {
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
       this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
+        writeOut: (str) => process3.stdout.write(str),
+        writeErr: (str) => process3.stderr.write(str),
+        getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : undefined,
+        getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : undefined,
         outputError: (str, write) => write(str)
       };
       this._hidden = false;
@@ -842,7 +1465,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._exitCallback) {
         this._exitCallback(new CommanderError(exitCode, code, message));
       }
-      process2.exit(exitCode);
+      process3.exit(exitCode);
     }
     action(fn) {
       const listener = (args) => {
@@ -1037,16 +1660,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       parseOptions = parseOptions || {};
       if (argv === undefined && parseOptions.from === undefined) {
-        if (process2.versions?.electron) {
+        if (process3.versions?.electron) {
           parseOptions.from = "electron";
         }
-        const execArgv = process2.execArgv ?? [];
+        const execArgv = process3.execArgv ?? [];
         if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
           parseOptions.from = "eval";
         }
       }
       if (argv === undefined) {
-        argv = process2.argv;
+        argv = process3.argv;
       }
       this.rawArgs = argv.slice();
       let userArgs;
@@ -1057,7 +1680,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           userArgs = argv.slice(2);
           break;
         case "electron":
-          if (process2.defaultApp) {
+          if (process3.defaultApp) {
             this._scriptPath = argv[1];
             userArgs = argv.slice(2);
           } else {
@@ -1128,23 +1751,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       launchWithNode = sourceExt.includes(path.extname(executableFile));
       let proc;
-      if (process2.platform !== "win32") {
+      if (process3.platform !== "win32") {
         if (launchWithNode) {
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process3.execArgv).concat(args);
+          proc = childProcess.spawn(process3.argv[0], args, { stdio: "inherit" });
         } else {
           proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
         }
       } else {
         args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
+        args = incrementNodeInspectorPort(process3.execArgv).concat(args);
+        proc = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
       }
       if (!proc.killed) {
         const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
         signals.forEach((signal) => {
-          process2.on(signal, () => {
+          process3.on(signal, () => {
             if (proc.killed === false && proc.exitCode === null) {
               proc.kill(signal);
             }
@@ -1155,7 +1778,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       proc.on("close", (code) => {
         code = code ?? 1;
         if (!exitCallback) {
-          process2.exit(code);
+          process3.exit(code);
         } else {
           exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
         }
@@ -1172,7 +1795,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           throw new Error(`'${executableFile}' not executable`);
         }
         if (!exitCallback) {
-          process2.exit(1);
+          process3.exit(1);
         } else {
           const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
           wrappedError.nestedError = err;
@@ -1520,11 +2143,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     _parseOptionsEnv() {
       this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process2.env) {
+        if (option.envVar && option.envVar in process3.env) {
           const optionKey = option.attributeName();
           if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
             if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
+              this.emit(`optionEnv:${option.name()}`, process3.env[option.envVar]);
             } else {
               this.emit(`optionEnv:${option.name()}`);
             }
@@ -1637,743 +2260,271 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     description(str, argsDescription) {
       if (str === undefined && argsDescription === undefined)
-        return this._description;
-      this._description = str;
-      if (argsDescription) {
-        this._argsDescription = argsDescription;
-      }
-      return this;
-    }
-    summary(str) {
-      if (str === undefined)
-        return this._summary;
-      this._summary = str;
-      return this;
-    }
-    alias(alias) {
-      if (alias === undefined)
-        return this._aliases[0];
-      let command = this;
-      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-        command = this.commands[this.commands.length - 1];
-      }
-      if (alias === command._name)
-        throw new Error("Command alias can't be the same as its name");
-      const matchingCommand = this.parent?._findCommand(alias);
-      if (matchingCommand) {
-        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
-        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
-      }
-      command._aliases.push(alias);
-      return this;
-    }
-    aliases(aliases) {
-      if (aliases === undefined)
-        return this._aliases;
-      aliases.forEach((alias) => this.alias(alias));
-      return this;
-    }
-    usage(str) {
-      if (str === undefined) {
-        if (this._usage)
-          return this._usage;
-        const args = this.registeredArguments.map((arg) => {
-          return humanReadableArgName(arg);
-        });
-        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
-      }
-      this._usage = str;
-      return this;
-    }
-    name(str) {
-      if (str === undefined)
-        return this._name;
-      this._name = str;
-      return this;
-    }
-    nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
-      return this;
-    }
-    executableDir(path2) {
-      if (path2 === undefined)
-        return this._executableDir;
-      this._executableDir = path2;
-      return this;
-    }
-    helpInformation(contextOptions) {
-      const helper = this.createHelp();
-      if (helper.helpWidth === undefined) {
-        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-      }
-      return helper.formatHelp(this, helper);
-    }
-    _getHelpContext(contextOptions) {
-      contextOptions = contextOptions || {};
-      const context = { error: !!contextOptions.error };
-      let write;
-      if (context.error) {
-        write = (arg) => this._outputConfiguration.writeErr(arg);
-      } else {
-        write = (arg) => this._outputConfiguration.writeOut(arg);
-      }
-      context.write = contextOptions.write || write;
-      context.command = this;
-      return context;
-    }
-    outputHelp(contextOptions) {
-      let deprecatedCallback;
-      if (typeof contextOptions === "function") {
-        deprecatedCallback = contextOptions;
-        contextOptions = undefined;
-      }
-      const context = this._getHelpContext(contextOptions);
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
-      this.emit("beforeHelp", context);
-      let helpInformation = this.helpInformation(context);
-      if (deprecatedCallback) {
-        helpInformation = deprecatedCallback(helpInformation);
-        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
-          throw new Error("outputHelp callback must return a string or a Buffer");
-        }
-      }
-      context.write(helpInformation);
-      if (this._getHelpOption()?.long) {
-        this.emit(this._getHelpOption().long);
-      }
-      this.emit("afterHelp", context);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
-    }
-    helpOption(flags, description) {
-      if (typeof flags === "boolean") {
-        if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
-        } else {
-          this._helpOption = null;
-        }
-        return this;
-      }
-      flags = flags ?? "-h, --help";
-      description = description ?? "display help for command";
-      this._helpOption = this.createOption(flags, description);
-      return this;
-    }
-    _getHelpOption() {
-      if (this._helpOption === undefined) {
-        this.helpOption(undefined, undefined);
-      }
-      return this._helpOption;
-    }
-    addHelpOption(option) {
-      this._helpOption = option;
-      return this;
-    }
-    help(contextOptions) {
-      this.outputHelp(contextOptions);
-      let exitCode = process2.exitCode || 0;
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
-      }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
-    }
-    addHelpText(position, text) {
-      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-      if (!allowedValues.includes(position)) {
-        throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      const helpEvent = `${position}Help`;
-      this.on(helpEvent, (context) => {
-        let helpStr;
-        if (typeof text === "function") {
-          helpStr = text({ error: context.error, command: context.command });
-        } else {
-          helpStr = text;
-        }
-        if (helpStr) {
-          context.write(`${helpStr}
-`);
-        }
-      });
-      return this;
-    }
-    _outputHelpIfRequested(args) {
-      const helpOption = this._getHelpOption();
-      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
-      if (helpRequested) {
-        this.outputHelp();
-        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
-      }
-    }
-  }
-  function incrementNodeInspectorPort(args) {
-    return args.map((arg) => {
-      if (!arg.startsWith("--inspect")) {
-        return arg;
-      }
-      let debugOption;
-      let debugHost = "127.0.0.1";
-      let debugPort = "9229";
-      let match;
-      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-        debugOption = match[1];
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-        debugOption = match[1];
-        if (/^\d+$/.test(match[3])) {
-          debugPort = match[3];
-        } else {
-          debugHost = match[3];
-        }
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-        debugOption = match[1];
-        debugHost = match[3];
-        debugPort = match[4];
-      }
-      if (debugOption && debugPort !== "0") {
-        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-      }
-      return arg;
-    });
-  }
-  exports.Command = Command;
-});
-
-// node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
-
-// node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
-
-// src/commands/create.ts
-import { existsSync } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-
-// node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
+        return this._description;
+      this._description = str;
+      if (argsDescription) {
+        this._argsDescription = argsDescription;
+      }
+      return this;
     }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "process";
-import os from "os";
-import tty from "tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
+    summary(str) {
+      if (str === undefined)
+        return this._summary;
+      this._summary = str;
+      return this;
     }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
+    alias(alias) {
+      if (alias === undefined)
+        return this._aliases[0];
+      let command = this;
+      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
+        command = this.commands[this.commands.length - 1];
+      }
+      if (alias === command._name)
+        throw new Error("Command alias can't be the same as its name");
+      const matchingCommand = this.parent?._findCommand(alias);
+      if (matchingCommand) {
+        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
+        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
+      }
+      command._aliases.push(alias);
+      return this;
     }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
+    aliases(aliases) {
+      if (aliases === undefined)
+        return this._aliases;
+      aliases.forEach((alias) => this.alias(alias));
+      return this;
     }
-    if (hasFlag("color=256")) {
-      return 2;
+    usage(str) {
+      if (str === undefined) {
+        if (this._usage)
+          return this._usage;
+        const args = this.registeredArguments.map((arg) => {
+          return humanReadableArgName(arg);
+        });
+        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
+      }
+      this._usage = str;
+      return this;
     }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    name(str) {
+      if (str === undefined)
+        return this._name;
+      this._name = str;
+      return this;
     }
-    return 1;
-  }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
-      return 3;
+    nameFromFilename(filename) {
+      this._name = path.basename(filename, path.extname(filename));
+      return this;
     }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-      return 1;
+    executableDir(path2) {
+      if (path2 === undefined)
+        return this._executableDir;
+      this._executableDir = path2;
+      return this;
     }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if (env.TERM === "wezterm") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
+    helpInformation(contextOptions) {
+      const helper = this.createHelp();
+      if (helper.helpWidth === undefined) {
+        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
       }
-      case "Apple_Terminal": {
-        return 2;
+      return helper.formatHelp(this, helper);
+    }
+    _getHelpContext(contextOptions) {
+      contextOptions = contextOptions || {};
+      const context = { error: !!contextOptions.error };
+      let write;
+      if (context.error) {
+        write = (arg) => this._outputConfiguration.writeErr(arg);
+      } else {
+        write = (arg) => this._outputConfiguration.writeOut(arg);
       }
+      context.write = contextOptions.write || write;
+      context.command = this;
+      return context;
     }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
+    outputHelp(contextOptions) {
+      let deprecatedCallback;
+      if (typeof contextOptions === "function") {
+        deprecatedCallback = contextOptions;
+        contextOptions = undefined;
+      }
+      const context = this._getHelpContext(contextOptions);
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
+      this.emit("beforeHelp", context);
+      let helpInformation = this.helpInformation(context);
+      if (deprecatedCallback) {
+        helpInformation = deprecatedCallback(helpInformation);
+        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
+          throw new Error("outputHelp callback must return a string or a Buffer");
+        }
+      }
+      context.write(helpInformation);
+      if (this._getHelpOption()?.long) {
+        this.emit(this._getHelpOption().long);
+      }
+      this.emit("afterHelp", context);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
     }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
+    helpOption(flags, description) {
+      if (typeof flags === "boolean") {
+        if (flags) {
+          this._helpOption = this._helpOption ?? undefined;
+        } else {
+          this._helpOption = null;
+        }
+        return this;
+      }
+      flags = flags ?? "-h, --help";
+      description = description ?? "display help for command";
+      this._helpOption = this.createOption(flags, description);
+      return this;
     }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    _getHelpOption() {
+      if (this._helpOption === undefined) {
+        this.helpOption(undefined, undefined);
+      }
+      return this._helpOption;
     }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
+    addHelpOption(option) {
+      this._helpOption = option;
+      return this;
     }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
+    help(contextOptions) {
+      this.outputHelp(contextOptions);
+      let exitCode = process3.exitCode || 0;
+      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+        exitCode = 1;
+      }
+      this._exit(exitCode, "commander.help", "(outputHelp)");
     }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
+    addHelpText(position, text) {
+      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
+      if (!allowedValues.includes(position)) {
+        throw new Error(`Unexpected value for position to addHelpText.
+Expecting one of '${allowedValues.join("', '")}'`);
+      }
+      const helpEvent = `${position}Help`;
+      this.on(helpEvent, (context) => {
+        let helpStr;
+        if (typeof text === "function") {
+          helpStr = text({ error: context.error, command: context.command });
+        } else {
+          helpStr = text;
+        }
+        if (helpStr) {
+          context.write(`${helpStr}
+`);
+        }
+      });
+      return this;
     }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
+    _outputHelpIfRequested(args) {
+      const helpOption = this._getHelpOption();
+      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
+      if (helpRequested) {
+        this.outputHelp();
+        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
+      }
     }
   }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  function incrementNodeInspectorPort(args) {
+    return args.map((arg) => {
+      if (!arg.startsWith("--inspect")) {
+        return arg;
+      }
+      let debugOption;
+      let debugHost = "127.0.0.1";
+      let debugPort = "9229";
+      let match;
+      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
+        debugOption = match[1];
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+        debugOption = match[1];
+        if (/^\d+$/.test(match[3])) {
+          debugPort = match[3];
+        } else {
+          debugHost = match[3];
+        }
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+        debugOption = match[1];
+        debugHost = match[3];
+        debugPort = match[4];
+      }
+      if (debugOption && debugPort !== "0") {
+        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
+      }
+      return arg;
+    });
   }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
+  exports.Command = Command;
+});
+
+// node_modules/commander/index.js
+var require_commander = __commonJS((exports) => {
+  var { Argument } = require_argument();
+  var { Command } = require_command();
+  var { CommanderError, InvalidArgumentError } = require_error();
+  var { Help } = require_help();
+  var { Option } = require_option();
+  exports.program = new Command;
+  exports.createCommand = (name) => new Command(name);
+  exports.createOption = (flags, description) => new Option(flags, description);
+  exports.createArgument = (name, description) => new Argument(name, description);
+  exports.Command = Command;
+  exports.Option = Option;
+  exports.Argument = Argument;
+  exports.Help = Help;
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+  exports.InvalidOptionArgumentError = InvalidArgumentError;
+});
 
 // src/commands/create.ts
+init_source();
+import { existsSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+var VALID_NPM_CHARS = new Set("abcdefghijklmnopqrstuvwxyz0123456789-_.");
+function isValidNpmName(name) {
+  if (!name || name.length === 0)
+    return false;
+  if (name.startsWith(".") || name.startsWith("_"))
+    return false;
+  if (name.includes(" "))
+    return false;
+  for (const char of name) {
+    if (!VALID_NPM_CHARS.has(char))
+      return false;
+  }
+  return true;
+}
+function normalizePluginName(name) {
+  let normalized = name.toLowerCase().split(" ").join("-");
+  normalized = Array.from(normalized).filter((char) => VALID_NPM_CHARS.has(char)).join("");
+  while (normalized.startsWith(".") || normalized.startsWith("_") || normalized.startsWith("-")) {
+    normalized = normalized.slice(1);
+  }
+  return normalized;
+}
 async function createPlugin(name, options = {}) {
-  const pluginName = name.startsWith("omp-") ? name : `omp-${name}`;
+  let pluginName = name.startsWith("omp-") ? name : `omp-${name}`;
+  if (!isValidNpmName(pluginName)) {
+    const normalized = normalizePluginName(pluginName);
+    if (!normalized || normalized === "omp-" || normalized === "omp") {
+      console.log(source_default.red(`Error: Invalid plugin name "${name}" cannot be normalized to a valid npm name`));
+      process.exitCode = 1;
+      return;
+    }
+    const finalName = normalized.startsWith("omp-") ? normalized : `omp-${normalized}`;
+    console.log(source_default.yellow(`Invalid plugin name. Normalized to: ${finalName}`));
+    pluginName = finalName;
+  }
   const pluginDir = pluginName;
   if (existsSync(pluginDir)) {
     console.log(source_default.red(`Error: Directory ${pluginDir} already exists`));
+    process.exitCode = 1;
     return;
   }
   console.log(source_default.blue(`Creating plugin: ${pluginName}...`));
@@ -2491,13 +2642,32 @@ Provide instructions for the agent here.
     console.log(source_default.dim("  5. Publish: npm publish"));
   } catch (err) {
     console.log(source_default.red(`Error creating plugin: ${err.message}`));
+    process.exitCode = 1;
   }
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 
 // src/conflicts.ts
+function detectIntraPluginDuplicates(pkgJson) {
+  const duplicates = [];
+  if (!pkgJson.omp?.install?.length) {
+    return duplicates;
+  }
+  const destMap = new Map;
+  for (const entry of pkgJson.omp.install) {
+    const sources = destMap.get(entry.dest) || [];
+    sources.push(entry.src);
+    destMap.set(entry.dest, sources);
+  }
+  for (const [dest, sources] of destMap) {
+    if (sources.length > 1) {
+      duplicates.push({ dest, sources });
+    }
+  }
+  return duplicates;
+}
 function detectConflicts(newPluginName, newPkgJson, existingPlugins) {
   const conflicts = [];
   if (!newPkgJson.omp?.install?.length) {
@@ -2551,36 +2721,63 @@ function formatConflicts(conflicts) {
 }
 
 // src/manifest.ts
-import { existsSync as existsSync2 } from "fs";
+init_paths();
+import { existsSync as existsSync3 } from "fs";
 import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join3 } from "path";
-
-// src/paths.ts
-import { homedir } from "os";
-import { join as join2 } from "path";
-var PI_CONFIG_DIR = join2(homedir(), ".pi");
-var PLUGINS_DIR = join2(PI_CONFIG_DIR, "plugins");
-var NODE_MODULES_DIR = join2(PLUGINS_DIR, "node_modules");
-var GLOBAL_PACKAGE_JSON = join2(PLUGINS_DIR, "package.json");
-var GLOBAL_LOCK_FILE = join2(PLUGINS_DIR, "package-lock.json");
-var LEGACY_MANIFEST_PATH = join2(PLUGINS_DIR, "manifest.json");
-var PROJECT_PI_DIR = ".pi";
-var PROJECT_PLUGINS_JSON = join2(PROJECT_PI_DIR, "plugins.json");
-var PROJECT_PLUGINS_LOCK = join2(PROJECT_PI_DIR, "plugins-lock.json");
-var PROJECT_NODE_MODULES = join2(PROJECT_PI_DIR, "node_modules");
-
-// src/manifest.ts
+import { dirname as dirname2, join as join3 } from "path";
+function formatPermissionError(err, path) {
+  if (err.code === "EACCES" || err.code === "EPERM") {
+    return `Permission denied: Cannot write to ${path}. Check directory permissions or run with appropriate privileges.`;
+  }
+  return err.message;
+}
 async function initGlobalPlugins() {
-  await mkdir2(PLUGINS_DIR, { recursive: true });
-  if (!existsSync2(GLOBAL_PACKAGE_JSON)) {
-    const packageJson = {
-      name: "pi-plugins",
-      version: "1.0.0",
-      private: true,
-      description: "Global pi plugins managed by omp",
-      dependencies: {}
-    };
-    await writeFile2(GLOBAL_PACKAGE_JSON, JSON.stringify(packageJson, null, 2));
+  try {
+    await mkdir2(PLUGINS_DIR, { recursive: true });
+    if (!existsSync3(GLOBAL_PACKAGE_JSON)) {
+      const packageJson = {
+        name: "pi-plugins",
+        version: "1.0.0",
+        private: true,
+        description: "Global pi plugins managed by omp",
+        dependencies: {}
+      };
+      await writeFile2(GLOBAL_PACKAGE_JSON, JSON.stringify(packageJson, null, 2));
+    }
+  } catch (err) {
+    const error = err;
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      throw new Error(formatPermissionError(error, PLUGINS_DIR));
+    }
+    throw err;
+  }
+}
+async function initProjectPlugins() {
+  const PROJECT_PI_DIR2 = dirname2(PROJECT_PLUGINS_JSON);
+  try {
+    await mkdir2(PROJECT_PI_DIR2, { recursive: true });
+    if (!existsSync3(PROJECT_PLUGINS_JSON)) {
+      const pluginsJson = {
+        plugins: {}
+      };
+      await writeFile2(PROJECT_PLUGINS_JSON, JSON.stringify(pluginsJson, null, 2));
+    }
+    if (!existsSync3(PROJECT_PACKAGE_JSON)) {
+      const packageJson = {
+        name: "pi-project-plugins",
+        version: "1.0.0",
+        private: true,
+        description: "Project-local pi plugins managed by omp",
+        dependencies: {}
+      };
+      await writeFile2(PROJECT_PACKAGE_JSON, JSON.stringify(packageJson, null, 2));
+    }
+  } catch (err) {
+    const error = err;
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      throw new Error(formatPermissionError(error, PROJECT_PI_DIR2));
+    }
+    throw err;
   }
 }
 async function loadPluginsJson(global = true) {
@@ -2591,42 +2788,85 @@ async function loadPluginsJson(global = true) {
     if (global) {
       return {
         plugins: parsed.dependencies || {},
+        devDependencies: parsed.devDependencies || {},
         disabled: parsed.omp?.disabled || []
       };
     }
     return {
       plugins: parsed.plugins || {},
+      devDependencies: parsed.devDependencies || {},
       disabled: parsed.disabled || []
     };
   } catch (err) {
     if (err.code === "ENOENT") {
-      return { plugins: {}, disabled: [] };
+      return { plugins: {}, devDependencies: {}, disabled: [] };
     }
     throw err;
   }
 }
+async function syncProjectPackageJson(data) {
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(PROJECT_PACKAGE_JSON, "utf-8"));
+  } catch {
+    existing = {
+      name: "pi-project-plugins",
+      version: "1.0.0",
+      private: true,
+      description: "Project-local pi plugins managed by omp"
+    };
+  }
+  existing.dependencies = data.plugins;
+  if (data.devDependencies && Object.keys(data.devDependencies).length > 0) {
+    existing.devDependencies = data.devDependencies;
+  } else {
+    delete existing.devDependencies;
+  }
+  await writeFile2(PROJECT_PACKAGE_JSON, JSON.stringify(existing, null, 2));
+}
 async function savePluginsJson(data, global = true) {
   const path = global ? GLOBAL_PACKAGE_JSON : PROJECT_PLUGINS_JSON;
-  await mkdir2(dirname(path), { recursive: true });
-  if (global) {
-    let existing = {};
-    try {
-      existing = JSON.parse(await readFile(path, "utf-8"));
-    } catch {
-      existing = {
-        name: "pi-plugins",
-        version: "1.0.0",
-        private: true,
-        description: "Global pi plugins managed by omp"
-      };
+  try {
+    await mkdir2(dirname2(path), { recursive: true });
+    if (global) {
+      let existing = {};
+      try {
+        existing = JSON.parse(await readFile(path, "utf-8"));
+      } catch {
+        existing = {
+          name: "pi-plugins",
+          version: "1.0.0",
+          private: true,
+          description: "Global pi plugins managed by omp"
+        };
+      }
+      existing.dependencies = data.plugins;
+      if (data.devDependencies && Object.keys(data.devDependencies).length > 0) {
+        existing.devDependencies = data.devDependencies;
+      } else {
+        delete existing.devDependencies;
+      }
+      if (data.disabled?.length) {
+        existing.omp = { ...existing.omp || {}, disabled: data.disabled };
+      }
+      await writeFile2(path, JSON.stringify(existing, null, 2));
+    } else {
+      const output = { plugins: data.plugins };
+      if (data.devDependencies && Object.keys(data.devDependencies).length > 0) {
+        output.devDependencies = data.devDependencies;
+      }
+      if (data.disabled?.length) {
+        output.disabled = data.disabled;
+      }
+      await writeFile2(path, JSON.stringify(output, null, 2));
+      await syncProjectPackageJson(data);
     }
-    existing.dependencies = data.plugins;
-    if (data.disabled?.length) {
-      existing.omp = { ...existing.omp || {}, disabled: data.disabled };
+  } catch (err) {
+    const error = err;
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      throw new Error(formatPermissionError(error, path));
     }
-    await writeFile2(path, JSON.stringify(existing, null, 2));
-  } else {
-    await writeFile2(path, JSON.stringify(data, null, 2));
+    throw err;
   }
 }
 async function readPluginPackageJson(pluginName, global = true) {
@@ -2649,7 +2889,7 @@ function getPluginSourceDir(pluginName, global = true) {
   return join3(nodeModules, pluginName);
 }
 function hasLegacyManifest() {
-  return existsSync2(LEGACY_MANIFEST_PATH);
+  return existsSync3(LEGACY_MANIFEST_PATH);
 }
 async function loadLegacyManifest() {
   try {
@@ -2671,11 +2911,32 @@ async function getInstalledPlugins(global = true) {
   return plugins;
 }
 
+// src/commands/doctor.ts
+init_paths();
+
 // src/symlinks.ts
-import { existsSync as existsSync3, lstatSync } from "fs";
+import { existsSync as existsSync4, lstatSync } from "fs";
 import { mkdir as mkdir3, readlink, rm, symlink } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
-async function createPluginSymlinks(pluginName, pkgJson, global = true, verbose = true) {
+import { platform } from "os";
+import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+init_paths();
+init_source();
+var isWindows = platform() === "win32";
+function formatPermissionError2(err, path) {
+  if (err.code === "EACCES" || err.code === "EPERM") {
+    return `Permission denied: Cannot write to ${path}. Check directory permissions or run with appropriate privileges.`;
+  }
+  return err.message;
+}
+function isPathWithinBase(basePath, targetPath) {
+  const normalizedBase = resolve2(basePath);
+  const resolvedTarget = resolve2(basePath, targetPath);
+  return resolvedTarget === normalizedBase || resolvedTarget.startsWith(`${normalizedBase}/`);
+}
+function getBaseDir(global) {
+  return global ? PI_CONFIG_DIR : PROJECT_PI_DIR;
+}
+async function createPluginSymlinks(pluginName, pkgJson, global = true, verbose = true, skipDestinations) {
   const result = { created: [], errors: [] };
   const sourceDir = getPluginSourceDir(pluginName, global);
   if (!pkgJson.omp?.install?.length) {
@@ -2684,56 +2945,115 @@ async function createPluginSymlinks(pluginName, pkgJson, global = true, verbose
     }
     return result;
   }
+  const baseDir = getBaseDir(global);
   for (const entry of pkgJson.omp.install) {
+    if (skipDestinations?.has(entry.dest)) {
+      if (verbose) {
+        console.log(source_default.dim(`  Skipped: ${entry.dest} (conflict resolved to existing plugin)`));
+      }
+      continue;
+    }
+    if (!isPathWithinBase(baseDir, entry.dest)) {
+      const msg = `Path traversal blocked: ${entry.dest} escapes base directory`;
+      result.errors.push(msg);
+      if (verbose) {
+        console.log(source_default.red(`  \u2717 ${msg}`));
+      }
+      continue;
+    }
     try {
       const src = join4(sourceDir, entry.src);
-      const dest = join4(PI_CONFIG_DIR, entry.dest);
-      if (!existsSync3(src)) {
+      const dest = join4(baseDir, entry.dest);
+      if (!existsSync4(src)) {
         result.errors.push(`Source not found: ${entry.src}`);
         if (verbose) {
           console.log(source_default.yellow(`  \u26A0 Source not found: ${entry.src}`));
         }
         continue;
       }
-      await mkdir3(dirname2(dest), { recursive: true });
+      await mkdir3(dirname3(dest), { recursive: true });
       try {
         await rm(dest, { force: true, recursive: true });
       } catch {}
-      await symlink(src, dest);
+      try {
+        if (isWindows) {
+          const stats = lstatSync(src);
+          if (stats.isDirectory()) {
+            await symlink(src, dest, "junction");
+          } else {
+            await symlink(src, dest, "file");
+          }
+        } else {
+          await symlink(src, dest);
+        }
+      } catch (symlinkErr) {
+        const error = symlinkErr;
+        if (isWindows && error.code === "EPERM") {
+          console.log(source_default.red(`  Permission denied creating symlink.`));
+          console.log(source_default.dim("  On Windows, enable Developer Mode or run as Administrator."));
+          console.log(source_default.dim("  Settings > Update & Security > For developers > Developer Mode"));
+        }
+        throw symlinkErr;
+      }
       result.created.push(entry.dest);
       if (verbose) {
         console.log(source_default.dim(`  Linked: ${entry.dest} \u2192 ${entry.src}`));
       }
     } catch (err) {
-      const msg = `Failed to link ${entry.dest}: ${err.message}`;
+      const error = err;
+      const msg = `Failed to link ${entry.dest}: ${formatPermissionError2(error, join4(baseDir, entry.dest))}`;
       result.errors.push(msg);
       if (verbose) {
         console.log(source_default.red(`  \u2717 ${msg}`));
+        if (error.code === "EACCES" || error.code === "EPERM") {
+          console.log(source_default.dim("  Check directory permissions or run with appropriate privileges."));
+        }
       }
     }
   }
   return result;
 }
-async function removePluginSymlinks(_pluginName, pkgJson, verbose = true) {
-  const result = { created: [], errors: [] };
+async function removePluginSymlinks(_pluginName, pkgJson, global = true, verbose = true) {
+  const result = { removed: [], errors: [], skippedNonSymlinks: [] };
   if (!pkgJson.omp?.install?.length) {
     return result;
   }
+  const baseDir = getBaseDir(global);
   for (const entry of pkgJson.omp.install) {
-    const dest = join4(PI_CONFIG_DIR, entry.dest);
+    if (!isPathWithinBase(baseDir, entry.dest)) {
+      const msg = `Path traversal blocked: ${entry.dest} escapes base directory`;
+      result.errors.push(msg);
+      if (verbose) {
+        console.log(source_default.red(`  \u2717 ${msg}`));
+      }
+      continue;
+    }
+    const dest = join4(baseDir, entry.dest);
     try {
-      if (existsSync3(dest)) {
+      if (existsSync4(dest)) {
+        const stats = lstatSync(dest);
+        if (!stats.isSymbolicLink()) {
+          result.skippedNonSymlinks.push(dest);
+          if (verbose) {
+            console.log(source_default.yellow(`  \u26A0 Skipping ${entry.dest}: not a symlink (may contain user data)`));
+          }
+          continue;
+        }
         await rm(dest, { force: true, recursive: true });
-        result.created.push(entry.dest);
+        result.removed.push(entry.dest);
         if (verbose) {
           console.log(source_default.dim(`  Removed: ${entry.dest}`));
         }
       }
     } catch (err) {
-      const msg = `Failed to remove ${entry.dest}: ${err.message}`;
+      const error = err;
+      const msg = `Failed to remove ${entry.dest}: ${formatPermissionError2(error, dest)}`;
       result.errors.push(msg);
       if (verbose) {
         console.log(source_default.yellow(`  \u26A0 ${msg}`));
+        if (error.code === "EACCES" || error.code === "EPERM") {
+          console.log(source_default.dim("  Check directory permissions or run with appropriate privileges."));
+        }
       }
     }
   }
@@ -2742,13 +3062,18 @@ async function removePluginSymlinks(_pluginName, pkgJson, verbose = true) {
 async function checkPluginSymlinks(pluginName, pkgJson, global = true) {
   const result = { valid: [], broken: [], missing: [] };
   const sourceDir = getPluginSourceDir(pluginName, global);
+  const baseDir = getBaseDir(global);
   if (!pkgJson.omp?.install?.length) {
     return result;
   }
   for (const entry of pkgJson.omp.install) {
+    if (!isPathWithinBase(baseDir, entry.dest)) {
+      result.broken.push(entry.dest);
+      continue;
+    }
     const src = join4(sourceDir, entry.src);
-    const dest = join4(PI_CONFIG_DIR, entry.dest);
-    if (!existsSync3(dest)) {
+    const dest = join4(baseDir, entry.dest);
+    if (!existsSync4(dest)) {
       result.missing.push(entry.dest);
       continue;
     }
@@ -2756,7 +3081,7 @@ async function checkPluginSymlinks(pluginName, pkgJson, global = true) {
       const stats = lstatSync(dest);
       if (stats.isSymbolicLink()) {
         const _target = await readlink(dest);
-        if (existsSync3(src)) {
+        if (existsSync4(src)) {
           result.valid.push(entry.dest);
         } else {
           result.broken.push(entry.dest);
@@ -2770,10 +3095,11 @@ async function checkPluginSymlinks(pluginName, pkgJson, global = true) {
   }
   return result;
 }
-async function traceInstalledFile(filePath, installedPlugins) {
+async function traceInstalledFile(filePath, installedPlugins, global = true) {
+  const baseDir = getBaseDir(global);
   let relativePath = filePath;
-  if (filePath.startsWith(PI_CONFIG_DIR)) {
-    relativePath = filePath.slice(PI_CONFIG_DIR.length + 1);
+  if (filePath.startsWith(baseDir)) {
+    relativePath = filePath.slice(baseDir.length + 1);
   }
   for (const [name, pkgJson] of installedPlugins) {
     if (pkgJson.omp?.install) {
@@ -2788,13 +3114,14 @@ async function traceInstalledFile(filePath, installedPlugins) {
 }
 
 // src/commands/doctor.ts
+init_source();
 async function runDoctor(options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const results = [];
   console.log(source_default.blue(`Running health checks...
 `));
   const pluginsDir = isGlobal ? PLUGINS_DIR : ".pi";
-  if (!existsSync4(pluginsDir)) {
+  if (!existsSync5(pluginsDir)) {
     results.push({
       check: "Plugins directory",
       status: "warning",
@@ -2808,8 +3135,8 @@ async function runDoctor(options = {}) {
       message: pluginsDir
     });
   }
-  const packageJsonPath = isGlobal ? GLOBAL_PACKAGE_JSON : ".pi/plugins.json";
-  if (!existsSync4(packageJsonPath)) {
+  const packageJsonPath = isGlobal ? GLOBAL_PACKAGE_JSON : PROJECT_PLUGINS_JSON;
+  if (!existsSync5(packageJsonPath)) {
     results.push({
       check: "Package manifest",
       status: "warning",
@@ -2823,8 +3150,8 @@ async function runDoctor(options = {}) {
       message: packageJsonPath
     });
   }
-  const nodeModules = isGlobal ? NODE_MODULES_DIR : ".pi/node_modules";
-  if (!existsSync4(nodeModules)) {
+  const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
+  if (!existsSync5(nodeModules)) {
     results.push({
       check: "Node modules",
       status: "warning",
@@ -2901,6 +3228,31 @@ async function runDoctor(options = {}) {
       fix: "Run: omp install (to reinstall) or remove from manifest"
     });
   }
+  const missingDeps = [];
+  for (const [name, pkgJson] of installedPlugins) {
+    if (pkgJson.dependencies) {
+      for (const depName of Object.keys(pkgJson.dependencies)) {
+        const depPkgJson = await readPluginPackageJson(depName, isGlobal);
+        if (!depPkgJson) {
+          if (pluginsJson.plugins[depName]) {
+            missingDeps.push(`${name} requires ${depName} (not in node_modules)`);
+          }
+        } else if (depPkgJson.omp?.install && depPkgJson.omp.install.length > 0) {
+          if (!pluginsJson.plugins[depName]) {
+            missingDeps.push(`${name} requires omp plugin ${depName} (installed but not in manifest)`);
+          }
+        }
+      }
+    }
+  }
+  if (missingDeps.length > 0) {
+    results.push({
+      check: "Missing omp dependencies",
+      status: "warning",
+      message: missingDeps.join("; "),
+      fix: isGlobal ? "Run: npm install in ~/.pi/plugins" : "Run: npm install in .pi"
+    });
+  }
   if (options.json) {
     console.log(JSON.stringify({ results }, null, 2));
     return;
@@ -2935,6 +3287,7 @@ async function runDoctor(options = {}) {
   } else {
     if (errors.length > 0) {
       console.log(source_default.red(`${errors.length} error(s) found`));
+      process.exitCode = 1;
     }
     if (warnings.length > 0) {
       console.log(source_default.yellow(`${warnings.length} warning(s) found`));
@@ -2954,28 +3307,81 @@ Missing symlinks:`));
       console.log(source_default.dim(`  - ${s}`));
     }
   }
+  if (options.fix) {
+    let fixedAnything = false;
+    if (brokenSymlinks.length > 0 || missingSymlinks.length > 0) {
+      console.log(source_default.blue(`
+Attempting to fix broken/missing symlinks...`));
+      for (const [name, pkgJson] of installedPlugins) {
+        const symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal, false);
+        if (symlinkResult.created.length > 0) {
+          fixedAnything = true;
+          console.log(source_default.green(`  \u2713 Re-created symlinks for ${name}`));
+        }
+        if (symlinkResult.errors.length > 0) {
+          for (const err of symlinkResult.errors) {
+            console.log(source_default.red(`  \u2717 ${name}: ${err}`));
+          }
+        }
+      }
+    }
+    if (orphaned.length > 0) {
+      console.log(source_default.blue(`
+Removing orphaned entries from manifest...`));
+      for (const name of orphaned) {
+        delete pluginsJson.plugins[name];
+        console.log(source_default.green(`  \u2713 Removed ${name}`));
+      }
+      await savePluginsJson(pluginsJson, isGlobal);
+      fixedAnything = true;
+    }
+    if (conflicts.length > 0) {
+      console.log(source_default.yellow(`
+Conflicts cannot be auto-fixed. Please resolve manually:`));
+      for (const conflict of formatConflicts(conflicts)) {
+        console.log(source_default.dim(`  - ${conflict}`));
+      }
+    }
+    if (fixedAnything) {
+      console.log(source_default.green(`
+\u2713 Fixes applied. Run 'omp doctor' again to verify.`));
+    } else if (conflicts.length === 0) {
+      console.log(source_default.dim(`
+No fixable issues found.`));
+    }
+  }
 }
 
 // src/commands/enable.ts
+init_paths();
+init_source();
 async function enablePlugin(name, options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const pluginsJson = await loadPluginsJson(isGlobal);
   if (!pluginsJson.plugins[name]) {
     console.log(source_default.yellow(`Plugin "${name}" is not installed.`));
+    process.exitCode = 1;
     return;
   }
   if (!pluginsJson.disabled?.includes(name)) {
     console.log(source_default.yellow(`Plugin "${name}" is already enabled.`));
+    process.exitCode = 1;
     return;
   }
   try {
     const pkgJson = await readPluginPackageJson(name, isGlobal);
     if (!pkgJson) {
       console.log(source_default.red(`Could not read package.json for ${name}`));
+      process.exitCode = 1;
       return;
     }
-    console.log(source_default.blue(`Enabling ${name}...`));
-    await createPluginSymlinks(name, pkgJson, isGlobal);
+    const symlinkStatus = await checkPluginSymlinks(name, pkgJson, isGlobal);
+    if (symlinkStatus.valid.length > 0 && symlinkStatus.broken.length === 0 && symlinkStatus.missing.length === 0) {
+      console.log(source_default.yellow(`Plugin "${name}" symlinks are already in place.`));
+    } else {
+      console.log(source_default.blue(`Enabling ${name}...`));
+      await createPluginSymlinks(name, pkgJson, isGlobal);
+    }
     pluginsJson.disabled = pluginsJson.disabled.filter((n) => n !== name);
     await savePluginsJson(pluginsJson, isGlobal);
     console.log(source_default.green(`\u2713 Enabled "${name}"`));
@@ -2984,27 +3390,31 @@ async function enablePlugin(name, options = {}) {
     }
   } catch (err) {
     console.log(source_default.red(`Error enabling plugin: ${err.message}`));
+    process.exitCode = 1;
   }
 }
 async function disablePlugin(name, options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const pluginsJson = await loadPluginsJson(isGlobal);
   if (!pluginsJson.plugins[name]) {
     console.log(source_default.yellow(`Plugin "${name}" is not installed.`));
+    process.exitCode = 1;
     return;
   }
   if (pluginsJson.disabled?.includes(name)) {
     console.log(source_default.yellow(`Plugin "${name}" is already disabled.`));
+    process.exitCode = 1;
     return;
   }
   try {
     const pkgJson = await readPluginPackageJson(name, isGlobal);
     if (!pkgJson) {
       console.log(source_default.red(`Could not read package.json for ${name}`));
+      process.exitCode = 1;
       return;
     }
     console.log(source_default.blue(`Disabling ${name}...`));
-    await removePluginSymlinks(name, pkgJson);
+    await removePluginSymlinks(name, pkgJson, isGlobal);
     if (!pluginsJson.disabled) {
       pluginsJson.disabled = [];
     }
@@ -3018,21 +3428,65 @@ async function disablePlugin(name, options = {}) {
     }
   } catch (err) {
     console.log(source_default.red(`Error disabling plugin: ${err.message}`));
+    process.exitCode = 1;
   }
 }
 
 // src/npm.ts
-import { execSync } from "child_process";
-function npmExec(args, cwd) {
-  const cmd = `npm ${args.join(" ")}`;
-  return execSync(cmd, {
-    cwd,
-    stdio: ["pipe", "pipe", "pipe"],
-    encoding: "utf-8"
-  });
+import { execFileSync } from "child_process";
+function checkNpmAvailable() {
+  try {
+    const version = execFileSync("npm", ["--version"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const major = parseInt(version.split(".")[0], 10);
+    if (major < 7) {
+      return {
+        available: false,
+        version,
+        error: `npm version ${version} is too old. Please upgrade to npm 7 or later.`
+      };
+    }
+    return { available: true, version };
+  } catch {
+    return {
+      available: false,
+      error: "npm is not installed or not in PATH. Please install Node.js/npm."
+    };
+  }
+}
+var DEFAULT_TIMEOUT_MS = 60000;
+function npmExec(args, cwd, timeout = DEFAULT_TIMEOUT_MS) {
+  try {
+    return execFileSync("npm", args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+      timeout
+    });
+  } catch (err) {
+    const error = err;
+    if (error.killed || error.code === "ETIMEDOUT") {
+      throw new Error(`npm operation timed out after ${timeout / 1000} seconds`);
+    }
+    throw err;
+  }
 }
-function npmExecWithPrefix(args, prefix) {
-  return npmExec(["--prefix", prefix, ...args]);
+function npmExecWithPrefix(args, prefix, timeout = DEFAULT_TIMEOUT_MS) {
+  try {
+    return execFileSync("npm", ["--prefix", prefix, ...args], {
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+      timeout
+    });
+  } catch (err) {
+    const error = err;
+    if (error.killed || error.code === "ETIMEDOUT") {
+      throw new Error(`npm operation timed out after ${timeout / 1000} seconds`);
+    }
+    throw err;
+  }
 }
 async function npmInstall(packages, prefix, options = {}) {
   const args = ["install"];
@@ -3056,13 +3510,9 @@ async function npmInfo(packageName) {
   }
 }
 async function npmSearch(query, keyword = "omp-plugin") {
-  try {
-    const searchTerm = keyword ? `keywords:${keyword} ${query}` : query;
-    const output = npmExec(["search", searchTerm, "--json"]);
-    return JSON.parse(output);
-  } catch {
-    return [];
-  }
+  const searchTerm = keyword ? `keywords:${keyword} ${query}` : query;
+  const output = npmExec(["search", searchTerm, "--json"]);
+  return JSON.parse(output);
 }
 async function npmOutdated(prefix) {
   try {
@@ -3089,12 +3539,14 @@ async function npmUpdate(packages, prefix) {
 }
 
 // src/commands/info.ts
+init_source();
 async function showInfo(packageName, options = {}) {
   console.log(source_default.blue(`Fetching info for ${packageName}...`));
   try {
     const info = await npmInfo(packageName);
     if (!info) {
       console.log(source_default.red(`Package not found: ${packageName}`));
+      process.exitCode = 1;
       return;
     }
     if (options.json) {
@@ -3122,6 +3574,13 @@ async function showInfo(packageName, options = {}) {
     if (info.keywords?.length) {
       console.log(source_default.dim("keywords: ") + info.keywords.join(", "));
     }
+    if (info.dependencies && Object.keys(info.dependencies).length > 0) {
+      console.log(source_default.dim(`
+dependencies:`));
+      for (const [depName, depVersion] of Object.entries(info.dependencies)) {
+        console.log(source_default.dim(`  ${depName}: ${depVersion}`));
+      }
+    }
     const isOmpPlugin = info.keywords?.includes("omp-plugin");
     if (isOmpPlugin) {
       console.log(source_default.green(`
@@ -3131,27 +3590,59 @@ async function showInfo(packageName, options = {}) {
 \u26A0 This package does not have the omp-plugin keyword`));
       console.log(source_default.dim("  It may work, but might not have omp.install configuration"));
     }
-    if (options.versions && info["dist-tags"]) {
+    if (info.omp?.install?.length) {
       console.log(source_default.dim(`
+Files to install:`));
+      for (const entry of info.omp.install) {
+        console.log(source_default.dim(`  ${entry.src} \u2192 ${entry.dest}`));
+      }
+    }
+    if (options.versions || options.allVersions) {
+      if (info["dist-tags"]) {
+        console.log(source_default.dim(`
 dist-tags:`));
-      for (const [tag, version] of Object.entries(info["dist-tags"])) {
-        console.log(source_default.dim(`  ${tag}: `) + version);
+        for (const [tag, version] of Object.entries(info["dist-tags"])) {
+          console.log(source_default.dim(`  ${tag}: `) + version);
+        }
+      }
+      if (info.versions?.length) {
+        console.log(source_default.dim(`
+all versions:`));
+        if (options.allVersions) {
+          console.log(source_default.dim(`  ${info.versions.join(", ")}`));
+        } else {
+          const versionsToShow = info.versions.slice(-10);
+          console.log(source_default.dim(`  ${versionsToShow.join(", ")}`));
+          if (info.versions.length > 10) {
+            console.log(source_default.dim(`  ... and ${info.versions.length - 10} more (use --all-versions to see all)`));
+          }
+        }
       }
     }
     console.log();
     console.log(source_default.dim(`Install with: omp install ${packageName}`));
   } catch (err) {
     console.log(source_default.red(`Error fetching info: ${err.message}`));
+    process.exitCode = 1;
   }
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync5 } from "fs";
+init_paths();
+init_source();
+import { existsSync as existsSync6 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+function formatPermissionError3(err, path) {
+  if (err.code === "EACCES" || err.code === "EPERM") {
+    return `Permission denied: Cannot write to ${path}. Check directory permissions or run with appropriate privileges.`;
+  }
+  return err.message;
+}
 async function initProject(options = {}) {
-  if (existsSync5(PROJECT_PLUGINS_JSON) && !options.force) {
+  if (existsSync6(PROJECT_PLUGINS_JSON) && !options.force) {
     console.log(source_default.yellow(`${PROJECT_PLUGINS_JSON} already exists.`));
     console.log(source_default.dim("Use --force to overwrite"));
+    process.exitCode = 1;
     return;
   }
   try {
@@ -3168,22 +3659,49 @@ async function initProject(options = {}) {
     console.log(source_default.dim("  2. Or edit plugins.json directly"));
     console.log(source_default.dim("  3. Run: omp install (to install all)"));
   } catch (err) {
-    console.log(source_default.red(`Error initializing project: ${err.message}`));
+    const error = err;
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      console.log(source_default.red(formatPermissionError3(error, PROJECT_PI_DIR)));
+      console.log(source_default.dim("  Check directory permissions or run with appropriate privileges."));
+    } else {
+      console.log(source_default.red(`Error initializing project: ${error.message}`));
+    }
+    process.exitCode = 1;
   }
 }
 
 // src/commands/install.ts
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { cp, mkdir as mkdir5, readFile as readFile2, rm as rm2 } from "fs/promises";
-import { basename, join as join5, resolve } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+import { cp, mkdir as mkdir5, readFile as readFile3, rm as rm2 } from "fs/promises";
+import { basename, join as join5, resolve as resolve3 } from "path";
 import { createInterface } from "readline";
+init_lockfile();
+init_paths();
+init_source();
+async function processOmpDependencies(pkgJson, isGlobal, seen) {
+  if (!pkgJson.dependencies)
+    return;
+  for (const depName of Object.keys(pkgJson.dependencies)) {
+    if (seen.has(depName)) {
+      console.log(source_default.yellow(`  Skipping circular dependency: ${depName}`));
+      continue;
+    }
+    seen.add(depName);
+    const depPkgJson = await readPluginPackageJson(depName, isGlobal);
+    if (depPkgJson?.omp?.install) {
+      console.log(source_default.dim(`  Processing dependency: ${depName}`));
+      await createPluginSymlinks(depName, depPkgJson, isGlobal);
+      await processOmpDependencies(depPkgJson, isGlobal, seen);
+    }
+  }
+}
 async function promptConflictResolution(conflict) {
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     console.log(source_default.yellow(`
 \u26A0 Conflict: ${formatConflicts([conflict])[0]}`));
     conflict.plugins.forEach((p, i) => {
@@ -3194,9 +3712,9 @@ async function promptConflictResolution(conflict) {
       rl.close();
       const choice = parseInt(answer, 10);
       if (choice > 0 && choice <= conflict.plugins.length) {
-        resolve2(choice - 1);
+        resolve4(choice - 1);
       } else {
-        resolve2(null);
+        resolve4(null);
       }
     });
   });
@@ -3225,23 +3743,25 @@ function isLocalPath(spec) {
   return spec.startsWith("/") || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("~");
 }
 async function installPlugin(packages, options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const prefix = isGlobal ? PLUGINS_DIR : ".pi";
   const _nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
   if (isGlobal) {
     await initGlobalPlugins();
   } else {
-    await mkdir5(prefix, { recursive: true });
-    if (!existsSync6(PROJECT_PLUGINS_JSON)) {
-      await savePluginsJson({ plugins: {} }, false);
-    }
+    await initProjectPlugins();
   }
   if (!packages || packages.length === 0) {
     const pluginsJson = await loadPluginsJson(isGlobal);
-    packages = Object.entries(pluginsJson.plugins).map(([name, version]) => `${name}@${version}`);
+    const lockFile = await Promise.resolve().then(() => (init_lockfile(), exports_lockfile)).then((m) => m.loadLockFile(isGlobal));
+    packages = await Promise.all(Object.entries(pluginsJson.plugins).map(async ([name, version]) => {
+      const lockedVersion = lockFile?.packages[name]?.version;
+      return `${name}@${lockedVersion || version}`;
+    }));
     if (packages.length === 0) {
       console.log(source_default.yellow("No plugins to install."));
       console.log(source_default.dim(isGlobal ? "Add plugins with: omp install <package>" : "Add plugins to .pi/plugins.json"));
+      process.exitCode = 1;
       return;
     }
     console.log(source_default.blue(`Installing ${packages.length} plugin(s) from ${isGlobal ? "package.json" : "plugins.json"}...`));
@@ -3256,57 +3776,168 @@ async function installPlugin(packages, options = {}) {
     }
     const { name, version } = parsePackageSpec(spec);
     const pkgSpec = version === "latest" ? name : `${name}@${version}`;
+    let npmInstallSucceeded = false;
+    let createdSymlinks = [];
+    let resolvedVersion = version;
     try {
       console.log(source_default.blue(`
 Installing ${pkgSpec}...`));
       const info = await npmInfo(pkgSpec);
       if (!info) {
         console.log(source_default.red(`  \u2717 Package not found: ${name}`));
+        process.exitCode = 1;
         results.push({ name, version, success: false, error: "Package not found" });
         continue;
       }
+      resolvedVersion = info.version;
+      const skipDestinations = new Set;
+      const preInstallPkgJson = info.omp?.install ? { name: info.name, version: info.version, omp: info.omp } : null;
+      if (preInstallPkgJson) {
+        const intraDupes = detectIntraPluginDuplicates(preInstallPkgJson);
+        if (intraDupes.length > 0) {
+          console.log(source_default.red(`  \u2717 Plugin has duplicate destinations:`));
+          for (const dupe of intraDupes) {
+            console.log(source_default.red(`    ${dupe.dest} \u2190 ${dupe.sources.join(", ")}`));
+          }
+          process.exitCode = 1;
+          results.push({ name, version: info.version, success: false, error: "Duplicate destinations in plugin" });
+          continue;
+        }
+        const preInstallConflicts = detectConflicts(name, preInstallPkgJson, existingPlugins);
+        if (preInstallConflicts.length > 0 && !options.force) {
+          if (!process.stdout.isTTY || !process.stdin.isTTY) {
+            console.log(source_default.red("Conflicts detected in non-interactive mode. Use --force to override."));
+            for (const conflict of preInstallConflicts) {
+              console.log(source_default.yellow(`  \u26A0 ${formatConflicts([conflict])[0]}`));
+            }
+            process.exitCode = 1;
+            results.push({
+              name,
+              version: info.version,
+              success: false,
+              error: "Conflicts in non-interactive mode"
+            });
+            continue;
+          }
+          let abort = false;
+          for (const conflict of preInstallConflicts) {
+            const choice = await promptConflictResolution(conflict);
+            if (choice === null) {
+              abort = true;
+              break;
+            }
+            const newPluginIndex = conflict.plugins.length - 1;
+            if (choice !== newPluginIndex) {
+              skipDestinations.add(conflict.dest);
+            }
+          }
+          if (abort) {
+            console.log(source_default.yellow(`  Aborted due to conflicts (before download)`));
+            process.exitCode = 1;
+            results.push({ name, version: info.version, success: false, error: "Conflicts" });
+            continue;
+          }
+        }
+      }
       console.log(source_default.dim(`  Fetching from npm...`));
       await npmInstall([pkgSpec], prefix, { save: options.save || isGlobal });
+      npmInstallSucceeded = true;
       const pkgJson = await readPluginPackageJson(name, isGlobal);
       if (!pkgJson) {
         console.log(source_default.yellow(`  \u26A0 Installed but no package.json found`));
         results.push({ name, version: info.version, success: true });
         continue;
       }
-      const conflicts = detectConflicts(name, pkgJson, existingPlugins);
-      if (conflicts.length > 0 && !options.force) {
-        let abort = false;
-        for (const conflict of conflicts) {
-          const choice = await promptConflictResolution(conflict);
-          if (choice === null) {
-            abort = true;
-            break;
+      if (!preInstallPkgJson) {
+        const intraDupes = detectIntraPluginDuplicates(pkgJson);
+        if (intraDupes.length > 0) {
+          console.log(source_default.red(`  \u2717 Plugin has duplicate destinations:`));
+          for (const dupe of intraDupes) {
+            console.log(source_default.red(`    ${dupe.dest} \u2190 ${dupe.sources.join(", ")}`));
           }
-        }
-        if (abort) {
-          console.log(source_default.yellow(`  Aborted due to conflicts`));
-          execSync2(`npm uninstall --prefix ${prefix} ${name}`, { stdio: "pipe" });
-          results.push({ name, version: info.version, success: false, error: "Conflicts" });
+          execFileSync2("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+          process.exitCode = 1;
+          results.push({ name, version: info.version, success: false, error: "Duplicate destinations in plugin" });
           continue;
         }
+        const conflicts = detectConflicts(name, pkgJson, existingPlugins);
+        if (conflicts.length > 0 && !options.force) {
+          if (!process.stdout.isTTY || !process.stdin.isTTY) {
+            console.log(source_default.red("Conflicts detected in non-interactive mode. Use --force to override."));
+            for (const conflict of conflicts) {
+              console.log(source_default.yellow(`  \u26A0 ${formatConflicts([conflict])[0]}`));
+            }
+            execFileSync2("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+            process.exitCode = 1;
+            results.push({
+              name,
+              version: info.version,
+              success: false,
+              error: "Conflicts in non-interactive mode"
+            });
+            continue;
+          }
+          let abort = false;
+          for (const conflict of conflicts) {
+            const choice = await promptConflictResolution(conflict);
+            if (choice === null) {
+              abort = true;
+              break;
+            }
+            const newPluginIndex = conflict.plugins.length - 1;
+            if (choice !== newPluginIndex) {
+              skipDestinations.add(conflict.dest);
+            }
+          }
+          if (abort) {
+            console.log(source_default.yellow(`  Aborted due to conflicts`));
+            execFileSync2("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+            process.exitCode = 1;
+            results.push({ name, version: info.version, success: false, error: "Conflicts" });
+            continue;
+          }
+        }
       }
-      const _symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal);
-      if (pkgJson.dependencies) {
-        for (const depName of Object.keys(pkgJson.dependencies)) {
-          const depPkgJson = await readPluginPackageJson(depName, isGlobal);
-          if (depPkgJson?.omp?.install) {
-            console.log(source_default.dim(`  Processing dependency: ${depName}`));
-            await createPluginSymlinks(depName, depPkgJson, isGlobal);
+      const symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal, true, skipDestinations);
+      createdSymlinks = symlinkResult.created;
+      await processOmpDependencies(pkgJson, isGlobal, new Set([name]));
+      if (options.save || options.saveDev) {
+        const pluginsJson = await loadPluginsJson(isGlobal);
+        if (options.saveDev) {
+          if (!pluginsJson.devDependencies) {
+            pluginsJson.devDependencies = {};
           }
+          pluginsJson.devDependencies[name] = info.version;
+          delete pluginsJson.plugins[name];
+        } else if (!isGlobal) {
+          pluginsJson.plugins[name] = info.version;
         }
+        await savePluginsJson(pluginsJson, isGlobal);
       }
       existingPlugins.set(name, pkgJson);
+      await updateLockFile(name, info.version, isGlobal);
       console.log(source_default.green(`\u2713 Installed ${name}@${info.version}`));
       results.push({ name, version: info.version, success: true });
     } catch (err) {
       const errorMsg = err.message;
       console.log(source_default.red(`  \u2717 Failed to install ${name}: ${errorMsg}`));
-      results.push({ name, version, success: false, error: errorMsg });
+      if (createdSymlinks.length > 0) {
+        console.log(source_default.dim("  Rolling back symlinks..."));
+        const baseDir = isGlobal ? PI_CONFIG_DIR : PROJECT_PI_DIR;
+        for (const dest of createdSymlinks) {
+          try {
+            await rm2(join5(baseDir, dest), { force: true, recursive: true });
+          } catch {}
+        }
+      }
+      if (npmInstallSucceeded) {
+        console.log(source_default.dim("  Rolling back npm install..."));
+        try {
+          execFileSync2("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+        } catch {}
+      }
+      process.exitCode = 1;
+      results.push({ name, version: resolvedVersion, success: false, error: errorMsg });
     }
   }
   const successful = results.filter((r) => r.success);
@@ -3317,6 +3948,7 @@ Installing ${pkgSpec}...`));
   }
   if (failed.length > 0) {
     console.log(source_default.red(`\u2717 Failed to install ${failed.length} plugin(s)`));
+    process.exitCode = 1;
   }
   if (options.json) {
     console.log(JSON.stringify({ results }, null, 2));
@@ -3326,9 +3958,10 @@ async function installLocalPlugin(localPath, isGlobal, _options) {
   if (localPath.startsWith("~")) {
     localPath = join5(process.env.HOME || "", localPath.slice(1));
   }
-  localPath = resolve(localPath);
-  if (!existsSync6(localPath)) {
+  localPath = resolve3(localPath);
+  if (!existsSync8(localPath)) {
     console.log(source_default.red(`Error: Path does not exist: ${localPath}`));
+    process.exitCode = 1;
     return { name: basename(localPath), version: "local", success: false, error: "Path not found" };
   }
   const _prefix = isGlobal ? PLUGINS_DIR : ".pi";
@@ -3336,12 +3969,12 @@ async function installLocalPlugin(localPath, isGlobal, _options) {
   try {
     const localPkgJsonPath = join5(localPath, "package.json");
     let pkgJson;
-    if (existsSync6(localPkgJsonPath)) {
-      pkgJson = JSON.parse(await readFile2(localPkgJsonPath, "utf-8"));
+    if (existsSync8(localPkgJsonPath)) {
+      pkgJson = JSON.parse(await readFile3(localPkgJsonPath, "utf-8"));
     } else {
       const ompJsonPath = join5(localPath, "omp.json");
-      if (existsSync6(ompJsonPath)) {
-        const ompJson = JSON.parse(await readFile2(ompJsonPath, "utf-8"));
+      if (existsSync8(ompJsonPath)) {
+        const ompJson = JSON.parse(await readFile3(ompJsonPath, "utf-8"));
         pkgJson = {
           name: ompJson.name || basename(localPath),
           version: ompJson.version || "0.0.0",
@@ -3361,49 +3994,91 @@ async function installLocalPlugin(localPath, isGlobal, _options) {
     }
     const pluginName = pkgJson.name;
     const pluginDir = join5(nodeModules, pluginName);
+    const intraDupes = detectIntraPluginDuplicates(pkgJson);
+    if (intraDupes.length > 0) {
+      console.log(source_default.red(`
+Error: Plugin has duplicate destinations:`));
+      for (const dupe of intraDupes) {
+        console.log(source_default.red(`  ${dupe.dest} \u2190 ${dupe.sources.join(", ")}`));
+      }
+      process.exitCode = 1;
+      return {
+        name: pluginName,
+        version: pkgJson.version,
+        success: false,
+        error: "Duplicate destinations in plugin"
+      };
+    }
     console.log(source_default.blue(`
 Installing ${pluginName} from ${localPath}...`));
     await mkdir5(nodeModules, { recursive: true });
-    if (existsSync6(pluginDir)) {
+    if (existsSync8(pluginDir)) {
       await rm2(pluginDir, { recursive: true, force: true });
     }
     await cp(localPath, pluginDir, { recursive: true });
     console.log(source_default.dim(`  Copied to ${pluginDir}`));
     const pluginsJson = await loadPluginsJson(isGlobal);
-    pluginsJson.plugins[pluginName] = `file:${localPath}`;
+    if (_options.saveDev) {
+      if (!pluginsJson.devDependencies) {
+        pluginsJson.devDependencies = {};
+      }
+      pluginsJson.devDependencies[pluginName] = `file:${localPath}`;
+      delete pluginsJson.plugins[pluginName];
+    } else {
+      pluginsJson.plugins[pluginName] = `file:${localPath}`;
+    }
     await savePluginsJson(pluginsJson, isGlobal);
     await createPluginSymlinks(pluginName, pkgJson, isGlobal);
+    await updateLockFile(pluginName, pkgJson.version, isGlobal);
     console.log(source_default.green(`\u2713 Installed ${pluginName}@${pkgJson.version}`));
     return { name: pluginName, version: pkgJson.version, success: true };
   } catch (err) {
     const errorMsg = err.message;
     console.log(source_default.red(`  \u2717 Failed: ${errorMsg}`));
+    process.exitCode = 1;
     return { name: basename(localPath), version: "local", success: false, error: errorMsg };
   }
 }
 
 // src/commands/link.ts
-import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir6, readFile as readFile3, rm as rm3, symlink as symlink2 } from "fs/promises";
-import { basename as basename2, dirname as dirname3, join as join6, resolve as resolve2 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { mkdir as mkdir6, readFile as readFile4, rm as rm3, symlink as symlink2, writeFile as writeFile5 } from "fs/promises";
+import { basename as basename2, dirname as dirname4, join as join6, resolve as resolve4 } from "path";
+import { createInterface as createInterface2 } from "readline";
+init_paths();
+init_source();
+async function confirmCreate(path) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.log(source_default.dim("  Non-interactive mode: auto-creating package.json"));
+    return true;
+  }
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve5) => {
+    rl.question(source_default.yellow(`  Create minimal package.json at ${path}? [Y/n] `), (answer) => {
+      rl.close();
+      resolve5(answer.toLowerCase() !== "n");
+    });
+  });
+}
 async function linkPlugin(localPath, options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
   if (localPath.startsWith("~")) {
     localPath = join6(process.env.HOME || "", localPath.slice(1));
   }
-  localPath = resolve2(localPath);
-  if (!existsSync7(localPath)) {
+  localPath = resolve4(localPath);
+  if (!existsSync9(localPath)) {
     console.log(source_default.red(`Error: Path does not exist: ${localPath}`));
+    process.exitCode = 1;
     return;
   }
   let pkgJson;
   const localPkgJsonPath = join6(localPath, "package.json");
   const localOmpJsonPath = join6(localPath, "omp.json");
-  if (existsSync7(localPkgJsonPath)) {
-    pkgJson = JSON.parse(await readFile3(localPkgJsonPath, "utf-8"));
-  } else if (existsSync7(localOmpJsonPath)) {
-    const ompJson = JSON.parse(await readFile3(localOmpJsonPath, "utf-8"));
+  if (existsSync9(localPkgJsonPath)) {
+    pkgJson = JSON.parse(await readFile4(localPkgJsonPath, "utf-8"));
+  } else if (existsSync9(localOmpJsonPath)) {
+    const ompJson = JSON.parse(await readFile4(localOmpJsonPath, "utf-8"));
     pkgJson = {
       name: ompJson.name || options.name || basename2(localPath),
       version: ompJson.version || "0.0.0-dev",
@@ -3413,26 +4088,51 @@ async function linkPlugin(localPath, options = {}) {
         install: ompJson.install
       }
     };
+    console.log(source_default.dim("  Converting omp.json to package.json..."));
+    await writeFile5(localPkgJsonPath, JSON.stringify(pkgJson, null, 2));
   } else {
+    console.log(source_default.yellow("  No package.json found in target directory."));
+    const shouldCreate = await confirmCreate(localPkgJsonPath);
+    if (!shouldCreate) {
+      console.log(source_default.yellow("  Aborted: package.json required for linking"));
+      process.exitCode = 1;
+      return;
+    }
     pkgJson = {
       name: options.name || basename2(localPath),
       version: "0.0.0-dev",
-      keywords: ["omp-plugin"]
+      keywords: ["omp-plugin"],
+      omp: {
+        install: []
+      }
     };
-    console.log(source_default.yellow("  Warning: No package.json or omp.json found"));
+    console.log(source_default.dim("  Creating minimal package.json..."));
+    await writeFile5(localPkgJsonPath, JSON.stringify(pkgJson, null, 2));
   }
   const pluginName = options.name || pkgJson.name;
   const pluginDir = join6(nodeModules, pluginName);
   const pluginsJson = await loadPluginsJson(isGlobal);
   if (pluginsJson.plugins[pluginName]) {
-    console.log(source_default.yellow(`Plugin "${pluginName}" is already installed.`));
-    console.log(source_default.dim("Use omp uninstall first, or specify a different name with -n"));
-    return;
+    const existingSpec = pluginsJson.plugins[pluginName];
+    const isLinked = existingSpec.startsWith("file:");
+    if (isLinked) {
+      console.log(source_default.yellow(`Plugin "${pluginName}" is already linked.`));
+      console.log(source_default.dim(`  Current link: ${existingSpec}`));
+      console.log(source_default.dim("  Re-linking..."));
+    } else if (options.force) {
+      console.log(source_default.yellow(`Plugin "${pluginName}" is installed from npm. Overwriting with link...`));
+    } else {
+      console.log(source_default.yellow(`Plugin "${pluginName}" is already installed from npm.`));
+      console.log(source_default.dim("Use omp uninstall first, or specify a different name with -n"));
+      console.log(source_default.dim("Or use --force to overwrite the npm installation"));
+      process.exitCode = 1;
+      return;
+    }
   }
   try {
     console.log(source_default.blue(`Linking ${localPath}...`));
-    await mkdir6(dirname3(pluginDir), { recursive: true });
-    if (existsSync7(pluginDir)) {
+    await mkdir6(dirname4(pluginDir), { recursive: true });
+    if (existsSync9(pluginDir)) {
       await rm3(pluginDir, { force: true, recursive: true });
     }
     await symlink2(localPath, pluginDir);
@@ -3447,6 +4147,7 @@ async function linkPlugin(localPath, options = {}) {
     console.log(source_default.dim("  Changes to the source will be reflected immediately"));
   } catch (err) {
     console.log(source_default.red(`Error linking plugin: ${err.message}`));
+    process.exitCode = 1;
     try {
       await rm3(pluginDir, { force: true });
     } catch {}
@@ -3454,13 +4155,16 @@ async function linkPlugin(localPath, options = {}) {
 }
 
 // src/commands/list.ts
+init_paths();
+init_source();
 async function listPlugins(options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const pluginsJson = await loadPluginsJson(isGlobal);
   const pluginNames = Object.keys(pluginsJson.plugins);
   if (pluginNames.length === 0) {
     console.log(source_default.yellow("No plugins installed."));
     console.log(source_default.dim("Install one with: omp install <package>"));
+    process.exitCode = 1;
     return;
   }
   if (options.json) {
@@ -3486,11 +4190,13 @@ async function listPlugins(options = {}) {
     const specifier = pluginsJson.plugins[name];
     const isLocal = specifier.startsWith("file:");
     const disabled = pluginsJson.disabled?.includes(name);
-    const version = pkgJson?.version ? source_default.dim(` v${pkgJson.version}`) : "";
+    const isMissing = !pkgJson;
+    const version = pkgJson?.version ? source_default.dim(` v${pkgJson.version}`) : source_default.dim(` (${specifier})`);
     const localBadge = isLocal ? source_default.cyan(" (local)") : "";
     const disabledBadge = disabled ? source_default.yellow(" (disabled)") : "";
-    const icon = disabled ? source_default.gray("\u25CB") : source_default.green("\u25C6");
-    console.log(`${icon} ${source_default.bold(name)}${version}${localBadge}${disabledBadge}`);
+    const missingBadge = isMissing ? source_default.red(" (missing)") : "";
+    const icon = disabled ? source_default.gray("\u25CB") : isMissing ? source_default.red("\u2717") : source_default.green("\u25C6");
+    console.log(`${icon} ${source_default.bold(name)}${version}${localBadge}${disabledBadge}${missingBadge}`);
     if (pkgJson?.description) {
       console.log(source_default.dim(`    ${pkgJson.description}`));
     }
@@ -3507,15 +4213,22 @@ async function listPlugins(options = {}) {
 }
 
 // src/commands/outdated.ts
+init_paths();
+init_source();
 async function showOutdated(options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const prefix = isGlobal ? PLUGINS_DIR : ".pi";
   console.log(source_default.blue("Checking for outdated plugins..."));
   try {
     const outdated = await npmOutdated(prefix);
     const pluginsJson = await loadPluginsJson(isGlobal);
     const managedOutdated = Object.entries(outdated).filter(([name]) => {
-      return pluginsJson.plugins[name] !== undefined;
+      const specifier = pluginsJson.plugins[name];
+      if (!specifier)
+        return false;
+      if (specifier.startsWith("file:"))
+        return false;
+      return true;
     });
     if (managedOutdated.length === 0) {
       console.log(source_default.green(`
@@ -3541,16 +4254,28 @@ Outdated plugins (${managedOutdated.length}):
       const latestColor = hasMajorUpdate ? source_default.red : wantedColor;
       console.log(`  ${source_default.white(name.padEnd(28))}` + `${source_default.dim(current.padEnd(15))}` + `${wantedColor(wanted.padEnd(15))}` + `${latestColor(latest)}`);
     }
+    const localPlugins = Object.entries(pluginsJson.plugins).filter(([_, spec]) => spec.startsWith("file:"));
+    if (localPlugins.length > 0) {
+      console.log(source_default.dim(`
+Note: ${localPlugins.length} local plugin(s) excluded from check`));
+    }
     console.log();
     console.log(source_default.dim("Update with: omp update [package]"));
     console.log(source_default.dim("  - 'wanted' = latest within semver range"));
     console.log(source_default.dim("  - 'latest' = latest available version"));
   } catch (err) {
     console.log(source_default.red(`Error checking outdated: ${err.message}`));
+    process.exitCode = 1;
   }
 }
 
 // src/commands/search.ts
+init_source();
+function truncate(str, maxLen) {
+  if (!str || str.length <= maxLen)
+    return str;
+  return `${str.slice(0, maxLen - 3)}...`;
+}
 async function searchPlugins(query, options = {}) {
   console.log(source_default.blue(`Searching npm for "${query}" with omp-plugin keyword...`));
   try {
@@ -3560,6 +4285,7 @@ async function searchPlugins(query, options = {}) {
 No plugins found.`));
       console.log(source_default.dim("Try a different search term, or search without keyword:"));
       console.log(source_default.dim("  npm search omp-plugin"));
+      process.exitCode = 1;
       return;
     }
     const limit = options.limit || 20;
@@ -3574,7 +4300,7 @@ Found ${results.length} plugin(s):
     for (const result of displayResults) {
       console.log(source_default.green("\u25C6 ") + source_default.bold(result.name) + source_default.dim(` v${result.version}`));
       if (result.description) {
-        console.log(source_default.dim(`    ${result.description}`));
+        console.log(source_default.dim(`    ${truncate(result.description, 100)}`));
       }
       if (result.keywords?.length) {
         const otherKeywords = result.keywords.filter((k) => k !== "omp-plugin");
@@ -3589,34 +4315,89 @@ Found ${results.length} plugin(s):
     }
     console.log(source_default.dim("Install with: omp install <package-name>"));
   } catch (err) {
-    console.log(source_default.red(`Error searching: ${err.message}`));
+    const error = err;
+    if (error.message.includes("ENOTFOUND") || error.message.includes("ETIMEDOUT") || error.message.includes("EAI_AGAIN")) {
+      console.log(source_default.red(`
+Network error: Unable to reach npm registry.`));
+      console.log(source_default.dim("  Check your internet connection and try again."));
+    } else {
+      console.log(source_default.red(`
+Search failed: ${error.message}`));
+    }
+    process.exitCode = 1;
   }
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { rm as rm4 } from "fs/promises";
 import { join as join7 } from "path";
+import { createInterface as createInterface3 } from "readline";
+init_paths();
+init_source();
 async function uninstallPlugin(name, options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const prefix = isGlobal ? PLUGINS_DIR : ".pi";
   const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
   const pluginsJson = await loadPluginsJson(isGlobal);
   if (!pluginsJson.plugins[name]) {
     console.log(source_default.yellow(`Plugin "${name}" is not installed.`));
+    process.exitCode = 1;
     return;
   }
   try {
     console.log(source_default.blue(`Uninstalling ${name}...`));
     const pkgJson = await readPluginPackageJson(name, isGlobal);
+    if (pkgJson?.dependencies) {
+      const allPlugins = await getInstalledPlugins(isGlobal);
+      const sharedDeps = [];
+      for (const depName of Object.keys(pkgJson.dependencies)) {
+        for (const [otherName, otherPkgJson] of allPlugins) {
+          if (otherName !== name && otherPkgJson.dependencies?.[depName]) {
+            sharedDeps.push(`${depName} (also used by ${otherName})`);
+            break;
+          }
+        }
+      }
+      if (sharedDeps.length > 0) {
+        console.log(source_default.yellow(`
+\u26A0 Warning: This plugin shares dependencies with other plugins:`));
+        for (const dep of sharedDeps) {
+          console.log(source_default.dim(`  - ${dep}`));
+        }
+        console.log(source_default.dim("  These dependencies will remain installed."));
+      }
+    }
     if (pkgJson) {
-      await removePluginSymlinks(name, pkgJson);
+      const result = await removePluginSymlinks(name, pkgJson, isGlobal);
+      if (result.skippedNonSymlinks.length > 0) {
+        console.log(source_default.yellow(`
+The following files are not symlinks and were not removed:`));
+        for (const file of result.skippedNonSymlinks) {
+          console.log(source_default.dim(`  - ${file}`));
+        }
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+          const rl = createInterface3({ input: process.stdin, output: process.stdout });
+          const answer = await new Promise((resolve5) => {
+            rl.question(source_default.yellow("Delete these files anyway? [y/N] "), (ans) => {
+              rl.close();
+              resolve5(ans);
+            });
+          });
+          if (answer.toLowerCase() === "y") {
+            for (const file of result.skippedNonSymlinks) {
+              await rm4(file, { force: true, recursive: true });
+              console.log(source_default.dim(`  Deleted: ${file}`));
+            }
+          }
+        }
+      }
     }
     try {
       await npmUninstall([name], prefix);
     } catch (_err) {
       const pluginDir = join7(nodeModules, name);
-      if (existsSync8(pluginDir)) {
+      if (existsSync10(pluginDir)) {
         await rm4(pluginDir, { recursive: true, force: true });
       }
     }
@@ -3631,6 +4412,7 @@ async function uninstallPlugin(name, options = {}) {
     }
   } catch (err) {
     console.log(source_default.red(`Error uninstalling plugin: ${err.message}`));
+    process.exitCode = 1;
     if (options.json) {
       console.log(JSON.stringify({ name, success: false, error: err.message }, null, 2));
     }
@@ -3638,18 +4420,24 @@ async function uninstallPlugin(name, options = {}) {
 }
 
 // src/commands/update.ts
+import { rm as rm5 } from "fs/promises";
+import { join as join8 } from "path";
+init_paths();
+init_source();
 async function updatePlugin(name, options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
   const prefix = isGlobal ? PLUGINS_DIR : ".pi";
   const _nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
   const pluginsJson = await loadPluginsJson(isGlobal);
   const pluginNames = Object.keys(pluginsJson.plugins);
   if (pluginNames.length === 0) {
     console.log(source_default.yellow("No plugins installed."));
+    process.exitCode = 1;
     return;
   }
   if (name && !pluginsJson.plugins[name]) {
     console.log(source_default.yellow(`Plugin "${name}" is not installed.`));
+    process.exitCode = 1;
     return;
   }
   const toUpdate = name ? [name] : pluginNames;
@@ -3666,25 +4454,45 @@ async function updatePlugin(name, options = {}) {
   }
   if (npmPlugins.length === 0) {
     console.log(source_default.yellow("No npm plugins to update."));
+    process.exitCode = 1;
     return;
   }
   console.log(source_default.blue(`Updating ${npmPlugins.length} plugin(s)...`));
   const results = [];
+  const oldPkgJsons = new Map;
+  const beforeVersions = {};
+  const oldInstallEntries = new Map;
   try {
-    const beforeVersions = {};
     for (const pluginName of npmPlugins) {
       const pkgJson = await readPluginPackageJson(pluginName, isGlobal);
       if (pkgJson) {
+        oldPkgJsons.set(pluginName, pkgJson);
         beforeVersions[pluginName] = pkgJson.version;
-        await removePluginSymlinks(pluginName, pkgJson, false);
+        if (pkgJson.omp?.install) {
+          oldInstallEntries.set(pluginName, [...pkgJson.omp.install]);
+        }
+        await removePluginSymlinks(pluginName, pkgJson, isGlobal);
       }
     }
     await npmUpdate(npmPlugins, prefix);
+    const baseDir = isGlobal ? PI_CONFIG_DIR : PROJECT_PI_DIR;
     for (const pluginName of npmPlugins) {
       const pkgJson = await readPluginPackageJson(pluginName, isGlobal);
       if (pkgJson) {
         const beforeVersion = beforeVersions[pluginName] || "unknown";
         const afterVersion = pkgJson.version;
+        const oldEntries = oldInstallEntries.get(pluginName) || [];
+        const newEntries = pkgJson.omp?.install || [];
+        const newDests = new Set(newEntries.map((e) => e.dest));
+        for (const oldEntry of oldEntries) {
+          if (!newDests.has(oldEntry.dest)) {
+            const dest = join8(baseDir, oldEntry.dest);
+            try {
+              await rm5(dest, { force: true });
+              console.log(source_default.dim(`  Removed orphaned: ${oldEntry.dest}`));
+            } catch {}
+          }
+        }
         await createPluginSymlinks(pluginName, pkgJson, isGlobal);
         const changed = beforeVersion !== afterVersion;
         if (changed) {
@@ -3707,32 +4515,56 @@ async function updatePlugin(name, options = {}) {
       console.log(JSON.stringify({ results }, null, 2));
     }
   } catch (err) {
+    if (oldPkgJsons.size > 0) {
+      console.log(source_default.yellow("  Update failed, restoring symlinks..."));
+      for (const [pluginName, pkgJson] of oldPkgJsons) {
+        try {
+          await createPluginSymlinks(pluginName, pkgJson, isGlobal);
+        } catch (restoreErr) {
+          console.log(source_default.red(`  Failed to restore symlinks for ${pluginName}: ${restoreErr.message}`));
+        }
+      }
+    }
     console.log(source_default.red(`Error updating plugins: ${err.message}`));
+    process.exitCode = 1;
   }
 }
 
 // src/commands/why.ts
-import { existsSync as existsSync9, lstatSync as lstatSync2 } from "fs";
+import { existsSync as existsSync11, lstatSync as lstatSync2 } from "fs";
 import { readlink as readlink2 } from "fs/promises";
-import { join as join8, relative } from "path";
+import { join as join9, relative, resolve as resolve5 } from "path";
+init_paths();
+init_source();
 async function whyFile(filePath, options = {}) {
-  const isGlobal = options.global !== false;
+  const isGlobal = resolveScope(options);
+  const baseDir = isGlobal ? PI_CONFIG_DIR : resolve5(PROJECT_PI_DIR);
   let relativePath = filePath;
-  if (filePath.startsWith(PI_CONFIG_DIR)) {
-    relativePath = relative(PI_CONFIG_DIR, filePath);
-  } else if (filePath.startsWith("~/.pi/")) {
-    relativePath = filePath.slice(6);
+  if (isGlobal) {
+    if (filePath.startsWith(PI_CONFIG_DIR)) {
+      relativePath = relative(PI_CONFIG_DIR, filePath);
+    } else if (filePath.startsWith("~/.pi/")) {
+      relativePath = filePath.slice(6);
+    }
+  } else {
+    const resolvedProjectDir = resolve5(PROJECT_PI_DIR);
+    if (filePath.startsWith(resolvedProjectDir)) {
+      relativePath = relative(resolvedProjectDir, filePath);
+    } else if (filePath.startsWith(".pi/")) {
+      relativePath = filePath.slice(4);
+    }
   }
   if (!relativePath.startsWith("agent/")) {
     const withAgent = `agent/${relativePath}`;
-    const fullWithAgent = join8(PI_CONFIG_DIR, withAgent);
-    if (existsSync9(fullWithAgent)) {
+    const fullWithAgent = join9(baseDir, withAgent);
+    if (existsSync11(fullWithAgent)) {
       relativePath = withAgent;
     }
   }
-  const fullPath = join8(PI_CONFIG_DIR, relativePath);
-  if (!existsSync9(fullPath)) {
+  const fullPath = join9(baseDir, relativePath);
+  if (!existsSync11(fullPath)) {
     console.log(source_default.yellow(`File not found: ${fullPath}`));
+    process.exitCode = 1;
     return;
   }
   const stats = lstatSync2(fullPath);
@@ -3742,7 +4574,7 @@ async function whyFile(filePath, options = {}) {
     target = await readlink2(fullPath);
   }
   const installedPlugins = await getInstalledPlugins(isGlobal);
-  const result = await traceInstalledFile(relativePath, installedPlugins);
+  const result = await traceInstalledFile(relativePath, installedPlugins, isGlobal);
   if (options.json) {
     console.log(JSON.stringify({
       path: relativePath,
@@ -3763,9 +4595,23 @@ async function whyFile(filePath, options = {}) {
     console.log();
   }
   if (result) {
-    console.log(source_default.green(`\u2713 Installed by: ${result.plugin}`));
-    console.log(source_default.dim(`  Source: ${result.entry.src}`));
-    console.log(source_default.dim(`  Dest: ${result.entry.dest}`));
+    if (!isSymlink) {
+      console.log(source_default.yellow("\u26A0 This file exists but is not a symlink"));
+      console.log(source_default.dim("  It may have been manually created or the symlink was replaced."));
+      console.log(source_default.dim(`  Expected to be installed by: ${result.plugin}`));
+    } else {
+      const expectedSrc = join9(getPluginSourceDir(result.plugin, isGlobal), result.entry.src);
+      if (target !== expectedSrc) {
+        console.log(source_default.yellow("\u26A0 Symlink target does not match expected source"));
+        console.log(source_default.dim(`  Expected: ${expectedSrc}`));
+        console.log(source_default.dim(`  Actual: ${target}`));
+        console.log(source_default.dim(`  Expected to be installed by: ${result.plugin}`));
+      } else {
+        console.log(source_default.green(`\u2713 Installed by: ${result.plugin}`));
+        console.log(source_default.dim(`  Source: ${result.entry.src}`));
+        console.log(source_default.dim(`  Dest: ${result.entry.dest}`));
+      }
+    }
     const pkgJson = await readPluginPackageJson(result.plugin, isGlobal);
     if (pkgJson) {
       console.log();
@@ -3780,20 +4626,39 @@ async function whyFile(filePath, options = {}) {
   }
 }
 
+// src/errors.ts
+init_source();
+function withErrorHandling(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      const error = err;
+      console.log(source_default.red(`Error: ${error.message}`));
+      if (process.env.DEBUG) {
+        console.log(source_default.dim(error.stack));
+      }
+      process.exitCode = 1;
+    }
+  };
+}
+
 // src/migrate.ts
-import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir7, readFile as readFile4, rename, rm as rm5, symlink as symlink3, writeFile as writeFile4 } from "fs/promises";
-import { basename as basename3, join as join9 } from "path";
-import { createInterface as createInterface2 } from "readline";
+import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir7, readFile as readFile5, rename, rm as rm6, symlink as symlink3, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename3, join as join10 } from "path";
+import { createInterface as createInterface4 } from "readline";
+init_paths();
+init_source();
 async function promptMigration() {
-  const rl = createInterface2({
+  const rl = createInterface4({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve3) => {
+  return new Promise((resolve6) => {
     rl.question(source_default.yellow("Migrate to npm-native format? [y/N] "), (answer) => {
       rl.close();
-      resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve6(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -3838,7 +4703,7 @@ Migrating to npm-native format...`));
         } else if (info.type === "local" && info.path) {
           newPluginsJson.plugins[name] = `file:${info.path}`;
         } else if (info.type === "github" && info.repo) {
-          newPluginsJson.plugins[name] = `file:${join9(NODE_MODULES_DIR, name)}`;
+          newPluginsJson.plugins[name] = `file:${join10(NODE_MODULES_DIR, name)}`;
         }
         migrated.push(name);
       } catch (err) {
@@ -3848,6 +4713,13 @@ Migrating to npm-native format...`));
     }
     await savePluginsJson(newPluginsJson, true);
     await archiveLegacyManifest();
+    console.log(source_default.dim("  Creating symlinks..."));
+    for (const [name] of Object.entries(newPluginsJson.plugins)) {
+      const pkgJson = await readPluginPackageJson(name, true);
+      if (pkgJson?.omp?.install?.length) {
+        await createPluginSymlinks(name, pkgJson, true);
+      }
+    }
     console.log();
     console.log(source_default.green(`\u2713 Migrated ${migrated.length} plugin(s)`));
     if (failed.length > 0) {
@@ -3860,28 +4732,28 @@ Migrating to npm-native format...`));
   }
 }
 async function migratePlugin(name, info) {
-  const oldPluginDir = join9(PLUGINS_DIR, name);
-  const newPluginDir = join9(NODE_MODULES_DIR, name);
-  if (!existsSync10(oldPluginDir)) {
+  const oldPluginDir = join10(PLUGINS_DIR, name);
+  const newPluginDir = join10(NODE_MODULES_DIR, name);
+  if (!existsSync12(oldPluginDir)) {
     throw new Error(`Plugin directory not found: ${oldPluginDir}`);
   }
   if (info.linked && info.path) {
     await mkdir7(NODE_MODULES_DIR, { recursive: true });
-    if (existsSync10(newPluginDir)) {
-      await rm5(newPluginDir, { force: true, recursive: true });
+    if (existsSync12(newPluginDir)) {
+      await rm6(newPluginDir, { force: true, recursive: true });
     }
     await symlink3(info.path, newPluginDir);
-    await rm5(oldPluginDir, { force: true });
+    await rm6(oldPluginDir, { force: true });
     return;
   }
-  if (existsSync10(newPluginDir)) {
-    await rm5(newPluginDir, { force: true, recursive: true });
+  if (existsSync12(newPluginDir)) {
+    await rm6(newPluginDir, { force: true, recursive: true });
   }
   await rename(oldPluginDir, newPluginDir);
-  const pkgJsonPath = join9(newPluginDir, "package.json");
-  const ompJsonPath = join9(newPluginDir, "omp.json");
-  if (!existsSync10(pkgJsonPath) && existsSync10(ompJsonPath)) {
-    const ompJson = JSON.parse(await readFile4(ompJsonPath, "utf-8"));
+  const pkgJsonPath = join10(newPluginDir, "package.json");
+  const ompJsonPath = join10(newPluginDir, "omp.json");
+  if (!existsSync12(pkgJsonPath) && existsSync12(ompJsonPath)) {
+    const ompJson = JSON.parse(await readFile5(ompJsonPath, "utf-8"));
     const pkgJson = {
       name: ompJson.name || name,
       version: ompJson.version || info.version || "0.0.0",
@@ -3891,20 +4763,44 @@ async function migratePlugin(name, info) {
         install: ompJson.install
       }
     };
-    await writeFile4(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+    await writeFile6(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
   }
 }
 async function archiveLegacyManifest() {
-  if (!existsSync10(LEGACY_MANIFEST_PATH)) {
+  if (!existsSync12(LEGACY_MANIFEST_PATH)) {
     return;
   }
-  const archivePath = join9(PLUGINS_DIR, `manifest.json.bak.${Date.now()}`);
+  const archivePath = join10(PLUGINS_DIR, `manifest.json.bak.${Date.now()}`);
   await rename(LEGACY_MANIFEST_PATH, archivePath);
   console.log(source_default.dim(`  Archived old manifest to ${basename3(archivePath)}`));
 }
 
 // src/cli.ts
-program.name("omp").description("Oh My Pi - Plugin manager for pi configuration").version("0.1.0");
+init_source();
+
+// node_modules/commander/esm.mjs
+var import__ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import__.default;
+
+// src/cli.ts
+var npmCheck = checkNpmAvailable();
+if (!npmCheck.available) {
+  console.log(source_default.red(npmCheck.error));
+  process.exit(1);
+}
+program.name("omp").description("Oh My Pi - Plugin manager for pi configuration").version("0.2.0");
 program.hook("preAction", async (thisCommand) => {
   const migratingCommands = ["install", "uninstall", "update", "list", "link"];
   if (migratingCommands.includes(thisCommand.name())) {
@@ -3918,24 +4814,24 @@ Examples:
   $ omp install @myorg/cool-theme           # Scoped package
   $ omp install ./local/path            # Local directory (copies)
   $ omp install                         # Install all from plugins.json
-`).option("-g, --global", "Install globally to ~/.pi (default)").option("-S, --save", "Add to plugins.json").option("-D, --save-dev", "Add as dev dependency").option("--force", "Overwrite conflicts without prompting").option("--json", "Output as JSON").action(installPlugin);
-program.command("uninstall <name>").alias("rm").description("Remove plugin and its symlinks").option("-g, --global", "Uninstall from ~/.pi (default)").option("--json", "Output as JSON").action(uninstallPlugin);
-program.command("update [name]").alias("up").description("Update to latest within semver range").option("-g, --global", "Update global plugins (default)").option("--json", "Output as JSON").action(updatePlugin);
-program.command("list").alias("ls").description("Show installed plugins").option("-g, --global", "List global plugins (default)").option("--json", "Output as JSON").action(listPlugins);
+`).option("-g, --global", "Install globally to ~/.pi").option("-l, --local", "Install to project-local .pi/").option("-S, --save", "Add to plugins.json").option("-D, --save-dev", "Add as dev dependency").option("--force", "Overwrite conflicts without prompting").option("--json", "Output as JSON").action(withErrorHandling(installPlugin));
+program.command("uninstall <name>").alias("rm").description("Remove plugin and its symlinks").option("-g, --global", "Uninstall from ~/.pi").option("-l, --local", "Uninstall from project-local .pi/").option("--json", "Output as JSON").action(withErrorHandling(uninstallPlugin));
+program.command("update [name]").alias("up").description("Update to latest within semver range").option("-g, --global", "Update global plugins").option("-l, --local", "Update project-local plugins").option("--json", "Output as JSON").action(withErrorHandling(updatePlugin));
+program.command("list").alias("ls").description("Show installed plugins").option("-g, --global", "List global plugins").option("-l, --local", "List project-local plugins").option("--json", "Output as JSON").action(withErrorHandling(listPlugins));
 program.command("link <path>").description("Symlink local plugin (dev mode)").addHelpText("after", `
 Unlike install, link creates a symlink to the original directory,
 so changes are reflected immediately without reinstalling.
-`).option("-n, --name <name>", "Custom name for the plugin").option("-g, --global", "Link globally (default)").action(linkPlugin);
-program.command("init").description("Create .pi/plugins.json in current project").option("--force", "Overwrite existing plugins.json").action(initProject);
-program.command("search <query>").description("Search npm for omp-plugin keyword").option("--json", "Output as JSON").option("--limit <n>", "Maximum results to show", "20").action((query, options) => searchPlugins(query, { ...options, limit: parseInt(options.limit, 10) }));
-program.command("info <package>").description("Show plugin details before install").option("--json", "Output as JSON").option("--versions", "Show available versions").action(showInfo);
-program.command("outdated").description("List plugins with newer versions").option("-g, --global", "Check global plugins (default)").option("--json", "Output as JSON").action(showOutdated);
-program.command("doctor").description("Check for broken symlinks, conflicts").option("-g, --global", "Check global plugins (default)").option("--fix", "Attempt to fix issues").option("--json", "Output as JSON").action(runDoctor);
-program.command("create <name>").description("Scaffold new plugin from template").option("-d, --description <desc>", "Plugin description").option("-a, --author <author>", "Plugin author").action(createPlugin);
-program.command("why <file>").description("Show which plugin installed a file").option("-g, --global", "Check global plugins (default)").option("--json", "Output as JSON").action(whyFile);
-program.command("enable <name>").description("Enable a disabled plugin").option("-g, --global", "Target global plugins (default)").option("--json", "Output as JSON").action(enablePlugin);
-program.command("disable <name>").description("Disable plugin without uninstalling").option("-g, --global", "Target global plugins (default)").option("--json", "Output as JSON").action(disablePlugin);
-program.command("migrate").description("Migrate from legacy manifest.json to npm-native format").action(async () => {
+`).option("-n, --name <name>", "Custom name for the plugin").option("-g, --global", "Link globally").option("-l, --local", "Link to project-local .pi/").option("--force", "Overwrite existing npm-installed plugin").action(withErrorHandling(linkPlugin));
+program.command("init").description("Create .pi/plugins.json in current project").option("--force", "Overwrite existing plugins.json").action(withErrorHandling(initProject));
+program.command("search <query>").description("Search npm for omp-plugin keyword").option("--json", "Output as JSON").option("--limit <n>", "Maximum results to show", "20").action(withErrorHandling((query, options) => searchPlugins(query, { ...options, limit: parseInt(options.limit, 10) })));
+program.command("info <package>").description("Show plugin details before install").option("--json", "Output as JSON").option("--versions", "Show available versions").option("--all-versions", "Show all published versions").action(withErrorHandling(showInfo));
+program.command("outdated").description("List plugins with newer versions").option("-g, --global", "Check global plugins").option("-l, --local", "Check project-local plugins").option("--json", "Output as JSON").action(withErrorHandling(showOutdated));
+program.command("doctor").description("Check for broken symlinks, conflicts").option("-g, --global", "Check global plugins").option("-l, --local", "Check project-local plugins").option("--fix", "Attempt to fix issues").option("--json", "Output as JSON").action(withErrorHandling(runDoctor));
+program.command("create <name>").description("Scaffold new plugin from template").option("-d, --description <desc>", "Plugin description").option("-a, --author <author>", "Plugin author").action(withErrorHandling(createPlugin));
+program.command("why <file>").description("Show which plugin installed a file").option("-g, --global", "Check global plugins").option("-l, --local", "Check project-local plugins").option("--json", "Output as JSON").action(withErrorHandling(whyFile));
+program.command("enable <name>").description("Enable a disabled plugin").option("-g, --global", "Target global plugins").option("-l, --local", "Target project-local plugins").option("--json", "Output as JSON").action(withErrorHandling(enablePlugin));
+program.command("disable <name>").description("Disable plugin without uninstalling").option("-g, --global", "Target global plugins").option("-l, --local", "Target project-local plugins").option("--json", "Output as JSON").action(withErrorHandling(disablePlugin));
+program.command("migrate").description("Migrate from legacy manifest.json to npm-native format").action(withErrorHandling(async () => {
   await migrateToNpm();
-});
+}));
 program.parse();