gennady 0.8.2 → 0.8.4

package/dist/chunks/index-DqSFtXFv.js

@@ -0,0 +1,813 @@
+import { execSync as Q } from "node:child_process";
+import { existsSync as K, readFileSync as Y, readdirSync as H, statSync as Z, lstatSync as ee } from "node:fs";
+import { resolve as y, relative as P, extname as F, join as te } from "node:path";
+import { l as C, D as ne, a as se, b as oe, s as ie } from "./services-IgZptnTi.js";
+import { p as re } from "./shared-9J_oXE74.js";
+class w {
+  /** @purpose Collected lint errors — empty array when clean. */
+  errors;
+  /** @purpose Count of errors auto-fixed by DbcContractCheck. */
+  autoFixed;
+  /** @purpose Deduplicated task file paths resolved from @tasks annotations in linted files. */
+  taskPaths;
+  /** @purpose Deduplicated spec file paths resolved from task files. */
+  specPaths;
+  /**
+   * @purpose Creates a LintReport with collected errors, autoFixed count, and resolved references.
+   * @param errors Collected lint errors.
+   * @param [autoFixed] Count of auto-fixed errors, defaults to 0.
+   * @param [taskPaths] Resolved task file paths (deduplicated).
+   * @param [specPaths] Resolved spec file paths (deduplicated).
+   */
+  constructor(t, e = 0, s = [], n = []) {
+    this.errors = t, this.autoFixed = e, this.taskPaths = s, this.specPaths = n;
+  }
+  /** @purpose Returns 0 when no errors, 1 otherwise — ESLint convention. | @returns 0 for clean, 1 for errors. */
+  get exitCode() {
+    return this.errors.length > 0 ? 1 : 0;
+  }
+  /**
+   * @purpose Formats errors in ESLint-compatible output with resolved task/spec references.
+   * @returns ESLint-compatible formatted string with References block.
+   */
+  format() {
+    const t = [];
+    if (this.autoFixed > 0 && t.push(`Auto-fixed: ${this.autoFixed} error(s)`), this.errors.length > 0 && t.push(
+      ...this.errors.map(
+        (e) => `${e.file}:${e.line}:${e.col}: ${e.severity}: ${e.code}: ${e.message}`
+      )
+    ), this.errors.length > 0 && (this.specPaths.length > 0 || this.taskPaths.length > 0)) {
+      t.push(""), t.push("---"), t.push("Relevant specs & tasks for errors above:");
+      for (const e of this.specPaths)
+        t.push(`  ${e}`);
+      for (const e of this.taskPaths)
+        t.push(`  ${e}`);
+    }
+    return t.join(`
+`);
+  }
+}
+const W = "ERR_CLI_LINT_MISSING_FILE", U = "ERR_CLI_LINT_MISSING_CONSUMERS", ce = "ERR_CLI_LINT_ANCHOR_UNPAIRED_START", le = "ERR_CLI_LINT_ANCHOR_UNPAIRED_END", ae = "ERR_CLI_LINT_ANCHOR_NESTING", O = "ERR_CLI_LINT_ANCHOR_MALFORMED", B = "ERR_CLI_LINT_NON_ENGLISH", fe = "ERR_CLI_LINT_RESOLVE_FAILED", ue = "ERR_CLI_LINT_STAGED_CONFLICT", he = "ERR_CLI_LINT_UNAUTHORIZED_DISABLE", de = "ERR_CLI_LINT_DISABLE_MISSING_PURPOSE", $ = "ERR_CLI_LINT_TOO_MANY_INVARIANTS", ge = "ERR_CLI_LINT_ANCHOR_AT_CLASS_BODY", me = "ERR_CLI_LINT_ANCHOR_CONSECUTIVE_START", _e = "ERR_CLI_LINT_ANCHOR_TOO_THIN";
+function pe(o, t) {
+  const e = [];
+  if (o.length === 0)
+    return e.push({
+      file: t,
+      line: 1,
+      col: 1,
+      severity: "error",
+      code: W,
+      message: "[FileHeaderCheck#check] Missing // @file: directive"
+    }), e.push({
+      file: t,
+      line: 1,
+      col: 1,
+      severity: "error",
+      code: U,
+      message: "[FileHeaderCheck#check] Missing // @consumers: directive"
+    }), e;
+  const s = o.split(`
+`);
+  let n = !1, i = !1;
+  for (const r of s) {
+    const c = r.trim();
+    if (c.startsWith("import ") || (c.startsWith("// @file:") && (n = !0), c.startsWith("// @consumers:") && (i = !0), n && i))
+      break;
+  }
+  return n || e.push({
+    file: t,
+    line: 1,
+    col: 1,
+    severity: "error",
+    code: W,
+    message: "[FileHeaderCheck#check] Missing // @file: directive"
+  }), i || e.push({
+    file: t,
+    line: 1,
+    col: 1,
+    severity: "error",
+    code: U,
+    message: "[FileHeaderCheck#check] Missing // @consumers: directive"
+  }), e;
+}
+function k(o) {
+  let t = "", e = 0, s = !1, n = !1, i = !1;
+  for (; e < o.length; ) {
+    const r = o[e], c = o[e + 1] ?? "";
+    if (!s && !n && !i) {
+      if (r === "/" && c === "/") break;
+      if (r === "/" && c === "*") {
+        for (e += 2; e < o.length - 1 && !(o[e] === "*" && o[e + 1] === "/"); ) e++;
+        e += 2;
+        continue;
+      }
+    }
+    if (r === "\\") {
+      e += 2;
+      continue;
+    }
+    if (!n && !i && r === "'") {
+      s = !s, e++;
+      continue;
+    }
+    if (!s && !i && r === '"') {
+      n = !n, e++;
+      continue;
+    }
+    if (!s && !n && r === "`") {
+      i = !i, e++;
+      continue;
+    }
+    !s && !n && !i && (t += r), e++;
+  }
+  return t;
+}
+const Re = /\/\/ #(region|endregion)\s+(START|END)_([A-Z0-9_]+)/, Ce = /\/\/ #(region|endregion)\s*$/;
+function Ie(o, t) {
+  const e = o.split(`
+`), s = [], n = [];
+  let i = 0;
+  const r = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
+  for (let l = 0; l < e.length; l++) {
+    const a = e[l], u = a.match(Re);
+    if (i = Te(a, i), u) {
+      const h = u[2], g = u[3], f = l + 1, R = u.index ?? 0, E = a.indexOf(h, R), p = (E >= 0 ? E : R) + 1;
+      if (h === "START") {
+        const I = r.get(i), N = c.get(i) ?? !1;
+        I && Ee(n, I) && !N && s.push({
+          file: t,
+          line: f,
+          col: p,
+          severity: "error",
+          code: me,
+          message: `START_${g} immediately follows START_${I.name} at the same level — merge regions or close START_${I.name} first`
+        }), n.push({ name: g, line: f, col: p }), r.set(i, { name: g, line: f, col: p }), c.set(i, !1);
+        continue;
+      }
+      const S = Le(n, (I) => I.name === g);
+      if (S === -1)
+        s.push({
+          file: t,
+          line: f,
+          col: p,
+          severity: "error",
+          code: le,
+          message: `END_${g} without matching START_${g} — add the missing opening anchor or remove this closing one`
+        });
+      else {
+        for (let I = n.length - 1; I > S; I--) {
+          const N = n[I];
+          s.push({
+            file: t,
+            line: f,
+            col: p,
+            severity: "error",
+            code: ae,
+            message: `END_${g} closes parent while START_${N.name} at line ${N.line} is still open — close inner block first`
+          });
+        }
+        n.length = S, r.delete(i), c.set(i, !1);
+      }
+      continue;
+    }
+    Ne(a) && c.set(i, !0);
+    const _ = a.match(Ce);
+    if (_) {
+      const h = l + 1, g = (_.index ?? 0) + 1;
+      if (_[1] === "endregion")
+        if (n.length > 0) {
+          const f = n[n.length - 1];
+          s.push({
+            file: t,
+            line: h,
+            col: g,
+            severity: "error",
+            code: O,
+            message: `#endregion without END_<NAME> — expected END_${f.name} (auto-closed by stack top START_${f.name} at line ${f.line})`
+          }), n.pop(), r.delete(i), c.set(i, !1);
+        } else
+          s.push({
+            file: t,
+            line: h,
+            col: g,
+            severity: "error",
+            code: O,
+            message: "#endregion without END_<NAME> — no open block to close"
+          });
+      else
+        s.push({
+          file: t,
+          line: h,
+          col: g,
+          severity: "error",
+          code: O,
+          message: "#region without START_<NAME> — add START_ prefix with a block name"
+        });
+    }
+  }
+  for (const l of n)
+    s.push({
+      file: t,
+      line: l.line,
+      col: l.col,
+      severity: "error",
+      code: ce,
+      message: `START_${l.name} without matching END_${l.name} — add the missing closing anchor`
+    });
+  return s.sort((l, a) => l.line - a.line || l.col - a.col), s;
+}
+function Le(o, t) {
+  for (let e = o.length - 1; e >= 0; e--)
+    if (t(o[e])) return e;
+  return -1;
+}
+function Te(o, t) {
+  let e = t;
+  const s = k(o);
+  for (const n of s)
+    n === "{" ? e++ : n === "}" && e--;
+  return e;
+}
+function Ee(o, t) {
+  return o.some(
+    (e) => e.name === t.name && e.line === t.line && e.col === t.col
+  );
+}
+function Ne(o) {
+  const t = o.trim();
+  return !(t === "" || t.startsWith("//") || t.startsWith("/*") && t.endsWith("*/"));
+}
+async function Se(o, t, e) {
+  C.debug(`[DbcContractCheck#check] [idle → creating] ${t}`);
+  const s = new se(), n = new oe(), i = new ne(s, n);
+  try {
+    if (!e) {
+      const c = await i.lint(t, { content: o });
+      return C.info(
+        `[DbcContractCheck#check] [creating → linted] ${t} (${c.errors.length} errors)`
+      ), { errors: c.errors.map(G), autoFixed: 0 };
+    }
+    const r = await i.lintAndFix(t, { content: o });
+    return C.info(
+      `[DbcContractCheck#check] [creating → fixed] ${t} (autoFixed=${r.autoFixed}, remaining=${r.errors.length})`
+    ), {
+      errors: r.errors.map(G),
+      autoFixed: r.autoFixed
+    };
+  } catch (r) {
+    const c = new Error(`[DbcContractCheck#check] Lint failed for ${t}`, { cause: r });
+    throw C.error(`[DbcContractCheck#check] [creating → failed] ${t}`, { error: c }), c;
+  }
+}
+function G(o) {
+  return {
+    file: o.file,
+    line: o.line,
+    col: o.col,
+    severity: "error",
+    code: o.code,
+    message: o.message
+  };
+}
+const j = 8, ye = /@ts-ignore|@ts-nocheck|@ts-expect-error|eslint-disable(?:-next-line|-line)?(?:-[a-z-]+)?\b/, Ae = /\bd-\d+\b/i;
+function xe(o) {
+  let t = !1, e = !1, s = !1;
+  for (let n = 0; n < o.length - 1; n++) {
+    const i = o[n], r = n > 0 ? o[n - 1] : "";
+    if (!t && !e && !s) {
+      if (i === "/" && (o[n + 1] === "/" || o[n + 1] === "*")) return n;
+      i === "'" ? t = !0 : i === '"' ? e = !0 : i === "`" && (s = !0);
+    } else r !== "\\" && (t && i === "'" ? t = !1 : e && i === '"' ? e = !1 : s && i === "`" && (s = !1));
+  }
+  return -1;
+}
+function $e(o, t) {
+  const e = o.split(`
+`), s = [];
+  for (let n = 0; n < e.length; n++) {
+    const i = e[n], r = xe(i);
+    if (r < 0) continue;
+    const c = i.slice(r), l = ye.exec(c);
+    if (!l) continue;
+    const a = l[0], u = r + l.index + 1, _ = Ae.exec(i);
+    if (!_) {
+      s.push({
+        file: t,
+        line: n + 1,
+        col: u,
+        severity: "error",
+        code: he,
+        message: `Unauthorized disable: \`${a}\` has no Decision Log reference. Add \`D-NNN\` (e.g., \`D-042\`) in the same comment line pointing to a Decision Log entry that authorizes this disable. Policy: see specs/cli/cli.spec.md#d-007.`
+      });
+      continue;
+    }
+    const h = ve(c, a, _[0]);
+    h < j && s.push({
+      file: t,
+      line: n + 1,
+      col: u,
+      severity: "error",
+      code: de,
+      message: `Disable lacks purpose: \`${a}\` cites \`${_[0]}\` but the explanation is too short (${h} non-whitespace chars; need ≥ ${j}). Add a purpose after the D-NNN reference, e.g., \`${a}: ${_[0]} — <why this disable is necessary>\`. Policy: see specs/cli/cli.spec.md#d-007.`
+    });
+  }
+  return s;
+}
+function ve(o, t, e) {
+  let s = o.replace(t, "");
+  return s = s.replace(e, ""), s = s.replace(/\*\//g, ""), s = s.replace(/^\/\/|^\/\*/g, ""), s.replace(/\s/g, "").length;
+}
+const J = new RegExp("\\p{Script=Cyrillic}", "u");
+function ke(o, t) {
+  const e = [], s = o.split(`
+`), n = De(s);
+  for (let i = 0; i < s.length; i++) {
+    const r = s[i], c = i + 1, l = r.trim();
+    if (l.startsWith("// @file:") || l.startsWith("// @consumers:")) {
+      const a = [...r];
+      for (let u = 0; u < a.length; u++)
+        J.test(a[u]) && e.push({
+          file: t,
+          line: c,
+          col: u + 1,
+          severity: "error",
+          code: B,
+          message: `[LanguageCheck#check] Cyrillic character '${a[u]}' in file header — use English only`
+        });
+    }
+    if (n.has(i)) {
+      const a = [...r];
+      for (let u = 0; u < a.length; u++)
+        if (J.test(a[u])) {
+          e.push({
+            file: t,
+            line: c,
+            col: u + 1,
+            severity: "error",
+            code: B,
+            message: `[LanguageCheck#check] Cyrillic character '${a[u]}' in JSDoc contract — use English only`
+          });
+          break;
+        }
+    }
+  }
+  return e;
+}
+function De(o) {
+  const t = /* @__PURE__ */ new Set();
+  let e = !1;
+  for (let s = 0; s < o.length; s++) {
+    const n = o[s].trim();
+    if (n.startsWith("/**")) {
+      e = !0, t.add(s), n.endsWith("*/") && (e = !1);
+      continue;
+    }
+    e && (t.add(s), n.includes("*/") && (e = !1));
+  }
+  return t;
+}
+const be = /^\s*export\s+(?:(?:default\s+)?(?:function|class|abstract\s+class|interface))\s+(\w+)/, we = /^\s*(?:function|class|abstract\s+class|interface)\s+(\w+)/, Oe = /\/\/\s*#region\s+START_\w+.*\binvariant\s*:/;
+function Fe(o, t, e) {
+  const s = o.split(`
+`), n = [];
+  let i = 0;
+  const r = [];
+  let c = null, l = !1, a = "", u = 0, _ = 0, h = !1, g = [];
+  for (let f = 0; f < s.length; f++) {
+    const R = s[f], E = f + 1, p = R.trim();
+    if (p.startsWith("/**"))
+      if (p.includes("*/") && p.length > 3) {
+        const m = V(p);
+        g = [];
+        for (let L = 0; L < m; L++) g.push(E);
+      } else {
+        h = !0, g = [];
+        continue;
+      }
+    if (h) {
+      if (p.includes("*/")) {
+        h = !1;
+        continue;
+      }
+      const m = V(p);
+      for (let L = 0; L < m; L++) g.push(E);
+      continue;
+    }
+    const S = R.match(be), I = p.includes("*/") ? p.slice(p.lastIndexOf("*/") + 2) : null, N = I ? I.match(
+      /^\s*export\s+(?:(?:default\s+)?(?:function|class|abstract\s+class|interface))\s+(\w+)/
+    ) : null, A = S || N, d = N ? p.lastIndexOf("*/") + 2 : 0;
+    if (A) {
+      l = !0, a = A[1], u = E;
+      const m = (A.index ?? 0) + d, L = R.indexOf(a, m);
+      _ = (L >= 0 ? L : m) + 1;
+    } else g.length > 0 && we.test(R) && (g = []);
+    const T = k(R);
+    for (const m of T)
+      if (m === "{") {
+        if (i++, l) {
+          const L = {
+            name: a,
+            nameLine: u,
+            nameCol: _,
+            bodyDepth: i,
+            jsdocCount: g.length,
+            regionCount: 0
+          };
+          r.push(L), c = L, l = !1, g = [];
+        }
+      } else m === "}" && (c && i === c.bodyDepth && (c.jsdocCount > e && n.push({
+        file: t,
+        line: c.nameLine,
+        col: c.nameCol,
+        severity: "error",
+        code: $,
+        message: `Entity "${c.name}" has ${c.jsdocCount} JSDoc @invariant tags (max ${e}) — consider reviewing the contract; too many invariants suggest the entity is overloaded`
+      }), c.regionCount > e && n.push({
+        file: t,
+        line: c.nameLine,
+        col: c.nameCol,
+        severity: "error",
+        code: $,
+        message: `Entity "${c.name}" has ${c.regionCount} region invariants (max ${e}) — consider reviewing the contract; too many region invariants suggest the entity is overloaded`
+      }), r.pop(), c = r.length > 0 ? r[r.length - 1] : null), i--);
+    c && Oe.test(R) && c.regionCount++;
+  }
+  for (const f of r)
+    f.jsdocCount > e && n.push({
+      file: t,
+      line: f.nameLine,
+      col: f.nameCol,
+      severity: "error",
+      code: $,
+      message: `Entity "${f.name}" has ${f.jsdocCount} JSDoc @invariant tags (max ${e}) — consider reviewing the contract; too many invariants suggest the entity is overloaded`
+    }), f.regionCount > e && n.push({
+      file: t,
+      line: f.nameLine,
+      col: f.nameCol,
+      severity: "error",
+      code: $,
+      message: `Entity "${f.name}" has ${f.regionCount} region invariants (max ${e}) — consider reviewing the contract; too many region invariants suggest the entity is overloaded`
+    });
+  return n.sort((f, R) => f.line - R.line || f.col - R.col), n;
+}
+function V(o) {
+  const t = o.match(/@invariant\b/g);
+  return t ? t.length : 0;
+}
+const Me = /\/\/ #(region|endregion)\s+(START|END)_([A-Z0-9_]+)/;
+function He(o, t) {
+  const e = o.split(`
+`), s = [];
+  let n = 0;
+  const i = [];
+  let r = !1;
+  for (let c = 0; c < e.length; c++) {
+    const l = e[c], a = c + 1;
+    /\b(?:class|namespace)\s+\w/.test(k(l)) && (r = !0);
+    const u = k(l);
+    for (const h of u)
+      h === "{" ? (n++, r && (i.push(n), r = !1)) : h === "}" && (i.length > 0 && n === i[i.length - 1] && i.pop(), n--);
+    const _ = l.match(Me);
+    if (_ && i.length > 0 && n === i[i.length - 1]) {
+      const h = _[3], f = _[2] === "START" ? "START" : "END", E = (_.index ?? 0) + 1;
+      s.push({
+        file: t,
+        line: a,
+        col: E,
+        severity: "error",
+        code: ge,
+        message: `#region ${f}_${h} at class body level — regions must not separate class members; move inside a method body or remove`
+      });
+    }
+  }
+  return s.sort((c, l) => c.line - l.line || c.col - l.col), s;
+}
+const X = /\/\/ #(region|endregion)\s+(START|END)_([A-Z0-9_]+)/, z = 2;
+function Pe(o, t) {
+  const e = o.split(`
+`), s = [], n = [];
+  for (let i = 0; i < e.length; i++) {
+    const r = e[i], c = r.match(X);
+    if (c && c[2] === "START") {
+      const l = c[3], a = c.index ?? 0, u = r.indexOf("START", a), _ = (u >= 0 ? u : a) + 1, g = r.slice(a + c[0].length).trim().length > 0;
+      n.push({
+        name: l,
+        startLine: i + 1,
+        col: _,
+        meaningfulCount: 0,
+        hasStartAnnotation: g,
+        hasBodyComment: !1
+      });
+      continue;
+    }
+    if (c && c[2] === "END") {
+      const l = c[3], a = Ue(n, (u) => u.name === l);
+      if (a !== -1) {
+        const u = n[a];
+        u.meaningfulCount < z && s.push(We(t, u)), n.length = a;
+      }
+      continue;
+    }
+    if (n.length !== 0)
+      if (Be(r))
+        for (const l of n)
+          l.meaningfulCount++;
+      else Ge(r) && (n[n.length - 1].hasBodyComment = !0);
+  }
+  return s.sort((i, r) => i.line - r.line || i.col - r.col), s;
+}
+function We(o, t) {
+  const { name: e, startLine: s, col: n, meaningfulCount: i, hasStartAnnotation: r, hasBodyComment: c } = t;
+  let l;
+  return i === 0 && (r || c) ? l = `START_${e} wraps only comments — keep the comment(s) and remove the region wrapper` : i === 0 ? l = `START_${e} is empty (0 meaningful lines) — remove the empty region` : r ? l = `START_${e} has only ${i} meaningful line(s) + annotation — keep the annotation as a plain comment and remove the region wrapper` : l = `START_${e} has only ${i} meaningful line(s) — regions need at least ${z} lines of code; consider removing the region`, {
+    file: o,
+    line: s,
+    col: n,
+    severity: "error",
+    code: _e,
+    message: l
+  };
+}
+function Ue(o, t) {
+  for (let e = o.length - 1; e >= 0; e--)
+    if (t(o[e])) return e;
+  return -1;
+}
+function Be(o) {
+  const t = o.trim();
+  return !(t === "" || t.startsWith("//") || t.startsWith("/*") && t.endsWith("*/"));
+}
+function Ge(o) {
+  const t = o.trim();
+  return t.startsWith("//") ? !X.test(t) : !1;
+}
+function je(o, t = "tasks") {
+  const e = /* @__PURE__ */ new Map(), s = y(o, t);
+  if (!K(s))
+    return e;
+  const n = Ke(s);
+  for (const i of n) {
+    let r;
+    try {
+      r = Y(i, "utf-8");
+    } catch {
+      continue;
+    }
+    const c = r.match(/-\s+\*\*Task-ID:\*\*\s+(TSK-\d+)/);
+    if (!c) continue;
+    const l = c[1], a = P(o, i), u = Je(r, o);
+    e.set(l, { taskPath: a, specPaths: u });
+  }
+  return e;
+}
+function Je(o, t) {
+  const e = /* @__PURE__ */ new Set(), s = o.match(/\*\*Spec References:\*\*[\s\S]*?(?=\n- \*\*|$)/);
+  if (!s) return [];
+  const n = s[0], i = /\[([^\]]*)\]\(([^)]+\.md)[^)]*\)/g;
+  let r;
+  for (; (r = i.exec(n)) !== null; ) {
+    const c = r[2].split("/").pop();
+    if (!c) continue;
+    const l = Ve(y(t, "specs"), c);
+    if (l) {
+      const a = P(t, l);
+      a.startsWith("..") || e.add(a);
+    }
+  }
+  return [...e].sort();
+}
+function Ve(o, t) {
+  if (!K(o)) return null;
+  const e = [o];
+  for (; e.length > 0; ) {
+    const s = e.pop();
+    let n;
+    try {
+      n = H(s);
+    } catch {
+      continue;
+    }
+    for (const i of n) {
+      const r = y(s, i);
+      try {
+        const c = Z(r);
+        if (c.isDirectory())
+          e.push(r);
+        else if (c.isFile() && i === t)
+          return r;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function Ke(o) {
+  const t = [], e = [o];
+  for (; e.length > 0; ) {
+    const s = e.pop();
+    let n;
+    try {
+      n = H(s);
+    } catch {
+      continue;
+    }
+    for (const i of n) {
+      const r = y(s, i);
+      try {
+        const c = Z(r);
+        c.isDirectory() ? e.push(r) : c.isFile() && i.endsWith(".md") && t.push(r);
+      } catch {
+      }
+    }
+  }
+  return t;
+}
+function Ye(o) {
+  const t = o.match(/@tasks:\s*(.+)/m);
+  return t ? t[1].split(/[,;\s]+/).map((e) => e.trim()).filter((e) => /^TSK-\d+$/.test(e)) : [];
+}
+function Ze(o, t) {
+  const e = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  for (const n of o) {
+    const i = t.get(n);
+    if (i) {
+      e.add(i.taskPath);
+      for (const r of i.specPaths)
+        s.add(r);
+    }
+  }
+  return {
+    taskPaths: [...e].sort(),
+    specPaths: [...s].sort()
+  };
+}
+function Xe(o) {
+  let t = "", e = 0;
+  for (; e < o.length; ) {
+    const s = o[e], n = o[e + 1];
+    if (s === "*" && n === "*")
+      o[e + 2] === "/" ? (t += "(?:.*\\/)?", e += 3) : (e + 2 >= o.length, t += ".*", e += 2);
+    else if (s === "*")
+      t += "[^/]*", e++;
+    else if (s === "?")
+      t += "[^/]", e++;
+    else if (s === ".")
+      t += "\\.", e++;
+    else if (s === "[") {
+      const i = o.indexOf("]", e);
+      i !== -1 ? (t += o.slice(e, i + 1), e = i + 1) : (t += "\\[", e++);
+    } else
+      t += ze(s), e++;
+  }
+  return new RegExp("^" + t + "$");
+}
+function ze(o) {
+  return "^$\\+*.?{}[]()|/".includes(o) ? "\\" + o : o;
+}
+async function qe(o) {
+  const t = re(o, {
+    autofix: ["autofix"],
+    staged: ["staged"],
+    verbose: ["verbose", "v"],
+    maxInvariants: ["max-invariants"],
+    exclude: ["exclude"]
+  }), e = t._.filter(
+    (d) => typeof d == "string" && d !== "lint"
+  ), s = t.autofix === !0 || t.autofix === "true", n = t.staged === !0 || t.staged === "true", i = t.verbose === !0 || t.verbose === "true", r = typeof t.maxInvariants == "string" ? parseInt(t.maxInvariants, 10) : 3, c = [
+    "**/node_modules/**",
+    "**/__tests__/**",
+    "**/fixtures/**",
+    "**/__tests__/fixtures/**",
+    "**/dist/**",
+    "**/coverage/**",
+    "**/build/**",
+    "**/out/**"
+  ], l = t.exclude, a = Array.isArray(l) ? l : typeof l == "string" ? [l] : [], _ = [...c, ...a].map(Xe);
+  i && ie("debug");
+  let h;
+  const g = [];
+  if (n) {
+    if (e.length > 0) {
+      const d = {
+        file: "",
+        line: 0,
+        col: 0,
+        severity: "error",
+        code: ue,
+        message: "--staged and positional targets are mutually exclusive. Use either --staged or provide file/directory paths, not both."
+      };
+      return C.warn("[LintCommand#run] --staged and positional targets are mutually exclusive"), new w([d]);
+    }
+    C.debug("[LintCommand#run] [idle → collecting] staged mode");
+    try {
+      h = Q("git diff --staged --name-only", { encoding: "utf-8" }).trim().split(`
+`).filter(Boolean).filter((T) => T.endsWith(".ts")), h = [...new Set(h)];
+    } catch (d) {
+      const T = new Error("[LintCommand#run] Git scan failed — not a git repository?", {
+        cause: d
+      });
+      throw C.error("[LintCommand#run] [collecting → failed]", { error: T }), T;
+    }
+  } else if (e.length > 0) {
+    C.debug(`[LintCommand#run] [idle → resolving] ${e.length} target(s)`);
+    const d = et(e);
+    h = d.files, g.push(...d.errors);
+    for (const T of d.errors)
+      C.warn(`[LintCommand#run] [resolving → failed] ${T.file}: ${T.message}`);
+  } else
+    h = [];
+  if (h.length > 0 && _.length > 0) {
+    const d = h.length, T = y(".");
+    h = h.filter((m) => {
+      const L = m.startsWith("/") ? P(T, m) : m;
+      return !_.some((x) => x.test(L));
+    }), C.debug(`[LintCommand#run] [filtering → filtered] ${d} → ${h.length} file(s)`);
+  }
+  if (h.length === 0)
+    return C.debug("[LintCommand#run] [collecting → done] no files to lint"), new w(g);
+  C.debug(`[LintCommand#run] [collecting → linting] ${h.length} file(s)`);
+  const f = [...g];
+  let R = 0;
+  const E = y("."), p = je(E), S = /* @__PURE__ */ new Set();
+  for (const d of h) {
+    const T = y(d);
+    let m;
+    try {
+      C.debug(`[LintCommand#run] [linting → reading] ${d}`), m = Y(T, "utf-8");
+    } catch (D) {
+      const b = new Error(`[LintCommand#run] Cannot read file: ${d}`, { cause: D });
+      C.error(`[LintCommand#run] [reading → failed] ${d}`, { error: b });
+      continue;
+    }
+    const L = f.length;
+    f.push(...pe(m, d)), f.push(...Ie(m, d)), f.push(...ke(m, d)), f.push(...$e(m, d)), f.push(...He(m, d)), f.push(...Pe(m, d)), f.push(...Fe(m, d, r));
+    const x = await Se(m, d, s);
+    if (f.push(...x.errors), R += x.autoFixed, f.length > L) {
+      const D = Ye(m);
+      for (const b of D)
+        S.add(b);
+    }
+  }
+  const { taskPaths: I, specPaths: N } = Ze([...S], p), A = new w(f, R, I, N);
+  return A.exitCode === 1 ? console.log(`❌ [LintCommand#run] [linting → failed] ${f.length} error(s)`) : console.log("✅ [LintCommand#run] [linting → clean] no errors"), A;
+}
+const M = [".ts", ".tsx"], Qe = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", "build", "out", "__tests__"]);
+function et(o) {
+  C.debug(`[resolveTargets] [idle → resolving] ${o.length} target(s)`);
+  const t = /* @__PURE__ */ new Set(), e = [];
+  for (const n of o) {
+    const i = F(n).toLowerCase();
+    if (i && !M.includes(i) && !n.endsWith("/"))
+      continue;
+    let r;
+    try {
+      r = ee(n);
+    } catch (l) {
+      const a = l;
+      e.push({
+        file: n,
+        line: 0,
+        col: 0,
+        severity: "error",
+        code: fe,
+        message: `${n}: ${a.code ?? "UNKNOWN"}: ${a.message}`
+      });
+      continue;
+    }
+    if (r.isSymbolicLink())
+      continue;
+    const c = y(n);
+    if (r.isDirectory())
+      q(c, t);
+    else if (r.isFile()) {
+      const l = F(n).toLowerCase();
+      M.includes(l) && t.add(c);
+    }
+  }
+  const s = [...t].sort();
+  return C.debug(
+    `[resolveTargets] [resolving → resolved] ${s.length} file(s), ${e.length} error(s)`
+  ), { files: s, errors: e };
+}
+function q(o, t) {
+  let e;
+  try {
+    e = H(o, { withFileTypes: !0 });
+  } catch {
+    return;
+  }
+  for (const s of e) {
+    const n = te(o, s.name);
+    if (!s.name.startsWith(".") && !Qe.has(s.name) && !s.isSymbolicLink()) {
+      if (s.isDirectory())
+        q(n, t);
+      else if (s.isFile()) {
+        const i = F(s.name).toLowerCase();
+        M.includes(i) && t.add(n);
+      }
+    }
+  }
+}
+const v = await qe(process.argv);
+(v.exitCode === 1 || v.autoFixed > 0) && console.log(v.format());
+process.exit(v.exitCode);