project-athena 0.3.0 → 0.5.0

package/dist/chunk-GU3ZX2J7.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import {
+  SCAN_FILE,
+  SecurityScan
+} from "./chunk-44EGCEB2.js";
+import {
+  GRAPH_FILE,
+  ProjectGraph
+} from "./chunk-SVTEJYMS.js";
+import {
+  ProjectModel
+} from "./chunk-QCC4VJUH.js";
+import {
+  athenaDir,
+  readState
+} from "./chunk-2DY4PUR4.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+
+// src/services/project-session.ts
+import { promises as fs } from "fs";
+import path from "path";
+var fileKey = (st) => `${st.ino}:${st.size}:${st.mtimeNs}`;
+var ProjectSession = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  cache = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  stateEntry = null;
+  get dir() {
+    return athenaDir(this.root);
+  }
+  /** model.json, or why it can't be used. */
+  readModel() {
+    return this.read("model.json", ProjectModel);
+  }
+  /** The parsed model, or null when missing or unusable. */
+  async model() {
+    const r = await this.readModel();
+    return r.kind === "ok" ? r.value : null;
+  }
+  /** The parsed model; throws an AthenaError with a hint when it is missing or corrupted. */
+  async requireModel() {
+    const r = await this.readModel();
+    if (r.kind === "ok") return r.value;
+    if (r.kind === "missing") throw new AthenaError("model.json is missing.", "Run `athena analyze` (or re-analyze from the overview) first.");
+    throw new AthenaError(`model.json is corrupted (${r.reason}).`, "Run `athena analyze` to rebuild it.");
+  }
+  /** Cheap existence check (a stat, no parsing). */
+  async hasModel() {
+    return this.exists("model.json");
+  }
+  readGraph() {
+    return this.read(GRAPH_FILE, ProjectGraph);
+  }
+  async graph() {
+    const r = await this.readGraph();
+    return r.kind === "ok" ? r.value : null;
+  }
+  readScan() {
+    return this.read(SCAN_FILE, SecurityScan);
+  }
+  async scan() {
+    const r = await this.readScan();
+    return r.kind === "ok" ? r.value : null;
+  }
+  /** state.json via `readState`, memoized like the other artifacts. */
+  async state() {
+    const file = path.join(this.dir, "state.json");
+    const st = await fs.stat(file, { bigint: true }).catch(() => null);
+    if (!st) return readState(this.dir);
+    const key = fileKey(st);
+    if (this.stateEntry?.key === key) return this.stateEntry.state;
+    const state = await readState(this.dir);
+    const after = await fs.stat(file, { bigint: true }).catch(() => null);
+    if (after && fileKey(after) === key) this.stateEntry = { key, state };
+    return state;
+  }
+  /**
+   * Record a value this process just wrote to `.athena/<name>`, so the next
+   * read doesn't parse it again. The file must already be on disk.
+   */
+  async remember(name, value) {
+    const st = await fs.stat(path.join(this.dir, name), { bigint: true }).catch(() => null);
+    if (st) this.cache.set(name, { key: fileKey(st), result: { kind: "ok", value } });
+    else this.cache.delete(name);
+  }
+  /** Drop memoized results (all, or one file). */
+  invalidate(name) {
+    if (!name || name === "state.json") this.stateEntry = null;
+    if (name) this.cache.delete(name);
+    else this.cache.clear();
+  }
+  async exists(name) {
+    const st = await fs.stat(path.join(this.dir, name)).catch(() => null);
+    return Boolean(st?.isFile());
+  }
+  read(name, schema) {
+    const running = this.inflight.get(name);
+    if (running) return running;
+    const p = this.load(name, schema).finally(() => this.inflight.delete(name));
+    this.inflight.set(name, p);
+    return p;
+  }
+  async load(name, schema) {
+    const file = path.join(this.dir, name);
+    let st;
+    try {
+      st = await fs.stat(file, { bigint: true });
+    } catch (err) {
+      const code = err.code;
+      this.cache.delete(name);
+      if (code === "ENOENT" || code === "ENOTDIR") return { kind: "missing" };
+      return { kind: "corrupted", reason: `unreadable (${code})` };
+    }
+    const key = fileKey(st);
+    const hit = this.cache.get(name);
+    if (hit?.key === key) return hit.result;
+    let raw;
+    try {
+      raw = await fs.readFile(file, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return { kind: "missing" };
+      return { kind: "corrupted", reason: `unreadable (${code})` };
+    }
+    const result = parseArtifact(raw, schema);
+    const after = await fs.stat(file, { bigint: true }).catch(() => null);
+    if (after && fileKey(after) === key) this.cache.set(name, { key, result });
+    return result;
+  }
+};
+function parseArtifact(raw, schema) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return { kind: "corrupted", reason: "invalid JSON" };
+  }
+  const parsed = schema.safeParse(json);
+  if (parsed.success) return { kind: "ok", value: parsed.data };
+  const issue = parsed.error.issues[0];
+  return { kind: "corrupted", reason: `schema mismatch at ${issue?.path.map(String).join(".") || "(root)"}: ${issue?.message}` };
+}
+var sessions = /* @__PURE__ */ new Map();
+function projectSession(root) {
+  const key = path.resolve(root);
+  let s = sessions.get(key);
+  if (!s) {
+    s = new ProjectSession(key);
+    sessions.set(key, s);
+  }
+  return s;
+}
+function releaseProjectSession(root) {
+  sessions.delete(path.resolve(root));
+}
+
+export {
+  projectSession,
+  releaseProjectSession
+};
+//# sourceMappingURL=chunk-GU3ZX2J7.js.map

package/dist/chunk-GYQG4Q2N.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import {
+  CONTEXT_MEMORY_LIMIT,
+  documentSections,
+  listMemory,
+  recall,
+  selectContext
+} from "./chunk-F65QINMR.js";
+import {
+  projectSession
+} from "./chunk-GU3ZX2J7.js";
+import {
+  analyzeProject
+} from "./chunk-44EGCEB2.js";
+import {
+  GRAPH_FILE,
+  buildGraph,
+  saveGraph
+} from "./chunk-SVTEJYMS.js";
+import {
+  KNOWLEDGE_DOCS
+} from "./chunk-FQEGEVLY.js";
+import {
+  athenaDir
+} from "./chunk-2DY4PUR4.js";
+import {
+  readTextIfExists
+} from "./chunk-IQQBAWSM.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+
+// src/services/context.ts
+import path from "path";
+async function refreshGraph(root, opts = {}) {
+  const session = projectSession(root);
+  const st = await session.state();
+  const analysis = await analyzeProject(root, { signal: opts.signal });
+  const files = analysis.files.map((f) => f.path);
+  const graph = await buildGraph(analysis.model, {
+    files,
+    signal: opts.signal,
+    read: async (rel) => readTextIfExists(path.join(root, rel)).catch(() => null)
+  });
+  await saveGraph(root, graph);
+  await session.remember(GRAPH_FILE, graph);
+  return graph;
+}
+async function getGraph(root, opts = {}) {
+  const existing = await projectSession(root).graph();
+  if (existing) return existing;
+  return opts.build ? refreshGraph(root, { signal: opts.signal }) : null;
+}
+async function getRelevantContext(root, task, opts = {}) {
+  if (!task.trim()) throw new AthenaError("Describe the task to get relevant context.", 'For example: athena context "add refunds to the payments API"');
+  const dir = athenaDir(root);
+  const documents = [];
+  for (const d of KNOWLEDGE_DOCS) {
+    if (d.id === "rules") continue;
+    const text = await readTextIfExists(path.join(dir, d.file));
+    if (text) documents.push({ id: d.id, file: d.file, sections: documentSections(text) });
+  }
+  if (!documents.length) throw new AthenaError("No knowledge documents found.", "Run `athena init` first.", 3);
+  return selectContext({
+    task,
+    documents,
+    rulesMarkdown: await readTextIfExists(path.join(dir, "rules.md")),
+    graph: await getGraph(root, { build: opts.buildGraph, signal: opts.signal }),
+    maxChars: opts.maxChars,
+    memories: await memoriesFor(root, task)
+  });
+}
+async function memoriesFor(root, task, files = []) {
+  let hits;
+  try {
+    hits = recall(await listMemory(root), { task, files, limit: CONTEXT_MEMORY_LIMIT * 2 });
+  } catch {
+    return [];
+  }
+  const rank = (s) => s === "confirmed" ? 0 : 1;
+  return hits.map((h, i) => ({ h, i })).sort((a, b) => rank(a.h.entry.status) - rank(b.h.entry.status) || a.i - b.i).slice(0, CONTEXT_MEMORY_LIMIT).map(({ h: { entry: e, why } }) => ({
+    id: e.id,
+    kind: e.kind,
+    status: e.status === "confirmed" ? "confirmed" : "unreviewed",
+    label: e.label,
+    stale: e.stale,
+    changedFiles: e.changedFiles,
+    source: e.source,
+    title: e.title,
+    details: e.details,
+    files: e.files,
+    evidence: e.evidence,
+    why
+  }));
+}
+async function graphSummary(root) {
+  const session = projectSession(root);
+  const [graph, hasModel] = await Promise.all([session.graph(), session.hasModel()]);
+  return { built: Boolean(graph), builtAt: graph?.builtAt ?? null, stats: graph?.stats ?? null, model: { hasModel } };
+}
+
+export {
+  refreshGraph,
+  getGraph,
+  getRelevantContext,
+  graphSummary
+};
+//# sourceMappingURL=chunk-GYQG4Q2N.js.map