@taskless/cli 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Taskless
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# @taskless/cli
+
+> A Work in Progress
+
+CLI companion for [Taskless](https://taskless.io). Designed to be invoked by skills via `npx` or `pnpm dlx`. Useful for agents, and works for humans too.
+
+## Usage
+
+```bash
+# npm
+npx @taskless/cli@latest info
+
+# pnpm
+pnpm dlx @taskless/cli@latest info
+```
+
+## Commands
+
+### `taskless info`
+
+Outputs CLI version as JSON to stdout:
+
+```json
+{ "version": "0.0.1" }
+```
+
+### `taskless --help`
+
+Lists available subcommands.
+
+## For skill authors
+
+Skills should detect the package manager by checking for lock files and invoke the CLI accordingly:
+
+1. If `pnpm-lock.yaml` exists, use `pnpm dlx @taskless/cli@latest <command>`
+2. Otherwise, use `npx @taskless/cli@latest <command>`
+
+All commands output structured JSON to stdout by default. Parse with `JSON.parse()` and handle non-zero exit codes as errors.

package/dist/index.js

@@ -0,0 +1,821 @@
+#!/usr/bin/env node
+import * as O from "node:tty";
+const g = {
+  fatal: 0,
+  error: 0,
+  warn: 1,
+  log: 2,
+  info: 3,
+  success: 3,
+  fail: 3,
+  debug: 4,
+  trace: 5,
+  verbose: Number.POSITIVE_INFINITY
+}, j = {
+  // Silent
+  silent: {
+    level: -1
+  },
+  // Level 0
+  fatal: {
+    level: g.fatal
+  },
+  error: {
+    level: g.error
+  },
+  // Level 1
+  warn: {
+    level: g.warn
+  },
+  // Level 2
+  log: {
+    level: g.log
+  },
+  // Level 3
+  info: {
+    level: g.info
+  },
+  success: {
+    level: g.success
+  },
+  fail: {
+    level: g.fail
+  },
+  ready: {
+    level: g.info
+  },
+  start: {
+    level: g.info
+  },
+  box: {
+    level: g.info
+  },
+  // Level 4
+  debug: {
+    level: g.debug
+  },
+  // Level 5
+  trace: {
+    level: g.trace
+  },
+  // Verbose
+  verbose: {
+    level: g.verbose
+  }
+};
+function S(t) {
+  if (t === null || typeof t != "object")
+    return !1;
+  const e = Object.getPrototypeOf(t);
+  return e !== null && e !== Object.prototype && Object.getPrototypeOf(e) !== null || Symbol.iterator in t ? !1 : Symbol.toStringTag in t ? Object.prototype.toString.call(t) === "[object Module]" : !0;
+}
+function M(t, e, o = ".", r) {
+  if (!S(e))
+    return M(t, {}, o);
+  const n = Object.assign({}, e);
+  for (const s in t) {
+    if (s === "__proto__" || s === "constructor")
+      continue;
+    const l = t[s];
+    l != null && (Array.isArray(l) && Array.isArray(n[s]) ? n[s] = [...l, ...n[s]] : S(l) && S(n[s]) ? n[s] = M(
+      l,
+      n[s],
+      (o ? `${o}.` : "") + s.toString()
+    ) : n[s] = l);
+  }
+  return n;
+}
+function W(t) {
+  return (...e) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    e.reduce((o, r) => M(o, r, ""), {})
+  );
+}
+const z = W();
+function V(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function Y(t) {
+  return !(!V(t) || !t.message && !t.args || t.stack);
+}
+let $ = !1;
+const I = [];
+class h {
+  options;
+  _lastLog;
+  _mockFn;
+  /**
+   * Creates an instance of Consola with specified options or defaults.
+   *
+   * @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
+   */
+  constructor(e = {}) {
+    const o = e.types || j;
+    this.options = z(
+      {
+        ...e,
+        defaults: { ...e.defaults },
+        level: k(e.level, o),
+        reporters: [...e.reporters || []]
+      },
+      {
+        types: j,
+        throttle: 1e3,
+        throttleMin: 5,
+        formatOptions: {
+          date: !0,
+          colors: !1,
+          compact: !0
+        }
+      }
+    );
+    for (const r in o) {
+      const n = {
+        type: r,
+        ...this.options.defaults,
+        ...o[r]
+      };
+      this[r] = this._wrapLogFn(n), this[r].raw = this._wrapLogFn(
+        n,
+        !0
+      );
+    }
+    this.options.mockFn && this.mockTypes(), this._lastLog = {};
+  }
+  /**
+   * Gets the current log level of the Consola instance.
+   *
+   * @returns {number} The current log level.
+   */
+  get level() {
+    return this.options.level;
+  }
+  /**
+   * Sets the minimum log level that will be output by the instance.
+   *
+   * @param {number} level - The new log level to set.
+   */
+  set level(e) {
+    this.options.level = k(
+      e,
+      this.options.types,
+      this.options.level
+    );
+  }
+  /**
+   * Displays a prompt to the user and returns the response.
+   * Throw an error if `prompt` is not supported by the current configuration.
+   *
+   * @template T
+   * @param {string} message - The message to display in the prompt.
+   * @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
+   * @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
+   */
+  prompt(e, o) {
+    if (!this.options.prompt)
+      throw new Error("prompt is not supported!");
+    return this.options.prompt(e, o);
+  }
+  /**
+   * Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
+   *
+   * @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  create(e) {
+    const o = new h({
+      ...this.options,
+      ...e
+    });
+    return this._mockFn && o.mockTypes(this._mockFn), o;
+  }
+  /**
+   * Creates a new Consola instance with the specified default log object properties.
+   *
+   * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withDefaults(e) {
+    return this.create({
+      ...this.options,
+      defaults: {
+        ...this.options.defaults,
+        ...e
+      }
+    });
+  }
+  /**
+   * Creates a new Consola instance with a specified tag, which will be included in every log.
+   *
+   * @param {string} tag - The tag to include in each log of the new instance.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withTag(e) {
+    return this.withDefaults({
+      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + e : e
+    });
+  }
+  /**
+   * Adds a custom reporter to the Consola instance.
+   * Reporters will be called for each log message, depending on their implementation and log level.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  addReporter(e) {
+    return this.options.reporters.push(e), this;
+  }
+  /**
+   * Removes a custom reporter from the Consola instance.
+   * If no reporter is specified, all reporters will be removed.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  removeReporter(e) {
+    if (e) {
+      const o = this.options.reporters.indexOf(e);
+      if (o !== -1)
+        return this.options.reporters.splice(o, 1);
+    } else
+      this.options.reporters.splice(0);
+    return this;
+  }
+  /**
+   * Replaces all reporters of the Consola instance with the specified array of reporters.
+   *
+   * @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  setReporters(e) {
+    return this.options.reporters = Array.isArray(e) ? e : [e], this;
+  }
+  wrapAll() {
+    this.wrapConsole(), this.wrapStd();
+  }
+  restoreAll() {
+    this.restoreConsole(), this.restoreStd();
+  }
+  /**
+   * Overrides console methods with Consola logging methods for consistent logging.
+   */
+  wrapConsole() {
+    for (const e in this.options.types)
+      console["__" + e] || (console["__" + e] = console[e]), console[e] = this[e].raw;
+  }
+  /**
+   * Restores the original console methods, removing Consola overrides.
+   */
+  restoreConsole() {
+    for (const e in this.options.types)
+      console["__" + e] && (console[e] = console["__" + e], delete console["__" + e]);
+  }
+  /**
+   * Overrides standard output and error streams to redirect them through Consola.
+   */
+  wrapStd() {
+    this._wrapStream(this.options.stdout, "log"), this._wrapStream(this.options.stderr, "log");
+  }
+  _wrapStream(e, o) {
+    e && (e.__write || (e.__write = e.write), e.write = (r) => {
+      this[o].raw(String(r).trim());
+    });
+  }
+  /**
+   * Restores the original standard output and error streams, removing the Consola redirection.
+   */
+  restoreStd() {
+    this._restoreStream(this.options.stdout), this._restoreStream(this.options.stderr);
+  }
+  _restoreStream(e) {
+    e && e.__write && (e.write = e.__write, delete e.__write);
+  }
+  /**
+   * Pauses logging, queues incoming logs until resumed.
+   */
+  pauseLogs() {
+    $ = !0;
+  }
+  /**
+   * Resumes logging, processing any queued logs.
+   */
+  resumeLogs() {
+    $ = !1;
+    const e = I.splice(0);
+    for (const o of e)
+      o[0]._logFn(o[1], o[2]);
+  }
+  /**
+   * Replaces logging methods with mocks if a mock function is provided.
+   *
+   * @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
+   */
+  mockTypes(e) {
+    const o = e || this.options.mockFn;
+    if (this._mockFn = o, typeof o == "function")
+      for (const r in this.options.types)
+        this[r] = o(r, this.options.types[r]) || this[r], this[r].raw = this[r];
+  }
+  _wrapLogFn(e, o) {
+    return (...r) => {
+      if ($) {
+        I.push([this, e, r, o]);
+        return;
+      }
+      return this._logFn(e, r, o);
+    };
+  }
+  _logFn(e, o, r) {
+    if ((e.level || 0) > this.level)
+      return !1;
+    const n = {
+      date: /* @__PURE__ */ new Date(),
+      args: [],
+      ...e,
+      level: k(e.level, this.options.types)
+    };
+    !r && o.length === 1 && Y(o[0]) ? Object.assign(n, o[0]) : n.args = [...o], n.message && (n.args.unshift(n.message), delete n.message), n.additional && (Array.isArray(n.additional) || (n.additional = n.additional.split(`
+`)), n.args.push(`
+` + n.additional.join(`
+`)), delete n.additional), n.type = typeof n.type == "string" ? n.type.toLowerCase() : "log", n.tag = typeof n.tag == "string" ? n.tag : "";
+    const s = (i = !1) => {
+      const a = (this._lastLog.count || 0) - this.options.throttleMin;
+      if (this._lastLog.object && a > 0) {
+        const u = [...this._lastLog.object.args];
+        a > 1 && u.push(`(repeated ${a} times)`), this._log({ ...this._lastLog.object, args: u }), this._lastLog.count = 1;
+      }
+      i && (this._lastLog.object = n, this._log(n));
+    };
+    clearTimeout(this._lastLog.timeout);
+    const l = this._lastLog.time && n.date ? n.date.getTime() - this._lastLog.time.getTime() : 0;
+    if (this._lastLog.time = n.date, l < this.options.throttle)
+      try {
+        const i = JSON.stringify([
+          n.type,
+          n.tag,
+          n.args
+        ]), a = this._lastLog.serialized === i;
+        if (this._lastLog.serialized = i, a && (this._lastLog.count = (this._lastLog.count || 0) + 1, this._lastLog.count > this.options.throttleMin)) {
+          this._lastLog.timeout = setTimeout(
+            s,
+            this.options.throttle
+          );
+          return;
+        }
+      } catch {
+      }
+    s(!0);
+  }
+  _log(e) {
+    for (const o of this.options.reporters)
+      o.log(e, {
+        options: this.options
+      });
+  }
+}
+function k(t, e = {}, o = 3) {
+  return t === void 0 ? o : typeof t == "number" ? t : e[t] && e[t].level !== void 0 ? e[t].level : o;
+}
+h.prototype.add = h.prototype.addReporter;
+h.prototype.remove = h.prototype.removeReporter;
+h.prototype.clear = h.prototype.removeReporter;
+h.prototype.withScope = h.prototype.withTag;
+h.prototype.mock = h.prototype.mockTypes;
+h.prototype.pause = h.prototype.pauseLogs;
+h.prototype.resume = h.prototype.resumeLogs;
+function J(t = {}) {
+  return new h(t);
+}
+class K {
+  options;
+  defaultColor;
+  levelColorMap;
+  typeColorMap;
+  constructor(e) {
+    this.options = { ...e }, this.defaultColor = "#7f8c8d", this.levelColorMap = {
+      0: "#c0392b",
+      // Red
+      1: "#f39c12",
+      // Yellow
+      3: "#00BCD4"
+      // Cyan
+    }, this.typeColorMap = {
+      success: "#2ecc71"
+      // Green
+    };
+  }
+  _getLogFn(e) {
+    return e < 1 ? console.__error || console.error : e === 1 ? console.__warn || console.warn : console.__log || console.log;
+  }
+  log(e) {
+    const o = this._getLogFn(e.level), r = e.type === "log" ? "" : e.type, n = e.tag || "", l = `
+      background: ${this.typeColorMap[e.type] || this.levelColorMap[e.level] || this.defaultColor};
+      border-radius: 0.5em;
+      color: white;
+      font-weight: bold;
+      padding: 2px 0.5em;
+    `, i = `%c${[n, r].filter(Boolean).join(":")}`;
+    typeof e.args[0] == "string" ? o(
+      `${i}%c ${e.args[0]}`,
+      l,
+      // Empty string as style resets to default console style
+      "",
+      ...e.args.slice(1)
+    ) : o(i, l, ...e.args);
+  }
+}
+function Q(t = {}) {
+  return J({
+    reporters: t.reporters || [new K({})],
+    prompt(o, r = {}) {
+      return r.type === "confirm" ? Promise.resolve(confirm(o)) : Promise.resolve(prompt(o));
+    },
+    ...t
+  });
+}
+const L = Q(), {
+  env: b = {},
+  argv: R = [],
+  platform: X = ""
+} = typeof process > "u" ? {} : process, Z = "NO_COLOR" in b || R.includes("--no-color"), ee = "FORCE_COLOR" in b || R.includes("--color"), te = X === "win32", E = b.TERM === "dumb", oe = O && O.isatty && O.isatty(1) && b.TERM && !E, ne = "CI" in b && ("GITHUB_ACTIONS" in b || "GITLAB_CI" in b || "CIRCLECI" in b), re = !Z && (ee || te && !E || oe || ne);
+function F(t, e, o, r, n = e.slice(0, Math.max(0, t)) + r, s = e.slice(Math.max(0, t + o.length)), l = s.indexOf(o)) {
+  return n + (l < 0 ? s : F(l, s, o, r));
+}
+function se(t, e, o, r, n) {
+  return t < 0 ? o + e + r : o + F(t, e, r, n) + r;
+}
+function ie(t, e, o = t, r = t.length + 1) {
+  return (n) => n || !(n === "" || n === void 0) ? se(
+    ("" + n).indexOf(e, r),
+    n,
+    t,
+    e,
+    o
+  ) : "";
+}
+function c(t, e, o) {
+  return ie(`\x1B[${t}m`, `\x1B[${e}m`, o);
+}
+const N = {
+  reset: c(0, 0),
+  bold: c(1, 22, "\x1B[22m\x1B[1m"),
+  dim: c(2, 22, "\x1B[22m\x1B[2m"),
+  italic: c(3, 23),
+  underline: c(4, 24),
+  inverse: c(7, 27),
+  hidden: c(8, 28),
+  strikethrough: c(9, 29),
+  black: c(30, 39),
+  red: c(31, 39),
+  green: c(32, 39),
+  yellow: c(33, 39),
+  blue: c(34, 39),
+  magenta: c(35, 39),
+  cyan: c(36, 39),
+  white: c(37, 39),
+  gray: c(90, 39),
+  bgBlack: c(40, 49),
+  bgRed: c(41, 49),
+  bgGreen: c(42, 49),
+  bgYellow: c(43, 49),
+  bgBlue: c(44, 49),
+  bgMagenta: c(45, 49),
+  bgCyan: c(46, 49),
+  bgWhite: c(47, 49),
+  blackBright: c(90, 39),
+  redBright: c(91, 39),
+  greenBright: c(92, 39),
+  yellowBright: c(93, 39),
+  blueBright: c(94, 39),
+  magentaBright: c(95, 39),
+  cyanBright: c(96, 39),
+  whiteBright: c(97, 39),
+  bgBlackBright: c(100, 49),
+  bgRedBright: c(101, 49),
+  bgGreenBright: c(102, 49),
+  bgYellowBright: c(103, 49),
+  bgBlueBright: c(104, 49),
+  bgMagentaBright: c(105, 49),
+  bgCyanBright: c(106, 49),
+  bgWhiteBright: c(107, 49)
+};
+function ae(t = re) {
+  return t ? N : Object.fromEntries(Object.keys(N).map((e) => [e, String]));
+}
+const w = ae();
+function le(t) {
+  return Array.isArray(t) ? t : t === void 0 ? [] : [t];
+}
+function x(t, e = "") {
+  const o = [];
+  for (const r of t)
+    for (const [n, s] of r.entries())
+      o[n] = Math.max(o[n] || 0, s.length);
+  return t.map(
+    (r) => r.map(
+      (n, s) => e + n[s === 0 ? "padStart" : "padEnd"](o[s])
+    ).join("  ")
+  ).join(`
+`);
+}
+function m(t) {
+  return typeof t == "function" ? t() : t;
+}
+class C extends Error {
+  constructor(e, o) {
+    super(e), this.code = o, this.name = "CLIError";
+  }
+}
+const ce = /\d/, ue = ["-", "_", "/", "."];
+function fe(t = "") {
+  if (!ce.test(t))
+    return t !== t.toLowerCase();
+}
+function U(t, e) {
+  const o = ue, r = [];
+  if (!t || typeof t != "string")
+    return r;
+  let n = "", s, l;
+  for (const i of t) {
+    const a = o.includes(i);
+    if (a === !0) {
+      r.push(n), n = "", s = void 0;
+      continue;
+    }
+    const u = fe(i);
+    if (l === !1) {
+      if (s === !1 && u === !0) {
+        r.push(n), n = i, s = u;
+        continue;
+      }
+      if (s === !0 && u === !1 && n.length > 1) {
+        const p = n.at(-1);
+        r.push(n.slice(0, Math.max(0, n.length - 1))), n = p + i, s = u;
+        continue;
+      }
+    }
+    n += i, s = u, l = a;
+  }
+  return r.push(n), r;
+}
+function pe(t) {
+  return t ? t[0].toUpperCase() + t.slice(1) : "";
+}
+function he(t) {
+  return t ? t[0].toLowerCase() + t.slice(1) : "";
+}
+function ge(t, e) {
+  return t ? (Array.isArray(t) ? t : U(t)).map((o) => pe(o)).join("") : "";
+}
+function de(t, e) {
+  return he(ge(t || ""));
+}
+function me(t, e) {
+  return t ? (Array.isArray(t) ? t : U(t)).map((o) => o.toLowerCase()).join("-") : "";
+}
+function B(t) {
+  return t == null ? [] : Array.isArray(t) ? t : [t];
+}
+function ye(t, e, o, r) {
+  let n;
+  const s = t[e], l = ~r.string.indexOf(e) ? o == null || o === !0 ? "" : String(o) : typeof o == "boolean" ? o : ~r.boolean.indexOf(e) ? o === "false" ? !1 : o === "true" || (t._.push((n = +o, n * 0 === 0 ? n : o)), !!o) : (n = +o, n * 0 === 0 ? n : o);
+  t[e] = s == null ? l : Array.isArray(s) ? s.concat(l) : [s, l];
+}
+function we(t = [], e = {}) {
+  let o, r, n, s, l;
+  const i = { _: [] };
+  let a = 0, u = 0, p = 0;
+  const v = t.length, A = e.alias !== void 0, f = e.unknown !== void 0, d = e.default !== void 0;
+  if (e.alias = e.alias || {}, e.string = B(e.string), e.boolean = B(e.boolean), A)
+    for (o in e.alias)
+      for (r = e.alias[o] = B(e.alias[o]), a = 0; a < r.length; a++)
+        (e.alias[r[a]] = r.concat(o)).splice(a, 1);
+  for (a = e.boolean.length; a-- > 0; )
+    for (r = e.alias[e.boolean[a]] || [], u = r.length; u-- > 0; )
+      e.boolean.push(r[u]);
+  for (a = e.string.length; a-- > 0; )
+    for (r = e.alias[e.string[a]] || [], u = r.length; u-- > 0; )
+      e.string.push(r[u]);
+  if (d) {
+    for (o in e.default)
+      if (s = typeof e.default[o], r = e.alias[o] = e.alias[o] || [], e[s] !== void 0)
+        for (e[s].push(o), a = 0; a < r.length; a++)
+          e[s].push(r[a]);
+  }
+  const y = f ? Object.keys(e.alias) : [];
+  for (a = 0; a < v; a++) {
+    if (n = t[a], n === "--") {
+      i._ = i._.concat(t.slice(++a));
+      break;
+    }
+    for (u = 0; u < n.length && n.charCodeAt(u) === 45; u++)
+      ;
+    if (u === 0)
+      i._.push(n);
+    else if (n.substring(u, u + 3) === "no-") {
+      if (s = n.slice(Math.max(0, u + 3)), f && !~y.indexOf(s))
+        return e.unknown(n);
+      i[s] = !1;
+    } else {
+      for (p = u + 1; p < n.length && n.charCodeAt(p) !== 61; p++)
+        ;
+      for (s = n.substring(u, p), l = n.slice(Math.max(0, ++p)) || a + 1 === v || ("" + t[a + 1]).charCodeAt(0) === 45 || t[++a], r = u === 2 ? [s] : s, p = 0; p < r.length; p++) {
+        if (s = r[p], f && !~y.indexOf(s))
+          return e.unknown("-".repeat(u) + s);
+        ye(i, s, p + 1 < r.length || l, e);
+      }
+    }
+  }
+  if (d)
+    for (o in e.default)
+      i[o] === void 0 && (i[o] = e.default[o]);
+  if (A)
+    for (o in i)
+      for (r = e.alias[o] || []; r.length > 0; )
+        i[r.shift()] = i[o];
+  return i;
+}
+function be(t, e) {
+  const o = {
+    boolean: [],
+    string: [],
+    mixed: [],
+    alias: {},
+    default: {}
+  }, r = P(e);
+  for (const i of r)
+    i.type !== "positional" && (i.type === "string" ? o.string.push(i.name) : i.type === "boolean" && o.boolean.push(i.name), i.default !== void 0 && (o.default[i.name] = i.default), i.alias && (o.alias[i.name] = i.alias));
+  const n = we(t, o), [...s] = n._, l = new Proxy(n, {
+    get(i, a) {
+      return i[a] ?? i[de(a)] ?? i[me(a)];
+    }
+  });
+  for (const [, i] of r.entries())
+    if (i.type === "positional") {
+      const a = s.shift();
+      if (a !== void 0)
+        l[i.name] = a;
+      else {
+        if (i.default === void 0 && i.required !== !1)
+          throw new C(
+            `Missing required positional argument: ${i.name.toUpperCase()}`,
+            "EARG"
+          );
+        l[i.name] = i.default;
+      }
+    } else if (i.required && l[i.name] === void 0)
+      throw new C(`Missing required argument: --${i.name}`, "EARG");
+  return l;
+}
+function P(t) {
+  const e = [];
+  for (const [o, r] of Object.entries(t || {}))
+    e.push({
+      ...r,
+      name: o,
+      alias: le(r.alias)
+    });
+  return e;
+}
+async function D(t, e) {
+  const o = await m(t.args || {}), r = be(e.rawArgs, o), n = {
+    rawArgs: e.rawArgs,
+    args: r,
+    data: e.data,
+    cmd: t
+  };
+  typeof t.setup == "function" && await t.setup(n);
+  let s;
+  try {
+    const l = await m(t.subCommands);
+    if (l && Object.keys(l).length > 0) {
+      const i = e.rawArgs.findIndex(
+        (u) => !u.startsWith("-")
+      ), a = e.rawArgs[i];
+      if (a) {
+        if (!l[a])
+          throw new C(
+            `Unknown command \`${a}\``,
+            "E_UNKNOWN_COMMAND"
+          );
+        const u = await m(l[a]);
+        u && await D(u, {
+          rawArgs: e.rawArgs.slice(i + 1)
+        });
+      } else if (!t.run)
+        throw new C("No command specified.", "E_NO_COMMAND");
+    }
+    typeof t.run == "function" && (s = await t.run(n));
+  } finally {
+    typeof t.cleanup == "function" && await t.cleanup(n);
+  }
+  return { result: s };
+}
+async function T(t, e, o) {
+  const r = await m(t.subCommands);
+  if (r && Object.keys(r).length > 0) {
+    const n = e.findIndex((i) => !i.startsWith("-")), s = e[n], l = await m(r[s]);
+    if (l)
+      return T(
+        l,
+        e.slice(n + 1),
+        t
+      );
+  }
+  return [t, o];
+}
+async function q(t, e) {
+  try {
+    L.log(await _e(t, e) + `
+`);
+  } catch (o) {
+    L.error(o);
+  }
+}
+async function _e(t, e) {
+  const o = await m(t.meta || {}), r = P(await m(t.args || {})), n = await m(e?.meta || {}), s = `${n.name ? `${n.name} ` : ""}` + (o.name || process.argv[1]), l = [], i = [], a = [], u = [];
+  for (const f of r)
+    if (f.type === "positional") {
+      const d = f.name.toUpperCase(), y = f.required !== !1 && f.default === void 0, _ = f.default ? `="${f.default}"` : "";
+      i.push([
+        "`" + d + _ + "`",
+        f.description || "",
+        f.valueHint ? `<${f.valueHint}>` : ""
+      ]), u.push(y ? `<${d}>` : `[${d}]`);
+    } else {
+      const d = f.required === !0 && f.default === void 0, y = (f.type === "boolean" && f.default === !0 ? [
+        ...(f.alias || []).map((_) => `--no-${_}`),
+        `--no-${f.name}`
+      ].join(", ") : [...(f.alias || []).map((_) => `-${_}`), `--${f.name}`].join(
+        ", "
+      )) + (f.type === "string" && (f.valueHint || f.default) ? `=${f.valueHint ? `<${f.valueHint}>` : `"${f.default || ""}"`}` : "");
+      l.push([
+        "`" + y + (d ? " (required)" : "") + "`",
+        f.description || ""
+      ]), d && u.push(y);
+    }
+  if (t.subCommands) {
+    const f = [], d = await m(t.subCommands);
+    for (const [y, _] of Object.entries(d)) {
+      const G = await m(_), H = await m(G?.meta);
+      a.push([`\`${y}\``, H?.description || ""]), f.push(y);
+    }
+    u.push(f.join("|"));
+  }
+  const p = [], v = o.version || n.version;
+  p.push(
+    w.gray(
+      `${o.description} (${s + (v ? ` v${v}` : "")})`
+    ),
+    ""
+  );
+  const A = l.length > 0 || i.length > 0;
+  return p.push(
+    `${w.underline(w.bold("USAGE"))} \`${s}${A ? " [OPTIONS]" : ""} ${u.join(" ")}\``,
+    ""
+  ), i.length > 0 && (p.push(w.underline(w.bold("ARGUMENTS")), ""), p.push(x(i, "  ")), p.push("")), l.length > 0 && (p.push(w.underline(w.bold("OPTIONS")), ""), p.push(x(l, "  ")), p.push("")), a.length > 0 && (p.push(w.underline(w.bold("COMMANDS")), ""), p.push(x(a, "  ")), p.push(
+    "",
+    `Use \`${s} <command> --help\` for more information about a command.`
+  )), p.filter((f) => typeof f == "string").join(`
+`);
+}
+async function Ce(t, e = {}) {
+  const o = e.rawArgs || process.argv.slice(2), r = e.showUsage || q;
+  try {
+    if (o.includes("--help") || o.includes("-h"))
+      await r(...await T(t, o)), process.exit(0);
+    else if (o.length === 1 && o[0] === "--version") {
+      const n = typeof t.meta == "function" ? await t.meta() : await t.meta;
+      if (!n?.version)
+        throw new C("No version specified", "E_NO_VERSION");
+      L.log(n.version);
+    } else
+      await D(t, { rawArgs: o });
+  } catch (n) {
+    const s = n instanceof C;
+    s || L.error(n, `
+`), s && await r(...await T(t, o)), L.error(n.message), process.exit(1);
+  }
+}
+const ve = {
+  meta: {
+    name: "info",
+    description: "Show Taskless CLI information"
+  },
+  run() {
+    console.log(JSON.stringify({ version: "0.0.2" }));
+  }
+}, Le = {
+  meta: {
+    name: "taskless",
+    version: "0.0.2",
+    description: "Taskless CLI"
+  },
+  subCommands: {
+    info: ve
+  },
+  async run({ rawArgs: t, cmd: e }) {
+    t.some((o) => !o.startsWith("-")) || await q(e);
+  }
+};
+Ce(Le);

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@taskless/cli",
+  "version": "0.0.2",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/taskless/skills.git",
+    "directory": "packages/cli"
+  },
+  "type": "module",
+  "bin": {
+    "taskless": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "citty": "^0.1.6"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2",
+    "vite": "^7.3.1",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.3"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}