project-athena 0.2.0 → 0.3.0

package/dist/context-AH5MFHRG.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+import {
+  formatContext,
+  getRelevantContext,
+  graphSummary,
+  refreshGraph
+} from "./chunk-CXUTYCZX.js";
+import "./chunk-3IS2X2Z7.js";
+import {
+  bullet,
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  relativeTime,
+  spinner,
+  sym
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import {
+  loadGraph,
+  neighbors
+} from "./chunk-PDFQ5BFG.js";
+import "./chunk-PANVPNYF.js";
+import "./chunk-ELKFRTZT.js";
+import "./chunk-PVCIGUIT.js";
+import "./chunk-OLPSEQS5.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/context.ts
+async function contextCommand(task, opts) {
+  const root = await requireProjectRoot(opts);
+  const maxChars = opts.maxChars ? Number(opts.maxChars) : void 0;
+  if (maxChars !== void 0 && (!Number.isInteger(maxChars) || maxChars < 500)) throw new AthenaError("--max-chars must be an integer of at least 500");
+  const ctx = await getRelevantContext(root, task, { maxChars, buildGraph: true, signal: opts.signal });
+  if (isJson()) {
+    json(ctx);
+    return;
+  }
+  if (opts.full) {
+    line(formatContext(ctx));
+    return;
+  }
+  heading(`Context for: ${task}`);
+  line();
+  heading("Documents to read");
+  for (const a of ctx.areas) bullet(`${c.bold(a.id)} ${dim(`\u2014 ${a.why.join("; ")}`)}`);
+  if (ctx.mentionedFiles.length) {
+    line();
+    heading("Files named in the task");
+    for (const f of ctx.mentionedFiles) line(`  ${dim(f)}`);
+  }
+  if (ctx.graphNodes.length) {
+    line();
+    heading("Related code (project graph)");
+    for (const n of ctx.graphNodes.slice(0, 12)) line(`  ${dim(`${n.kind}:`)} ${n.name}${n.path ? dim(` (${n.path})`) : ""}`);
+    if (ctx.graphNodes.length > 12) line(dim(`  +${ctx.graphNodes.length - 12} more`));
+  }
+  line();
+  heading("Sections selected");
+  for (const s of ctx.sections) line(`  ${dim(`${s.file} \u2192`)} ${s.section}`);
+  line();
+  line(dim(`${ctx.sections.length} sections \xB7 ~${ctx.approxChars} characters \xB7 ${ctx.rules.length} rules${ctx.truncated ? " \xB7 some sections omitted for budget" : ""}`));
+  line(dim("Use --full to print the context an agent would read, or --json for tooling."));
+}
+async function graphCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  if (opts.build) {
+    const sp = spinner("Building project graph...");
+    try {
+      const graph2 = await refreshGraph(root, { signal: opts.signal });
+      sp.succeed(`Graph built: ${graph2.stats.nodes} nodes, ${graph2.stats.edges} relationships`);
+    } catch (err) {
+      sp.stop();
+      throw err;
+    }
+  }
+  const graph = await loadGraph(root);
+  if (!graph) throw new AthenaError("No project graph yet.", "Run `athena graph --build`.");
+  if (opts.node) {
+    const hood = neighbors(graph, opts.node) ?? neighbors(graph, graph.nodes.find((n) => n.name === opts.node || n.path === opts.node)?.id ?? "");
+    if (!hood) throw new AthenaError(`No graph node matches "${opts.node}".`, "Use `athena graph --search <term>` to find one.");
+    if (isJson()) {
+      json(hood);
+      return;
+    }
+    heading(`${hood.node.kind}: ${hood.node.name}`);
+    if (hood.node.path) line(dim(hood.node.path));
+    line();
+    for (const e of hood.edges) line(`  ${e.direction === "out" ? sym.arrow : "\u2190"} ${dim(e.edge.kind)} ${e.other.kind}: ${e.other.name}${e.other.path ? dim(` (${e.other.path})`) : ""}`);
+    return;
+  }
+  const q = opts.search?.toLowerCase();
+  const nodes = graph.nodes.filter((n) => (!opts.kind || n.kind === opts.kind) && (!q || `${n.name} ${n.path ?? ""}`.toLowerCase().includes(q)));
+  if (isJson()) {
+    json({ stats: graph.stats, builtAt: graph.builtAt, nodes: nodes.slice(0, 200) });
+    return;
+  }
+  heading("Project graph");
+  line(dim(`Built ${relativeTime(graph.builtAt)} \xB7 ${graph.stats.nodes} nodes \xB7 ${graph.stats.edges} relationships`));
+  line();
+  for (const [kind, count] of Object.entries(graph.stats.byKind).sort((a, b) => b[1] - a[1])) line(`  ${String(count).padStart(5)} ${kind}`);
+  if (q || opts.kind) {
+    line();
+    heading(`Matching nodes (${nodes.length})`);
+    for (const n of nodes.slice(0, 30)) line(`  ${dim(`${n.kind}:`)} ${n.name}${n.path ? dim(` (${n.path})`) : ""}`);
+    if (nodes.length > 30) line(dim(`  +${nodes.length - 30} more`));
+  }
+}
+async function architectureCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const summary = await graphSummary(root);
+  if (isJson()) {
+    json(summary);
+    return;
+  }
+  if (!summary.built) {
+    line(dim("No project graph yet. Run `athena graph --build`."));
+    return;
+  }
+  heading("Architecture (from the project graph)");
+  line(dim(`Built ${relativeTime(summary.builtAt)}`));
+  line();
+  for (const [kind, count] of Object.entries(summary.stats.byKind).sort((a, b) => b[1] - a[1])) line(`  ${String(count).padStart(5)} ${kind}`);
+  line();
+  line(dim("See .athena/architecture.md for the written architecture, and `athena graph --search <term>` to explore."));
+}
+export {
+  architectureCommand,
+  contextCommand,
+  graphCommand
+};
+//# sourceMappingURL=context-AH5MFHRG.js.map

package/dist/doctor-RSJMLE2P.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import {
+  runDoctor
+} from "./chunk-PR53DT7I.js";
+import "./chunk-RXNRMIZP.js";
+import "./chunk-VSYBC3VY.js";
+import "./chunk-3IS2X2Z7.js";
+import "./chunk-65TSRDQ3.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  sym
+} from "./chunk-Z6QWMJLK.js";
+import {
+  resolveCwd
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-2R6PXY6Z.js";
+import "./chunk-PVCIGUIT.js";
+import "./chunk-OLPSEQS5.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/doctor.ts
+async function doctorCommand(opts) {
+  const cwd = await resolveCwd(opts);
+  const { checks } = await runDoctor(cwd);
+  const errors = checks.filter((c2) => c2.level === "error").length;
+  if (isJson()) {
+    json({ ok: errors === 0, checks });
+    return errors ? 1 : 0;
+  }
+  heading("Athena Doctor");
+  line();
+  for (const c2 of checks) {
+    const icon = c2.level === "ok" ? c.green(sym.ok) : c2.level === "warn" ? c.yellow(sym.warn) : c2.level === "error" ? c.red(sym.err) : c.dim(sym.ring);
+    line(`${icon} ${c.bold(c2.area)} ${dim("\u2014")} ${c2.message}`);
+    if (c2.hint) line(`  ${dim(c2.hint)}`);
+  }
+  line();
+  const warns = checks.filter((c2) => c2.level === "warn").length;
+  if (errors) line(c.red(`${errors} problem${errors === 1 ? "" : "s"} found.`));
+  else line(c.green(`Athena is ready.${warns ? dim(` (${warns} warning${warns === 1 ? "" : "s"})`) : ""}`));
+  return errors ? 1 : 0;
+}
+export {
+  doctorCommand
+};
+//# sourceMappingURL=doctor-RSJMLE2P.js.map

package/dist/event-TNT6CQZR.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import {
+  appendEvent
+} from "./chunk-65TSRDQ3.js";
+import {
+  findProjectRoot
+} from "./chunk-KBO7XRBW.js";
+import "./chunk-JCGDR4UV.js";
+import {
+  normalizeHookEvent
+} from "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/event.ts
+import path from "path";
+function parseEventArgs(args) {
+  const opts = {};
+  const valued = { "--agent": "agent", "--hook": "hook", "--cwd": "cwd", "-C": "cwd" };
+  const flags = /* @__PURE__ */ new Set(["--athena-hook", "--verbose-errors", "--json", "--quiet", "-q", "--no-color"]);
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const eq = a.startsWith("--") ? a.indexOf("=") : -1;
+    const name = eq > 0 ? a.slice(0, eq) : a;
+    const key = valued[name];
+    if (key) {
+      const value = eq > 0 ? a.slice(eq + 1) : args[++i];
+      if (value === void 0) return null;
+      opts[key] = value;
+    } else if (a.startsWith("-C") && a.length > 2) {
+      opts.cwd = a.slice(2);
+    } else if (flags.has(a)) {
+      if (a === "--verbose-errors") opts.verbose = true;
+    } else {
+      return null;
+    }
+  }
+  return opts;
+}
+var STDIN_TIMEOUT_MS = 2e3;
+var MAX_PAYLOAD_BYTES = 256 * 1024;
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  return new Promise((resolve) => {
+    let data = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      process.stdin.removeAllListeners();
+      resolve(data);
+    };
+    const timer = setTimeout(finish, STDIN_TIMEOUT_MS);
+    timer.unref();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+      if (data.length > MAX_PAYLOAD_BYTES) finish();
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      finish();
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      finish();
+    });
+  });
+}
+async function eventCommand(opts) {
+  try {
+    const raw = await readStdin();
+    let payload = {};
+    if (raw.trim().startsWith("{")) {
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        payload = {};
+      }
+    }
+    const cwdCandidates = [opts.cwd, typeof payload.cwd === "string" ? payload.cwd : void 0, Array.isArray(payload.workspace_roots) ? payload.workspace_roots.find((x) => typeof x === "string") : void 0, process.cwd()];
+    let root = null;
+    for (const c of cwdCandidates) {
+      if (!c) continue;
+      root = await findProjectRoot(path.resolve(c));
+      if (root) break;
+    }
+    if (!root) return;
+    const event = normalizeHookEvent(opts.agent ?? "unknown", opts.hook ?? "", payload);
+    if (!event) return;
+    await appendEvent(root, event);
+  } catch (err) {
+    if (opts.verbose) process.stderr.write(`athena event: ${err.message}
+`);
+  }
+}
+export {
+  eventCommand,
+  parseEventArgs
+};
+//# sourceMappingURL=event-TNT6CQZR.js.map

package/dist/git-hook-YZNZGAAP.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import {
+  dim,
+  info,
+  isJson,
+  isQuiet,
+  json,
+  line,
+  ok,
+  warn
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import {
+  git
+} from "./chunk-OLPSEQS5.js";
+import {
+  hookCommand
+} from "./chunk-GHFRQAYT.js";
+import {
+  readTextIfExists
+} from "./chunk-IQQBAWSM.js";
+import {
+  AthenaError,
+  EXIT,
+  conflict
+} from "./chunk-AD4OZCU2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/git-hook.ts
+import path2 from "path";
+
+// src/services/git-hook.ts
+import { promises as fs } from "fs";
+import path from "path";
+var HOOK_START = "# athena:start";
+var HOOK_END = "# athena:end";
+var HOOK_MANAGER_COMMAND = "npx --no-install athena sync --check --staged";
+var SHELL_SHEBANG = /^#!\s*(?:\/usr\/bin\/env\s+)?(?:\/usr\/local\/bin\/|\/usr\/bin\/|\/bin\/)?(?:sh|bash|dash|zsh|ksh)(?:\s|$)/;
+var HOOK_MANAGERS = [
+  { name: "husky", pattern: /husky/i },
+  { name: "lefthook", pattern: /lefthook/i },
+  { name: "pre-commit", pattern: /pre-commit\.com|INSTALL_PYTHON|pre_commit/ },
+  { name: "simple-git-hooks", pattern: /simple-git-hooks/i },
+  { name: "overcommit", pattern: /overcommit/i }
+];
+async function locateHook(projectRoot) {
+  const top = await git(projectRoot, ["rev-parse", "--show-toplevel"]);
+  if (!top.ok || !top.stdout.trim()) throw new AthenaError("`athena git-hook` needs a Git repository.", "Run `git init` first, or use `athena sync --check` in your own tooling.");
+  const topLevel = await fs.realpath(top.stdout.trim());
+  const hooks = await git(topLevel, ["rev-parse", "--git-path", "hooks"]);
+  if (!hooks.ok || !hooks.stdout.trim()) throw new AthenaError("Could not find the Git hooks directory.");
+  const hooksDir = path.resolve(topLevel, hooks.stdout.trim());
+  const projectPrefix = path.relative(topLevel, await fs.realpath(projectRoot)).split(path.sep).join("/");
+  return { topLevel, hooksDir, hookFile: path.join(hooksDir, "pre-commit"), projectPrefix };
+}
+function shQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function renderHookBlock(opts) {
+  const cmd = opts.command ?? hookCommand();
+  const probe = cmd.split(/\s+/)[0];
+  const cwdArg = opts.projectPrefix ? ` -C ${shQuote(opts.projectPrefix)}` : "";
+  const athena = `${cmd} --no-color${cwdArg}`;
+  const lines = [
+    `${HOOK_START} (added by \`athena git-hook install\`; remove with \`athena git-hook uninstall\`)`,
+    `if command -v ${probe} >/dev/null 2>&1; then`,
+    "  athena_rc=0",
+    `  athena_out=$(${athena} sync --check --staged --quiet 2>&1) || athena_rc=$?`,
+    '  if [ "$athena_rc" -eq 3 ]; then',
+    "    echo 'athena: no Athena knowledge to check (not initialized, or .athena/ is not committed); skipping the knowledge check.' >&2",
+    '  elif [ "$athena_rc" -ne 0 ]; then',
+    `    printf '%s\\n' "$athena_out" >&2`,
+    "    echo 'athena: commit blocked: staged .athena/ knowledge is out of date. Run `athena sync`, stage .athena/ and commit again (or skip once with `git commit --no-verify`).' >&2",
+    "    exit 1",
+    "  fi"
+  ];
+  if (opts.review) {
+    lines.push(
+      "  athena_rc=0",
+      `  athena_out=$(${athena} review --staged --no-sync 2>&1) || athena_rc=$?`,
+      '  if [ "$athena_rc" -eq 1 ]; then',
+      `    printf '%s\\n' "$athena_out" >&2`,
+      "    echo 'athena: commit blocked: `athena review` found blockers (possible secrets or env files). Fix them, or skip once with `git commit --no-verify`.' >&2",
+      "    exit 1",
+      '  elif [ "$athena_rc" -ne 0 ] && [ "$athena_rc" -ne 3 ]; then',
+      `    printf '%s\\n' "$athena_out" >&2`,
+      "    echo 'athena: commit blocked: `athena review` could not check the staged changes. Fix the error above, or skip once with `git commit --no-verify`.' >&2",
+      "    exit 1",
+      "  fi"
+    );
+  }
+  lines.push("else", `  echo 'athena: \`${probe}\` not found on PATH; skipping Athena pre-commit checks.' >&2`, "fi", HOOK_END);
+  return `${lines.join("\n")}
+`;
+}
+function parseHook(text) {
+  const start = text.indexOf(`${HOOK_START}`);
+  if (start < 0) return null;
+  const lineStart = text.lastIndexOf("\n", start) + 1;
+  const endIdx = text.indexOf(HOOK_END, start);
+  if (endIdx < 0) return null;
+  let blockEnd = endIdx + HOOK_END.length;
+  if (text[blockEnd] === "\n") blockEnd++;
+  return { before: text.slice(0, lineStart), block: text.slice(lineStart, blockEnd), after: text.slice(blockEnd) };
+}
+function detectManager(loc, text) {
+  const rel2 = path.relative(loc.topLevel, loc.hooksDir).split(path.sep);
+  if (rel2.includes(".husky")) return "husky";
+  if (text) {
+    for (const m of HOOK_MANAGERS) if (m.pattern.test(text)) return m.name;
+  }
+  return null;
+}
+var NEW_FILE_HEADER = "#!/bin/sh\n";
+async function hookStatus(projectRoot) {
+  const loc = await locateHook(projectRoot);
+  const text = await readTextIfExists(loc.hookFile);
+  const parsed = text ? parseHook(text) : null;
+  return {
+    ...loc,
+    installed: Boolean(parsed),
+    review: Boolean(parsed?.block.includes(" review ")),
+    staged: Boolean(parsed?.block.includes(" sync --check --staged")),
+    ownsFile: Boolean(parsed && `${parsed.before}${parsed.after}`.trim() === NEW_FILE_HEADER.trim()),
+    manager: detectManager(loc, text && parsed ? `${parsed.before}${parsed.after}` : text)
+  };
+}
+async function installHook(projectRoot, opts = {}) {
+  const loc = await locateHook(projectRoot);
+  const block = renderHookBlock({ projectPrefix: loc.projectPrefix, review: Boolean(opts.review) });
+  const text = await readTextIfExists(loc.hookFile);
+  let next;
+  let action;
+  const parsed = text ? parseHook(text) : null;
+  if (text === null) {
+    const manager = detectManager(loc, null);
+    if (manager) throw managedError(manager);
+    next = `${NEW_FILE_HEADER}
+${block}`;
+    action = "created";
+  } else if (parsed) {
+    next = `${parsed.before}${block}${parsed.after}`;
+    action = next === text ? "unchanged" : "updated";
+  } else {
+    const manager = detectManager(loc, text);
+    if (manager) throw managedError(manager);
+    const firstLine = text.split("\n", 1)[0];
+    if (!SHELL_SHEBANG.test(firstLine)) {
+      throw conflict(
+        `${path.relative(loc.topLevel, loc.hookFile) || loc.hookFile} already exists and is not a shell script, so Athena will not modify it.`,
+        `Add this command to your pre-commit hook yourself: ${HOOK_MANAGER_COMMAND}`
+      );
+    }
+    const rest = text.slice(firstLine.length + 1);
+    next = `${firstLine}
+${block}
+${rest}`;
+    action = "added-to-existing";
+  }
+  if (action !== "unchanged") {
+    await fs.mkdir(loc.hooksDir, { recursive: true });
+    await fs.writeFile(loc.hookFile, next, "utf8");
+  }
+  await fs.chmod(loc.hookFile, 493);
+  return { action, status: await hookStatus(projectRoot) };
+}
+async function uninstallHook(projectRoot) {
+  const loc = await locateHook(projectRoot);
+  const text = await readTextIfExists(loc.hookFile);
+  const parsed = text ? parseHook(text) : null;
+  if (!parsed) return { removed: false, deletedFile: false, status: await hookStatus(projectRoot) };
+  let rest = parsed.after;
+  if (rest.startsWith("\n")) rest = rest.slice(1);
+  const remaining = `${parsed.before}${rest}`;
+  let deletedFile = false;
+  if (!remaining.trim() || remaining.trim() === NEW_FILE_HEADER.trim()) {
+    await fs.rm(loc.hookFile, { force: true });
+    deletedFile = true;
+  } else {
+    await fs.writeFile(loc.hookFile, remaining, "utf8");
+  }
+  return { removed: true, deletedFile, status: await hookStatus(projectRoot) };
+}
+function managedError(manager) {
+  return conflict(
+    `Git hooks in this repository are managed by ${manager}, so Athena will not write a hook file.`,
+    `Add this line to your ${manager} pre-commit configuration instead: ${HOOK_MANAGER_COMMAND}`
+  );
+}
+
+// src/cli/commands/git-hook.ts
+var rel = (s) => path2.relative(s.topLevel, s.hookFile).split(path2.sep).join("/") || s.hookFile;
+function managerTip() {
+  line(dim(`Using husky, lefthook or pre-commit? Add \`${HOOK_MANAGER_COMMAND}\` to its pre-commit config instead.`));
+}
+async function gitHookInstallCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const { action, status } = await installHook(root, { review: opts.review });
+  if (isJson()) {
+    json({ action, ...status });
+    return EXIT.OK;
+  }
+  const what = status.review ? "knowledge check + review" : "knowledge check";
+  const message = {
+    created: `Installed the pre-commit hook (${what}) at ${rel(status)}`,
+    updated: `Updated Athena's block in ${rel(status)} (${what})`,
+    unchanged: `Pre-commit hook already installed at ${rel(status)} (${what})`,
+    "added-to-existing": `Added Athena's block to your existing ${rel(status)} (${what}); the rest of the hook is unchanged`
+  };
+  ok(message[action]);
+  info(dim("Commits are blocked when the staged .athena/ knowledge is out of date for the staged code (untracked and unstaged files are ignored). Teammates without Athena installed are not blocked."));
+  if (!isQuiet()) managerTip();
+  return EXIT.OK;
+}
+async function gitHookUninstallCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const r = await uninstallHook(root);
+  if (isJson()) {
+    json({ removed: r.removed, deletedFile: r.deletedFile, ...r.status });
+    return EXIT.OK;
+  }
+  if (!r.removed) line(`No Athena pre-commit hook found in ${rel(r.status)}.`);
+  else if (r.deletedFile) ok(`Removed ${rel(r.status)}`);
+  else ok(`Removed Athena's block from ${rel(r.status)}; the rest of the hook is unchanged`);
+  return EXIT.OK;
+}
+async function gitHookStatusCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const s = await hookStatus(root);
+  if (isJson()) {
+    json(s);
+    return EXIT.OK;
+  }
+  if (s.installed) {
+    ok(`Installed in ${rel(s)} (${s.review ? "knowledge check + review" : "knowledge check"}${s.ownsFile ? "" : "; shared with your own hook"})`);
+    if (!s.staged) warn("This hook checks the working tree, so untracked or unstaged files can block commits. Run `athena git-hook install` to check only what is staged.");
+  } else {
+    line(`Not installed ${dim(`(${rel(s)})`)}`);
+    if (s.manager) line(dim(`Hooks here are managed by ${s.manager}: add \`${HOOK_MANAGER_COMMAND}\` to its pre-commit config.`));
+    else line(dim("Run `athena git-hook install` (add `--review` to also block commits with secrets or env files)."));
+  }
+  return EXIT.OK;
+}
+export {
+  gitHookInstallCommand,
+  gitHookStatusCommand,
+  gitHookUninstallCommand
+};
+//# sourceMappingURL=git-hook-YZNZGAAP.js.map

package/dist/init-2V34DVRQ.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import {
+  initCommand,
+  parseAgentsOption,
+  printSummary,
+  runWithProgress,
+  summarize
+} from "./chunk-DOQMAZL5.js";
+import "./chunk-SHKXELUX.js";
+import "./chunk-Z6QWMJLK.js";
+import "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-SJOOXO34.js";
+import "./chunk-PANVPNYF.js";
+import "./chunk-ELKFRTZT.js";
+import "./chunk-2R6PXY6Z.js";
+import "./chunk-PVCIGUIT.js";
+import "./chunk-OLPSEQS5.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+export {
+  initCommand,
+  parseAgentsOption,
+  printSummary,
+  runWithProgress,
+  summarize
+};
+//# sourceMappingURL=init-2V34DVRQ.js.map