project-athena 0.2.1 → 0.4.0

package/dist/chunk-Z6QWMJLK.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+// src/cli/ui/term.ts
+import pc from "picocolors";
+var out = process.stdout;
+var isTTY = Boolean(out.isTTY) && process.env.TERM !== "dumb" && !process.env.CI;
+var unicode = process.platform !== "win32" || Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === "vscode" || Boolean(process.env.TERMINAL_EMULATOR);
+var sym = {
+  ok: unicode ? "\u2713" : "\u221A",
+  warn: unicode ? "\u26A0" : "!",
+  err: unicode ? "\u2717" : "\xD7",
+  info: unicode ? "\u2022" : "*",
+  dot: unicode ? "\u25CF" : "*",
+  ring: unicode ? "\u25CB" : "o",
+  arrow: unicode ? "\u2192" : "->"
+};
+var c = pc;
+var quiet = false;
+var jsonMode = false;
+function setOutputMode(opts) {
+  quiet = Boolean(opts.quiet);
+  jsonMode = Boolean(opts.json);
+}
+var isJson = () => jsonMode;
+var isQuiet = () => quiet;
+var interruptMessage = "No partial knowledge was written.";
+var setInterruptMessage = (m) => interruptMessage = m;
+var getInterruptMessage = () => interruptMessage;
+function line(s = "") {
+  if (jsonMode) return;
+  out.write(`${s}
+`);
+}
+function info(s) {
+  if (!quiet) line(s);
+}
+var ok = (s) => line(`${c.green(sym.ok)} ${s}`);
+var warn = (s) => line(`${c.yellow(sym.warn)} ${s}`);
+var fail = (s) => line(`${c.red(sym.err)} ${s}`);
+var bullet = (s) => line(`${c.dim(sym.info)} ${s}`);
+var heading = (s) => line(c.bold(s));
+var dim = (s) => c.dim(s);
+function json(value) {
+  out.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+var FRAMES = unicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["-", "\\", "|", "/"];
+function spinner(text) {
+  let current = text;
+  let timer = null;
+  let frame = 0;
+  const clear = () => {
+    if (isTTY) out.write("\r\x1B[2K");
+  };
+  const done = (symbol, msg, suppressible = false) => {
+    const wasSpinning = timer !== null;
+    if (timer) clearInterval(timer);
+    timer = null;
+    if (jsonMode) return;
+    if (wasSpinning) {
+      clear();
+      out.write("\x1B[?25h");
+    }
+    if (!(suppressible && quiet)) line(`${symbol} ${msg ?? current}`);
+  };
+  if (!jsonMode && !quiet && isTTY) {
+    out.write("\x1B[?25l");
+    timer = setInterval(() => {
+      clear();
+      out.write(`${c.cyan(FRAMES[frame = (frame + 1) % FRAMES.length])} ${current}`);
+    }, 80);
+    timer.unref();
+  }
+  return {
+    update(t) {
+      current = t;
+    },
+    succeed: (msg) => done(c.green(sym.ok), msg, true),
+    warn: (msg) => done(c.yellow(sym.warn), msg),
+    fail: (msg) => done(c.red(sym.err), msg),
+    stop() {
+      if (!timer) return;
+      clearInterval(timer);
+      timer = null;
+      clear();
+      out.write("\x1B[?25h");
+    }
+  };
+}
+function relativeTime(iso) {
+  const ms = Date.now() - Date.parse(iso);
+  if (Number.isNaN(ms)) return "unknown";
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${s}s ago`;
+  const m = Math.round(s / 60);
+  if (m < 60) return `${m} min ago`;
+  const h = Math.round(m / 60);
+  if (h < 48) return `${h} h ago`;
+  return `${Math.round(h / 24)} days ago`;
+}
+
+export {
+  isTTY,
+  unicode,
+  sym,
+  c,
+  setOutputMode,
+  isJson,
+  isQuiet,
+  setInterruptMessage,
+  getInterruptMessage,
+  line,
+  info,
+  ok,
+  warn,
+  fail,
+  bullet,
+  heading,
+  dim,
+  json,
+  spinner,
+  relativeTime
+};
+//# sourceMappingURL=chunk-Z6QWMJLK.js.map

package/dist/chunk-ZB7LC6FP.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+import {
+  impactOf
+} from "./chunk-GR4DL2VM.js";
+import {
+  IgnoreMatcher,
+  factsConfigHash,
+  mapLimit,
+  statEntry,
+  walkProject
+} from "./chunk-ELKFRTZT.js";
+import {
+  git,
+  statusV2,
+  workingChanges
+} from "./chunk-OLPSEQS5.js";
+import {
+  isBlockModified,
+  parseBlocks
+} from "./chunk-673EPYYH.js";
+import {
+  KNOWLEDGE_DOCS
+} from "./chunk-FQEGEVLY.js";
+import {
+  CACHE_DIR,
+  RACY_WINDOW_MS,
+  athenaDir,
+  buildFileIndex,
+  diffFileIndex,
+  fileIndexPath,
+  loadConfig,
+  readFileIndex,
+  readState,
+  sameHash
+} from "./chunk-2DY4PUR4.js";
+import {
+  readTextIfExists
+} from "./chunk-IQQBAWSM.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+import {
+  ATHENA_DIR
+} from "./chunk-EUPETUWA.js";
+
+// src/services/status.ts
+import path2 from "path";
+
+// src/services/status-fast.ts
+import { promises as fs, readFileSync, statSync } from "fs";
+import path from "path";
+async function sameFactsConfig(root, config) {
+  try {
+    const v = JSON.parse(await fs.readFile(path.join(root, ATHENA_DIR, CACHE_DIR, "facts", "version.json"), "utf8"));
+    return v.config === factsConfigHash(config);
+  } catch {
+    return false;
+  }
+}
+var byPath = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var mtimeOf = (p) => statSync(p, { throwIfNoEntry: false })?.mtimeMs ?? null;
+async function fastIndexChanges(root, config, prevIndex, signal) {
+  const indexPaths = Object.keys(prevIndex);
+  if (!indexPaths.length || config.include.length) return null;
+  if (!statSync(path.join(root, ".git"), { throwIfNoEntry: false })?.isDirectory()) return null;
+  const indexMtime = mtimeOf(fileIndexPath(path.join(root, ATHENA_DIR)));
+  if (indexMtime === null) return null;
+  const excludeFile = path.join(root, ".git", "info", "exclude");
+  const excludeMtime = mtimeOf(excludeFile);
+  if (excludeMtime !== null && excludeMtime > indexMtime) return null;
+  const configMtime = mtimeOf(path.join(root, ATHENA_DIR, "config.json"));
+  if (configMtime !== null && configMtime > indexMtime - RACY_WINDOW_MS) {
+    if (configMtime > indexMtime || !await sameFactsConfig(root, config)) return null;
+  }
+  const hasExclude = excludeMtime !== null;
+  const gitCalls = Promise.all([
+    statusV2(root, { signal }),
+    git(root, ["ls-files", "-z", "-s", "--", "."], { signal }),
+    git(root, ["ls-files", "-z", "-o", "--exclude-per-directory=.gitignore", ...hasExclude ? ["--exclude-from=.git/info/exclude"] : [], "--", "."], { signal })
+  ]);
+  const diff = { added: [], modified: [], deleted: [] };
+  const recheck = [];
+  for (const rel of indexPaths) {
+    const prev = prevIndex[rel];
+    const st = statSync(path.join(root, rel), { throwIfNoEntry: false });
+    if (!st?.isFile()) {
+      diff.deleted.push(rel);
+      continue;
+    }
+    const large = st.size > config.maxFileBytes;
+    if (prev.s === st.size && prev.m === Math.floor(st.mtimeMs) && prev.h.startsWith("meta:") === large) continue;
+    recheck.push(rel);
+  }
+  signal?.throwIfAborted();
+  const rechecked = await mapLimit(recheck, 32, (rel) => statEntry(root, rel, config.maxFileBytes));
+  rechecked.forEach((e, i) => {
+    const rel = recheck[i];
+    if (!e) diff.deleted.push(rel);
+    else if (!sameHash(prevIndex[rel].h, e.hash)) diff.modified.push(rel);
+  });
+  const [status, tracked, untracked] = await gitCalls;
+  signal?.throwIfAborted();
+  if (!status || !tracked.ok || !untracked.ok) return null;
+  if (status.some((e) => e.submodule)) return null;
+  const uncommitted = status.filter((e) => e.kind !== "!" && !e.path.startsWith(`${ATHENA_DIR}/`)).length;
+  const candidates = /* @__PURE__ */ new Set();
+  for (const rec of tracked.stdout.split("\0")) {
+    if (!rec) continue;
+    const tab = rec.indexOf("	");
+    const mode = rec.slice(0, rec.indexOf(" "));
+    const rel = rec.slice(tab + 1);
+    if (mode === "160000") return null;
+    if (mode === "120000" && statSync(path.join(root, rel), { throwIfNoEntry: false })?.isDirectory()) return null;
+    if (!Object.hasOwn(prevIndex, rel)) candidates.add(rel);
+  }
+  for (const rel of untracked.stdout.split("\0")) {
+    if (!rel) continue;
+    if (rel.endsWith("/")) return null;
+    if (!Object.hasOwn(prevIndex, rel)) candidates.add(rel);
+  }
+  const matcher = await IgnoreMatcher.load(root, config);
+  const loaded = /* @__PURE__ */ new Set();
+  const ignored = (rel) => {
+    for (let i = rel.indexOf("/"); i > 0; i = rel.indexOf("/", i + 1)) {
+      const dir = rel.slice(0, i);
+      if (matcher.ignores(dir, true)) return true;
+      if (!loaded.has(dir)) {
+        loaded.add(dir);
+        try {
+          matcher.setGitignore(dir, readFileSync(path.join(root, dir, ".gitignore"), "utf8"));
+        } catch {
+        }
+      }
+    }
+    return matcher.ignores(rel, false);
+  };
+  const toAdd = [];
+  for (const rel of candidates) {
+    if (ignored(rel)) continue;
+    let st;
+    try {
+      st = await fs.lstat(path.join(root, rel));
+    } catch {
+      continue;
+    }
+    if (st.isSymbolicLink()) {
+      const target = await fs.realpath(path.join(root, rel)).catch(() => null);
+      if (!target) continue;
+      const relTarget = path.relative(await fs.realpath(root), target);
+      if (relTarget.startsWith("..") || path.isAbsolute(relTarget)) continue;
+      const tst = await fs.stat(target).catch(() => null);
+      if (tst?.isDirectory()) return null;
+      if (!tst?.isFile()) continue;
+    } else if (!st.isFile()) continue;
+    toAdd.push(rel);
+  }
+  const added = await mapLimit(toAdd, 32, (rel) => statEntry(root, rel, config.maxFileBytes));
+  added.forEach((e, i) => {
+    if (e) diff.added.push(toAdd[i]);
+  });
+  if ([...diff.added, ...diff.modified, ...diff.deleted].some((p) => p === ".gitignore" || p.endsWith("/.gitignore"))) return null;
+  if (indexPaths.length - diff.deleted.length + diff.added.length > config.maxFiles) return null;
+  diff.added.sort(byPath);
+  diff.modified.sort(byPath);
+  const deleted = new Set(diff.deleted);
+  diff.deleted = indexPaths.filter((p) => deleted.has(p));
+  return { diff, uncommitted };
+}
+
+// src/services/status.ts
+async function buildStatus(root, signal, opts = {}) {
+  const dir = athenaDir(root);
+  const st = await readState(dir);
+  if (st.kind === "missing") throw new AthenaError(".athena/state.json is missing.", "Run `athena analyze` to rebuild it.");
+  if (st.kind === "corrupted") throw new AthenaError(`.athena/state.json is corrupted (${st.reason}).`, "Run `athena analyze` \u2014 the corrupted file will be backed up and rebuilt.");
+  const state = st.state;
+  const documents = [];
+  for (const d of KNOWLEDGE_DOCS) {
+    const text = await readTextIfExists(path2.join(dir, d.file));
+    documents.push({
+      file: d.file,
+      title: d.title,
+      present: text !== null,
+      editedBlocks: text ? parseBlocks(text).filter(isBlockModified).map((b) => b.id) : [],
+      lastChangedAt: state.documents[d.id]?.lastChangedAt
+    });
+  }
+  const { config } = await loadConfig(root);
+  const prevIndex = await readFileIndex(dir);
+  const fast = state.git.isRepo && !opts.noFastPath ? await fastIndexChanges(root, config, prevIndex, signal) : null;
+  const raw = fast ? fast.diff : diffFileIndex(prevIndex, buildFileIndex((await walkProject(root, { config, signal, reuse: prevIndex })).files));
+  const managed = new Set(Object.values(state.agents).flatMap((a) => a.files));
+  const keep = (p) => !managed.has(p);
+  const changes = { added: raw.added.filter(keep), modified: raw.modified.filter(keep), deleted: raw.deleted.filter(keep) };
+  const git2 = { isRepo: state.git.isRepo, branch: state.git.branch, headChanged: false, uncommitted: null };
+  if (fast) git2.uncommitted = fast.uncommitted;
+  else if (state.git.isRepo) {
+    const wc = await workingChanges(root);
+    git2.uncommitted = wc ? wc.filter((f) => !f.path.startsWith(".athena/")).length : null;
+  }
+  const impact = impactOf([...changes.added, ...changes.modified, ...changes.deleted], { structural: [...changes.added, ...changes.deleted] });
+  const affectedDocuments = impact.docs.map((id) => ({ file: KNOWLEDGE_DOCS.find((d) => d.id === id).file, reasons: impact.reasons[id] ?? [] }));
+  const totalChanges = changes.added.length + changes.modified.length + changes.deleted.length;
+  const missing = documents.some((d) => !d.present);
+  return {
+    project: state.projectName,
+    root,
+    health: missing ? "degraded" : totalChanges ? "needs-update" : "healthy",
+    analyzedAt: state.analyzedAt,
+    documents,
+    changes,
+    git: git2,
+    affectedDocuments,
+    sync: totalChanges ? "needs-update" : "up-to-date"
+  };
+}
+
+export {
+  buildStatus
+};
+//# sourceMappingURL=chunk-ZB7LC6FP.js.map

package/dist/clean-MDBYH62P.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  cleanCommand,
+  confirm
+} from "./chunk-7DZK6WSQ.js";
+import "./chunk-Z6QWMJLK.js";
+import "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-YRIS7ZS6.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-INT3IGMQ.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";
+export {
+  cleanCommand,
+  confirm
+};
+//# sourceMappingURL=clean-MDBYH62P.js.map