project-athena 0.2.1 → 0.4.0

package/dist/staged-check-X24C3YRD.js

@@ -0,0 +1,502 @@
+#!/usr/bin/env node
+import {
+  HISTORY_SECTIONS
+} from "./chunk-KHMBNT66.js";
+import "./chunk-WVQC2EGO.js";
+import "./chunk-GR4DL2VM.js";
+import {
+  planKnowledge
+} from "./chunk-GGXPG6OE.js";
+import {
+  REAL_ENV_NAMES,
+  SCAN_FILE,
+  analyzeProject,
+  redactDeep
+} from "./chunk-MPG3IEGB.js";
+import {
+  mapLimit
+} from "./chunk-ELKFRTZT.js";
+import "./chunk-2R6PXY6Z.js";
+import {
+  readLocalConfig
+} from "./chunk-PVCIGUIT.js";
+import {
+  git,
+  gitInfo,
+  isGitRepo
+} from "./chunk-OLPSEQS5.js";
+import "./chunk-SVTEJYMS.js";
+import "./chunk-QCC4VJUH.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-YRIS7ZS6.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import {
+  cacheRoot,
+  loadConfig,
+  readFileIndex,
+  readState
+} from "./chunk-2DY4PUR4.js";
+import {
+  readTextIfExists,
+  writeFileAtomic
+} from "./chunk-IQQBAWSM.js";
+import {
+  AthenaError,
+  EXIT
+} from "./chunk-AD4OZCU2.js";
+import "./chunk-XW3MLHI2.js";
+import {
+  athenaDir
+} from "./chunk-EUPETUWA.js";
+
+// src/services/staged-check.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import crypto from "crypto";
+
+// src/core/git/index-snapshot.ts
+import { spawn } from "child_process";
+import { lstatSync, promises as fs } from "fs";
+import path from "path";
+var IndexSnapshotError = class extends Error {
+};
+async function gitOrFail(cwd, args, signal) {
+  const r = await git(cwd, args, { signal, timeoutMs: 12e4, maxBytes: 512 * 1024 * 1024 });
+  signal?.throwIfAborted();
+  if (!r.ok) throw new IndexSnapshotError(`git ${args[0]} failed: ${r.stderr.trim() || `exit ${r.code}`}`);
+  return r.stdout;
+}
+async function readIndex(cwd, signal) {
+  const out = await gitOrFail(cwd, ["ls-files", "-s", "-v", "--debug", "-z"], signal);
+  const entries = [];
+  const unmerged = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < out.length) {
+    const nul = out.indexOf("\0", i);
+    if (nul < 0) break;
+    const rec = out.slice(i, nul);
+    i = nul + 1;
+    const stat = {};
+    while (out.startsWith("  ", i)) {
+      const nl = out.indexOf("\n", i);
+      const end = nl < 0 ? out.length : nl;
+      for (const part of out.slice(i + 2, end).split("	")) {
+        const c = part.indexOf(": ");
+        if (c > 0) stat[part.slice(0, c)] = part.slice(c + 2);
+      }
+      i = end + 1;
+    }
+    const m = /^(\S) (\d{6}) ([0-9a-f]{40,64}) (\d)\t([\s\S]+)$/.exec(rec);
+    if (!m) throw new IndexSnapshotError(`unexpected \`git ls-files\` output: ${JSON.stringify(rec.slice(0, 80))}`);
+    const [, tag, mode, sha, stage, p] = m;
+    if (stage !== "0") {
+      unmerged.add(p);
+      continue;
+    }
+    const mt = /^(\d+):(\d+)$/.exec(stat.mtime ?? "");
+    const size = /^\d+$/.test(stat.size ?? "") ? Number(stat.size) : void 0;
+    entries.push({ mode, sha, path: p, trustWorktree: tag === "H", size, mtimeMs: mt ? Number(mt[1]) * 1e3 + Number(mt[2]) / 1e6 : void 0 });
+  }
+  if (unmerged.size) throw new IndexSnapshotError(`the index has unresolved merge conflicts (${[...unmerged].slice(0, 3).join(", ")}${unmerged.size > 3 ? ", \u2026" : ""})`);
+  return entries;
+}
+function inside(dest, rel) {
+  const abs = path.resolve(dest, rel);
+  const r = path.relative(dest, abs);
+  if (!r || r.startsWith("..") || path.isAbsolute(r)) throw new IndexSnapshotError(`refusing index path outside the project: ${rel}`);
+  return abs;
+}
+function needsRealContent(rel) {
+  return rel.startsWith(".athena/") || rel === ".gitignore" || rel.endsWith("/.gitignore");
+}
+async function catFileBatch(cwd, shas, onBlob, signal) {
+  if (!shas.length) return;
+  const child = spawn("git", ["cat-file", "--batch"], { cwd, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" } });
+  const onAbort = () => child.kill("SIGKILL");
+  signal?.addEventListener("abort", onAbort, { once: true });
+  let stderr = "";
+  child.stderr.on("data", (d) => {
+    if (stderr.length < 4096) stderr += d.toString("utf8");
+  });
+  const exited = new Promise((resolve) => {
+    child.on("close", (code) => resolve(code));
+    child.on("error", () => resolve(null));
+  });
+  child.stdin.on("error", () => {
+  });
+  child.stdin.end(`${shas.join("\n")}
+`);
+  try {
+    let buf = Buffer.alloc(0);
+    let want = null;
+    let received = 0;
+    for await (const chunk of child.stdout) {
+      buf = buf.length ? Buffer.concat([buf, chunk]) : chunk;
+      for (; ; ) {
+        if (!want) {
+          const nl = buf.indexOf(10);
+          if (nl < 0) break;
+          const header = buf.subarray(0, nl).toString("utf8");
+          buf = buf.subarray(nl + 1);
+          const h = /^([0-9a-f]+) (\w+) (\d+)$/.exec(header);
+          if (!h) throw new IndexSnapshotError(`git cat-file: ${header}`);
+          want = { sha: h[1], size: Number(h[3]) };
+        }
+        if (buf.length < want.size + 1) break;
+        const data = Buffer.from(buf.subarray(0, want.size));
+        buf = buf.subarray(want.size + 1);
+        const done = want;
+        want = null;
+        received++;
+        await onBlob(done.sha, data);
+      }
+    }
+    const code = await exited;
+    signal?.throwIfAborted();
+    if (code !== 0 || received !== shas.length) throw new IndexSnapshotError(`git cat-file failed: ${stderr.trim() || `exit ${code}`}`);
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    if (child.exitCode === null) child.kill("SIGKILL");
+  }
+}
+var placeholderWant = (size, mtimeMs) => ({ kind: "placeholder", key: `p:${size}:${mtimeMs}`, size, mtimeMs });
+async function submoduleFiles(root, rel, out) {
+  let ents;
+  try {
+    ents = await fs.readdir(path.join(root, rel), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of ents) {
+    if (e.name === ".git") continue;
+    const r = `${rel}/${e.name}`;
+    if (e.isDirectory()) await submoduleFiles(root, r, out);
+    else if (e.isFile()) {
+      const st = await fs.stat(path.join(root, r)).catch(() => null);
+      if (st) out.set(r, placeholderWant(st.size, st.mtimeMs));
+    }
+  }
+}
+async function writePlaceholder(file, size, mtimeMs) {
+  const fh = await fs.open(file, "w");
+  try {
+    if (size) await fh.truncate(size);
+    const t = (Math.floor(mtimeMs) + 0.5) / 1e3;
+    await fh.utimes(t, t);
+  } finally {
+    await fh.close();
+  }
+}
+async function place(file, make) {
+  try {
+    await make();
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EISDIR" && code !== "EEXIST" && code !== "ENOTDIR" && code !== "ENOENT" && code !== "EPERM") throw err;
+    await fs.rm(file, { recursive: true, force: true });
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await make();
+  }
+}
+async function ensureDir(dir) {
+  try {
+    await fs.mkdir(dir, { recursive: true });
+  } catch (err) {
+    let d = dir;
+    for (; ; ) {
+      const st = await fs.lstat(d).catch(() => null);
+      if (st && !st.isDirectory()) break;
+      const up = path.dirname(d);
+      if (up === d) throw err;
+      d = up;
+    }
+    await fs.rm(d, { force: true });
+    await fs.mkdir(dir, { recursive: true });
+  }
+}
+async function updateIndexSnapshot(root, dest, opts) {
+  const { signal } = opts;
+  const [entries, dirtyOut] = await Promise.all([readIndex(root, signal), gitOrFail(root, ["diff-files", "--name-only", "--relative", "-z"], signal)]);
+  const dirty = new Set(dirtyOut.split("\0").filter(Boolean));
+  const want = /* @__PURE__ */ new Map();
+  const needBlob = [];
+  for (const [i, e] of entries.entries()) {
+    if (i % 1024 === 0) signal?.throwIfAborted();
+    inside(dest, e.path);
+    if (e.mode === "120000") want.set(e.path, { kind: "symlink", key: `l:${e.sha}`, sha: e.sha });
+    else if (e.mode === "100644" || e.mode === "100755") {
+      if (e.trustWorktree && !dirty.has(e.path) && !needsRealContent(e.path)) {
+        if (e.size !== void 0 && e.mtimeMs !== void 0 && e.size < 2 ** 32 - 1) {
+          want.set(e.path, placeholderWant(e.size, e.mtimeMs));
+          continue;
+        }
+        const st = lstatSync(path.join(root, e.path), { throwIfNoEntry: false });
+        if (st?.isFile()) {
+          want.set(e.path, placeholderWant(st.size, st.mtimeMs));
+          continue;
+        }
+      }
+      needBlob.push(e);
+    }
+  }
+  for (const e of entries) if (e.mode === "160000") await submoduleFiles(root, e.path, want);
+  const prev = opts.previous ?? {};
+  const sizeFromKey = (key, sha) => key?.startsWith(`s:${sha}:`) ? Number(key.split(":")[2]) : key?.startsWith(`b:${sha}:`) ? Number(key.split(":")[2]) : void 0;
+  const unknown = [...new Set(needBlob.filter((e) => sizeFromKey(prev[e.path], e.sha) === void 0).map((e) => e.sha))];
+  const sizes = /* @__PURE__ */ new Map();
+  if (unknown.length) {
+    const r = await git(root, ["cat-file", "--batch-check=%(objectname) %(objectsize)"], { signal, input: `${unknown.join("\n")}
+`, timeoutMs: 12e4, maxBytes: 64 * 1024 * 1024 });
+    if (!r.ok) throw new IndexSnapshotError(`git cat-file failed: ${r.stderr.trim()}`);
+    for (const line of r.stdout.split("\n")) {
+      const m = /^([0-9a-f]+) (\d+)$/.exec(line);
+      if (m) sizes.set(m[1], Number(m[2]));
+    }
+  }
+  for (const e of needBlob) {
+    const size = sizes.get(e.sha) ?? sizeFromKey(prev[e.path], e.sha);
+    if (size === void 0) throw new IndexSnapshotError(`object ${e.sha} for ${e.path} is missing from the repository`);
+    if (size > opts.maxFileBytes) want.set(e.path, { kind: "sparse", key: `s:${e.sha}:${size}`, size });
+    else want.set(e.path, { kind: "blob", key: `b:${e.sha}:${size}`, sha: e.sha });
+  }
+  const removals = Object.keys(prev).filter((p) => want.get(p)?.key !== prev[p]);
+  await mapLimit(removals, 64, (p) => fs.rm(inside(dest, p), { force: true, recursive: true }));
+  const todo = [...want].filter(([p, w]) => prev[p] !== w.key);
+  const dirs = new Set(todo.map(([p]) => path.dirname(inside(dest, p))));
+  for (const d of [...dirs].sort()) await ensureDir(d);
+  const byBlob = /* @__PURE__ */ new Map();
+  await mapLimit(todo, 64, async ([p, w]) => {
+    signal?.throwIfAborted();
+    const file = inside(dest, p);
+    if (w.kind === "placeholder") await place(file, () => writePlaceholder(file, w.size, w.mtimeMs));
+    else if (w.kind === "sparse") await place(file, () => writePlaceholder(file, w.size, Date.now()));
+    else byBlob.set(w.sha, [...byBlob.get(w.sha) ?? [], p]);
+  });
+  const links = [];
+  await catFileBatch(
+    root,
+    [...byBlob.keys()],
+    async (sha, data) => {
+      for (const p of byBlob.get(sha) ?? []) {
+        if (want.get(p).kind === "symlink") links.push([p, data.toString("utf8")]);
+        else {
+          const file = inside(dest, p);
+          await place(file, () => fs.writeFile(file, data));
+        }
+      }
+    },
+    signal
+  );
+  for (const [p, target] of links) {
+    const at = inside(dest, p);
+    const rel = path.relative(dest, path.resolve(path.dirname(at), target));
+    if (path.isAbsolute(target) || !rel || rel.startsWith("..") || path.isAbsolute(rel)) continue;
+    await place(at, () => fs.symlink(target, at)).catch(() => {
+    });
+  }
+  const manifest = {};
+  const placeholders = /* @__PURE__ */ new Set();
+  let fromIndex = 0;
+  for (const [p, w] of want) {
+    manifest[p] = w.key;
+    if (w.kind === "placeholder") placeholders.add(p);
+    else if (w.kind === "blob") fromIndex++;
+  }
+  return { manifest, entries: entries.filter((e) => e.mode !== "160000").length, placeholders, fromIndex, written: todo.length, removed: removals.length };
+}
+function snapshotReader(snapRoot, workRoot, placeholders) {
+  return async (abs) => {
+    const real = await fs.realpath(abs).catch(() => abs);
+    const rel = path.relative(snapRoot, real).split(path.sep).join("/");
+    if (placeholders.has(rel)) return fs.readFile(path.join(workRoot, rel));
+    return fs.readFile(abs);
+  };
+}
+
+// src/services/staged-check.ts
+var STAGED_DIR = "staged";
+var MANIFEST_VERSION = 1;
+var STALE_MS = 60 * 60 * 1e3;
+async function readManifest(file, root) {
+  try {
+    const m = JSON.parse(await fs2.readFile(file, "utf8"));
+    return m.v === MANIFEST_VERSION && m.root === root && m.entries && typeof m.entries === "object" ? m.entries : null;
+  } catch {
+    return null;
+  }
+}
+async function lock(file) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fh = await fs2.open(file, "wx");
+      await fh.writeFile(String(process.pid));
+      await fh.close();
+      return () => fs2.rm(file, { force: true });
+    } catch (err) {
+      if (err.code !== "EEXIST") return null;
+      const [pid, st] = await Promise.all([fs2.readFile(file, "utf8").catch(() => ""), fs2.stat(file).catch(() => null)]);
+      let alive = Date.now() - (st?.mtimeMs ?? 0) < STALE_MS;
+      try {
+        if (alive && Number(pid) > 0) process.kill(Number(pid), 0);
+      } catch (e) {
+        if (e.code === "ESRCH") alive = false;
+      }
+      if (alive) return null;
+      await fs2.rm(file, { force: true });
+    }
+  }
+  return null;
+}
+async function linkOrCopy(src, dst) {
+  await fs2.mkdir(path2.dirname(dst), { recursive: true });
+  await fs2.link(src, dst).catch(() => fs2.copyFile(src, dst));
+}
+async function addLocalInputs(root, snapRoot, snap) {
+  const dir = athenaDir(root);
+  const snapAthena = athenaDir(snapRoot);
+  await fs2.rm(path2.join(snapRoot, ".git"), { recursive: true, force: true });
+  await Promise.all(REAL_ENV_NAMES.filter((n) => !snap.manifest[n]).map((n) => fs2.rm(path2.join(snapRoot, n), { force: true, recursive: true })));
+  const facts = path2.join(cacheRoot(dir), "facts");
+  const snapFacts = path2.join(cacheRoot(snapAthena), "facts");
+  const [names, old] = await Promise.all([fs2.readdir(facts).catch(() => []), fs2.readdir(snapFacts).catch(() => [])]);
+  const keep = new Set(names);
+  await Promise.all(old.filter((n) => !keep.has(n)).map((n) => fs2.rm(path2.join(snapFacts, n), { force: true, recursive: true })));
+  await Promise.all(
+    names.map(async (n) => {
+      const [a, b] = await Promise.all([fs2.stat(path2.join(facts, n)).catch(() => null), fs2.stat(path2.join(snapFacts, n)).catch(() => null)]);
+      if (!a?.isFile() || b && a.ino === b.ino && a.dev === b.dev && a.size === b.size && a.mtimeMs === b.mtimeMs) return;
+      await fs2.rm(path2.join(snapFacts, n), { force: true, recursive: true });
+      await linkOrCopy(path2.join(facts, n), path2.join(snapFacts, n)).catch(() => {
+      });
+    })
+  );
+  if (!snap.manifest[`.athena/${SCAN_FILE}`]) {
+    await fs2.rm(path2.join(snapAthena, SCAN_FILE), { force: true });
+    await linkOrCopy(path2.join(dir, SCAN_FILE), path2.join(snapAthena, SCAN_FILE)).catch(() => {
+    });
+  }
+  const exclude = await readTextIfExists(path2.join(root, ".git", "info", "exclude")).catch(() => null);
+  if (exclude) {
+    await fs2.mkdir(path2.join(snapRoot, ".git", "info"), { recursive: true });
+    await fs2.writeFile(path2.join(snapRoot, ".git", "info", "exclude"), exclude);
+  }
+}
+async function untrackedEnvFiles(root, snap) {
+  const out = [];
+  for (const name of REAL_ENV_NAMES) {
+    if (!snap.manifest[name] && await fs2.stat(path2.join(root, name)).then((s) => s.isFile(), () => false)) out.push(name);
+  }
+  return out;
+}
+async function removeStale(parent) {
+  const names = await fs2.readdir(parent).catch(() => []);
+  await Promise.all(
+    names.filter((n) => n.startsWith("tmp-")).map(async (n) => {
+      const st = await fs2.stat(path2.join(parent, n)).catch(() => null);
+      if (st && Date.now() - st.mtimeMs > STALE_MS) await fs2.rm(path2.join(parent, n), { recursive: true, force: true }).catch(() => {
+      });
+    })
+  );
+}
+async function checkStaged(rootInput, opts = {}) {
+  const started = Date.now();
+  const { signal } = opts;
+  const root = await fs2.realpath(rootInput);
+  const dir = athenaDir(root);
+  const st = await readState(dir);
+  if (st.kind === "missing" && !await readTextIfExists(path2.join(dir, "rules.md"))) {
+    throw new AthenaError("Athena is not initialized in this project.", "Run `athena init` first.", EXIT.NOT_INITIALIZED);
+  }
+  if (!await isGitRepo(root, { signal })) throw new AthenaError("`--staged` needs a Git repository.", "Use `athena sync --check` outside Git.", EXIT.NOT_AVAILABLE);
+  const parent = path2.join(cacheRoot(dir), "..", STAGED_DIR);
+  await fs2.mkdir(parent, { recursive: true });
+  const ignoreFile = path2.join(parent, ".gitignore");
+  if (await readTextIfExists(ignoreFile) !== "*\n") await fs2.writeFile(ignoreFile, "*\n");
+  await removeStale(parent);
+  const manifestFile = path2.join(parent, "manifest.json");
+  const unlock = await lock(path2.join(parent, "lock"));
+  const base = unlock ? path2.join(parent, "tree") : path2.join(parent, `tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`);
+  const snapRoot = path2.join(base, path2.basename(root));
+  try {
+    const history = gitInfo(root, { signal });
+    history.catch(() => {
+    });
+    const { config } = await loadConfig(root);
+    let previous = unlock ? await readManifest(manifestFile, root) : null;
+    if (!previous) await fs2.rm(base, { recursive: true, force: true });
+    await fs2.rm(manifestFile, { force: true });
+    await fs2.mkdir(snapRoot, { recursive: true });
+    let snap;
+    try {
+      snap = await updateIndexSnapshot(root, snapRoot, { maxFileBytes: config.maxFileBytes, previous, signal });
+      const staged = await loadConfig(snapRoot);
+      if (staged.config.maxFileBytes !== config.maxFileBytes) {
+        previous = snap.manifest;
+        snap = await updateIndexSnapshot(root, snapRoot, { maxFileBytes: staged.config.maxFileBytes, previous, signal });
+      }
+    } catch (err) {
+      if (err instanceof IndexSnapshotError) throw new AthenaError(`Cannot read the staged files: ${err.message}.`, "Resolve it (for example, finish the merge), or check the working tree with `athena sync --check`.", EXIT.NOT_AVAILABLE);
+      throw err;
+    }
+    if (unlock) await writeFileAtomic(manifestFile, JSON.stringify({ v: MANIFEST_VERSION, root, entries: snap.manifest }));
+    if (!Object.keys(snap.manifest).some((p) => p.startsWith(".athena/"))) {
+      throw new AthenaError("No Athena knowledge is staged or committed (.athena/ is not in the index).", "Commit .athena/ to check knowledge before commits.", EXIT.NOT_INITIALIZED);
+    }
+    await addLocalInputs(root, snapRoot, snap);
+    const prevIndex = await readFileIndex(dir);
+    const reuse = {};
+    for (const p of snap.placeholders) if (prevIndex[p]) reuse[p] = prevIndex[p];
+    const salt = (await readLocalConfig(root)).salt;
+    const reader = snapshotReader(await fs2.realpath(snapRoot), root, snap.placeholders);
+    const analyze = async () => {
+      const analysis = await analyzeProject(snapRoot, { signal, reuse, fingerprintSalt: salt, readFile: reader });
+      return { ...analysis.model, root, git: redactDeep(await history) };
+    };
+    const prevState = st.kind === "ok" ? st.state : null;
+    const previousBlocks = prevState ? Object.fromEntries(Object.entries(prevState.documents).map(([k, v]) => [k, v.blocks])) : void 0;
+    const staleDocs = async (model2) => {
+      const out = [];
+      for (const p of await planKnowledge(athenaDir(snapRoot), model2, { previousBlocks })) {
+        if (p.status === "unchanged") continue;
+        if (p.status === "updated" && p.changedBlocks.length && p.changedBlocks.every((b) => HISTORY_SECTIONS.has(b))) continue;
+        const worktree = await readTextIfExists(path2.join(dir, p.file));
+        out.push({ file: p.file, status: p.status === "created" ? "missing" : "outdated", changedSections: p.changedBlocks, syncedButUnstaged: worktree === p.after });
+      }
+      return out;
+    };
+    const model = await analyze();
+    let stale = await staleDocs(model);
+    const localEnv = await untrackedEnvFiles(root, snap);
+    if (stale.length && localEnv.length) {
+      const withEnv = (names) => ({ ...model, env: { ...model.env, envFilesPresent: [.../* @__PURE__ */ new Set([...model.env.envFilesPresent, ...names])].sort() } });
+      const all = (1 << localEnv.length) - 1;
+      const masks = localEnv.length <= 3 ? Array.from({ length: all }, (_, i) => i + 1).reverse() : [all];
+      for (const mask of masks) {
+        if (!(await staleDocs(withEnv(localEnv.filter((_, i) => mask & 1 << i)))).length) {
+          stale = [];
+          break;
+        }
+      }
+      if (stale.length) {
+        await Promise.all(localEnv.map((n) => linkOrCopy(path2.join(root, n), path2.join(snapRoot, n))));
+        try {
+          stale = await staleDocs(await analyze());
+        } finally {
+          await Promise.all(localEnv.map((n) => fs2.rm(path2.join(snapRoot, n), { force: true })));
+        }
+      }
+    }
+    return { inSync: stale.length === 0, stale, files: snap.entries, fromIndex: snap.fromIndex, durationMs: Date.now() - started };
+  } finally {
+    if (unlock) await unlock();
+    else await fs2.rm(base, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+export {
+  checkStaged
+};
+//# sourceMappingURL=staged-check-X24C3YRD.js.map

package/dist/status-RR57ZNGI.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import {
+  buildStatus
+} from "./chunk-ZB7LC6FP.js";
+import {
+  bullet,
+  c,
+  dim,
+  fail,
+  heading,
+  isJson,
+  json,
+  line,
+  ok,
+  relativeTime
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-GR4DL2VM.js";
+import "./chunk-ELKFRTZT.js";
+import "./chunk-OLPSEQS5.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/status.ts
+async function statusCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const report = await buildStatus(root, opts.signal);
+  const memory = await (await import("./memory-VSVNLEJC.js")).memorySummary(root);
+  if (isJson()) {
+    json(memory ? { ...report, memory: { total: memory.total, unreviewed: memory.unreviewed, stale: memory.stale } } : report);
+    return;
+  }
+  const healthLabel = report.health === "healthy" ? c.green("Healthy") : report.health === "needs-update" ? c.yellow("Needs update") : c.red("Degraded (missing knowledge files)");
+  heading("Athena Status");
+  line();
+  line(`Project:  ${c.bold(report.project)}`);
+  line(`Athena:   ${healthLabel}`);
+  line(`Analyzed: ${relativeTime(report.analyzedAt)}${report.git.branch ? dim(` \xB7 branch ${report.git.branch}`) : ""}`);
+  line();
+  heading("Knowledge");
+  for (const d of report.documents) {
+    if (!d.present) fail(`${d.title} ${dim(`\u2014 ${d.file} missing`)}`);
+    else if (d.editedBlocks.length) ok(`${d.title} ${dim(`\u2014 developer-edited sections: ${d.editedBlocks.join(", ")}`)}`);
+    else ok(d.title);
+  }
+  line();
+  const total = report.changes.added.length + report.changes.modified.length + report.changes.deleted.length;
+  heading("Changes since last analysis");
+  if (!total) line(dim("No file changes detected."));
+  else {
+    line(`${total} file${total === 1 ? "" : "s"} changed ${dim(`(${report.changes.modified.length} modified, ${report.changes.added.length} added, ${report.changes.deleted.length} deleted)`)}`);
+    const sample = [...report.changes.modified, ...report.changes.added, ...report.changes.deleted].slice(0, 8);
+    for (const p of sample) line(`  ${dim(p)}`);
+    if (total > sample.length) line(dim(`  +${total - sample.length} more`));
+  }
+  if (report.git.uncommitted !== null) line(dim(`Git: ${report.git.uncommitted} uncommitted change(s) in the working tree`));
+  if (report.affectedDocuments.length) {
+    line();
+    heading("Potentially affected");
+    for (const a of report.affectedDocuments) bullet(`${a.file} ${dim(`(${a.reasons.join(", ")})`)}`);
+  }
+  if (memory?.total) {
+    line();
+    const notes = [memory.unreviewed ? c.yellow(`${memory.unreviewed} unreviewed`) : "", memory.stale ? c.yellow(`${memory.stale} stale`) : ""].filter(Boolean);
+    line(`Memory:   ${memory.total} ${memory.total === 1 ? "entry" : "entries"}${notes.length ? ` \xB7 ${notes.join(" \xB7 ")} ${dim("\u2014 run `athena memory review` / `athena memory stale`")}` : ""}`);
+  }
+  line();
+  line(`Synchronization: ${report.sync === "up-to-date" ? c.green("Up to date") : `${c.yellow("Needs update")} ${dim("\u2014 run `athena sync` to review")}`}`);
+}
+export {
+  statusCommand
+};
+//# sourceMappingURL=status-RR57ZNGI.js.map