gennady 0.8.3 → 0.8.4-draft.2

package/dist/chunks/index-CXpkT25O.js

@@ -0,0 +1,183 @@
+import u from "node:fs";
+import S from "node:os";
+import v from "node:path";
+import { execSync as P } from "node:child_process";
+import { p as d, A as E } from "./index-9Gv5trS_.js";
+import { g as H, s as t, x as D, p as F } from "./shared-B5CTGvpG.js";
+import { l as N } from "./services-Csd556Tv.js";
+class U {
+  /** @purpose Configuration with defaults for mode, prompts, timeout. */
+  init;
+  /** @purpose AI core instance for LLM requests. */
+  ai;
+  /**
+   * @purpose Initialize CommitGen with configuration and AI core.
+   * @param [init] Configuration overrides (mode, oneline, targetBranch, task, timeout).
+   */
+  constructor(n = {}) {
+    this.init = {
+      mode: "auto",
+      oneline: !1,
+      targetBranch: void 0,
+      task: void 0,
+      logger: N,
+      promptCommitMessage: d.commit("message"),
+      promptCommitChangeset: d.commit("changeset"),
+      timeout: 120,
+      ...n
+    }, this.ai = new E({
+      logger: this.init.logger,
+      timeout: this.init.timeout
+    });
+  }
+  /**
+   * @purpose Get the logger instance used during generation.
+   * @returns Logger instance.
+   */
+  get logger() {
+    return this.init.logger;
+  }
+  /**
+   * @purpose Commit output mode: auto | oneline | detailed.
+   * @returns Mode string.
+   */
+  get mode() {
+    return this.init.mode;
+  }
+  /**
+   * @purpose Active AI model name (from the first available rc).
+   * @returns Model name string or undefined.
+   */
+  get model() {
+    return this.ai.model;
+  }
+  /**
+   * @purpose Active model API URL.
+   * @returns API URL string or undefined.
+   */
+  get apiUrl() {
+    return this.ai.apiUrl;
+  }
+  /**
+   * @purpose Branch against which the diff is built (if specified).
+   * @returns Target branch name or undefined.
+   */
+  get targetBranch() {
+    return this.init.targetBranch;
+  }
+  /**
+   * @purpose Task identifier for substitution in subject (optional).
+   * @returns Task ID string or number, or undefined.
+   */
+  get task() {
+    return this.init.task;
+  }
+  /**
+   * @purpose Call LLM with a single prompt without think blocks (for tests or custom input).
+   * @param input Prompt text.
+   * @returns Model response as string.
+   * @sideEffect Network: request to AI API.
+   */
+  async fetchPrompt(n) {
+    return this.ai.generate(`/no_think ${n} /no_think`);
+  }
+  /**
+   * @purpose Generate commit message from staged diff (batches → changeset → message).
+   * @returns Message string (oneline or with description) or undefined on empty diff/error.
+   * @sideEffect Network: requests to AI; Logs: info/warn/debug.
+   */
+  async generate() {
+    const n = performance.now();
+    this.init.logger.info(
+      `[CommitGen#generate] [idle → loading] targetBranch=${this.init.targetBranch ?? "HEAD"}`
+    );
+    const {
+      commitCount: y,
+      parsedCodeDiff: g,
+      parsedCodeTokens: k,
+      parsedCodeChunkMaxTokens: w,
+      programmingLanguages: B
+    } = H(this.init.targetBranch);
+    if (g.length === 0) {
+      this.init.logger.warn("[CommitGen#generate] [loading → skipped] No staged changes"), this.init.logger.info(t.italic.gray("Hint: git add ."));
+      return;
+    }
+    const h = this.init.oneline ? "oneline" : this.init.mode === "auto" ? this.init.targetBranch ? "detailed" : y > 1 && g.length < 5 ? "oneline" : "detailed" : this.init.mode;
+    this.init.logger.info(
+      `[CommitGen#generate] [loading → batching] mode=${t.bold.magentaBright(h)} languages=${B.join(", ")} tokens=${k} (max per file: ${w})`
+    );
+    const p = this.ai.createPromptsBatchesByDiff(g);
+    this.init.logger.debug(`[CommitGen#generate] [batching → ready] queue=${p.length}`);
+    const G = performance.now(), _ = await Promise.all(
+      p.map(async (e) => {
+        this.init.logger.debug(
+          `[CommitGen#generate] [batching → task] ${e.tokens} tokens, ${e.languages?.join("/")}`
+        );
+        const a = this.init.promptCommitChangeset.replaceAll("{languages}", e.languages.join("/")).replaceAll("{input}", e.diff);
+        return this.fetchPrompt(a);
+      })
+    ), A = performance.now() - G;
+    this.init.logger.info(
+      `[CommitGen#generate] [batching → changeset] (${(A / 1e3).toFixed(2)}s)`
+    );
+    const T = performance.now(), b = `<changeset>
+  ${_.flatMap((e) => e.match(/<changeset>([\s\S]*?)<\/changeset>/)?.[1]?.match(/<change.*?>.*?<\/change>/g) ?? []).join(`
+  `)}
+</changeset>`, x = await this.fetchPrompt(
+      this.init.promptCommitMessage.replaceAll("{input}", b)
+    ), M = performance.now() - T;
+    this.init.logger.info(
+      `[CommitGen#generate] [changeset → message] (${(M / 1e3).toFixed(2)}s)`
+    );
+    const i = D(x);
+    if (!i) return;
+    let o = i.subject;
+    if (this.init.task) {
+      const e = this.init.task.toString(), a = /^\d+$/.test(e) ? `#${e}` : e;
+      o = `${o} (${a})`;
+    }
+    const j = performance.now() - n;
+    return this.init.logger.info(
+      `[CommitGen#generate] [message → completed] (${(j / 1e3).toFixed(2)}ms)`
+    ), h === "oneline" ? `${i.type}: ${o} ${i.icon}` : `${i.type}: ${o} ${i.icon}
+
+${i.description}`;
+  }
+}
+const C = v.join(S.homedir(), ".gennady_commit_cache.json"), c = process.cwd(), $ = I(), m = F(process.argv, {
+  apply: ["apply"],
+  mode: ["mode", "m"],
+  oneline: ["short", "one", "o"],
+  model: ["model"],
+  targetBranch: ["branch", "b"],
+  apiUrl: ["api", "apiUrl"],
+  task: ["task", "t"]
+}), r = new U(m);
+console.info(
+  "🤖",
+  t.whiteBright.bold("GENNADY"),
+  `(${t.cyan(r.model ?? "")} → ${t.yellow(r.mode)})`,
+  "🗯️"
+);
+console.info(t.gray("-".repeat(40)));
+console.info(`- url: ${t.blue(r.apiUrl ?? "")}`);
+console.info(t.gray("-".repeat(40)));
+const s = (m.apply && $[c]) ?? await r.generate();
+s || process.exit(0);
+m.apply ? (P(`git commit -am "${String(s).replace(/(["`])/g, "\\$1")}"`, {
+  stdio: "inherit"
+}), f({ [c]: void 0 })) : (console.info("-".repeat(40), `
+`), console.info(t.whiteBright(String(s)), `
+`), console.info("^".repeat(40), `
+`), console.log(t.italic.gray(`Hint: npx gennady ${process.argv.slice(3).join(" ")} --apply`)), console.log(""), f({ [c]: s }));
+function I() {
+  try {
+    return JSON.parse(u.readFileSync(C, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function f(l) {
+  const n = { ...$, ...l };
+  u.writeFileSync(C, JSON.stringify(n, null, 2));
+}

package/dist/chunks/index-CZuTNeNm.js

@@ -0,0 +1,2 @@
+import { M as r } from "./services-Csd556Tv.js";
+process.exit(await r());

package/dist/chunks/index-CasNhhrL.js

@@ -0,0 +1,96 @@
+import { p as v, c as h, d as x, V as j, r as p } from "./shared-B5CTGvpG.js";
+import { mkdtempSync as C, writeFileSync as V } from "node:fs";
+import { tmpdir as y } from "node:os";
+import { join as w } from "node:path";
+import { l as t } from "./services-Csd556Tv.js";
+function F() {
+  return {
+    resolveVcsContext: p,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    exit: (o) => process.exit(o)
+  };
+}
+async function I(o, e) {
+  try {
+    t.debug("[resolveContextOrFail] [idle → resolving]");
+    const r = await e.resolveVcsContext(o);
+    return t.info(
+      `[resolveContextOrFail] [resolving → resolved] ${r.host}/${r.project}${r.iid ? `!${r.iid}` : ""}`
+    ), r;
+  } catch (r) {
+    r instanceof j && (t.error(
+      `[resolveContextOrFail] [resolving → failed] ${r.message}`,
+      { cause: r }
+    ), e.stderr.write(`✖ Ошибка: ${r.message}
+`), e.exit(1));
+    const n = new Error("[resolveContextOrFail] VCS context resolution failed", { cause: r });
+    t.error("[resolveContextOrFail] [resolving → failed]", { error: n }), e.stderr.write(`✖ Ошибка: ${r.message ?? "неизвестная ошибка"}
+`), e.exit(1);
+  }
+}
+function g(o) {
+  const e = o.match(/(\d+)$/);
+  return e ? e[1] : o;
+}
+function O(o, e) {
+  const r = o.jobs.find((i) => g(i.id) === e);
+  if (r) return g(r.id);
+  const n = o.jobs.find((i) => i.name === e);
+  if (n) return g(n.id);
+  throw new Error(`[resolveJobId] Job not found: ${e}`);
+}
+async function P(o, e = F()) {
+  t.debug("[run] [idle → parsing]");
+  const r = v(o, {
+    ref: { aliases: ["ref"], takesValue: !0 },
+    host: { aliases: ["host", "vcs-host"], takesValue: !0 },
+    url: { aliases: ["url"], takesValue: !0 },
+    job: { aliases: ["job"], takesValue: !0 },
+    raw: { aliases: ["raw"] }
+  }), n = {
+    ref: r.ref,
+    host: r.host,
+    url: r.url
+  }, i = r.job, $ = !!r.raw;
+  i || (e.stderr.write(`✖ Ошибка: --job <name|id> обязателен
+`), e.exit(1)), t.debug(
+    `[run] [parsing → parsed] job=${i} ref=${n.ref ?? ""} host=${n.host ?? ""}`
+  );
+  const s = await I(n, e);
+  let c;
+  s.iid !== void 0 ? (c = s.iid, t.debug(`[run] [determining-iid → explicit] iid=${c}`)) : (e.stderr.write(`✖ Ошибка: vcs-job-log требует явный MR ref (--ref group/repo!iid)
+`), e.exit(1));
+  const f = h(s);
+  f.Pipeline || (e.stderr.write(`✖ Ошибка: Pipeline API не поддерживается данным VCS-клиентом
+`), e.exit(1));
+  try {
+    t.debug(`[run] [resolved → fetching-pipeline] ${s.project}!${c}`);
+    const a = await f.MergeRequests.getPipeline({
+      project: s.project,
+      iid: c
+    });
+    t.info(
+      `[run] [fetching-pipeline → fetched] status=${a.status || "none"} jobs=${a.jobs.length}`
+    );
+    const l = O(a, i);
+    t.debug(`[run] [resolving-job → resolved] spec=${i} id=${l}`), t.debug(`[run] [idle → fetching-log] ${l}`);
+    const u = await f.Pipeline.getJobLog({ project: s.project, jobId: l });
+    t.info(`[run] [fetching-log → fetched] ${l} length=${u.length}`), $ && (e.stdout.write(u), e.exit(0));
+    const m = C(w(y(), "gennady-job-log-")), d = w(m, "raw.log");
+    V(d, u, "utf-8"), t.debug(`[run] [raw-log → saved] ${d}`);
+    const b = x(u);
+    b.trim() ? (e.stdout.write(b), e.stdout.write(`
+`)) : e.stdout.write(`(empty — no error lines detected)
+`), e.stdout.write(`
+📁 Полный лог: ${d}  (--raw для вывода без фильтрации)
+`), e.exit(0);
+  } catch (a) {
+    const l = new Error(`[run] Fetch failed for ${s.project}!${c} job=${i}`, {
+      cause: a
+    });
+    t.error("[run] [fetching → failed]", { error: l }), e.stderr.write(`✖ GitLab API error: ${a.message ?? "неизвестная ошибка"}
+`), e.exit(1);
+  }
+}
+await P(process.argv);

package/dist/chunks/index-Ce7GWENF.js

@@ -0,0 +1,377 @@
+import { readdirSync as $, statSync as L, readFileSync as N, rmdirSync as O, unlinkSync as x, mkdirSync as T, writeFileSync as W } from "node:fs";
+import { join as k, sep as K } from "node:path";
+import { fileURLToPath as z } from "node:url";
+import { l as I } from "./services-CwvXl2MB.js";
+import { au as B, az as b, av as M, p as j, aw as G } from "./shared-DSZTUx5b.js";
+class H {
+  /** @purpose List of all synced file entries, sorted lexicographically by skillName then relativePath. */
+  entries;
+  /**
+   * @purpose Construct a SyncSkillsResult from a list of entries.
+   * @param entries File entries.
+   */
+  constructor(e) {
+    this.entries = e;
+  }
+  /** @purpose Files with status "added". | @returns Array of added entries. */
+  get added() {
+    return this.entries.filter((e) => e.status === "added");
+  }
+  /** @purpose Files with status "updated". | @returns Array of updated entries. */
+  get updated() {
+    return this.entries.filter((e) => e.status === "updated");
+  }
+  /** @purpose Files with status "deleted". | @returns Array of deleted entries. */
+  get deleted() {
+    return this.entries.filter((e) => e.status === "deleted");
+  }
+  /** @purpose Files with status "unchanged". | @returns Array of unchanged entries. */
+  get unchanged() {
+    return this.entries.filter((e) => e.status === "unchanged");
+  }
+  /** @purpose Files with status "deleteFailed". | @returns Array of delete-failed entries. */
+  get deleteFailed() {
+    return this.entries.filter((e) => e.status === "deleteFailed");
+  }
+  /** @purpose Human-readable summary of sync counts. | @returns Summary string. */
+  get summary() {
+    const e = this.added.length, r = this.updated.length, a = this.unchanged.length, l = this.deleted.length, i = this.deleteFailed.length;
+    let c = `Synced: ${e} added, ${r} updated, ${a} skipped, ${l} deleted`;
+    return i > 0 && (c += `, ${i} delete failed`), c;
+  }
+  /** @purpose Dry-run summary message. | @returns Dry-run message. */
+  get dryRunSummary() {
+    return "Dry-run: no files written.";
+  }
+}
+const C = "ERR_SKILLS_SOURCE_NOT_FOUND", R = "ERR_SKILLS_SKILL_NOT_FOUND", v = /* @__PURE__ */ new Set([".DS_Store"]);
+function J(t, e) {
+  const r = $(t).filter((i) => {
+    if (i.startsWith(".") || v.has(i)) return !1;
+    try {
+      return L(k(t, i)).isDirectory();
+    } catch {
+      return !1;
+    }
+  }), a = e && e.length > 0 ? e : r;
+  for (const i of a)
+    if (!r.includes(i)) {
+      const c = `[scanSkills] Skill "${i}" not found in source.
+Available: ${r.join(", ")}`, n = new Error(c);
+      throw n.code = R, n;
+    }
+  const l = /* @__PURE__ */ new Map();
+  for (const i of a) {
+    const c = k(t, i), n = /* @__PURE__ */ new Map();
+    P(c, "", void 0, n), l.set(i, n);
+  }
+  return l;
+}
+function P(t, e, r, a) {
+  const l = r ? r.readdir : $, i = r ? r.stat : L, c = r ? r.readFile : N;
+  let n;
+  try {
+    n = l(t);
+  } catch {
+    return;
+  }
+  for (const d of n) {
+    if (d.startsWith(".") || v.has(d)) continue;
+    const g = k(t, d), y = e ? k(e, d) : d;
+    let s;
+    try {
+      s = i(g);
+    } catch {
+      continue;
+    }
+    if (s) {
+      if (s.isDirectory())
+        P(g, y, r, a);
+      else if (s.isFile()) {
+        const u = y.split(K).join("/");
+        a.set(u, c(g));
+      }
+    }
+  }
+}
+function V(t, e, r, a, l, i, c, n) {
+  let d;
+  if (a ? M(r, a) ? d = "updated" : d = "unchanged" : d = "added", !i && d !== "unchanged") {
+    const g = k(l, e);
+    n(k(g, ".."), { recursive: !0 }), c(g, r);
+  }
+  return {
+    skillName: t,
+    relativePath: e,
+    status: d,
+    sourceSize: r.length,
+    targetSize: a?.length
+  };
+}
+function F(t, e) {
+  const r = [];
+  let a;
+  try {
+    a = e.readdir(t);
+  } catch {
+    return r;
+  }
+  for (const l of a) {
+    if (l.startsWith(".") || v.has(l)) continue;
+    const i = k(t, l);
+    try {
+      const c = e.stat(i);
+      c.isDirectory() ? r.push(...F(i, e).map((n) => k(l, n))) : c.isFile() && r.push(l);
+    } catch {
+    }
+  }
+  return r;
+}
+function X(t, e, r, a) {
+  const l = k(e, t);
+  let i = [];
+  try {
+    i = F(l, a);
+  } catch {
+  }
+  if (r) {
+    const y = [
+      {
+        skillName: t,
+        relativePath: "",
+        status: "deleted",
+        sourceSize: void 0,
+        targetSize: void 0
+      }
+    ];
+    for (const s of i.sort())
+      y.push({
+        skillName: t,
+        relativePath: s,
+        status: "deleted",
+        sourceSize: void 0,
+        targetSize: void 0
+      });
+    return y;
+  }
+  const c = a.unlink ?? (() => {
+  }), n = a.rmdir ?? (() => {
+  });
+  let d = !1, g;
+  for (const y of i) {
+    const s = k(l, y);
+    try {
+      c(s);
+    } catch (u) {
+      d = !0, g = u.code ?? "UNKNOWN";
+    }
+  }
+  try {
+    n(l, { recursive: !0 });
+  } catch (y) {
+    d = !0, g = y.code ?? "UNKNOWN";
+  }
+  return d ? [
+    {
+      skillName: t,
+      relativePath: "",
+      status: "deleteFailed",
+      errorCode: g
+    }
+  ] : [
+    {
+      skillName: t,
+      relativePath: "",
+      status: "deleted"
+    }
+  ];
+}
+function Y(t, e) {
+  let r;
+  try {
+    r = t.stat(e.sourceDir);
+  } catch {
+    const s = `[collectAndCompareSkills] Source directory not found: ${e.sourceDir}`, u = new Error(s);
+    throw u.code = C, u;
+  }
+  if (!r.isDirectory())
+    throw new Error(`[collectAndCompareSkills] sourceDir is not a directory: ${e.sourceDir}`);
+  const a = k(e.targetDir, "..");
+  try {
+    if (t.stat(a).isFile())
+      throw new Error("[collectAndCompareSkills] .claude exists but is not a directory");
+  } catch (s) {
+    if (s.code !== "ENOENT") throw s;
+  }
+  try {
+    t.mkdir(e.targetDir, { recursive: !0 });
+  } catch (s) {
+    const u = s;
+    throw u.code === "EACCES" ? new Error(`[collectAndCompareSkills] cannot write to ${e.targetDir}: ${u.code}`, {
+      cause: s
+    }) : u.code === "ENOTDIR" ? new Error("[collectAndCompareSkills] .claude exists but is not a directory", {
+      cause: s
+    }) : s;
+  }
+  const l = t.writeFile, i = t.mkdir, c = J(e.sourceDir, e.skillNames);
+  let n = [];
+  try {
+    n = t.readdir(e.targetDir).filter((s) => {
+      if (s.startsWith(".") || v.has(s)) return !1;
+      try {
+        return t.stat(k(e.targetDir, s)).isDirectory();
+      } catch {
+        return !1;
+      }
+    });
+  } catch {
+  }
+  const d = [];
+  for (const s of [...c.keys()].sort()) {
+    const u = c.get(s), o = k(e.targetDir, s);
+    let f = /* @__PURE__ */ new Map();
+    P(o, "", t, f);
+    for (const [p, D] of [...u.entries()].sort(
+      ([h], [S]) => h.localeCompare(S)
+    )) {
+      const h = B(D.toString("utf-8"), b), S = Buffer.from(h, "utf-8"), m = f.get(p);
+      d.push(
+        V(
+          s,
+          p,
+          S,
+          m,
+          o,
+          e.dryRun ?? !1,
+          l,
+          i
+        )
+      );
+    }
+    n = n.filter((p) => p !== s);
+  }
+  const g = e.skillNames, y = g ? n.filter((s) => g.includes(s)) : n;
+  for (const s of y.sort())
+    d.push(...X(s, e.targetDir, e.dryRun ?? !1, t));
+  return new H(d);
+}
+const q = "(would add)", Q = "(would update)", Z = "(would delete)", ee = "(unchanged, skip)", te = "(unchanged)", E = {
+  added: 0,
+  updated: 1,
+  deleted: 2,
+  deleteFailed: 3,
+  unchanged: 4
+};
+function re(t, e = {}) {
+  const r = e.dryRun === !0;
+  if (t.length === 0)
+    return r ? ["Dry-run: no files written."] : ["Synced: 0 added, 0 updated, 0 skipped, 0 deleted"];
+  const a = /* @__PURE__ */ new Map();
+  for (const o of t) {
+    let f = a.get(o.skillName);
+    f || (f = { entries: [], dominantStatus: "unchanged" }, a.set(o.skillName, f)), f.entries.push(o);
+    const p = E[o.status], D = E[f.dominantStatus];
+    p < D && (f.dominantStatus = o.status);
+  }
+  const l = [...a.entries()].sort(([o, f], [p, D]) => {
+    const h = E[f.dominantStatus] - E[D.dominantStatus];
+    return h !== 0 ? h : o.localeCompare(p);
+  }), c = Math.max(...l.map(([o]) => `  _ ${o}/`.length)) + 4, n = [];
+  for (const [o, f] of l) {
+    const p = f.dominantStatus;
+    if (p === "added") {
+      const h = `  + ${o}/`;
+      n.push(h);
+      for (const S of f.entries.sort((m, _) => m.relativePath.localeCompare(_.relativePath)))
+        r ? n.push(`      ${S.relativePath}`.padEnd(c) + q) : n.push(`      ${S.relativePath}`);
+    } else if (p === "updated") {
+      const h = `  ~ ${o}/`;
+      n.push(h);
+      const S = f.entries.filter((m) => m.status === "added" || m.status === "updated").sort((m, _) => m.relativePath.localeCompare(_.relativePath));
+      for (const m of S)
+        r ? n.push(`      ${m.relativePath}`.padEnd(c) + Q) : n.push(`      ${m.relativePath}`);
+    } else if (p === "deleted") {
+      const h = `  - ${o}/`;
+      r ? n.push(h.padEnd(c) + Z) : n.push(h);
+      for (const S of f.entries.filter((m) => m.relativePath !== "").sort((m, _) => m.relativePath.localeCompare(_.relativePath)))
+        n.push(`      ${S.relativePath}`);
+    } else if (p === "deleteFailed") {
+      const h = f.entries.find((m) => m.errorCode)?.errorCode ?? "UNKNOWN", S = `  ! ${o}/`;
+      n.push(S.padEnd(c) + `(delete failed: ${h})`);
+    } else {
+      const h = `  = ${o}/`, S = r ? ee : te;
+      n.push(h.padEnd(c) + S);
+    }
+  }
+  const d = t.filter((o) => o.status === "added").length, g = t.filter((o) => o.status === "updated").length, y = t.filter((o) => o.status === "unchanged").length, s = t.filter((o) => o.status === "deleted").length, u = t.filter((o) => o.status === "deleteFailed").length;
+  if (r)
+    n.push("Dry-run: no files written.");
+  else {
+    let o = `Synced: ${d} added, ${g} updated, ${y} skipped, ${s} deleted`;
+    u > 0 && (o += `, ${u} delete failed`), n.push(o);
+  }
+  return n;
+}
+function ne(t) {
+  try {
+    const e = k(t, "..", ".."), r = N(k(e, "package.json"), "utf-8");
+    return JSON.parse(r).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function se(t, e, r, a, l) {
+  r.write(`Sync skills (v${l})${e ? " (dry-run)" : ""}: ${a}
+`);
+  const i = re(t, { dryRun: e });
+  for (const c of i)
+    r.write(c + `
+`);
+}
+function A(t, e) {
+  const r = N, a = W, l = T, i = L, c = $, n = x, d = O, g = G, y = process.stdout, s = process.stderr, u = j(t, {
+    dryRun: ["dry-run"]
+  }), o = u.dryRun === !0 || u.dryRun === "true", f = u._.filter(
+    (_) => typeof _ == "string" && _ !== "sync-skills"
+  ), p = process.cwd(), D = g(p, "ai/skills");
+  if (!D)
+    return s.write(`Error: gennady package not found. Install it locally: npm i -D gennady
+`), 1;
+  const h = ne(D), S = k(p, ".claude", "skills"), m = {
+    sourceDir: D,
+    targetDir: S,
+    skillNames: f.length > 0 ? f : void 0,
+    dryRun: o
+  };
+  try {
+    const w = Y({
+      readFile: r,
+      writeFile: a,
+      mkdir: l,
+      stat: (U) => i(U),
+      readdir: c,
+      unlink: n,
+      rmdir: d,
+      resolvePackageDir: g
+    }, m);
+    return se(w.entries, o, y, p, h), 0;
+  } catch (_) {
+    const w = _;
+    if (w.code === R || w.code === C)
+      return s.write(`Error: ${w.message}
+`), 1;
+    throw w;
+  }
+}
+if (process.argv[1]) {
+  const t = z(import.meta.url);
+  if (t === process.argv[1] || t.endsWith(process.argv[1]))
+    try {
+      const e = A(process.argv);
+      process.exit(e);
+    } catch (e) {
+      const r = new Error("[syncSkillsCmd] Self-execution failed", { cause: e });
+      I.error("[syncSkillsCmd#run] [self-executing → failed]", { error: r }), process.exit(1);
+    }
+}
+process.exit(A(process.argv));