project-athena 0.2.1 → 0.3.0

package/dist/chunk-OLPSEQS5.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+
+// src/core/git/git.ts
+import { spawn } from "child_process";
+var DEFAULT_MAX_BYTES = 32 * 1024 * 1024;
+var MAX_STDERR_BYTES = 64 * 1024;
+function git(cwd, args, opts = {}) {
+  const o = typeof opts === "number" ? { timeoutMs: opts } : opts;
+  const timeoutMs = o.timeoutMs ?? 15e3;
+  const maxBytes = o.maxBytes ?? DEFAULT_MAX_BYTES;
+  return new Promise((resolve) => {
+    if (o.signal?.aborted) {
+      resolve({ ok: false, code: null, stdout: "", stderr: "", aborted: true });
+      return;
+    }
+    const out = [];
+    const err = [];
+    let outBytes = 0;
+    let errBytes = 0;
+    let overflow = false;
+    let timedOut = false;
+    let aborted = false;
+    let settled = false;
+    const child = spawn("git", args, {
+      cwd,
+      windowsHide: true,
+      stdio: [o.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" }
+    });
+    const kill = () => {
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill();
+    }, timeoutMs);
+    const onAbort = () => {
+      aborted = true;
+      kill();
+    };
+    o.signal?.addEventListener("abort", onAbort, { once: true });
+    const finish = (code, spawnError) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      o.signal?.removeEventListener("abort", onAbort);
+      let stderr = Buffer.concat(err).toString("utf8");
+      if (spawnError) stderr = stderr || spawnError.message;
+      if (overflow) stderr = `${stderr}${stderr ? "\n" : ""}output exceeded ${maxBytes} bytes`;
+      if (timedOut) stderr = `${stderr}${stderr ? "\n" : ""}timed out after ${timeoutMs} ms`;
+      const failed = overflow || timedOut || aborted || Boolean(spawnError);
+      resolve({
+        ok: !failed && code === 0,
+        code: failed ? null : code,
+        stdout: Buffer.concat(out).toString("utf8"),
+        stderr,
+        ...overflow ? { overflow } : {},
+        ...aborted ? { aborted } : {},
+        ...timedOut ? { timedOut } : {}
+      });
+    };
+    child.stdout.on("data", (chunk) => {
+      if (overflow) return;
+      outBytes += chunk.length;
+      if (outBytes > maxBytes) {
+        overflow = true;
+        kill();
+        return;
+      }
+      out.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (errBytes >= MAX_STDERR_BYTES) return;
+      errBytes += chunk.length;
+      err.push(chunk);
+    });
+    child.on("error", (e) => finish(null, e));
+    child.on("close", (code) => finish(code));
+    if (o.input !== void 0) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(o.input);
+    }
+  });
+}
+var GitCommandError = class extends Error {
+  constructor(args, result) {
+    const detail = result.stderr.trim().split("\n").filter(Boolean).slice(-1)[0]?.slice(0, 300);
+    super(`git ${args.find((a) => !a.startsWith("-") && !a.includes("=")) ?? args[0]} failed${detail ? `: ${detail}` : result.code !== null ? ` (exit ${result.code})` : ""}`);
+    this.args = args;
+    this.result = result;
+    this.name = "GitCommandError";
+  }
+  args;
+  result;
+};
+async function gitOrThrow(cwd, args, opts = {}) {
+  const r = await git(cwd, args, opts);
+  if (r.aborted) throw opts.signal?.reason ?? new Error("Aborted");
+  if (!r.ok) throw new GitCommandError(args, r);
+  return r.stdout;
+}
+var availability = null;
+function gitAvailable(opts = {}) {
+  if (availability) return availability;
+  const p = git(process.cwd(), ["--version"], { signal: opts.signal }).then((r) => {
+    if (r.aborted && availability === p) availability = null;
+    return r.ok;
+  });
+  availability = p;
+  return p;
+}
+async function isGitRepo(cwd, opts = {}) {
+  const r = await git(cwd, ["rev-parse", "--is-inside-work-tree"], { signal: opts.signal });
+  return r.ok && r.stdout.trim() === "true";
+}
+var HISTORY_DAYS = 180;
+var HISTORY_MAX_COMMITS = 2e3;
+var AUTHOR_MARK = "";
+async function gitInfo(cwd, opts = {}) {
+  const { signal } = opts;
+  const days = opts.historyDays ?? HISTORY_DAYS;
+  const maxCommits = opts.maxCommits ?? HISTORY_MAX_COMMITS;
+  const run = (args) => git(cwd, args, { signal });
+  const [available, isRepo, branch, head, date, log] = await Promise.all([
+    gitAvailable({ signal }),
+    isGitRepo(cwd, { signal }),
+    run(["rev-parse", "--abbrev-ref", "HEAD"]),
+    run(["rev-parse", "HEAD"]),
+    run(["log", "-1", "--format=%cI"]),
+    run(["log", `--since=${days}.days`, `--max-count=${maxCommits}`, "--no-merges", `--format=${AUTHOR_MARK}%aN`, "--name-only", "--relative", "--", "."])
+  ]);
+  signal?.throwIfAborted();
+  const info = { available, isRepo: false, hotspots: [] };
+  if (!info.available) return info;
+  info.isRepo = isRepo;
+  if (!info.isRepo) return info;
+  if (branch.ok) info.branch = branch.stdout.trim();
+  if (head.ok) info.head = head.stdout.trim();
+  if (date.ok && date.stdout.trim()) info.lastCommitDate = date.stdout.trim();
+  if (log.ok) {
+    const authors = /* @__PURE__ */ new Set();
+    const counts = /* @__PURE__ */ new Map();
+    for (const line of log.stdout.split("\n")) {
+      if (line.startsWith(AUTHOR_MARK)) {
+        authors.add(line.slice(1));
+        continue;
+      }
+      const p = line.trim();
+      if (!p || p === ".athena" || p.startsWith(".athena/")) continue;
+      const dir = p.includes("/") ? p.split("/").slice(0, 2).join("/") : ".";
+      counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    info.contributorCount = authors.size;
+    info.hotspots = [...counts.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).slice(0, 10).map(([path, commits]) => ({ path, commits }));
+  }
+  return info;
+}
+async function workingChanges(cwd, opts = {}) {
+  const [r, prefix] = await Promise.all([git(cwd, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."], { signal: opts.signal }), repoPrefix(cwd, opts)]);
+  if (!r.ok) return null;
+  const out = [];
+  const parts = r.stdout.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    const code = entry.slice(0, 2);
+    const p = entry.slice(3);
+    if (code.includes("R")) {
+      out.push({ path: p, status: "renamed", from: parts[++i] });
+    } else if (code === "??") out.push({ path: p, status: "untracked" });
+    else if (code.includes("D")) out.push({ path: p, status: "deleted" });
+    else if (code.includes("A")) out.push({ path: p, status: "added" });
+    else if (code.includes("M")) out.push({ path: p, status: "modified" });
+    else out.push({ path: p, status: "other" });
+  }
+  return stripPrefix(out, prefix);
+}
+async function repoPrefix(cwd, opts = {}) {
+  const r = await git(cwd, ["rev-parse", "--show-prefix"], { signal: opts.signal });
+  return r.ok ? r.stdout.trim() : "";
+}
+function stripPrefix(files, prefix) {
+  if (!prefix) return files;
+  return files.filter((f) => f.path.startsWith(prefix)).map((f) => ({ ...f, path: f.path.slice(prefix.length), from: f.from?.startsWith(prefix) ? f.from.slice(prefix.length) : f.from }));
+}
+function parseNameStatusZ(stdout) {
+  const out = [];
+  const parts = stdout.split("\0").filter(Boolean);
+  for (let i = 0; i < parts.length; i++) {
+    const code = parts[i];
+    if (code.startsWith("R") || code.startsWith("C")) {
+      const from = parts[++i];
+      const to = parts[++i];
+      if (to === void 0) break;
+      out.push(code.startsWith("R") ? { path: to, status: "renamed", from } : { path: to, status: "added" });
+    } else {
+      const p = parts[++i];
+      if (p === void 0) break;
+      out.push({ path: p, status: code === "A" ? "added" : code === "D" ? "deleted" : code === "M" ? "modified" : "other" });
+    }
+  }
+  return out;
+}
+function isSafeRef(ref) {
+  return /^[A-Za-z0-9][\w./@^~-]{0,119}$/.test(ref);
+}
+async function headMovement(cwd, from, to, limit = 20, opts = {}) {
+  if (!/^[0-9a-f]{7,64}$/i.test(from) || !/^[0-9a-f]{7,64}$/i.test(to)) return null;
+  if (from === to) return { commits: [], diverged: false, truncated: false };
+  const { signal } = opts;
+  const exists = await git(cwd, ["cat-file", "-e", `${from}^{commit}`], { signal });
+  if (!exists.ok) return { commits: [], diverged: true, truncated: false };
+  const [ancestor, log] = await Promise.all([git(cwd, ["merge-base", "--is-ancestor", from, to], { signal }), git(cwd, ["log", `-n${limit + 1}`, "--format=%H%x1f%s", `${from}..${to}`], { signal })]);
+  if (!log.ok) return null;
+  const commits = log.stdout.split("\n").filter(Boolean).map((l) => {
+    const [sha, subject] = l.split("");
+    return { sha, subject: subject ?? "" };
+  });
+  return { commits: commits.slice(0, limit), diverged: !ancestor.ok, truncated: commits.length > limit };
+}
+function parseStatusV2Z(stdout) {
+  const out = [];
+  const parts = stdout.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const rec = parts[i];
+    if (!rec) continue;
+    const kind = rec[0];
+    if (kind === "?" || kind === "!") {
+      out.push({ kind, path: rec.slice(2), submodule: false });
+      continue;
+    }
+    if (kind === "#") continue;
+    if (kind !== "1" && kind !== "2" && kind !== "u") return null;
+    const fields = kind === "1" ? 8 : kind === "2" ? 9 : 10;
+    let at = 0;
+    for (let f = 0; f < fields && at >= 0; f++) at = rec.indexOf(" ", at + 1);
+    if (at < 0) return null;
+    const sub = rec.split(" ", 3)[2] ?? "N...";
+    const entry = { kind, path: rec.slice(at + 1), submodule: sub.startsWith("S") };
+    if (kind === "2") entry.from = parts[++i];
+    out.push(entry);
+  }
+  return out;
+}
+async function statusV2(cwd, opts = {}) {
+  const r = await git(cwd, ["status", "--porcelain=v2", "-z", "--untracked-files=all", "--ignore-submodules=none", "--", "."], { signal: opts.signal });
+  return r.ok ? parseStatusV2Z(r.stdout) : null;
+}
+
+export {
+  git,
+  GitCommandError,
+  gitOrThrow,
+  gitAvailable,
+  isGitRepo,
+  gitInfo,
+  workingChanges,
+  parseNameStatusZ,
+  isSafeRef,
+  headMovement,
+  statusV2
+};
+//# sourceMappingURL=chunk-OLPSEQS5.js.map