@calebmabry/wami 0.1.2 → 0.2.0

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -16,6 +17,7 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/cli-spinners/spinners.json
 var require_spinners = __commonJS((exports, module) => {
@@ -1657,12 +1659,2001 @@ var require_cli_spinners = __commonJS((exports, module) => {
   module.exports = spinners;
 });
 
+// node_modules/@iarna/toml/lib/parser.js
+var require_parser = __commonJS((exports, module) => {
+  var ParserEND = 1114112;
+
+  class ParserError extends Error {
+    constructor(msg, filename, linenumber) {
+      super("[ParserError] " + msg, filename, linenumber);
+      this.name = "ParserError";
+      this.code = "ParserError";
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(this, ParserError);
+    }
+  }
+
+  class State {
+    constructor(parser) {
+      this.parser = parser;
+      this.buf = "";
+      this.returned = null;
+      this.result = null;
+      this.resultTable = null;
+      this.resultArr = null;
+    }
+  }
+
+  class Parser {
+    constructor() {
+      this.pos = 0;
+      this.col = 0;
+      this.line = 0;
+      this.obj = {};
+      this.ctx = this.obj;
+      this.stack = [];
+      this._buf = "";
+      this.char = null;
+      this.ii = 0;
+      this.state = new State(this.parseStart);
+    }
+    parse(str) {
+      if (str.length === 0 || str.length == null)
+        return;
+      this._buf = String(str);
+      this.ii = -1;
+      this.char = -1;
+      let getNext;
+      while (getNext === false || this.nextChar()) {
+        getNext = this.runOne();
+      }
+      this._buf = null;
+    }
+    nextChar() {
+      if (this.char === 10) {
+        ++this.line;
+        this.col = -1;
+      }
+      ++this.ii;
+      this.char = this._buf.codePointAt(this.ii);
+      ++this.pos;
+      ++this.col;
+      return this.haveBuffer();
+    }
+    haveBuffer() {
+      return this.ii < this._buf.length;
+    }
+    runOne() {
+      return this.state.parser.call(this, this.state.returned);
+    }
+    finish() {
+      this.char = ParserEND;
+      let last;
+      do {
+        last = this.state.parser;
+        this.runOne();
+      } while (this.state.parser !== last);
+      this.ctx = null;
+      this.state = null;
+      this._buf = null;
+      return this.obj;
+    }
+    next(fn) {
+      if (typeof fn !== "function")
+        throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn));
+      this.state.parser = fn;
+    }
+    goto(fn) {
+      this.next(fn);
+      return this.runOne();
+    }
+    call(fn, returnWith) {
+      if (returnWith)
+        this.next(returnWith);
+      this.stack.push(this.state);
+      this.state = new State(fn);
+    }
+    callNow(fn, returnWith) {
+      this.call(fn, returnWith);
+      return this.runOne();
+    }
+    return(value) {
+      if (this.stack.length === 0)
+        throw this.error(new ParserError("Stack underflow"));
+      if (value === undefined)
+        value = this.state.buf;
+      this.state = this.stack.pop();
+      this.state.returned = value;
+    }
+    returnNow(value) {
+      this.return(value);
+      return this.runOne();
+    }
+    consume() {
+      if (this.char === ParserEND)
+        throw this.error(new ParserError("Unexpected end-of-buffer"));
+      this.state.buf += this._buf[this.ii];
+    }
+    error(err) {
+      err.line = this.line;
+      err.col = this.col;
+      err.pos = this.pos;
+      return err;
+    }
+    parseStart() {
+      throw new ParserError("Must declare a parseStart method");
+    }
+  }
+  Parser.END = ParserEND;
+  Parser.Error = ParserError;
+  module.exports = Parser;
+});
+
+// node_modules/@iarna/toml/lib/create-datetime.js
+var require_create_datetime = __commonJS((exports, module) => {
+  module.exports = (value) => {
+    const date = new Date(value);
+    if (isNaN(date)) {
+      throw new TypeError("Invalid Datetime");
+    } else {
+      return date;
+    }
+  };
+});
+
+// node_modules/@iarna/toml/lib/format-num.js
+var require_format_num = __commonJS((exports, module) => {
+  module.exports = (d, num) => {
+    num = String(num);
+    while (num.length < d)
+      num = "0" + num;
+    return num;
+  };
+});
+
+// node_modules/@iarna/toml/lib/create-datetime-float.js
+var require_create_datetime_float = __commonJS((exports, module) => {
+  var f = require_format_num();
+
+  class FloatingDateTime extends Date {
+    constructor(value) {
+      super(value + "Z");
+      this.isFloating = true;
+    }
+    toISOString() {
+      const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+      const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+      return `${date}T${time}`;
+    }
+  }
+  module.exports = (value) => {
+    const date = new FloatingDateTime(value);
+    if (isNaN(date)) {
+      throw new TypeError("Invalid Datetime");
+    } else {
+      return date;
+    }
+  };
+});
+
+// node_modules/@iarna/toml/lib/create-date.js
+var require_create_date = __commonJS((exports, module) => {
+  var f = require_format_num();
+  var DateTime = global.Date;
+
+  class Date2 extends DateTime {
+    constructor(value) {
+      super(value);
+      this.isDate = true;
+    }
+    toISOString() {
+      return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+    }
+  }
+  module.exports = (value) => {
+    const date = new Date2(value);
+    if (isNaN(date)) {
+      throw new TypeError("Invalid Datetime");
+    } else {
+      return date;
+    }
+  };
+});
+
+// node_modules/@iarna/toml/lib/create-time.js
+var require_create_time = __commonJS((exports, module) => {
+  var f = require_format_num();
+
+  class Time extends Date {
+    constructor(value) {
+      super(`0000-01-01T${value}Z`);
+      this.isTime = true;
+    }
+    toISOString() {
+      return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+    }
+  }
+  module.exports = (value) => {
+    const date = new Time(value);
+    if (isNaN(date)) {
+      throw new TypeError("Invalid Datetime");
+    } else {
+      return date;
+    }
+  };
+});
+
+// node_modules/@iarna/toml/lib/toml-parser.js
+var require_toml_parser = __commonJS((exports, module) => {
+  module.exports = makeParserClass(require_parser());
+  module.exports.makeParserClass = makeParserClass;
+
+  class TomlError extends Error {
+    constructor(msg) {
+      super(msg);
+      this.name = "TomlError";
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(this, TomlError);
+      this.fromTOML = true;
+      this.wrapped = null;
+    }
+  }
+  TomlError.wrap = (err) => {
+    const terr = new TomlError(err.message);
+    terr.code = err.code;
+    terr.wrapped = err;
+    return terr;
+  };
+  module.exports.TomlError = TomlError;
+  var createDateTime = require_create_datetime();
+  var createDateTimeFloat = require_create_datetime_float();
+  var createDate = require_create_date();
+  var createTime = require_create_time();
+  var CTRL_I = 9;
+  var CTRL_J = 10;
+  var CTRL_M = 13;
+  var CTRL_CHAR_BOUNDARY = 31;
+  var CHAR_SP = 32;
+  var CHAR_QUOT = 34;
+  var CHAR_NUM = 35;
+  var CHAR_APOS = 39;
+  var CHAR_PLUS = 43;
+  var CHAR_COMMA = 44;
+  var CHAR_HYPHEN = 45;
+  var CHAR_PERIOD = 46;
+  var CHAR_0 = 48;
+  var CHAR_1 = 49;
+  var CHAR_7 = 55;
+  var CHAR_9 = 57;
+  var CHAR_COLON = 58;
+  var CHAR_EQUALS = 61;
+  var CHAR_A = 65;
+  var CHAR_E = 69;
+  var CHAR_F = 70;
+  var CHAR_T = 84;
+  var CHAR_U = 85;
+  var CHAR_Z = 90;
+  var CHAR_LOWBAR = 95;
+  var CHAR_a = 97;
+  var CHAR_b = 98;
+  var CHAR_e = 101;
+  var CHAR_f = 102;
+  var CHAR_i = 105;
+  var CHAR_l = 108;
+  var CHAR_n = 110;
+  var CHAR_o = 111;
+  var CHAR_r = 114;
+  var CHAR_s = 115;
+  var CHAR_t = 116;
+  var CHAR_u = 117;
+  var CHAR_x = 120;
+  var CHAR_z = 122;
+  var CHAR_LCUB = 123;
+  var CHAR_RCUB = 125;
+  var CHAR_LSQB = 91;
+  var CHAR_BSOL = 92;
+  var CHAR_RSQB = 93;
+  var CHAR_DEL = 127;
+  var SURROGATE_FIRST = 55296;
+  var SURROGATE_LAST = 57343;
+  var escapes = {
+    [CHAR_b]: "\b",
+    [CHAR_t]: "\t",
+    [CHAR_n]: `
+`,
+    [CHAR_f]: "\f",
+    [CHAR_r]: "\r",
+    [CHAR_QUOT]: '"',
+    [CHAR_BSOL]: "\\"
+  };
+  function isDigit(cp) {
+    return cp >= CHAR_0 && cp <= CHAR_9;
+  }
+  function isHexit(cp) {
+    return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
+  }
+  function isBit(cp) {
+    return cp === CHAR_1 || cp === CHAR_0;
+  }
+  function isOctit(cp) {
+    return cp >= CHAR_0 && cp <= CHAR_7;
+  }
+  function isAlphaNumQuoteHyphen(cp) {
+    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+  }
+  function isAlphaNumHyphen(cp) {
+    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+  }
+  var _type = Symbol("type");
+  var _declared = Symbol("declared");
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var defineProperty = Object.defineProperty;
+  var descriptor = { configurable: true, enumerable: true, writable: true, value: undefined };
+  function hasKey(obj, key) {
+    if (hasOwnProperty.call(obj, key))
+      return true;
+    if (key === "__proto__")
+      defineProperty(obj, "__proto__", descriptor);
+    return false;
+  }
+  var INLINE_TABLE = Symbol("inline-table");
+  function InlineTable() {
+    return Object.defineProperties({}, {
+      [_type]: { value: INLINE_TABLE }
+    });
+  }
+  function isInlineTable(obj) {
+    if (obj === null || typeof obj !== "object")
+      return false;
+    return obj[_type] === INLINE_TABLE;
+  }
+  var TABLE = Symbol("table");
+  function Table() {
+    return Object.defineProperties({}, {
+      [_type]: { value: TABLE },
+      [_declared]: { value: false, writable: true }
+    });
+  }
+  function isTable(obj) {
+    if (obj === null || typeof obj !== "object")
+      return false;
+    return obj[_type] === TABLE;
+  }
+  var _contentType = Symbol("content-type");
+  var INLINE_LIST = Symbol("inline-list");
+  function InlineList(type) {
+    return Object.defineProperties([], {
+      [_type]: { value: INLINE_LIST },
+      [_contentType]: { value: type }
+    });
+  }
+  function isInlineList(obj) {
+    if (obj === null || typeof obj !== "object")
+      return false;
+    return obj[_type] === INLINE_LIST;
+  }
+  var LIST = Symbol("list");
+  function List() {
+    return Object.defineProperties([], {
+      [_type]: { value: LIST }
+    });
+  }
+  function isList(obj) {
+    if (obj === null || typeof obj !== "object")
+      return false;
+    return obj[_type] === LIST;
+  }
+  var _custom;
+  try {
+    const utilInspect = eval("require('util').inspect");
+    _custom = utilInspect.custom;
+  } catch (_) {}
+  var _inspect = _custom || "inspect";
+
+  class BoxedBigInt {
+    constructor(value) {
+      try {
+        this.value = global.BigInt.asIntN(64, value);
+      } catch (_) {
+        this.value = null;
+      }
+      Object.defineProperty(this, _type, { value: INTEGER });
+    }
+    isNaN() {
+      return this.value === null;
+    }
+    toString() {
+      return String(this.value);
+    }
+    [_inspect]() {
+      return `[BigInt: ${this.toString()}]}`;
+    }
+    valueOf() {
+      return this.value;
+    }
+  }
+  var INTEGER = Symbol("integer");
+  function Integer(value) {
+    let num = Number(value);
+    if (Object.is(num, -0))
+      num = 0;
+    if (global.BigInt && !Number.isSafeInteger(num)) {
+      return new BoxedBigInt(value);
+    } else {
+      return Object.defineProperties(new Number(num), {
+        isNaN: { value: function() {
+          return isNaN(this);
+        } },
+        [_type]: { value: INTEGER },
+        [_inspect]: { value: () => `[Integer: ${value}]` }
+      });
+    }
+  }
+  function isInteger(obj) {
+    if (obj === null || typeof obj !== "object")
+      return false;
+    return obj[_type] === INTEGER;
+  }
+  var FLOAT = Symbol("float");
+  function Float(value) {
+    return Object.defineProperties(new Number(value), {
+      [_type]: { value: FLOAT },
+      [_inspect]: { value: () => `[Float: ${value}]` }
+    });
+  }
+  function isFloat(obj) {
+    if (obj === null || typeof obj !== "object")
+      return false;
+    return obj[_type] === FLOAT;
+  }
+  function tomlType(value) {
+    const type = typeof value;
+    if (type === "object") {
+      if (value === null)
+        return "null";
+      if (value instanceof Date)
+        return "datetime";
+      if (_type in value) {
+        switch (value[_type]) {
+          case INLINE_TABLE:
+            return "inline-table";
+          case INLINE_LIST:
+            return "inline-list";
+          case TABLE:
+            return "table";
+          case LIST:
+            return "list";
+          case FLOAT:
+            return "float";
+          case INTEGER:
+            return "integer";
+        }
+      }
+    }
+    return type;
+  }
+  function makeParserClass(Parser) {
+
+    class TOMLParser extends Parser {
+      constructor() {
+        super();
+        this.ctx = this.obj = Table();
+      }
+      atEndOfWord() {
+        return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
+      }
+      atEndOfLine() {
+        return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
+      }
+      parseStart() {
+        if (this.char === Parser.END) {
+          return null;
+        } else if (this.char === CHAR_LSQB) {
+          return this.call(this.parseTableOrList);
+        } else if (this.char === CHAR_NUM) {
+          return this.call(this.parseComment);
+        } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+          return null;
+        } else if (isAlphaNumQuoteHyphen(this.char)) {
+          return this.callNow(this.parseAssignStatement);
+        } else {
+          throw this.error(new TomlError(`Unknown character "${this.char}"`));
+        }
+      }
+      parseWhitespaceToEOL() {
+        if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+          return null;
+        } else if (this.char === CHAR_NUM) {
+          return this.goto(this.parseComment);
+        } else if (this.char === Parser.END || this.char === CTRL_J) {
+          return this.return();
+        } else {
+          throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
+        }
+      }
+      parseAssignStatement() {
+        return this.callNow(this.parseAssign, this.recordAssignStatement);
+      }
+      recordAssignStatement(kv) {
+        let target = this.ctx;
+        let finalKey = kv.key.pop();
+        for (let kw of kv.key) {
+          if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          target = target[kw] = target[kw] || Table();
+        }
+        if (hasKey(target, finalKey)) {
+          throw this.error(new TomlError("Can't redefine existing key"));
+        }
+        if (isInteger(kv.value) || isFloat(kv.value)) {
+          target[finalKey] = kv.value.valueOf();
+        } else {
+          target[finalKey] = kv.value;
+        }
+        return this.goto(this.parseWhitespaceToEOL);
+      }
+      parseAssign() {
+        return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+      }
+      recordAssignKeyword(key) {
+        if (this.state.resultTable) {
+          this.state.resultTable.push(key);
+        } else {
+          this.state.resultTable = [key];
+        }
+        return this.goto(this.parseAssignKeywordPreDot);
+      }
+      parseAssignKeywordPreDot() {
+        if (this.char === CHAR_PERIOD) {
+          return this.next(this.parseAssignKeywordPostDot);
+        } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+          return this.goto(this.parseAssignEqual);
+        }
+      }
+      parseAssignKeywordPostDot() {
+        if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+        }
+      }
+      parseAssignEqual() {
+        if (this.char === CHAR_EQUALS) {
+          return this.next(this.parseAssignPreValue);
+        } else {
+          throw this.error(new TomlError('Invalid character, expected "="'));
+        }
+      }
+      parseAssignPreValue() {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else {
+          return this.callNow(this.parseValue, this.recordAssignValue);
+        }
+      }
+      recordAssignValue(value) {
+        return this.returnNow({ key: this.state.resultTable, value });
+      }
+      parseComment() {
+        do {
+          if (this.char === Parser.END || this.char === CTRL_J) {
+            return this.return();
+          }
+        } while (this.nextChar());
+      }
+      parseTableOrList() {
+        if (this.char === CHAR_LSQB) {
+          this.next(this.parseList);
+        } else {
+          return this.goto(this.parseTable);
+        }
+      }
+      parseTable() {
+        this.ctx = this.obj;
+        return this.goto(this.parseTableNext);
+      }
+      parseTableNext() {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else {
+          return this.callNow(this.parseKeyword, this.parseTableMore);
+        }
+      }
+      parseTableMore(keyword) {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else if (this.char === CHAR_RSQB) {
+          if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          } else {
+            this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
+            this.ctx[_declared] = true;
+          }
+          return this.next(this.parseWhitespaceToEOL);
+        } else if (this.char === CHAR_PERIOD) {
+          if (!hasKey(this.ctx, keyword)) {
+            this.ctx = this.ctx[keyword] = Table();
+          } else if (isTable(this.ctx[keyword])) {
+            this.ctx = this.ctx[keyword];
+          } else if (isList(this.ctx[keyword])) {
+            this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+          } else {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          return this.next(this.parseTableNext);
+        } else {
+          throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+        }
+      }
+      parseList() {
+        this.ctx = this.obj;
+        return this.goto(this.parseListNext);
+      }
+      parseListNext() {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else {
+          return this.callNow(this.parseKeyword, this.parseListMore);
+        }
+      }
+      parseListMore(keyword) {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else if (this.char === CHAR_RSQB) {
+          if (!hasKey(this.ctx, keyword)) {
+            this.ctx[keyword] = List();
+          }
+          if (isInlineList(this.ctx[keyword])) {
+            throw this.error(new TomlError("Can't extend an inline array"));
+          } else if (isList(this.ctx[keyword])) {
+            const next = Table();
+            this.ctx[keyword].push(next);
+            this.ctx = next;
+          } else {
+            throw this.error(new TomlError("Can't redefine an existing key"));
+          }
+          return this.next(this.parseListEnd);
+        } else if (this.char === CHAR_PERIOD) {
+          if (!hasKey(this.ctx, keyword)) {
+            this.ctx = this.ctx[keyword] = Table();
+          } else if (isInlineList(this.ctx[keyword])) {
+            throw this.error(new TomlError("Can't extend an inline array"));
+          } else if (isInlineTable(this.ctx[keyword])) {
+            throw this.error(new TomlError("Can't extend an inline table"));
+          } else if (isList(this.ctx[keyword])) {
+            this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+          } else if (isTable(this.ctx[keyword])) {
+            this.ctx = this.ctx[keyword];
+          } else {
+            throw this.error(new TomlError("Can't redefine an existing key"));
+          }
+          return this.next(this.parseListNext);
+        } else {
+          throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+        }
+      }
+      parseListEnd(keyword) {
+        if (this.char === CHAR_RSQB) {
+          return this.next(this.parseWhitespaceToEOL);
+        } else {
+          throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+        }
+      }
+      parseValue() {
+        if (this.char === Parser.END) {
+          throw this.error(new TomlError("Key without value"));
+        } else if (this.char === CHAR_QUOT) {
+          return this.next(this.parseDoubleString);
+        }
+        if (this.char === CHAR_APOS) {
+          return this.next(this.parseSingleString);
+        } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+          return this.goto(this.parseNumberSign);
+        } else if (this.char === CHAR_i) {
+          return this.next(this.parseInf);
+        } else if (this.char === CHAR_n) {
+          return this.next(this.parseNan);
+        } else if (isDigit(this.char)) {
+          return this.goto(this.parseNumberOrDateTime);
+        } else if (this.char === CHAR_t || this.char === CHAR_f) {
+          return this.goto(this.parseBoolean);
+        } else if (this.char === CHAR_LSQB) {
+          return this.call(this.parseInlineList, this.recordValue);
+        } else if (this.char === CHAR_LCUB) {
+          return this.call(this.parseInlineTable, this.recordValue);
+        } else {
+          throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
+        }
+      }
+      recordValue(value) {
+        return this.returnNow(value);
+      }
+      parseInf() {
+        if (this.char === CHAR_n) {
+          return this.next(this.parseInf2);
+        } else {
+          throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+        }
+      }
+      parseInf2() {
+        if (this.char === CHAR_f) {
+          if (this.state.buf === "-") {
+            return this.return(-Infinity);
+          } else {
+            return this.return(Infinity);
+          }
+        } else {
+          throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+        }
+      }
+      parseNan() {
+        if (this.char === CHAR_a) {
+          return this.next(this.parseNan2);
+        } else {
+          throw this.error(new TomlError('Unexpected character, expected "nan"'));
+        }
+      }
+      parseNan2() {
+        if (this.char === CHAR_n) {
+          return this.return(NaN);
+        } else {
+          throw this.error(new TomlError('Unexpected character, expected "nan"'));
+        }
+      }
+      parseKeyword() {
+        if (this.char === CHAR_QUOT) {
+          return this.next(this.parseBasicString);
+        } else if (this.char === CHAR_APOS) {
+          return this.next(this.parseLiteralString);
+        } else {
+          return this.goto(this.parseBareKey);
+        }
+      }
+      parseBareKey() {
+        do {
+          if (this.char === Parser.END) {
+            throw this.error(new TomlError("Key ended without value"));
+          } else if (isAlphaNumHyphen(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 0) {
+            throw this.error(new TomlError("Empty bare keys are not allowed"));
+          } else {
+            return this.returnNow();
+          }
+        } while (this.nextChar());
+      }
+      parseSingleString() {
+        if (this.char === CHAR_APOS) {
+          return this.next(this.parseLiteralMultiStringMaybe);
+        } else {
+          return this.goto(this.parseLiteralString);
+        }
+      }
+      parseLiteralString() {
+        do {
+          if (this.char === CHAR_APOS) {
+            return this.return();
+          } else if (this.atEndOfLine()) {
+            throw this.error(new TomlError("Unterminated string"));
+          } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+            throw this.errorControlCharInString();
+          } else {
+            this.consume();
+          }
+        } while (this.nextChar());
+      }
+      parseLiteralMultiStringMaybe() {
+        if (this.char === CHAR_APOS) {
+          return this.next(this.parseLiteralMultiString);
+        } else {
+          return this.returnNow();
+        }
+      }
+      parseLiteralMultiString() {
+        if (this.char === CTRL_M) {
+          return null;
+        } else if (this.char === CTRL_J) {
+          return this.next(this.parseLiteralMultiStringContent);
+        } else {
+          return this.goto(this.parseLiteralMultiStringContent);
+        }
+      }
+      parseLiteralMultiStringContent() {
+        do {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiEnd);
+          } else if (this.char === Parser.END) {
+            throw this.error(new TomlError("Unterminated multi-line string"));
+          } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+            throw this.errorControlCharInString();
+          } else {
+            this.consume();
+          }
+        } while (this.nextChar());
+      }
+      parseLiteralMultiEnd() {
+        if (this.char === CHAR_APOS) {
+          return this.next(this.parseLiteralMultiEnd2);
+        } else {
+          this.state.buf += "'";
+          return this.goto(this.parseLiteralMultiStringContent);
+        }
+      }
+      parseLiteralMultiEnd2() {
+        if (this.char === CHAR_APOS) {
+          return this.return();
+        } else {
+          this.state.buf += "''";
+          return this.goto(this.parseLiteralMultiStringContent);
+        }
+      }
+      parseDoubleString() {
+        if (this.char === CHAR_QUOT) {
+          return this.next(this.parseMultiStringMaybe);
+        } else {
+          return this.goto(this.parseBasicString);
+        }
+      }
+      parseBasicString() {
+        do {
+          if (this.char === CHAR_BSOL) {
+            return this.call(this.parseEscape, this.recordEscapeReplacement);
+          } else if (this.char === CHAR_QUOT) {
+            return this.return();
+          } else if (this.atEndOfLine()) {
+            throw this.error(new TomlError("Unterminated string"));
+          } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+            throw this.errorControlCharInString();
+          } else {
+            this.consume();
+          }
+        } while (this.nextChar());
+      }
+      recordEscapeReplacement(replacement) {
+        this.state.buf += replacement;
+        return this.goto(this.parseBasicString);
+      }
+      parseMultiStringMaybe() {
+        if (this.char === CHAR_QUOT) {
+          return this.next(this.parseMultiString);
+        } else {
+          return this.returnNow();
+        }
+      }
+      parseMultiString() {
+        if (this.char === CTRL_M) {
+          return null;
+        } else if (this.char === CTRL_J) {
+          return this.next(this.parseMultiStringContent);
+        } else {
+          return this.goto(this.parseMultiStringContent);
+        }
+      }
+      parseMultiStringContent() {
+        do {
+          if (this.char === CHAR_BSOL) {
+            return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
+          } else if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiEnd);
+          } else if (this.char === Parser.END) {
+            throw this.error(new TomlError("Unterminated multi-line string"));
+          } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+            throw this.errorControlCharInString();
+          } else {
+            this.consume();
+          }
+        } while (this.nextChar());
+      }
+      errorControlCharInString() {
+        let displayCode = "\\u00";
+        if (this.char < 16) {
+          displayCode += "0";
+        }
+        displayCode += this.char.toString(16);
+        return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
+      }
+      recordMultiEscapeReplacement(replacement) {
+        this.state.buf += replacement;
+        return this.goto(this.parseMultiStringContent);
+      }
+      parseMultiEnd() {
+        if (this.char === CHAR_QUOT) {
+          return this.next(this.parseMultiEnd2);
+        } else {
+          this.state.buf += '"';
+          return this.goto(this.parseMultiStringContent);
+        }
+      }
+      parseMultiEnd2() {
+        if (this.char === CHAR_QUOT) {
+          return this.return();
+        } else {
+          this.state.buf += '""';
+          return this.goto(this.parseMultiStringContent);
+        }
+      }
+      parseMultiEscape() {
+        if (this.char === CTRL_M || this.char === CTRL_J) {
+          return this.next(this.parseMultiTrim);
+        } else if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return this.next(this.parsePreMultiTrim);
+        } else {
+          return this.goto(this.parseEscape);
+        }
+      }
+      parsePreMultiTrim() {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else if (this.char === CTRL_M || this.char === CTRL_J) {
+          return this.next(this.parseMultiTrim);
+        } else {
+          throw this.error(new TomlError("Can't escape whitespace"));
+        }
+      }
+      parseMultiTrim() {
+        if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+          return null;
+        } else {
+          return this.returnNow();
+        }
+      }
+      parseEscape() {
+        if (this.char in escapes) {
+          return this.return(escapes[this.char]);
+        } else if (this.char === CHAR_u) {
+          return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
+        } else if (this.char === CHAR_U) {
+          return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
+        } else {
+          throw this.error(new TomlError("Unknown escape character: " + this.char));
+        }
+      }
+      parseUnicodeReturn(char) {
+        try {
+          const codePoint = parseInt(char, 16);
+          if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
+            throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+          }
+          return this.returnNow(String.fromCodePoint(codePoint));
+        } catch (err) {
+          throw this.error(TomlError.wrap(err));
+        }
+      }
+      parseSmallUnicode() {
+        if (!isHexit(this.char)) {
+          throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+        } else {
+          this.consume();
+          if (this.state.buf.length >= 4)
+            return this.return();
+        }
+      }
+      parseLargeUnicode() {
+        if (!isHexit(this.char)) {
+          throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+        } else {
+          this.consume();
+          if (this.state.buf.length >= 8)
+            return this.return();
+        }
+      }
+      parseNumberSign() {
+        this.consume();
+        return this.next(this.parseMaybeSignedInfOrNan);
+      }
+      parseMaybeSignedInfOrNan() {
+        if (this.char === CHAR_i) {
+          return this.next(this.parseInf);
+        } else if (this.char === CHAR_n) {
+          return this.next(this.parseNan);
+        } else {
+          return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
+        }
+      }
+      parseNumberIntegerStart() {
+        if (this.char === CHAR_0) {
+          this.consume();
+          return this.next(this.parseNumberIntegerExponentOrDecimal);
+        } else {
+          return this.goto(this.parseNumberInteger);
+        }
+      }
+      parseNumberIntegerExponentOrDecimal() {
+        if (this.char === CHAR_PERIOD) {
+          this.consume();
+          return this.call(this.parseNoUnder, this.parseNumberFloat);
+        } else if (this.char === CHAR_E || this.char === CHAR_e) {
+          this.consume();
+          return this.next(this.parseNumberExponentSign);
+        } else {
+          return this.returnNow(Integer(this.state.buf));
+        }
+      }
+      parseNumberInteger() {
+        if (isDigit(this.char)) {
+          this.consume();
+        } else if (this.char === CHAR_LOWBAR) {
+          return this.call(this.parseNoUnder);
+        } else if (this.char === CHAR_E || this.char === CHAR_e) {
+          this.consume();
+          return this.next(this.parseNumberExponentSign);
+        } else if (this.char === CHAR_PERIOD) {
+          this.consume();
+          return this.call(this.parseNoUnder, this.parseNumberFloat);
+        } else {
+          const result = Integer(this.state.buf);
+          if (result.isNaN()) {
+            throw this.error(new TomlError("Invalid number"));
+          } else {
+            return this.returnNow(result);
+          }
+        }
+      }
+      parseNoUnder() {
+        if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
+          throw this.error(new TomlError("Unexpected character, expected digit"));
+        } else if (this.atEndOfWord()) {
+          throw this.error(new TomlError("Incomplete number"));
+        }
+        return this.returnNow();
+      }
+      parseNoUnderHexOctBinLiteral() {
+        if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
+          throw this.error(new TomlError("Unexpected character, expected digit"));
+        } else if (this.atEndOfWord()) {
+          throw this.error(new TomlError("Incomplete number"));
+        }
+        return this.returnNow();
+      }
+      parseNumberFloat() {
+        if (this.char === CHAR_LOWBAR) {
+          return this.call(this.parseNoUnder, this.parseNumberFloat);
+        } else if (isDigit(this.char)) {
+          this.consume();
+        } else if (this.char === CHAR_E || this.char === CHAR_e) {
+          this.consume();
+          return this.next(this.parseNumberExponentSign);
+        } else {
+          return this.returnNow(Float(this.state.buf));
+        }
+      }
+      parseNumberExponentSign() {
+        if (isDigit(this.char)) {
+          return this.goto(this.parseNumberExponent);
+        } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+          this.consume();
+          this.call(this.parseNoUnder, this.parseNumberExponent);
+        } else {
+          throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
+        }
+      }
+      parseNumberExponent() {
+        if (isDigit(this.char)) {
+          this.consume();
+        } else if (this.char === CHAR_LOWBAR) {
+          return this.call(this.parseNoUnder);
+        } else {
+          return this.returnNow(Float(this.state.buf));
+        }
+      }
+      parseNumberOrDateTime() {
+        if (this.char === CHAR_0) {
+          this.consume();
+          return this.next(this.parseNumberBaseOrDateTime);
+        } else {
+          return this.goto(this.parseNumberOrDateTimeOnly);
+        }
+      }
+      parseNumberOrDateTimeOnly() {
+        if (this.char === CHAR_LOWBAR) {
+          return this.call(this.parseNoUnder, this.parseNumberInteger);
+        } else if (isDigit(this.char)) {
+          this.consume();
+          if (this.state.buf.length > 4)
+            this.next(this.parseNumberInteger);
+        } else if (this.char === CHAR_E || this.char === CHAR_e) {
+          this.consume();
+          return this.next(this.parseNumberExponentSign);
+        } else if (this.char === CHAR_PERIOD) {
+          this.consume();
+          return this.call(this.parseNoUnder, this.parseNumberFloat);
+        } else if (this.char === CHAR_HYPHEN) {
+          return this.goto(this.parseDateTime);
+        } else if (this.char === CHAR_COLON) {
+          return this.goto(this.parseOnlyTimeHour);
+        } else {
+          return this.returnNow(Integer(this.state.buf));
+        }
+      }
+      parseDateTimeOnly() {
+        if (this.state.buf.length < 4) {
+          if (isDigit(this.char)) {
+            return this.consume();
+          } else if (this.char === CHAR_COLON) {
+            return this.goto(this.parseOnlyTimeHour);
+          } else {
+            throw this.error(new TomlError("Expected digit while parsing year part of a date"));
+          }
+        } else {
+          if (this.char === CHAR_HYPHEN) {
+            return this.goto(this.parseDateTime);
+          } else {
+            throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
+          }
+        }
+      }
+      parseNumberBaseOrDateTime() {
+        if (this.char === CHAR_b) {
+          this.consume();
+          return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
+        } else if (this.char === CHAR_o) {
+          this.consume();
+          return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
+        } else if (this.char === CHAR_x) {
+          this.consume();
+          return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
+        } else if (this.char === CHAR_PERIOD) {
+          return this.goto(this.parseNumberInteger);
+        } else if (isDigit(this.char)) {
+          return this.goto(this.parseDateTimeOnly);
+        } else {
+          return this.returnNow(Integer(this.state.buf));
+        }
+      }
+      parseIntegerHex() {
+        if (isHexit(this.char)) {
+          this.consume();
+        } else if (this.char === CHAR_LOWBAR) {
+          return this.call(this.parseNoUnderHexOctBinLiteral);
+        } else {
+          const result = Integer(this.state.buf);
+          if (result.isNaN()) {
+            throw this.error(new TomlError("Invalid number"));
+          } else {
+            return this.returnNow(result);
+          }
+        }
+      }
+      parseIntegerOct() {
+        if (isOctit(this.char)) {
+          this.consume();
+        } else if (this.char === CHAR_LOWBAR) {
+          return this.call(this.parseNoUnderHexOctBinLiteral);
+        } else {
+          const result = Integer(this.state.buf);
+          if (result.isNaN()) {
+            throw this.error(new TomlError("Invalid number"));
+          } else {
+            return this.returnNow(result);
+          }
+        }
+      }
+      parseIntegerBin() {
+        if (isBit(this.char)) {
+          this.consume();
+        } else if (this.char === CHAR_LOWBAR) {
+          return this.call(this.parseNoUnderHexOctBinLiteral);
+        } else {
+          const result = Integer(this.state.buf);
+          if (result.isNaN()) {
+            throw this.error(new TomlError("Invalid number"));
+          } else {
+            return this.returnNow(result);
+          }
+        }
+      }
+      parseDateTime() {
+        if (this.state.buf.length < 4) {
+          throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
+        }
+        this.state.result = this.state.buf;
+        this.state.buf = "";
+        return this.next(this.parseDateMonth);
+      }
+      parseDateMonth() {
+        if (this.char === CHAR_HYPHEN) {
+          if (this.state.buf.length < 2) {
+            throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
+          }
+          this.state.result += "-" + this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseDateDay);
+        } else if (isDigit(this.char)) {
+          this.consume();
+        } else {
+          throw this.error(new TomlError("Incomplete datetime"));
+        }
+      }
+      parseDateDay() {
+        if (this.char === CHAR_T || this.char === CHAR_SP) {
+          if (this.state.buf.length < 2) {
+            throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
+          }
+          this.state.result += "-" + this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseStartTimeHour);
+        } else if (this.atEndOfWord()) {
+          return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
+        } else if (isDigit(this.char)) {
+          this.consume();
+        } else {
+          throw this.error(new TomlError("Incomplete datetime"));
+        }
+      }
+      parseStartTimeHour() {
+        if (this.atEndOfWord()) {
+          return this.returnNow(createDate(this.state.result));
+        } else {
+          return this.goto(this.parseTimeHour);
+        }
+      }
+      parseTimeHour() {
+        if (this.char === CHAR_COLON) {
+          if (this.state.buf.length < 2) {
+            throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+          }
+          this.state.result += "T" + this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseTimeMin);
+        } else if (isDigit(this.char)) {
+          this.consume();
+        } else {
+          throw this.error(new TomlError("Incomplete datetime"));
+        }
+      }
+      parseTimeMin() {
+        if (this.state.buf.length < 2 && isDigit(this.char)) {
+          this.consume();
+        } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+          this.state.result += ":" + this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseTimeSec);
+        } else {
+          throw this.error(new TomlError("Incomplete datetime"));
+        }
+      }
+      parseTimeSec() {
+        if (isDigit(this.char)) {
+          this.consume();
+          if (this.state.buf.length === 2) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeZoneOrFraction);
+          }
+        } else {
+          throw this.error(new TomlError("Incomplete datetime"));
+        }
+      }
+      parseOnlyTimeHour() {
+        if (this.char === CHAR_COLON) {
+          if (this.state.buf.length < 2) {
+            throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+          }
+          this.state.result = this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseOnlyTimeMin);
+        } else {
+          throw this.error(new TomlError("Incomplete time"));
+        }
+      }
+      parseOnlyTimeMin() {
+        if (this.state.buf.length < 2 && isDigit(this.char)) {
+          this.consume();
+        } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+          this.state.result += ":" + this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseOnlyTimeSec);
+        } else {
+          throw this.error(new TomlError("Incomplete time"));
+        }
+      }
+      parseOnlyTimeSec() {
+        if (isDigit(this.char)) {
+          this.consume();
+          if (this.state.buf.length === 2) {
+            return this.next(this.parseOnlyTimeFractionMaybe);
+          }
+        } else {
+          throw this.error(new TomlError("Incomplete time"));
+        }
+      }
+      parseOnlyTimeFractionMaybe() {
+        this.state.result += ":" + this.state.buf;
+        if (this.char === CHAR_PERIOD) {
+          this.state.buf = "";
+          this.next(this.parseOnlyTimeFraction);
+        } else {
+          return this.return(createTime(this.state.result));
+        }
+      }
+      parseOnlyTimeFraction() {
+        if (isDigit(this.char)) {
+          this.consume();
+        } else if (this.atEndOfWord()) {
+          if (this.state.buf.length === 0)
+            throw this.error(new TomlError("Expected digit in milliseconds"));
+          return this.returnNow(createTime(this.state.result + "." + this.state.buf));
+        } else {
+          throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+        }
+      }
+      parseTimeZoneOrFraction() {
+        if (this.char === CHAR_PERIOD) {
+          this.consume();
+          this.next(this.parseDateTimeFraction);
+        } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+          this.consume();
+          this.next(this.parseTimeZoneHour);
+        } else if (this.char === CHAR_Z) {
+          this.consume();
+          return this.return(createDateTime(this.state.result + this.state.buf));
+        } else if (this.atEndOfWord()) {
+          return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+        } else {
+          throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+        }
+      }
+      parseDateTimeFraction() {
+        if (isDigit(this.char)) {
+          this.consume();
+        } else if (this.state.buf.length === 1) {
+          throw this.error(new TomlError("Expected digit in milliseconds"));
+        } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+          this.consume();
+          this.next(this.parseTimeZoneHour);
+        } else if (this.char === CHAR_Z) {
+          this.consume();
+          return this.return(createDateTime(this.state.result + this.state.buf));
+        } else if (this.atEndOfWord()) {
+          return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+        } else {
+          throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+        }
+      }
+      parseTimeZoneHour() {
+        if (isDigit(this.char)) {
+          this.consume();
+          if (/\d\d$/.test(this.state.buf))
+            return this.next(this.parseTimeZoneSep);
+        } else {
+          throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+        }
+      }
+      parseTimeZoneSep() {
+        if (this.char === CHAR_COLON) {
+          this.consume();
+          this.next(this.parseTimeZoneMin);
+        } else {
+          throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
+        }
+      }
+      parseTimeZoneMin() {
+        if (isDigit(this.char)) {
+          this.consume();
+          if (/\d\d$/.test(this.state.buf))
+            return this.return(createDateTime(this.state.result + this.state.buf));
+        } else {
+          throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+        }
+      }
+      parseBoolean() {
+        if (this.char === CHAR_t) {
+          this.consume();
+          return this.next(this.parseTrue_r);
+        } else if (this.char === CHAR_f) {
+          this.consume();
+          return this.next(this.parseFalse_a);
+        }
+      }
+      parseTrue_r() {
+        if (this.char === CHAR_r) {
+          this.consume();
+          return this.next(this.parseTrue_u);
+        } else {
+          throw this.error(new TomlError("Invalid boolean, expected true or false"));
+        }
+      }
+      parseTrue_u() {
+        if (this.char === CHAR_u) {
+          this.consume();
+          return this.next(this.parseTrue_e);
+        } else {
+          throw this.error(new TomlError("Invalid boolean, expected true or false"));
+        }
+      }
+      parseTrue_e() {
+        if (this.char === CHAR_e) {
+          return this.return(true);
+        } else {
+          throw this.error(new TomlError("Invalid boolean, expected true or false"));
+        }
+      }
+      parseFalse_a() {
+        if (this.char === CHAR_a) {
+          this.consume();
+          return this.next(this.parseFalse_l);
+        } else {
+          throw this.error(new TomlError("Invalid boolean, expected true or false"));
+        }
+      }
+      parseFalse_l() {
+        if (this.char === CHAR_l) {
+          this.consume();
+          return this.next(this.parseFalse_s);
+        } else {
+          throw this.error(new TomlError("Invalid boolean, expected true or false"));
+        }
+      }
+      parseFalse_s() {
+        if (this.char === CHAR_s) {
+          this.consume();
+          return this.next(this.parseFalse_e);
+        } else {
+          throw this.error(new TomlError("Invalid boolean, expected true or false"));
+        }
+      }
+      parseFalse_e() {
+        if (this.char === CHAR_e) {
+          return this.return(false);
+        } else {
+          throw this.error(new TomlError("Invalid boolean, expected true or false"));
+        }
+      }
+      parseInlineList() {
+        if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+          return null;
+        } else if (this.char === Parser.END) {
+          throw this.error(new TomlError("Unterminated inline array"));
+        } else if (this.char === CHAR_NUM) {
+          return this.call(this.parseComment);
+        } else if (this.char === CHAR_RSQB) {
+          return this.return(this.state.resultArr || InlineList());
+        } else {
+          return this.callNow(this.parseValue, this.recordInlineListValue);
+        }
+      }
+      recordInlineListValue(value) {
+        if (this.state.resultArr) {
+          const listType = this.state.resultArr[_contentType];
+          const valueType = tomlType(value);
+          if (listType !== valueType) {
+            throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
+          }
+        } else {
+          this.state.resultArr = InlineList(tomlType(value));
+        }
+        if (isFloat(value) || isInteger(value)) {
+          this.state.resultArr.push(value.valueOf());
+        } else {
+          this.state.resultArr.push(value);
+        }
+        return this.goto(this.parseInlineListNext);
+      }
+      parseInlineListNext() {
+        if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+          return null;
+        } else if (this.char === CHAR_NUM) {
+          return this.call(this.parseComment);
+        } else if (this.char === CHAR_COMMA) {
+          return this.next(this.parseInlineList);
+        } else if (this.char === CHAR_RSQB) {
+          return this.goto(this.parseInlineList);
+        } else {
+          throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+        }
+      }
+      parseInlineTable() {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+          throw this.error(new TomlError("Unterminated inline array"));
+        } else if (this.char === CHAR_RCUB) {
+          return this.return(this.state.resultTable || InlineTable());
+        } else {
+          if (!this.state.resultTable)
+            this.state.resultTable = InlineTable();
+          return this.callNow(this.parseAssign, this.recordInlineTableValue);
+        }
+      }
+      recordInlineTableValue(kv) {
+        let target = this.state.resultTable;
+        let finalKey = kv.key.pop();
+        for (let kw of kv.key) {
+          if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          target = target[kw] = target[kw] || Table();
+        }
+        if (hasKey(target, finalKey)) {
+          throw this.error(new TomlError("Can't redefine existing key"));
+        }
+        if (isInteger(kv.value) || isFloat(kv.value)) {
+          target[finalKey] = kv.value.valueOf();
+        } else {
+          target[finalKey] = kv.value;
+        }
+        return this.goto(this.parseInlineTableNext);
+      }
+      parseInlineTableNext() {
+        if (this.char === CHAR_SP || this.char === CTRL_I) {
+          return null;
+        } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+          throw this.error(new TomlError("Unterminated inline array"));
+        } else if (this.char === CHAR_COMMA) {
+          return this.next(this.parseInlineTable);
+        } else if (this.char === CHAR_RCUB) {
+          return this.goto(this.parseInlineTable);
+        } else {
+          throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+        }
+      }
+    }
+    return TOMLParser;
+  }
+});
+
+// node_modules/@iarna/toml/parse-pretty-error.js
+var require_parse_pretty_error = __commonJS((exports, module) => {
+  module.exports = prettyError;
+  function prettyError(err, buf) {
+    if (err.pos == null || err.line == null)
+      return err;
+    let msg = err.message;
+    msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
+`;
+    if (buf && buf.split) {
+      const lines = buf.split(/\n/);
+      const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
+      let linePadding = " ";
+      while (linePadding.length < lineNumWidth)
+        linePadding += " ";
+      for (let ii = Math.max(0, err.line - 1);ii < Math.min(lines.length, err.line + 2); ++ii) {
+        let lineNum = String(ii + 1);
+        if (lineNum.length < lineNumWidth)
+          lineNum = " " + lineNum;
+        if (err.line === ii) {
+          msg += lineNum + "> " + lines[ii] + `
+`;
+          msg += linePadding + "  ";
+          for (let hh = 0;hh < err.col; ++hh) {
+            msg += " ";
+          }
+          msg += `^
+`;
+        } else {
+          msg += lineNum + ": " + lines[ii] + `
+`;
+        }
+      }
+    }
+    err.message = msg + `
+`;
+    return err;
+  }
+});
+
+// node_modules/@iarna/toml/parse-string.js
+var require_parse_string = __commonJS((exports, module) => {
+  module.exports = parseString;
+  var TOMLParser = require_toml_parser();
+  var prettyError = require_parse_pretty_error();
+  function parseString(str) {
+    if (global.Buffer && global.Buffer.isBuffer(str)) {
+      str = str.toString("utf8");
+    }
+    const parser = new TOMLParser;
+    try {
+      parser.parse(str);
+      return parser.finish();
+    } catch (err) {
+      throw prettyError(err, str);
+    }
+  }
+});
+
+// node_modules/@iarna/toml/parse-async.js
+var require_parse_async = __commonJS((exports, module) => {
+  module.exports = parseAsync;
+  var TOMLParser = require_toml_parser();
+  var prettyError = require_parse_pretty_error();
+  function parseAsync(str, opts) {
+    if (!opts)
+      opts = {};
+    const index = 0;
+    const blocksize = opts.blocksize || 40960;
+    const parser = new TOMLParser;
+    return new Promise((resolve2, reject) => {
+      setImmediate(parseAsyncNext, index, blocksize, resolve2, reject);
+    });
+    function parseAsyncNext(index2, blocksize2, resolve2, reject) {
+      if (index2 >= str.length) {
+        try {
+          return resolve2(parser.finish());
+        } catch (err) {
+          return reject(prettyError(err, str));
+        }
+      }
+      try {
+        parser.parse(str.slice(index2, index2 + blocksize2));
+        setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve2, reject);
+      } catch (err) {
+        reject(prettyError(err, str));
+      }
+    }
+  }
+});
+
+// node_modules/@iarna/toml/parse-stream.js
+var require_parse_stream = __commonJS((exports, module) => {
+  module.exports = parseStream;
+  var stream = __require("stream");
+  var TOMLParser = require_toml_parser();
+  function parseStream(stm) {
+    if (stm) {
+      return parseReadable(stm);
+    } else {
+      return parseTransform(stm);
+    }
+  }
+  function parseReadable(stm) {
+    const parser = new TOMLParser;
+    stm.setEncoding("utf8");
+    return new Promise((resolve2, reject) => {
+      let readable;
+      let ended = false;
+      let errored = false;
+      function finish() {
+        ended = true;
+        if (readable)
+          return;
+        try {
+          resolve2(parser.finish());
+        } catch (err) {
+          reject(err);
+        }
+      }
+      function error(err) {
+        errored = true;
+        reject(err);
+      }
+      stm.once("end", finish);
+      stm.once("error", error);
+      readNext();
+      function readNext() {
+        readable = true;
+        let data;
+        while ((data = stm.read()) !== null) {
+          try {
+            parser.parse(data);
+          } catch (err) {
+            return error(err);
+          }
+        }
+        readable = false;
+        if (ended)
+          return finish();
+        if (errored)
+          return;
+        stm.once("readable", readNext);
+      }
+    });
+  }
+  function parseTransform() {
+    const parser = new TOMLParser;
+    return new stream.Transform({
+      objectMode: true,
+      transform(chunk, encoding, cb) {
+        try {
+          parser.parse(chunk.toString(encoding));
+        } catch (err) {
+          this.emit("error", err);
+        }
+        cb();
+      },
+      flush(cb) {
+        try {
+          this.push(parser.finish());
+        } catch (err) {
+          this.emit("error", err);
+        }
+        cb();
+      }
+    });
+  }
+});
+
+// node_modules/@iarna/toml/parse.js
+var require_parse = __commonJS((exports, module) => {
+  module.exports = require_parse_string();
+  module.exports.async = require_parse_async();
+  module.exports.stream = require_parse_stream();
+  module.exports.prettyError = require_parse_pretty_error();
+});
+
+// node_modules/@iarna/toml/stringify.js
+var require_stringify = __commonJS((exports, module) => {
+  module.exports = stringify;
+  module.exports.value = stringifyInline;
+  function stringify(obj) {
+    if (obj === null)
+      throw typeError("null");
+    if (obj === undefined)
+      throw typeError("undefined");
+    if (typeof obj !== "object")
+      throw typeError(typeof obj);
+    if (typeof obj.toJSON === "function")
+      obj = obj.toJSON();
+    if (obj == null)
+      return null;
+    const type = tomlType(obj);
+    if (type !== "table")
+      throw typeError(type);
+    return stringifyObject("", "", obj);
+  }
+  function typeError(type) {
+    return new Error("Can only stringify objects, not " + type);
+  }
+  function arrayOneTypeError() {
+    return new Error("Array values can't have mixed types");
+  }
+  function getInlineKeys(obj) {
+    return Object.keys(obj).filter((key) => isInline(obj[key]));
+  }
+  function getComplexKeys(obj) {
+    return Object.keys(obj).filter((key) => !isInline(obj[key]));
+  }
+  function toJSON(obj) {
+    let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: undefined } : {};
+    for (let prop of Object.keys(obj)) {
+      if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
+        nobj[prop] = obj[prop].toJSON();
+      } else {
+        nobj[prop] = obj[prop];
+      }
+    }
+    return nobj;
+  }
+  function stringifyObject(prefix, indent, obj) {
+    obj = toJSON(obj);
+    var inlineKeys;
+    var complexKeys;
+    inlineKeys = getInlineKeys(obj);
+    complexKeys = getComplexKeys(obj);
+    var result = [];
+    var inlineIndent = indent || "";
+    inlineKeys.forEach((key) => {
+      var type = tomlType(obj[key]);
+      if (type !== "undefined" && type !== "null") {
+        result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
+      }
+    });
+    if (result.length > 0)
+      result.push("");
+    var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
+    complexKeys.forEach((key) => {
+      result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
+    });
+    return result.join(`
+`);
+  }
+  function isInline(value) {
+    switch (tomlType(value)) {
+      case "undefined":
+      case "null":
+      case "integer":
+      case "nan":
+      case "float":
+      case "boolean":
+      case "string":
+      case "datetime":
+        return true;
+      case "array":
+        return value.length === 0 || tomlType(value[0]) !== "table";
+      case "table":
+        return Object.keys(value).length === 0;
+      default:
+        return false;
+    }
+  }
+  function tomlType(value) {
+    if (value === undefined) {
+      return "undefined";
+    } else if (value === null) {
+      return "null";
+    } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
+      return "integer";
+    } else if (typeof value === "number") {
+      return "float";
+    } else if (typeof value === "boolean") {
+      return "boolean";
+    } else if (typeof value === "string") {
+      return "string";
+    } else if ("toISOString" in value) {
+      return isNaN(value) ? "undefined" : "datetime";
+    } else if (Array.isArray(value)) {
+      return "array";
+    } else {
+      return "table";
+    }
+  }
+  function stringifyKey(key) {
+    var keyStr = String(key);
+    if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
+      return keyStr;
+    } else {
+      return stringifyBasicString(keyStr);
+    }
+  }
+  function stringifyBasicString(str) {
+    return '"' + escapeString(str).replace(/"/g, "\\\"") + '"';
+  }
+  function stringifyLiteralString(str) {
+    return "'" + str + "'";
+  }
+  function numpad(num, str) {
+    while (str.length < num)
+      str = "0" + str;
+    return str;
+  }
+  function escapeString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c) => "\\u" + numpad(4, c.codePointAt(0).toString(16)));
+  }
+  function stringifyMultilineString(str) {
+    let escaped = str.split(/\n/).map((str2) => {
+      return escapeString(str2).replace(/"(?="")/g, "\\\"");
+    }).join(`
+`);
+    if (escaped.slice(-1) === '"')
+      escaped += "\\\n";
+    return `"""
+` + escaped + '"""';
+  }
+  function stringifyAnyInline(value, multilineOk) {
+    let type = tomlType(value);
+    if (type === "string") {
+      if (multilineOk && /\n/.test(value)) {
+        type = "string-multiline";
+      } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
+        type = "string-literal";
+      }
+    }
+    return stringifyInline(value, type);
+  }
+  function stringifyInline(value, type) {
+    if (!type)
+      type = tomlType(value);
+    switch (type) {
+      case "string-multiline":
+        return stringifyMultilineString(value);
+      case "string":
+        return stringifyBasicString(value);
+      case "string-literal":
+        return stringifyLiteralString(value);
+      case "integer":
+        return stringifyInteger(value);
+      case "float":
+        return stringifyFloat(value);
+      case "boolean":
+        return stringifyBoolean(value);
+      case "datetime":
+        return stringifyDatetime(value);
+      case "array":
+        return stringifyInlineArray(value.filter((_) => tomlType(_) !== "null" && tomlType(_) !== "undefined" && tomlType(_) !== "nan"));
+      case "table":
+        return stringifyInlineTable(value);
+      default:
+        throw typeError(type);
+    }
+  }
+  function stringifyInteger(value) {
+    return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+  }
+  function stringifyFloat(value) {
+    if (value === Infinity) {
+      return "inf";
+    } else if (value === -Infinity) {
+      return "-inf";
+    } else if (Object.is(value, NaN)) {
+      return "nan";
+    } else if (Object.is(value, -0)) {
+      return "-0.0";
+    }
+    var chunks = String(value).split(".");
+    var int = chunks[0];
+    var dec = chunks[1] || 0;
+    return stringifyInteger(int) + "." + dec;
+  }
+  function stringifyBoolean(value) {
+    return String(value);
+  }
+  function stringifyDatetime(value) {
+    return value.toISOString();
+  }
+  function isNumber(type) {
+    return type === "float" || type === "integer";
+  }
+  function arrayType(values) {
+    var contentType = tomlType(values[0]);
+    if (values.every((_) => tomlType(_) === contentType))
+      return contentType;
+    if (values.every((_) => isNumber(tomlType(_))))
+      return "float";
+    return "mixed";
+  }
+  function validateArray(values) {
+    const type = arrayType(values);
+    if (type === "mixed") {
+      throw arrayOneTypeError();
+    }
+    return type;
+  }
+  function stringifyInlineArray(values) {
+    values = toJSON(values);
+    const type = validateArray(values);
+    var result = "[";
+    var stringified = values.map((_) => stringifyInline(_, type));
+    if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
+      result += `
+  ` + stringified.join(`,
+  `) + `
+`;
+    } else {
+      result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
+    }
+    return result + "]";
+  }
+  function stringifyInlineTable(value) {
+    value = toJSON(value);
+    var result = [];
+    Object.keys(value).forEach((key) => {
+      result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
+    });
+    return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
+  }
+  function stringifyComplex(prefix, indent, key, value) {
+    var valueType = tomlType(value);
+    if (valueType === "array") {
+      return stringifyArrayOfTables(prefix, indent, key, value);
+    } else if (valueType === "table") {
+      return stringifyComplexTable(prefix, indent, key, value);
+    } else {
+      throw typeError(valueType);
+    }
+  }
+  function stringifyArrayOfTables(prefix, indent, key, values) {
+    values = toJSON(values);
+    validateArray(values);
+    var firstValueType = tomlType(values[0]);
+    if (firstValueType !== "table")
+      throw typeError(firstValueType);
+    var fullKey = prefix + stringifyKey(key);
+    var result = "";
+    values.forEach((table) => {
+      if (result.length > 0)
+        result += `
+`;
+      result += indent + "[[" + fullKey + `]]
+`;
+      result += stringifyObject(fullKey + ".", indent, table);
+    });
+    return result;
+  }
+  function stringifyComplexTable(prefix, indent, key, value) {
+    var fullKey = prefix + stringifyKey(key);
+    var result = "";
+    if (getInlineKeys(value).length > 0) {
+      result += indent + "[" + fullKey + `]
+`;
+    }
+    return result + stringifyObject(fullKey + ".", indent, value);
+  }
+});
+
 // src/cli.tsx
 import { render } from "ink";
 
 // src/app.tsx
-import { useEffect as useEffect3, useState as useState5 } from "react";
-import { Text as Text7, Box as Box6 } from "ink";
+import { useEffect as useEffect3, useState as useState7 } from "react";
+import { Text as Text9, Box as Box8 } from "ink";
 
 // node_modules/ink-spinner/build/index.js
 var import_cli_spinners = __toESM(require_cli_spinners(), 1);
@@ -1753,7 +3744,11 @@ class NodeJSDetector extends EcosystemDetector {
     const packageJson = await readJsonFile(packageJsonPath);
     const name = packageJson.name || path2.basename(projectRoot);
     const packageManager = await this.detectPackageManager(projectRoot);
-    const scripts = this.extractScripts(packageJson);
+    let scripts = this.extractScripts(packageJson);
+    const toolScripts = await this.detectToolCommands(packageJson, projectRoot);
+    const existingScriptNames = new Set(scripts.map((s) => s.name));
+    const uniqueToolScripts = toolScripts.filter((tool) => !existingScriptNames.has(tool.name));
+    scripts = [...scripts, ...uniqueToolScripts];
     const workspace = await this.detectWorkspace(projectRoot);
     return {
       path: packageJsonPath,
@@ -1763,6 +3758,61 @@ class NodeJSDetector extends EcosystemDetector {
       workspace
     };
   }
+  async detectToolCommands(packageJson, projectRoot) {
+    const tools = [];
+    const allDeps = {
+      ...packageJson.dependencies || {},
+      ...packageJson.devDependencies || {},
+      ...packageJson.peerDependencies || {}
+    };
+    const dependencies = new Set(Object.keys(allDeps).map((dep) => dep.toLowerCase()));
+    if (dependencies.has("typescript")) {
+      const hasTsConfig = await fileExists(path2.join(projectRoot, "tsconfig.json"));
+      if (hasTsConfig) {
+        tools.push({ name: "tsc", command: "tsc --noEmit", description: "\uD83D\uDD0D Type check with TypeScript" }, { name: "tsc-build", command: "tsc", description: "\uD83C\uDFD7️  Build TypeScript project" });
+      }
+    }
+    if (dependencies.has("eslint")) {
+      tools.push({ name: "eslint", command: "eslint .", description: "\uD83D\uDD0D Lint code with ESLint" }, { name: "eslint-fix", command: "eslint . --fix", description: "\uD83D\uDD27 Lint and auto-fix issues" });
+    }
+    if (dependencies.has("prettier")) {
+      tools.push({ name: "prettier-check", command: "prettier --check .", description: "\uD83D\uDC40 Check code formatting" }, { name: "prettier-write", command: "prettier --write .", description: "✨ Format code with Prettier" });
+    }
+    if (dependencies.has("@biomejs/biome") || dependencies.has("biome")) {
+      tools.push({ name: "biome-check", command: "biome check .", description: "\uD83D\uDD0D Check code with Biome" }, { name: "biome-check-fix", command: "biome check --write .", description: "\uD83D\uDD27 Check and auto-fix with Biome" }, { name: "biome-format", command: "biome format --write .", description: "✨ Format code with Biome" });
+    }
+    if (dependencies.has("vitest")) {
+      tools.push({ name: "vitest", command: "vitest", description: "\uD83E\uDDEA Run tests with Vitest" }, { name: "vitest-ui", command: "vitest --ui", description: "\uD83E\uDDEA Run tests with Vitest UI" }, { name: "vitest-run", command: "vitest run", description: "\uD83E\uDDEA Run tests once" }, { name: "vitest-coverage", command: "vitest --coverage", description: "\uD83D\uDCCA Run tests with coverage" });
+    }
+    if (dependencies.has("jest") || dependencies.has("@jest/core")) {
+      tools.push({ name: "jest", command: "jest", description: "\uD83E\uDDEA Run tests with Jest" }, { name: "jest-watch", command: "jest --watch", description: "\uD83E\uDDEA Run tests in watch mode" }, { name: "jest-coverage", command: "jest --coverage", description: "\uD83D\uDCCA Run tests with coverage" });
+    }
+    if (dependencies.has("@playwright/test") || dependencies.has("playwright")) {
+      tools.push({ name: "playwright-test", command: "playwright test", description: "\uD83C\uDFAD Run Playwright tests" }, { name: "playwright-ui", command: "playwright test --ui", description: "\uD83C\uDFAD Run Playwright tests with UI" }, { name: "playwright-debug", command: "playwright test --debug", description: "\uD83D\uDC1B Debug Playwright tests" });
+    }
+    if (dependencies.has("cypress")) {
+      tools.push({ name: "cypress-open", command: "cypress open", description: "\uD83C\uDF32 Open Cypress test runner" }, { name: "cypress-run", command: "cypress run", description: "\uD83C\uDF32 Run Cypress tests headlessly" });
+    }
+    if (dependencies.has("vite")) {
+      tools.push({ name: "vite-dev", command: "vite", description: "⚡ Start Vite dev server" }, { name: "vite-build", command: "vite build", description: "⚡ Build with Vite" }, { name: "vite-preview", command: "vite preview", description: "⚡ Preview Vite build" });
+    }
+    if (dependencies.has("turbo")) {
+      tools.push({ name: "turbo-build", command: "turbo build", description: "\uD83D\uDE80 Build with Turbo" }, { name: "turbo-dev", command: "turbo dev", description: "\uD83D\uDE80 Start dev mode with Turbo" }, { name: "turbo-test", command: "turbo test", description: "\uD83D\uDE80 Run tests with Turbo" });
+    }
+    if (dependencies.has("nx") || dependencies.has("@nx/workspace")) {
+      tools.push({ name: "nx-build", command: "nx build", description: "\uD83D\uDD37 Build with Nx" }, { name: "nx-test", command: "nx test", description: "\uD83D\uDD37 Run tests with Nx" }, { name: "nx-graph", command: "nx graph", description: "\uD83D\uDD37 View project graph" });
+    }
+    if (dependencies.has("typescript") && !packageJson.scripts?.typecheck) {
+      tools.push({ name: "typecheck", command: "tsc --noEmit", description: "\uD83D\uDD0D Type check code" });
+    }
+    if (dependencies.has("stylelint")) {
+      tools.push({ name: "stylelint", command: 'stylelint "**/*.css"', description: "\uD83D\uDC85 Lint CSS files" }, { name: "stylelint-fix", command: 'stylelint "**/*.css" --fix', description: "\uD83D\uDC85 Lint and fix CSS files" });
+    }
+    if (dependencies.has("@storybook/react") || dependencies.has("storybook")) {
+      tools.push({ name: "storybook", command: "storybook dev", description: "\uD83D\uDCD6 Start Storybook dev server" }, { name: "storybook-build", command: "storybook build", description: "\uD83D\uDCD6 Build Storybook" });
+    }
+    return tools;
+  }
   async detectPackageManager(projectRoot) {
     const lockFiles = [
       ["bun.lockb", "bun"],
@@ -1826,7 +3876,11 @@ class NodeJSDetector extends EcosystemDetector {
 }
 
 // src/core/python-detector.ts
-import * as path4 from "path";
+import * as path5 from "path";
+
+// node_modules/@iarna/toml/toml.js
+var $parse = require_parse();
+var $stringify = require_stringify();
 
 // src/utils/config.ts
 import * as path3 from "path";
@@ -1858,7 +3912,134 @@ async function detectVenv(projectRoot) {
       return venvPath;
     }
   }
-  return null;
+  return null;
+}
+
+// src/core/python/poe-parser.ts
+class PoeTaskParser {
+  name = "poethepoet";
+  isConfigured(toml) {
+    return !!toml.tool?.poe?.tasks;
+  }
+  parse(toml) {
+    const scripts = [];
+    if (!this.isConfigured(toml)) {
+      return scripts;
+    }
+    const tasks = toml.tool.poe.tasks;
+    for (const [taskName, taskConfig] of Object.entries(tasks)) {
+      let command = "";
+      let description = "";
+      if (typeof taskConfig === "string") {
+        command = taskConfig;
+      } else if (typeof taskConfig === "object" && taskConfig !== null) {
+        const config = taskConfig;
+        if (config.shell) {
+          command = config.shell;
+        } else if (config.script) {
+          command = config.script;
+        } else if (config.cmd) {
+          command = config.cmd;
+        } else if (Array.isArray(config)) {
+          command = config.join(" && ");
+        }
+        if (config.help) {
+          description = config.help;
+        }
+      }
+      if (command) {
+        scripts.push({
+          name: `poe:${taskName}`,
+          command: `poe ${taskName}`,
+          description: description || `Run poe task: ${taskName}`
+        });
+      }
+    }
+    return scripts;
+  }
+}
+var poeTaskParser = new PoeTaskParser;
+
+// src/core/python/parser-registry.ts
+class PythonParserRegistry {
+  parsers = [];
+  constructor() {
+    this.register(poeTaskParser);
+  }
+  register(parser) {
+    this.parsers.push(parser);
+  }
+  getAllParsers() {
+    return [...this.parsers];
+  }
+  parseAll(toml) {
+    const allScripts = [];
+    for (const parser of this.parsers) {
+      if (parser.isConfigured(toml)) {
+        const scripts = parser.parse(toml);
+        allScripts.push(...scripts);
+      }
+    }
+    return allScripts;
+  }
+  getParserNames() {
+    return this.parsers.map((p) => p.name);
+  }
+}
+var pythonParserRegistry = new PythonParserRegistry;
+
+// src/core/python/tool-detector.ts
+import * as path4 from "path";
+async function detectPythonTools(dependencies, projectRoot) {
+  const tools = [];
+  if (dependencies.has("ruff")) {
+    tools.push({ name: "ruff-check", command: "ruff check", description: "\uD83D\uDD0D Run ruff linter" }, { name: "ruff-check-fix", command: "ruff check --fix", description: "\uD83D\uDD27 Run ruff linter and auto-fix issues" }, { name: "ruff-format", command: "ruff format", description: "✨ Format code with ruff" }, { name: "ruff-format-check", command: "ruff format --check", description: "\uD83D\uDC40 Check if code is formatted" });
+  }
+  if (dependencies.has("pytest")) {
+    tools.push({ name: "test", command: "pytest", description: "\uD83E\uDDEA Run all tests" }, { name: "test-verbose", command: "pytest -v", description: "\uD83E\uDDEA Run tests with verbose output" }, { name: "test-cov", command: "pytest --cov", description: "\uD83D\uDCCA Run tests with coverage report" });
+  }
+  if (dependencies.has("black")) {
+    tools.push({ name: "black", command: "black .", description: "✨ Format code with black" }, { name: "black-check", command: "black --check .", description: "\uD83D\uDC40 Check if code is formatted" });
+  }
+  if (dependencies.has("mypy")) {
+    tools.push({ name: "mypy", command: "mypy .", description: "\uD83D\uDD0D Run mypy type checker" });
+  }
+  if (dependencies.has("pyright")) {
+    tools.push({ name: "pyright", command: "pyright", description: "\uD83D\uDD0D Run pyright type checker" });
+  }
+  if (dependencies.has("isort")) {
+    tools.push({ name: "isort", command: "isort .", description: "\uD83D\uDCD1 Sort imports with isort" }, { name: "isort-check", command: "isort --check-only .", description: "\uD83D\uDC40 Check import sorting" });
+  }
+  if (dependencies.has("flake8")) {
+    tools.push({ name: "flake8", command: "flake8", description: "\uD83D\uDD0D Run flake8 linter" });
+  }
+  if (dependencies.has("pylint")) {
+    tools.push({ name: "pylint", command: "pylint src", description: "\uD83D\uDD0D Run pylint linter" });
+  }
+  if (dependencies.has("coverage")) {
+    tools.push({ name: "coverage-run", command: "coverage run -m pytest", description: "\uD83D\uDCCA Run tests with coverage" }, { name: "coverage-report", command: "coverage report", description: "\uD83D\uDCCA Show coverage report" }, { name: "coverage-html", command: "coverage html", description: "\uD83D\uDCCA Generate HTML coverage report" });
+  }
+  if (dependencies.has("pre-commit")) {
+    tools.push({ name: "pre-commit-install", command: "pre-commit install", description: "\uD83E\uDE9D Install pre-commit hooks" }, { name: "pre-commit-run", command: "pre-commit run --all-files", description: "\uD83E\uDE9D Run pre-commit on all files" });
+  }
+  if (dependencies.has("bandit")) {
+    tools.push({ name: "bandit", command: "bandit -r .", description: "\uD83D\uDD12 Run security checks with bandit" });
+  }
+  if (dependencies.has("sphinx")) {
+    const docsDir = await fileExists(path4.join(projectRoot, "docs")) ? "docs" : ".";
+    tools.push({ name: "docs-build", command: `sphinx-build -b html ${docsDir} ${docsDir}/_build`, description: "\uD83D\uDCDA Build documentation with Sphinx" });
+  }
+  return tools;
+}
+function extractDependencyNames(dependencies) {
+  if (Array.isArray(dependencies)) {
+    return dependencies.map((dep) => {
+      const match = dep.match(/^([a-zA-Z0-9_-]+)/);
+      return match ? match[1].toLowerCase() : "";
+    }).filter(Boolean);
+  } else {
+    return Object.keys(dependencies).map((dep) => dep.toLowerCase());
+  }
 }
 
 // src/core/python-detector.ts
@@ -1883,10 +4064,10 @@ class PythonDetector extends EcosystemDetector {
     return null;
   }
   async parse(projectRoot) {
-    const pyprojectPath = path4.join(projectRoot, "pyproject.toml");
-    const pipfilePath = path4.join(projectRoot, "Pipfile");
-    const requirementsPath = path4.join(projectRoot, "requirements.txt");
-    let name = path4.basename(projectRoot);
+    const pyprojectPath = path5.join(projectRoot, "pyproject.toml");
+    const pipfilePath = path5.join(projectRoot, "Pipfile");
+    const requirementsPath = path5.join(projectRoot, "requirements.txt");
+    let name = path5.basename(projectRoot);
     let scripts = [];
     let packageManager = "pip";
     if (await fileExists(pyprojectPath)) {
@@ -1920,12 +4101,12 @@ class PythonDetector extends EcosystemDetector {
   async parsePyProject(pyprojectPath, projectRoot) {
     const content = await fs2.readFile(pyprojectPath, "utf-8");
     const toml = this.parseToml(content);
-    let name = path4.basename(projectRoot);
+    let name = path5.basename(projectRoot);
     let scripts = [];
     let packageManager = "pip";
-    const hasUvLock = await fileExists(path4.join(projectRoot, "uv.lock"));
-    const hasPoetryLock = await fileExists(path4.join(projectRoot, "poetry.lock"));
-    const hasPdmLock = await fileExists(path4.join(projectRoot, "pdm.lock"));
+    const hasUvLock = await fileExists(path5.join(projectRoot, "uv.lock"));
+    const hasPoetryLock = await fileExists(path5.join(projectRoot, "poetry.lock"));
+    const hasPdmLock = await fileExists(path5.join(projectRoot, "pdm.lock"));
     if (toml.tool?.poetry || hasPoetryLock) {
       packageManager = "poetry";
       name = toml.tool?.poetry?.name || name;
@@ -1968,10 +4149,40 @@ class PythonDetector extends EcosystemDetector {
         name: key,
         command: `python -m ${key}`
       }));
-      scripts.push({ name: "install", command: "pip install -e ." });
+      scripts.push({ name: "install", command: "pip install -e .", description: "Install package in editable mode" });
     }
+    const taskScripts = pythonParserRegistry.parseAll(toml);
+    scripts.push(...taskScripts);
+    const allDependencies = this.collectAllDependencies(toml);
+    const toolScripts = await detectPythonTools(allDependencies, projectRoot);
+    const existingScriptNames = new Set(scripts.map((s) => s.name));
+    const uniqueToolScripts = toolScripts.filter((tool) => !existingScriptNames.has(tool.name));
+    scripts.push(...uniqueToolScripts);
     return { name, scripts, packageManager };
   }
+  collectAllDependencies(toml) {
+    const dependencies = new Set;
+    if (toml.project?.dependencies) {
+      extractDependencyNames(toml.project.dependencies).forEach((dep) => dependencies.add(dep));
+    }
+    if (toml["dependency-groups"]) {
+      Object.values(toml["dependency-groups"]).forEach((group) => {
+        if (Array.isArray(group)) {
+          extractDependencyNames(group).forEach((dep) => dependencies.add(dep));
+        }
+      });
+    }
+    if (toml.tool?.poetry?.dependencies) {
+      Object.keys(toml.tool.poetry.dependencies).forEach((dep) => dependencies.add(dep.toLowerCase()));
+    }
+    if (toml.tool?.poetry?.["dev-dependencies"]) {
+      Object.keys(toml.tool.poetry["dev-dependencies"]).forEach((dep) => dependencies.add(dep.toLowerCase()));
+    }
+    if (toml.tool?.pdm?.["dev-dependencies"]) {
+      Object.keys(toml.tool.pdm["dev-dependencies"]).forEach((dep) => dependencies.add(dep.toLowerCase()));
+    }
+    return dependencies;
+  }
   async parsePipfile(pipfilePath) {
     const content = await fs2.readFile(pipfilePath, "utf-8");
     const pipfile = this.parseToml(content);
@@ -1991,41 +4202,7 @@ class PythonDetector extends EcosystemDetector {
     ];
   }
   parseToml(content) {
-    const result = {};
-    let currentSection = result;
-    const sectionPath = [];
-    const lines = content.split(`
-`);
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) {
-        continue;
-      }
-      if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-        const section = trimmed.slice(1, -1);
-        const parts = section.split(".");
-        currentSection = result;
-        sectionPath.length = 0;
-        for (const part of parts) {
-          sectionPath.push(part);
-          if (!currentSection[part]) {
-            currentSection[part] = {};
-          }
-          currentSection = currentSection[part];
-        }
-        continue;
-      }
-      const match = trimmed.match(/^([^=]+)=(.+)$/);
-      if (match && match[1] && match[2]) {
-        const key = match[1].trim();
-        let value = match[2].trim();
-        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-          value = value.slice(1, -1);
-        }
-        currentSection[key] = value;
-      }
-    }
-    return result;
+    return $parse(content);
   }
   applyConfig(scripts, config) {
     const configCommands = config.commands || {};
@@ -2056,9 +4233,22 @@ class PythonDetector extends EcosystemDetector {
     const manager = packageInfo.packageManager;
     const script = packageInfo.scripts.find((s) => s.name === scriptName);
     if (script) {
-      if (script.command.includes(manager) || script.command.includes("uv run")) {
+      if (script.command.includes(manager) || script.command.includes("uv run") || script.command.includes("poetry run") || script.command.includes("pdm run") || script.command.includes("pipenv run")) {
         return script.command;
       }
+      switch (manager) {
+        case "uv":
+          return `uv run ${script.command}`;
+        case "poetry":
+          return `poetry run ${script.command}`;
+        case "pdm":
+          return `pdm run ${script.command}`;
+        case "pipenv":
+          return `pipenv run ${script.command}`;
+        case "pip":
+        default:
+          return script.command;
+      }
     }
     switch (manager) {
       case "uv":
@@ -2107,6 +4297,61 @@ class DetectorRegistry {
       error: "No supported project found in current directory or parent directories"
     };
   }
+  async detectAll(cwd) {
+    const projects = [];
+    const scannedPaths = new Set;
+    const tryDetect = async (path7) => {
+      for (const detector of this.detectors) {
+        try {
+          const projectRoot = await detector.detect(path7);
+          if (projectRoot) {
+            if (scannedPaths.has(projectRoot)) {
+              break;
+            }
+            scannedPaths.add(projectRoot);
+            const packageInfo = await detector.parse(projectRoot);
+            projects.push({
+              found: true,
+              packageInfo,
+              detector
+            });
+            break;
+          }
+        } catch (error) {}
+      }
+    };
+    const fs3 = await import("fs/promises");
+    const path6 = await import("path");
+    await tryDetect(cwd);
+    const parent = path6.dirname(cwd);
+    try {
+      const siblings = await fs3.readdir(parent, { withFileTypes: true });
+      for (const sibling of siblings) {
+        if (sibling.isDirectory()) {
+          const siblingPath = path6.join(parent, sibling.name);
+          await tryDetect(siblingPath);
+        }
+      }
+    } catch (error) {}
+    const scanChildren = async (basePath, depth, maxDepth = 2) => {
+      if (depth > maxDepth)
+        return;
+      try {
+        const entries = await fs3.readdir(basePath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+            const childPath = path6.join(basePath, entry.name);
+            await tryDetect(childPath);
+            if (depth < maxDepth) {
+              await scanChildren(childPath, depth + 1, maxDepth);
+            }
+          }
+        }
+      } catch (error) {}
+    };
+    await scanChildren(cwd, 1);
+    return projects;
+  }
   getSupportedEcosystems() {
     return this.detectors.map((d) => d.name);
   }
@@ -2229,20 +4474,20 @@ function Header({ packageInfo, ecosystemName }) {
 }
 
 // src/components/ScriptList.tsx
-import { useState as useState4, useEffect as useEffect2 } from "react";
-import { Text as Text5, Box as Box4, useInput as useInput3, useApp } from "ink";
+import { useState as useState6, useEffect as useEffect2 } from "react";
+import { Text as Text7, Box as Box6, useInput as useInput5, useApp } from "ink";
 
 // src/utils/command.ts
 import { spawn } from "child_process";
 
 // src/utils/history.ts
 import { promises as fs3 } from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 import * as os from "os";
-var HISTORY_FILE = path5.join(os.homedir(), ".wami", "history.json");
+var HISTORY_FILE = path6.join(os.homedir(), ".wami", "history.json");
 var MAX_HISTORY_PER_PROJECT = 10;
 async function ensureWamiDir() {
-  const wamiDir = path5.dirname(HISTORY_FILE);
+  const wamiDir = path6.dirname(HISTORY_FILE);
   try {
     await fs3.mkdir(wamiDir, { recursive: true });
   } catch (error) {}
@@ -2304,7 +4549,7 @@ async function getHistory(projectPath) {
   return history[projectPath].history.map((entry) => ({
     name: entry.script,
     command: entry.command,
-    description: `Run ${entry.count} time${entry.count > 1 ? "s" : ""} before`
+    description: entry.command
   }));
 }
 async function deleteFromHistory(projectPath, command) {
@@ -2593,20 +4838,320 @@ function CommandEditor({
   }, undefined, true, undefined, this);
 }
 
+// src/components/CustomCommandInput.tsx
+import { useState as useState4 } from "react";
+import { Text as Text5, Box as Box4, useInput as useInput3 } from "ink";
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+function CustomCommandInput({
+  onSubmit,
+  onCancel
+}) {
+  const [name, setName] = useState4("");
+  const [command, setCommand] = useState4("");
+  const [focusedField, setFocusedField] = useState4("name");
+  const [nameCursorPos, setNameCursorPos] = useState4(0);
+  const [commandCursorPos, setCommandCursorPos] = useState4(0);
+  const currentText = focusedField === "name" ? name : command;
+  const cursorPos = focusedField === "name" ? nameCursorPos : commandCursorPos;
+  const setCurrentText = focusedField === "name" ? setName : setCommand;
+  const setCursorPos = focusedField === "name" ? setNameCursorPos : setCommandCursorPos;
+  useInput3((char, key) => {
+    if (key.return) {
+      if (focusedField === "name" && name.trim()) {
+        setFocusedField("command");
+      } else if (focusedField === "command" && command.trim()) {
+        onSubmit(name.trim() || "custom", command.trim());
+      }
+    } else if (key.escape) {
+      onCancel();
+    } else if (key.tab) {
+      setFocusedField(focusedField === "name" ? "command" : "name");
+    } else if (key.backspace || key.delete) {
+      if (cursorPos > 0) {
+        setCurrentText((prev) => prev.slice(0, cursorPos - 1) + prev.slice(cursorPos));
+        setCursorPos((prev) => prev - 1);
+      }
+    } else if (key.leftArrow) {
+      setCursorPos((prev) => Math.max(0, prev - 1));
+    } else if (key.rightArrow) {
+      setCursorPos((prev) => Math.min(currentText.length, prev + 1));
+    } else if (!key.ctrl && !key.meta && char) {
+      setCurrentText((prev) => prev.slice(0, cursorPos) + char + prev.slice(cursorPos));
+      setCursorPos((prev) => prev + 1);
+    }
+  });
+  const renderField = (fieldName, value, cursor) => {
+    const isFocused = focusedField === fieldName;
+    return /* @__PURE__ */ jsxDEV4(Box4, {
+      flexDirection: "column",
+      marginBottom: 1,
+      children: [
+        /* @__PURE__ */ jsxDEV4(Text5, {
+          color: isFocused ? "cyan" : "dim",
+          bold: isFocused,
+          children: [
+            fieldName === "name" ? "\uD83D\uDCDD Name" : "⚡ Command",
+            " ",
+            isFocused && "(active)",
+            ":"
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV4(Box4, {
+          paddingLeft: 2,
+          children: isFocused ? /* @__PURE__ */ jsxDEV4(Text5, {
+            color: "green",
+            children: [
+              value.slice(0, cursor),
+              /* @__PURE__ */ jsxDEV4(Text5, {
+                inverse: true,
+                children: value[cursor] || " "
+              }, undefined, false, undefined, this),
+              value.slice(cursor + 1)
+            ]
+          }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV4(Text5, {
+            dimColor: true,
+            children: value || " "
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  };
+  return /* @__PURE__ */ jsxDEV4(Box4, {
+    flexDirection: "column",
+    padding: 1,
+    width: "100%",
+    children: [
+      /* @__PURE__ */ jsxDEV4(Box4, {
+        marginBottom: 1,
+        borderStyle: "round",
+        borderColor: "cyan",
+        paddingX: 1,
+        children: /* @__PURE__ */ jsxDEV4(Text5, {
+          bold: true,
+          color: "cyan",
+          children: "✨ Create Custom Command"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      renderField("name", name, nameCursorPos),
+      renderField("command", command, commandCursorPos),
+      /* @__PURE__ */ jsxDEV4(Box4, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsxDEV4(Text5, {
+          dimColor: true,
+          children: [
+            /* @__PURE__ */ jsxDEV4(Text5, {
+              bold: true,
+              children: "Enter"
+            }, undefined, false, undefined, this),
+            " ",
+            focusedField === "name" ? "next" : "run",
+            "  ",
+            /* @__PURE__ */ jsxDEV4(Text5, {
+              bold: true,
+              children: "Tab"
+            }, undefined, false, undefined, this),
+            " switch field  ",
+            /* @__PURE__ */ jsxDEV4(Text5, {
+              bold: true,
+              children: "Esc"
+            }, undefined, false, undefined, this),
+            " cancel  ",
+            /* @__PURE__ */ jsxDEV4(Text5, {
+              bold: true,
+              children: "←/→"
+            }, undefined, false, undefined, this),
+            " move  ",
+            /* @__PURE__ */ jsxDEV4(Text5, {
+              bold: true,
+              children: "Backspace"
+            }, undefined, false, undefined, this),
+            " delete"
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/ProjectSwitcher.tsx
+import { useState as useState5 } from "react";
+import { Text as Text6, Box as Box5, useInput as useInput4 } from "ink";
+import * as path7 from "path";
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+function ProjectSwitcher({
+  projects,
+  currentProjectPath,
+  onSelect,
+  onCancel
+}) {
+  const [selectedIndex, setSelectedIndex] = useState5(() => {
+    return projects.findIndex((p) => p.packageInfo?.path.replace(/\/(package\.json|pyproject\.toml|Pipfile|requirements\.txt)$/, "") === currentProjectPath);
+  });
+  useInput4((input, key) => {
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow || input === "j") {
+      setSelectedIndex((prev) => Math.min(projects.length - 1, prev + 1));
+    } else if (key.return) {
+      const selected = projects[selectedIndex];
+      if (selected) {
+        onSelect(selected);
+      }
+    } else if (key.escape || input === "q") {
+      onCancel();
+    }
+  });
+  if (projects.length === 0) {
+    return /* @__PURE__ */ jsxDEV5(Box5, {
+      flexDirection: "column",
+      padding: 1,
+      children: [
+        /* @__PURE__ */ jsxDEV5(Text6, {
+          bold: true,
+          color: "yellow",
+          children: "\uD83D\uDCC1 Project Switcher"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(Box5, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsxDEV5(Text6, {
+            dimColor: true,
+            children: "No other projects detected in this mono-repo."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(Box5, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsxDEV5(Text6, {
+            dimColor: true,
+            children: [
+              "Press ",
+              /* @__PURE__ */ jsxDEV5(Text6, {
+                bold: true,
+                children: "Esc"
+              }, undefined, false, undefined, this),
+              " to close"
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV5(Box5, {
+    flexDirection: "column",
+    padding: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV5(Text6, {
+        bold: true,
+        color: "cyan",
+        children: [
+          "\uD83D\uDCC1 Switch Project (",
+          projects.length,
+          " found):"
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Box5, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: projects.map((project, index) => {
+          if (!project.packageInfo)
+            return null;
+          const isSelected = index === selectedIndex;
+          const projectPath = project.packageInfo.path.replace(/\/(package\.json|pyproject\.toml|Pipfile|requirements\.txt)$/, "");
+          const isCurrent = projectPath === currentProjectPath;
+          const relativePath = path7.relative(process.cwd(), projectPath) || ".";
+          return /* @__PURE__ */ jsxDEV5(Box5, {
+            marginLeft: 2,
+            children: isSelected ? /* @__PURE__ */ jsxDEV5(Text6, {
+              color: "cyan",
+              bold: true,
+              children: [
+                "▶ ",
+                relativePath,
+                " ",
+                /* @__PURE__ */ jsxDEV5(Text6, {
+                  dimColor: true,
+                  children: [
+                    "(",
+                    project.detector?.name,
+                    " - ",
+                    project.packageInfo.packageManager,
+                    ")"
+                  ]
+                }, undefined, true, undefined, this),
+                isCurrent && /* @__PURE__ */ jsxDEV5(Text6, {
+                  color: "green",
+                  children: " [current]"
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV5(Text6, {
+              children: [
+                "  ",
+                relativePath,
+                " ",
+                /* @__PURE__ */ jsxDEV5(Text6, {
+                  dimColor: true,
+                  children: [
+                    "(",
+                    project.detector?.name,
+                    " - ",
+                    project.packageInfo.packageManager,
+                    ")"
+                  ]
+                }, undefined, true, undefined, this),
+                isCurrent && /* @__PURE__ */ jsxDEV5(Text6, {
+                  color: "green",
+                  children: " [current]"
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, projectPath, false, undefined, this);
+        })
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Box5, {
+        marginTop: 1,
+        marginLeft: 2,
+        children: /* @__PURE__ */ jsxDEV5(Text6, {
+          dimColor: true,
+          children: [
+            /* @__PURE__ */ jsxDEV5(Text6, {
+              bold: true,
+              children: "↑/↓/k/j"
+            }, undefined, false, undefined, this),
+            " navigate  ",
+            /* @__PURE__ */ jsxDEV5(Text6, {
+              bold: true,
+              children: "Enter"
+            }, undefined, false, undefined, this),
+            " select  ",
+            /* @__PURE__ */ jsxDEV5(Text6, {
+              bold: true,
+              children: "Esc/q"
+            }, undefined, false, undefined, this),
+            " cancel"
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
 // src/components/ScriptList.tsx
-import { jsxDEV as jsxDEV4, Fragment as Fragment2 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV6, Fragment as Fragment2 } from "react/jsx-dev-runtime";
 function ScriptList({
   packageInfo,
   detector,
   history: initialHistory,
-  projectPath
+  projectPath,
+  allProjects,
+  onProjectSwitch
 }) {
-  const [selectedIndex, setSelectedIndex] = useState4(0);
-  const [showArgInput, setShowArgInput] = useState4(false);
-  const [showEditor, setShowEditor] = useState4(false);
-  const [history, setHistory] = useState4(initialHistory);
-  const [isSearching, setIsSearching] = useState4(false);
-  const [searchQuery, setSearchQuery] = useState4("");
+  const [selectedIndex, setSelectedIndex] = useState6(0);
+  const [showArgInput, setShowArgInput] = useState6(false);
+  const [showEditor, setShowEditor] = useState6(false);
+  const [showCustomCommand, setShowCustomCommand] = useState6(false);
+  const [showProjectSwitcher, setShowProjectSwitcher] = useState6(false);
+  const [history, setHistory] = useState6(initialHistory);
+  const [isSearching, setIsSearching] = useState6(false);
+  const [searchQuery, setSearchQuery] = useState6("");
   const { exit } = useApp();
   const allScriptsUnfiltered = [...history, ...packageInfo.scripts];
   const historyCount = history.length;
@@ -2625,8 +5170,8 @@ function ScriptList({
       setSelectedIndex(Math.max(0, allScripts.length - 1));
     }
   }, [allScripts.length, selectedIndex]);
-  useInput3((input, key) => {
-    if (showArgInput || showEditor) {
+  useInput5((input, key) => {
+    if (showArgInput || showEditor || showCustomCommand || showProjectSwitcher) {
       return;
     }
     if (isSearching) {
@@ -2647,16 +5192,16 @@ function ScriptList({
       }
       return;
     }
-    if (key.upArrow) {
+    if (key.upArrow || input === "k") {
       setSelectedIndex((prev) => Math.max(0, prev - 1));
-    } else if (key.downArrow) {
+    } else if (key.downArrow || input === "j") {
       setSelectedIndex((prev) => Math.min(allScripts.length - 1, prev + 1));
     } else if (key.return) {
       const selectedScript = allScripts[selectedIndex];
       if (selectedScript) {
         const isHistory = selectedIndex < historyCount;
         const command = isHistory ? selectedScript.command : detector.buildCommand(packageInfo, selectedScript.name);
-        executeCommand(command, exit);
+        executeCommand(command, exit, projectPath, selectedScript.name, true);
       }
     } else if (input === "a") {
       setShowArgInput(true);
@@ -2665,9 +5210,13 @@ function ScriptList({
     } else if (input === "/" || input === "s") {
       setIsSearching(true);
       setSearchQuery("");
-    } else if (input === "c" && searchQuery) {
-      setSearchQuery("");
-      setSelectedIndex(0);
+    } else if (input === "c") {
+      if (searchQuery) {
+        setSearchQuery("");
+        setSelectedIndex(0);
+      } else {
+        setShowCustomCommand(true);
+      }
     } else if (input === "d" || key.delete) {
       const isHistory = selectedIndex < historyCount;
       if (isHistory) {
@@ -2682,7 +5231,9 @@ function ScriptList({
           }
         }
       }
-    } else if (key.escape || input === "q") {
+    } else if (input === "p" && allProjects.length > 1) {
+      setShowProjectSwitcher(true);
+    } else if (input === "q") {
       exit();
     }
   });
@@ -2714,12 +5265,40 @@ function ScriptList({
   const handleEditorCancel = () => {
     setShowEditor(false);
   };
+  const handleProjectSelect = (project) => {
+    setShowProjectSwitcher(false);
+    onProjectSwitch(project);
+  };
+  const handleProjectSwitcherCancel = () => {
+    setShowProjectSwitcher(false);
+  };
+  const handleCustomCommandSubmit = (name, command) => {
+    setShowCustomCommand(false);
+    executeCommand(command, exit, projectPath, name, true);
+  };
+  const handleCustomCommandCancel = () => {
+    setShowCustomCommand(false);
+  };
+  if (showCustomCommand) {
+    return /* @__PURE__ */ jsxDEV6(CustomCommandInput, {
+      onSubmit: handleCustomCommandSubmit,
+      onCancel: handleCustomCommandCancel
+    }, undefined, false, undefined, this);
+  }
+  if (showProjectSwitcher) {
+    return /* @__PURE__ */ jsxDEV6(ProjectSwitcher, {
+      projects: allProjects,
+      currentProjectPath: projectPath,
+      onSelect: handleProjectSelect,
+      onCancel: handleProjectSwitcherCancel
+    }, undefined, false, undefined, this);
+  }
   if (showArgInput) {
     const selectedScript = allScripts[selectedIndex];
     if (selectedScript) {
       const isHistory = selectedIndex < historyCount;
       const baseCommand = isHistory ? selectedScript.command : detector.buildCommand(packageInfo, selectedScript.name);
-      return /* @__PURE__ */ jsxDEV4(ArgumentInput, {
+      return /* @__PURE__ */ jsxDEV6(ArgumentInput, {
         scriptName: selectedScript.name,
         baseCommand,
         onSubmit: handleArgumentSubmit,
@@ -2732,7 +5311,7 @@ function ScriptList({
     if (selectedScript) {
       const isHistory = selectedIndex < historyCount;
       const fullCommand = isHistory ? selectedScript.command : detector.buildCommand(packageInfo, selectedScript.name);
-      return /* @__PURE__ */ jsxDEV4(CommandEditor, {
+      return /* @__PURE__ */ jsxDEV6(CommandEditor, {
         scriptName: selectedScript.name,
         initialCommand: fullCommand,
         onSubmit: handleEditorSubmit,
@@ -2741,29 +5320,29 @@ function ScriptList({
     }
   }
   if (allScripts.length === 0) {
-    return /* @__PURE__ */ jsxDEV4(Box4, {
+    return /* @__PURE__ */ jsxDEV6(Box6, {
       flexDirection: "column",
-      children: searchQuery ? /* @__PURE__ */ jsxDEV4(Fragment2, {
+      children: searchQuery ? /* @__PURE__ */ jsxDEV6(Fragment2, {
         children: [
-          /* @__PURE__ */ jsxDEV4(Box4, {
+          /* @__PURE__ */ jsxDEV6(Box6, {
             marginBottom: 1,
             children: [
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 color: "cyan",
                 children: "Search: "
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 color: "yellow",
                 children: searchQuery
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             dimColor: true,
             children: [
               "No matches found. Press ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "Esc"
               }, undefined, false, undefined, this),
@@ -2771,16 +5350,16 @@ function ScriptList({
             ]
           }, undefined, true, undefined, this)
         ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV4(Fragment2, {
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV6(Fragment2, {
         children: [
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             bold: true,
             color: "yellow",
             children: "Available Scripts:"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV4(Box4, {
+          /* @__PURE__ */ jsxDEV6(Box6, {
             marginLeft: 2,
-            children: /* @__PURE__ */ jsxDEV4(Text5, {
+            children: /* @__PURE__ */ jsxDEV6(Text7, {
               dimColor: true,
               children: "No scripts found"
             }, undefined, false, undefined, this)
@@ -2804,38 +5383,38 @@ function ScriptList({
   const visibleScripts = allScripts.slice(startIndex, endIndex);
   const hasMoreAbove = startIndex > 0;
   const hasMoreBelow = endIndex < totalItems;
-  return /* @__PURE__ */ jsxDEV4(Box4, {
+  return /* @__PURE__ */ jsxDEV6(Box6, {
     flexDirection: "column",
     children: [
-      (isSearching || searchQuery) && /* @__PURE__ */ jsxDEV4(Box4, {
+      (isSearching || searchQuery) && /* @__PURE__ */ jsxDEV6(Box6, {
         marginBottom: 1,
         borderStyle: "round",
         borderColor: "cyan",
         paddingX: 1,
         children: [
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             bold: true,
             color: "cyan",
             children: [
-              isSearching && /* @__PURE__ */ jsxDEV4(build_default, {
+              isSearching && /* @__PURE__ */ jsxDEV6(build_default, {
                 type: "dots"
               }, undefined, false, undefined, this),
               " Search:"
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             color: "yellow",
             children: searchQuery
           }, undefined, false, undefined, this),
-          isSearching && /* @__PURE__ */ jsxDEV4(Text5, {
+          isSearching && /* @__PURE__ */ jsxDEV6(Text7, {
             inverse: true,
             children: " "
           }, undefined, false, undefined, this),
-          searchQuery && !isSearching && /* @__PURE__ */ jsxDEV4(Text5, {
+          searchQuery && !isSearching && /* @__PURE__ */ jsxDEV6(Text7, {
             dimColor: true,
             children: [
               " (press ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "c"
               }, undefined, false, undefined, this),
@@ -2844,14 +5423,14 @@ function ScriptList({
           }, undefined, true, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      searchQuery && allScripts.length > 0 && /* @__PURE__ */ jsxDEV4(Box4, {
+      searchQuery && allScripts.length > 0 && /* @__PURE__ */ jsxDEV6(Box6, {
         marginBottom: 1,
         children: [
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             color: "green",
             children: "✓ "
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             dimColor: true,
             children: [
               allScripts.length,
@@ -2862,9 +5441,9 @@ function ScriptList({
           }, undefined, true, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      hasMoreAbove && /* @__PURE__ */ jsxDEV4(Box4, {
+      hasMoreAbove && /* @__PURE__ */ jsxDEV6(Box6, {
         marginBottom: 1,
-        children: /* @__PURE__ */ jsxDEV4(Text5, {
+        children: /* @__PURE__ */ jsxDEV6(Text7, {
           dimColor: true,
           children: [
             "↑ ",
@@ -2873,9 +5452,9 @@ function ScriptList({
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      historyCount > 0 && startIndex < historyCount && /* @__PURE__ */ jsxDEV4(Fragment2, {
+      historyCount > 0 && startIndex < historyCount && /* @__PURE__ */ jsxDEV6(Fragment2, {
         children: [
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             bold: true,
             color: "green",
             children: "⚡ Recent Commands:"
@@ -2890,27 +5469,27 @@ function ScriptList({
             if (displayText.length > maxLength) {
               displayText = displayText.substring(0, maxLength) + "... (" + displayText.length + " chars)";
             }
-            return /* @__PURE__ */ jsxDEV4(Box4, {
+            return /* @__PURE__ */ jsxDEV6(Box6, {
               marginLeft: 2,
               flexDirection: "column",
-              children: /* @__PURE__ */ jsxDEV4(Box4, {
+              children: /* @__PURE__ */ jsxDEV6(Box6, {
                 children: [
-                  isSelected ? /* @__PURE__ */ jsxDEV4(Text5, {
+                  isSelected ? /* @__PURE__ */ jsxDEV6(Text7, {
                     color: "cyan",
                     bold: true,
                     children: [
-                      /* @__PURE__ */ jsxDEV4(Text5, {
+                      /* @__PURE__ */ jsxDEV6(Text7, {
                         children: "▶ "
                       }, undefined, false, undefined, this),
                       script.name
                     ]
-                  }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV4(Text5, {
+                  }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV6(Text7, {
                     children: [
                       "  ",
                       script.name
                     ]
                   }, undefined, true, undefined, this),
-                  /* @__PURE__ */ jsxDEV4(Text5, {
+                  /* @__PURE__ */ jsxDEV6(Text7, {
                     dimColor: true,
                     children: [
                       " - ",
@@ -2921,14 +5500,14 @@ function ScriptList({
               }, undefined, true, undefined, this)
             }, `history-${actualIndex}`, false, undefined, this);
           }),
-          /* @__PURE__ */ jsxDEV4(Box4, {
+          /* @__PURE__ */ jsxDEV6(Box6, {
             marginTop: 1
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      endIndex > historyCount && /* @__PURE__ */ jsxDEV4(Fragment2, {
+      endIndex > historyCount && /* @__PURE__ */ jsxDEV6(Fragment2, {
         children: [
-          /* @__PURE__ */ jsxDEV4(Text5, {
+          /* @__PURE__ */ jsxDEV6(Text7, {
             bold: true,
             color: "yellow",
             children: "\uD83D\uDCDC Available Scripts:"
@@ -2943,27 +5522,27 @@ function ScriptList({
             if (displayText.length > maxLength) {
               displayText = displayText.substring(0, maxLength) + "...";
             }
-            return /* @__PURE__ */ jsxDEV4(Box4, {
+            return /* @__PURE__ */ jsxDEV6(Box6, {
               marginLeft: 2,
               flexDirection: "column",
-              children: /* @__PURE__ */ jsxDEV4(Box4, {
+              children: /* @__PURE__ */ jsxDEV6(Box6, {
                 children: [
-                  isSelected ? /* @__PURE__ */ jsxDEV4(Text5, {
+                  isSelected ? /* @__PURE__ */ jsxDEV6(Text7, {
                     color: "cyan",
                     bold: true,
                     children: [
-                      /* @__PURE__ */ jsxDEV4(Text5, {
+                      /* @__PURE__ */ jsxDEV6(Text7, {
                         children: "▶ "
                       }, undefined, false, undefined, this),
                       script.name
                     ]
-                  }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV4(Text5, {
+                  }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV6(Text7, {
                     children: [
                       "  ",
                       script.name
                     ]
                   }, undefined, true, undefined, this),
-                  /* @__PURE__ */ jsxDEV4(Text5, {
+                  /* @__PURE__ */ jsxDEV6(Text7, {
                     dimColor: true,
                     children: [
                       " - ",
@@ -2976,9 +5555,9 @@ function ScriptList({
           })
         ]
       }, undefined, true, undefined, this),
-      hasMoreBelow && /* @__PURE__ */ jsxDEV4(Box4, {
+      hasMoreBelow && /* @__PURE__ */ jsxDEV6(Box6, {
         marginTop: 1,
-        children: /* @__PURE__ */ jsxDEV4(Text5, {
+        children: /* @__PURE__ */ jsxDEV6(Text7, {
           dimColor: true,
           children: [
             "↓ ",
@@ -2987,71 +5566,97 @@ function ScriptList({
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV4(Box4, {
+      /* @__PURE__ */ jsxDEV6(Box6, {
         marginTop: 1,
         marginLeft: 2,
-        children: /* @__PURE__ */ jsxDEV4(Text5, {
+        children: /* @__PURE__ */ jsxDEV6(Text7, {
           dimColor: true,
-          children: isSearching ? /* @__PURE__ */ jsxDEV4(Fragment2, {
+          children: isSearching ? /* @__PURE__ */ jsxDEV6(Fragment2, {
             children: [
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "Type"
               }, undefined, false, undefined, this),
               " to search  ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
-                children: "↑/↓"
+                children: "↑/↓/k/j"
               }, undefined, false, undefined, this),
               " navigate  ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "Enter"
               }, undefined, false, undefined, this),
               " done  ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "Esc"
               }, undefined, false, undefined, this),
               " cancel"
             ]
-          }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV4(Fragment2, {
+          }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV6(Fragment2, {
             children: [
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
-                children: "↑/↓"
+                children: "↑/↓/k/j"
               }, undefined, false, undefined, this),
               " navigate  ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "Enter"
               }, undefined, false, undefined, this),
               " run  ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "a"
               }, undefined, false, undefined, this),
               " add args  ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "e"
               }, undefined, false, undefined, this),
               " edit  ",
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              searchQuery ? /* @__PURE__ */ jsxDEV6(Fragment2, {
+                children: [
+                  /* @__PURE__ */ jsxDEV6(Text7, {
+                    bold: true,
+                    children: "c"
+                  }, undefined, false, undefined, this),
+                  " clear  "
+                ]
+              }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV6(Fragment2, {
+                children: [
+                  /* @__PURE__ */ jsxDEV6(Text7, {
+                    bold: true,
+                    children: "c"
+                  }, undefined, false, undefined, this),
+                  " custom  "
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "/"
               }, undefined, false, undefined, this),
               " search  ",
-              historyCount > 0 && /* @__PURE__ */ jsxDEV4(Fragment2, {
+              historyCount > 0 && /* @__PURE__ */ jsxDEV6(Fragment2, {
                 children: [
-                  /* @__PURE__ */ jsxDEV4(Text5, {
+                  /* @__PURE__ */ jsxDEV6(Text7, {
                     bold: true,
                     children: "d"
                   }, undefined, false, undefined, this),
                   " delete  "
                 ]
               }, undefined, true, undefined, this),
-              /* @__PURE__ */ jsxDEV4(Text5, {
+              allProjects.length > 1 && /* @__PURE__ */ jsxDEV6(Fragment2, {
+                children: [
+                  /* @__PURE__ */ jsxDEV6(Text7, {
+                    bold: true,
+                    children: "p"
+                  }, undefined, false, undefined, this),
+                  " projects  "
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV6(Text7, {
                 bold: true,
                 children: "q"
               }, undefined, false, undefined, this),
@@ -3065,32 +5670,32 @@ function ScriptList({
 }
 
 // src/components/ErrorMessage.tsx
-import { Text as Text6, Box as Box5 } from "ink";
-import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+import { Text as Text8, Box as Box7 } from "ink";
+import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
 function ErrorMessage({ error, supportedEcosystems }) {
-  return /* @__PURE__ */ jsxDEV5(Box5, {
+  return /* @__PURE__ */ jsxDEV7(Box7, {
     flexDirection: "column",
     padding: 1,
     children: [
-      /* @__PURE__ */ jsxDEV5(Box5, {
+      /* @__PURE__ */ jsxDEV7(Box7, {
         borderStyle: "double",
         borderColor: "red",
         padding: 1,
-        children: /* @__PURE__ */ jsxDEV5(Text6, {
+        children: /* @__PURE__ */ jsxDEV7(Text8, {
           bold: true,
           color: "red",
           children: "❌ No Project Found"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV5(Box5, {
+      /* @__PURE__ */ jsxDEV7(Box7, {
         marginTop: 1,
-        children: /* @__PURE__ */ jsxDEV5(Text6, {
+        children: /* @__PURE__ */ jsxDEV7(Text8, {
           children: error
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV5(Box5, {
+      /* @__PURE__ */ jsxDEV7(Box7, {
         marginTop: 1,
-        children: /* @__PURE__ */ jsxDEV5(Text6, {
+        children: /* @__PURE__ */ jsxDEV7(Text8, {
           dimColor: true,
           children: [
             "Supported ecosystems: ",
@@ -3103,16 +5708,19 @@ function ErrorMessage({ error, supportedEcosystems }) {
 }
 
 // src/app.tsx
-import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
 function App() {
-  const [result, setResult] = useState5(null);
-  const [history, setHistory] = useState5([]);
-  const [loading, setLoading] = useState5(true);
+  const [result, setResult] = useState7(null);
+  const [allProjects, setAllProjects] = useState7([]);
+  const [history, setHistory] = useState7([]);
+  const [loading, setLoading] = useState7(true);
   useEffect3(() => {
     const detectProject = async () => {
       const cwd = process.cwd();
       const detectionResult = await registry.detect(cwd);
       setResult(detectionResult);
+      const allDetected = await registry.detectAll(cwd);
+      setAllProjects(allDetected);
       if (detectionResult.found && detectionResult.packageInfo) {
         const projectPath2 = detectionResult.packageInfo.path.replace(/\/(package\.json|pyproject\.toml|Pipfile|requirements\.txt)$/, "");
         const projectHistory = await getHistory(projectPath2);
@@ -3122,48 +5730,58 @@ function App() {
     };
     detectProject();
   }, []);
+  const handleProjectSwitch = async (newProject) => {
+    if (!newProject.packageInfo)
+      return;
+    setResult(newProject);
+    const projectPath2 = newProject.packageInfo.path.replace(/\/(package\.json|pyproject\.toml|Pipfile|requirements\.txt)$/, "");
+    const projectHistory = await getHistory(projectPath2);
+    setHistory(projectHistory);
+  };
   if (loading) {
-    return /* @__PURE__ */ jsxDEV6(Box6, {
+    return /* @__PURE__ */ jsxDEV8(Box8, {
       padding: 1,
       children: [
-        /* @__PURE__ */ jsxDEV6(Text7, {
+        /* @__PURE__ */ jsxDEV8(Text9, {
           color: "cyan",
-          children: /* @__PURE__ */ jsxDEV6(build_default, {
+          children: /* @__PURE__ */ jsxDEV8(build_default, {
             type: "dots"
           }, undefined, false, undefined, this)
         }, undefined, false, undefined, this),
-        /* @__PURE__ */ jsxDEV6(Text7, {
+        /* @__PURE__ */ jsxDEV8(Text9, {
           children: " Detecting project..."
         }, undefined, false, undefined, this)
       ]
     }, undefined, true, undefined, this);
   }
   if (!result?.found) {
-    return /* @__PURE__ */ jsxDEV6(ErrorMessage, {
+    return /* @__PURE__ */ jsxDEV8(ErrorMessage, {
       error: result?.error || "Unknown error",
       supportedEcosystems: registry.getSupportedEcosystems()
     }, undefined, false, undefined, this);
   }
   const { packageInfo, detector } = result;
   const projectPath = packageInfo.path.replace(/\/(package\.json|pyproject\.toml|Pipfile|requirements\.txt)$/, "");
-  return /* @__PURE__ */ jsxDEV6(Box6, {
+  return /* @__PURE__ */ jsxDEV8(Box8, {
     flexDirection: "column",
     padding: 1,
     children: [
-      /* @__PURE__ */ jsxDEV6(Header, {
+      /* @__PURE__ */ jsxDEV8(Header, {
         packageInfo,
         ecosystemName: detector.name
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV6(Box6, {
+      /* @__PURE__ */ jsxDEV8(Box8, {
         marginTop: 1,
         borderStyle: "single",
         borderColor: "gray",
         padding: 1,
-        children: /* @__PURE__ */ jsxDEV6(ScriptList, {
+        children: /* @__PURE__ */ jsxDEV8(ScriptList, {
           packageInfo,
           detector,
           history,
-          projectPath
+          projectPath,
+          allProjects,
+          onProjectSwitch: handleProjectSwitch
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this)
     ]
@@ -3171,10 +5789,11 @@ function App() {
 }
 
 // src/cli.tsx
-import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
-var { waitUntilExit, clear } = render(/* @__PURE__ */ jsxDEV7(App, {}, undefined, false, undefined, this), {
+import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
+var { waitUntilExit, clear } = render(/* @__PURE__ */ jsxDEV9(App, {}, undefined, false, undefined, this), {
   exitOnCtrlC: true,
   patchConsole: false
 });
 await waitUntilExit();
 clear();
+process.stdout.write("\x1Bc");