gennady 0.6.0 → 0.7.0

package/dist/chunks/index-KxSZKmZn.js

@@ -0,0 +1,540 @@
+import { execSync as $ } from "node:child_process";
+import { existsSync as O, readFileSync as M, readdirSync as y, statSync as P, lstatSync as B } from "node:fs";
+import { resolve as _, relative as H, extname as k, join as K } from "node:path";
+import { l as d, D as z, a as J, b as Z, s as j } from "./services-CaLOhuLV.js";
+import { p as V } from "./shared-Bjy30TeM.js";
+class E {
+  /** @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.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 x = "ERR_CLI_LINT_MISSING_FILE", A = "ERR_CLI_LINT_MISSING_CONSUMERS", X = "ERR_CLI_LINT_ANCHOR_UNPAIRED_START", Y = "ERR_CLI_LINT_ANCHOR_UNPAIRED_END", q = "ERR_CLI_LINT_ANCHOR_NESTING", C = "ERR_CLI_LINT_ANCHOR_MALFORMED", b = "ERR_CLI_LINT_NON_ENGLISH", Q = "ERR_CLI_LINT_RESOLVE_FAILED", ee = "ERR_CLI_LINT_STAGED_CONFLICT", te = "ERR_CLI_LINT_UNAUTHORIZED_DISABLE", se = "ERR_CLI_LINT_DISABLE_MISSING_PURPOSE";
+function ne(i, t) {
+  const e = [];
+  if (i.length === 0)
+    return e.push({
+      file: t,
+      line: 1,
+      col: 1,
+      severity: "error",
+      code: x,
+      message: "[FileHeaderCheck#check] Missing // @file: directive"
+    }), e.push({
+      file: t,
+      line: 1,
+      col: 1,
+      severity: "error",
+      code: A,
+      message: "[FileHeaderCheck#check] Missing // @consumers: directive"
+    }), e;
+  const s = i.split(`
+`);
+  let n = !1, r = !1;
+  for (const o of s) {
+    const c = o.trim();
+    if (c.startsWith("import ") || (c.startsWith("// @file:") && (n = !0), c.startsWith("// @consumers:") && (r = !0), n && r))
+      break;
+  }
+  return n || e.push({
+    file: t,
+    line: 1,
+    col: 1,
+    severity: "error",
+    code: x,
+    message: "[FileHeaderCheck#check] Missing // @file: directive"
+  }), r || e.push({
+    file: t,
+    line: 1,
+    col: 1,
+    severity: "error",
+    code: A,
+    message: "[FileHeaderCheck#check] Missing // @consumers: directive"
+  }), e;
+}
+const re = /\/\/ #(region|endregion)\s+(START|END)_([A-Z0-9_]+)/, oe = /\/\/ #(region|endregion)\s*$/;
+function ie(i, t) {
+  const e = i.split(`
+`), s = [], n = [];
+  for (let r = 0; r < e.length; r++) {
+    const o = e[r], c = o.match(re);
+    if (c) {
+      const a = c[2], l = c[3], h = r + 1, p = c.index ?? 0, I = o.indexOf(a, p), L = (I >= 0 ? I : p) + 1;
+      if (a === "START") {
+        n.push({ name: l, line: h, col: L });
+        continue;
+      }
+      const R = ce(n, (u) => u.name === l);
+      if (R === -1)
+        s.push({
+          file: t,
+          line: h,
+          col: L,
+          severity: "error",
+          code: Y,
+          message: `END_${l} without matching START_${l} — add the missing opening anchor or remove this closing one`
+        });
+      else {
+        for (let u = n.length - 1; u > R; u--) {
+          const g = n[u];
+          s.push({
+            file: t,
+            line: h,
+            col: L,
+            severity: "error",
+            code: q,
+            message: `END_${l} closes parent while START_${g.name} at line ${g.line} is still open — close inner block first`
+          });
+        }
+        n.length = R;
+      }
+      continue;
+    }
+    const f = o.match(oe);
+    if (f) {
+      const a = r + 1, l = (f.index ?? 0) + 1;
+      if (f[1] === "endregion")
+        if (n.length > 0) {
+          const h = n[n.length - 1];
+          s.push({
+            file: t,
+            line: a,
+            col: l,
+            severity: "error",
+            code: C,
+            message: `#endregion without END_<NAME> — expected END_${h.name} (auto-closed by stack top START_${h.name} at line ${h.line})`
+          }), n.pop();
+        } else
+          s.push({
+            file: t,
+            line: a,
+            col: l,
+            severity: "error",
+            code: C,
+            message: "#endregion without END_<NAME> — no open block to close"
+          });
+      else
+        s.push({
+          file: t,
+          line: a,
+          col: l,
+          severity: "error",
+          code: C,
+          message: "#region without START_<NAME> — add START_ prefix with a block name"
+        });
+    }
+  }
+  for (const r of n)
+    s.push({
+      file: t,
+      line: r.line,
+      col: r.col,
+      severity: "error",
+      code: X,
+      message: `START_${r.name} without matching END_${r.name} — add the missing closing anchor`
+    });
+  return s.sort((r, o) => r.line - o.line || r.col - o.col), s;
+}
+function ce(i, t) {
+  for (let e = i.length - 1; e >= 0; e--)
+    if (t(i[e])) return e;
+  return -1;
+}
+async function ae(i, t, e) {
+  d.debug(`[DbcContractCheck#check] [idle → creating] ${t}`);
+  const s = new J(), n = new Z(), r = new z(s, n);
+  try {
+    if (!e) {
+      const c = await r.lint(t, { content: i });
+      return d.info(
+        `[DbcContractCheck#check] [creating → linted] ${t} (${c.errors.length} errors)`
+      ), { errors: c.errors.map(v), autoFixed: 0 };
+    }
+    const o = await r.lintAndFix(t, { content: i });
+    return d.info(
+      `[DbcContractCheck#check] [creating → fixed] ${t} (autoFixed=${o.autoFixed}, remaining=${o.errors.length})`
+    ), {
+      errors: o.errors.map(v),
+      autoFixed: o.autoFixed
+    };
+  } catch (o) {
+    const c = new Error(`[DbcContractCheck#check] Lint failed for ${t}`, { cause: o });
+    throw d.error(`[DbcContractCheck#check] [creating → failed] ${t}`, { error: c }), c;
+  }
+}
+function v(i) {
+  return {
+    file: i.file,
+    line: i.line,
+    col: i.col,
+    severity: "error",
+    code: i.code,
+    message: i.message
+  };
+}
+const w = 8, le = /@ts-ignore|@ts-nocheck|@ts-expect-error|eslint-disable(?:-next-line|-line)?(?:-[a-z-]+)?\b/, ue = /\bd-\d+\b/i;
+function fe(i) {
+  let t = !1, e = !1, s = !1;
+  for (let n = 0; n < i.length - 1; n++) {
+    const r = i[n], o = n > 0 ? i[n - 1] : "";
+    if (!t && !e && !s) {
+      if (r === "/" && (i[n + 1] === "/" || i[n + 1] === "*")) return n;
+      r === "'" ? t = !0 : r === '"' ? e = !0 : r === "`" && (s = !0);
+    } else o !== "\\" && (t && r === "'" ? t = !1 : e && r === '"' ? e = !1 : s && r === "`" && (s = !1));
+  }
+  return -1;
+}
+function de(i, t) {
+  const e = i.split(`
+`), s = [];
+  for (let n = 0; n < e.length; n++) {
+    const r = e[n], o = fe(r);
+    if (o < 0) continue;
+    const c = r.slice(o), f = le.exec(c);
+    if (!f) continue;
+    const a = f[0], l = o + f.index + 1, h = ue.exec(r);
+    if (!h) {
+      s.push({
+        file: t,
+        line: n + 1,
+        col: l,
+        severity: "error",
+        code: te,
+        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 p = he(c, a, h[0]);
+    p < w && s.push({
+      file: t,
+      line: n + 1,
+      col: l,
+      severity: "error",
+      code: se,
+      message: `Disable lacks purpose: \`${a}\` cites \`${h[0]}\` but the explanation is too short (${p} non-whitespace chars; need ≥ ${w}). Add a purpose after the D-NNN reference, e.g., \`${a}: ${h[0]} — <why this disable is necessary>\`. Policy: see specs/cli/cli.spec.md#d-007.`
+    });
+  }
+  return s;
+}
+function he(i, t, e) {
+  let s = i.replace(t, "");
+  return s = s.replace(e, ""), s = s.replace(/\*\//g, ""), s = s.replace(/^\/\/|^\/\*/g, ""), s.replace(/\s/g, "").length;
+}
+const F = new RegExp("\\p{Script=Cyrillic}", "u");
+function ge(i, t) {
+  const e = [], s = i.split(`
+`), n = me(s);
+  for (let r = 0; r < s.length; r++) {
+    const o = s[r], c = r + 1, f = o.trim();
+    if (f.startsWith("// @file:") || f.startsWith("// @consumers:")) {
+      const a = [...o];
+      for (let l = 0; l < a.length; l++)
+        F.test(a[l]) && e.push({
+          file: t,
+          line: c,
+          col: l + 1,
+          severity: "error",
+          code: b,
+          message: `[LanguageCheck#check] Cyrillic character '${a[l]}' in file header — use English only`
+        });
+    }
+    if (n.has(r)) {
+      const a = [...o];
+      for (let l = 0; l < a.length; l++)
+        if (F.test(a[l])) {
+          e.push({
+            file: t,
+            line: c,
+            col: l + 1,
+            severity: "error",
+            code: b,
+            message: `[LanguageCheck#check] Cyrillic character '${a[l]}' in JSDoc contract — use English only`
+          });
+          break;
+        }
+    }
+  }
+  return e;
+}
+function me(i) {
+  const t = /* @__PURE__ */ new Set();
+  let e = !1;
+  for (let s = 0; s < i.length; s++) {
+    const n = i[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;
+}
+function pe(i, t = "tasks") {
+  const e = /* @__PURE__ */ new Map(), s = _(i, t);
+  if (!O(s))
+    return e;
+  const n = Le(s);
+  for (const r of n) {
+    let o;
+    try {
+      o = M(r, "utf-8");
+    } catch {
+      continue;
+    }
+    const c = o.match(/-\s+\*\*Task-ID:\*\*\s+(TSK-\d+)/);
+    if (!c) continue;
+    const f = c[1], a = H(i, r), l = _e(o, i);
+    e.set(f, { taskPath: a, specPaths: l });
+  }
+  return e;
+}
+function _e(i, t) {
+  const e = /* @__PURE__ */ new Set(), s = i.match(/\*\*Spec References:\*\*[\s\S]*?(?=\n- \*\*|$)/);
+  if (!s) return [];
+  const n = s[0], r = /\[([^\]]*)\]\(([^)]+\.md)[^)]*\)/g;
+  let o;
+  for (; (o = r.exec(n)) !== null; ) {
+    const c = o[2].split("/").pop();
+    if (!c) continue;
+    const f = Re(_(t, "specs"), c);
+    if (f) {
+      const a = H(t, f);
+      a.startsWith("..") || e.add(a);
+    }
+  }
+  return [...e].sort();
+}
+function Re(i, t) {
+  if (!O(i)) return null;
+  const e = [i];
+  for (; e.length > 0; ) {
+    const s = e.pop();
+    let n;
+    try {
+      n = y(s);
+    } catch {
+      continue;
+    }
+    for (const r of n) {
+      const o = _(s, r);
+      try {
+        const c = P(o);
+        if (c.isDirectory())
+          e.push(o);
+        else if (c.isFile() && r === t)
+          return o;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function Le(i) {
+  const t = [], e = [i];
+  for (; e.length > 0; ) {
+    const s = e.pop();
+    let n;
+    try {
+      n = y(s);
+    } catch {
+      continue;
+    }
+    for (const r of n) {
+      const o = _(s, r);
+      try {
+        const c = P(o);
+        c.isDirectory() ? e.push(o) : c.isFile() && r.endsWith(".md") && t.push(o);
+      } catch {
+      }
+    }
+  }
+  return t;
+}
+function Ie(i) {
+  const t = i.match(/@tasks:\s*(.+)/m);
+  return t ? t[1].split(/[,;\s]+/).map((e) => e.trim()).filter((e) => /^TSK-\d+$/.test(e)) : [];
+}
+function Ne(i, t) {
+  const e = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  for (const n of i) {
+    const r = t.get(n);
+    if (r) {
+      e.add(r.taskPath);
+      for (const o of r.specPaths)
+        s.add(o);
+    }
+  }
+  return {
+    taskPaths: [...e].sort(),
+    specPaths: [...s].sort()
+  };
+}
+async function Ee(i) {
+  const t = V(i, {
+    autofix: ["autofix"],
+    staged: ["staged"],
+    verbose: ["verbose", "v"]
+  }), e = t._.filter(
+    (u) => typeof u == "string" && u !== "lint"
+  ), s = t.autofix === !0 || t.autofix === "true", n = t.staged === !0 || t.staged === "true";
+  (t.verbose === !0 || t.verbose === "true") && j("debug");
+  let o;
+  const c = [];
+  if (n) {
+    if (e.length > 0) {
+      const u = {
+        file: "",
+        line: 0,
+        col: 0,
+        severity: "error",
+        code: ee,
+        message: "--staged and positional targets are mutually exclusive. Use either --staged or provide file/directory paths, not both."
+      };
+      return d.warn("[LintCommand#run] --staged and positional targets are mutually exclusive"), new E([u]);
+    }
+    d.debug("[LintCommand#run] [idle → collecting] staged mode");
+    try {
+      const u = $("git diff --staged --name-only", { encoding: "utf-8" }).trim(), g = $("git ls-files --others --exclude-standard", {
+        encoding: "utf-8"
+      }).trim();
+      o = [...u.split(`
+`), ...g.split(`
+`)].filter(Boolean).filter((m) => m.endsWith(".ts")), o = [...new Set(o)];
+    } catch (u) {
+      const g = new Error("[LintCommand#run] Git scan failed — not a git repository?", {
+        cause: u
+      });
+      throw d.error("[LintCommand#run] [collecting → failed]", { error: g }), g;
+    }
+  } else if (e.length > 0) {
+    d.debug(`[LintCommand#run] [idle → resolving] ${e.length} target(s)`);
+    const u = ke(e);
+    o = u.files, c.push(...u.errors);
+    for (const g of u.errors)
+      d.warn(`[LintCommand#run] [resolving → failed] ${g.file}: ${g.message}`);
+  } else
+    o = [];
+  if (o.length === 0)
+    return d.debug("[LintCommand#run] [collecting → done] no files to lint"), new E(c);
+  d.debug(`[LintCommand#run] [collecting → linting] ${o.length} file(s)`);
+  const f = [...c];
+  let a = 0;
+  const l = _("."), h = pe(l), p = /* @__PURE__ */ new Set();
+  for (const u of o) {
+    const g = _(u);
+    let m;
+    try {
+      d.debug(`[LintCommand#run] [linting → reading] ${u}`), m = M(g, "utf-8");
+    } catch (N) {
+      const G = new Error(`[LintCommand#run] Cannot read file: ${u}`, { cause: N });
+      d.error(`[LintCommand#run] [reading → failed] ${u}`, { error: G });
+      continue;
+    }
+    f.push(...ne(m, u)), f.push(...ie(m, u)), f.push(...ge(m, u)), f.push(...de(m, u));
+    const W = Ie(m);
+    for (const N of W)
+      p.add(N);
+    const D = await ae(m, u, s);
+    f.push(...D.errors), a += D.autoFixed;
+  }
+  const { taskPaths: I, specPaths: L } = Ne([...p], h), R = new E(f, a, I, L);
+  return R.exitCode === 1 ? console.log(`[LintCommand#run] [linting → failed] ${f.length} error(s)`) : console.log("[LintCommand#run] [linting → clean] no errors"), R;
+}
+const S = [".ts", ".tsx"], Ce = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", "build", "out", "__tests__"]);
+function ke(i) {
+  d.debug(`[resolveTargets] [idle → resolving] ${i.length} target(s)`);
+  const t = /* @__PURE__ */ new Set(), e = [];
+  for (const n of i) {
+    const r = k(n).toLowerCase();
+    if (r && !S.includes(r) && !n.endsWith("/"))
+      continue;
+    let o;
+    try {
+      o = B(n);
+    } catch (f) {
+      const a = f;
+      e.push({
+        file: n,
+        line: 0,
+        col: 0,
+        severity: "error",
+        code: Q,
+        message: `${n}: ${a.code ?? "UNKNOWN"}: ${a.message}`
+      });
+      continue;
+    }
+    if (o.isSymbolicLink())
+      continue;
+    const c = _(n);
+    if (o.isDirectory())
+      U(c, t);
+    else if (o.isFile()) {
+      const f = k(n).toLowerCase();
+      S.includes(f) && t.add(c);
+    }
+  }
+  const s = [...t].sort();
+  return d.debug(
+    `[resolveTargets] [resolving → resolved] ${s.length} file(s), ${e.length} error(s)`
+  ), { files: s, errors: e };
+}
+function U(i, t) {
+  let e;
+  try {
+    e = y(i, { withFileTypes: !0 });
+  } catch {
+    return;
+  }
+  for (const s of e) {
+    const n = K(i, s.name);
+    if (!s.name.startsWith(".") && !Ce.has(s.name) && !s.isSymbolicLink()) {
+      if (s.isDirectory())
+        U(n, t);
+      else if (s.isFile()) {
+        const r = k(s.name).toLowerCase();
+        S.includes(r) && t.add(n);
+      }
+    }
+  }
+}
+const T = await Ee(process.argv);
+T.exitCode === 1 && console.log(T.format());
+process.exit(T.exitCode);

package/dist/chunks/{index-Dqe1TdW4.js → index-UbHoePfr.js}

@@ -1,4 +1,4 @@
-import { p as D, e as o, b as M, a as H, c as B, l as U, d as O, f as k, s as F } from "./shared-BgLzFWMH.js";
+import { p as D, e as o, b as M, a as H, d as B, l as U, f as O, h as k, s as F } from "./shared-Bjy30TeM.js";
 import a from "node:fs";
 import P from "node:path";
 function C(e) {
@@ -147,11 +147,11 @@ function G(e) {
 `).map((s) => s.trim()).filter(Boolean);
   if (m.length === 0)
     throw new Error("Конфликтующие файлы не найдены (`git diff --diff-filter=U` пуст).");
-  const b = o("git status --porcelain --untracked-files=no 2>/dev/null"), E = X(b), f = x("MERGE_MSG").trim(), v = e.incoming?.trim() || T(f) || $(r) || r, w = e.branch?.trim() || M(), A = H(), S = d(
+  const b = o("git status --porcelain --untracked-files=no 2>/dev/null"), E = X(b), g = x("MERGE_MSG").trim(), v = e.incoming?.trim() || T(g) || $(r) || r, w = e.branch?.trim() || M(), _ = H(), A = d(
     o(`git rev-list --count ${r}..HEAD 2>/dev/null`)
-  ), R = d(
+  ), S = d(
     o(`git rev-list --count HEAD..${r} 2>/dev/null`)
-  ), _ = m.map(
+  ), R = m.map(
     (s) => z(s, E.get(s) ?? "UU")
   );
   return {
@@ -160,11 +160,11 @@ function G(e) {
     currentHead: c,
     incomingHead: r,
     mergeBase: l,
-    mergeMessage: f,
-    currentOnlyCommits: S,
-    incomingOnlyCommits: R,
-    remote: A,
-    conflictFiles: _
+    mergeMessage: g,
+    currentOnlyCommits: A,
+    incomingOnlyCommits: S,
+    remote: _,
+    conflictFiles: R
   };
 }
 function u(e) {
@@ -260,6 +260,6 @@ async function q(e) {
     };
   }
 }
-const J = C(process.argv), g = await q(J);
-g.output && console.info(g.output);
-process.exit(g.code);
+const J = C(process.argv), f = await q(J);
+f.output && console.info(f.output);
+process.exit(f.code);

package/dist/chunks/{index-5xIgwwKx.js → index-g1LXlp77.js}

@@ -1,6 +1,6 @@
-import { p as $, s as e, a as k } from "./shared-BgLzFWMH.js";
+import { p as $, s as e, a as k } from "./shared-Bjy30TeM.js";
 import I from "node:fs";
-import { V as S } from "./services-Sb7TwLxt.js";
+import { V as S } from "./services-CaLOhuLV.js";
 async function m(r = {}) {
   const l = r.project, a = r.iid, f = !!r.dryRun, B = r.stdinJsonArray;
   if (!l)