gennady 0.7.0 → 0.8.0

package/dist/chunks/index-Du1xR-qO.js

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