project-athena 0.2.1 → 0.3.0

package/dist/chunk-PDFQ5BFG.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+import {
+  ProjectModel,
+  SCAN_FILE,
+  SecurityScan
+} from "./chunk-PANVPNYF.js";
+import {
+  athenaDir,
+  readState
+} from "./chunk-2DY4PUR4.js";
+import {
+  readTextIfExists,
+  writeFileAtomic
+} from "./chunk-IQQBAWSM.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+import {
+  toPosix
+} from "./chunk-XW3MLHI2.js";
+
+// src/core/graph/graph.ts
+import { z } from "zod";
+import path from "path";
+var NodeKind = z.enum(["package", "file", "route", "entity", "framework", "command", "infra", "doc"]);
+var EdgeKind = z.enum(["contains", "imports", "handles", "defines", "depends_on", "documents", "runs"]);
+var GraphNode = z.object({
+  id: z.string(),
+  kind: NodeKind,
+  name: z.string(),
+  path: z.string().optional(),
+  meta: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).default({})
+});
+var GraphEdge = z.object({ from: z.string(), to: z.string(), kind: EdgeKind });
+var ProjectGraph = z.object({
+  schemaVersion: z.literal(1),
+  builtAt: z.string(),
+  nodes: z.array(GraphNode),
+  edges: z.array(GraphEdge),
+  stats: z.object({ nodes: z.number(), edges: z.number(), byKind: z.record(z.string(), z.number()) })
+});
+var GRAPH_FILE = "graph.json";
+var nodeId = (kind, key) => `${kind}:${key}`;
+var IMPORT_RE = /^\s*(?:import\s[^'"]*from\s*['"]([^'"]+)['"]|import\s*['"]([^'"]+)['"]|export\s[^'"]*from\s*['"]([^'"]+)['"]|(?:const|let|var)\s[^=]*=\s*require\(\s*['"]([^'"]+)['"]\s*\))/gm;
+var PY_IMPORT_RE = /^\s*(?:from\s+([.\w]+)\s+import|import\s+([.\w]+))/gm;
+var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".py", ".vue", ".svelte"];
+function resolveImport(fromFile, spec, fileSet) {
+  if (!spec.startsWith(".")) return null;
+  const base = toPosix(path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), spec)));
+  if (fileSet.has(base)) return base;
+  for (const ext of RESOLVE_EXTS) {
+    for (const c of [`${base}${ext}`, `${base}/index${ext}`, `${base}/__init__${ext}`]) if (fileSet.has(c)) return c;
+  }
+  return null;
+}
+var compare = new Intl.Collator().compare;
+async function buildGraph(model, opts) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const fileSet = new Set(opts.files);
+  const addNode = (n) => {
+    if (!nodes.has(n.id)) nodes.set(n.id, n);
+    return n.id;
+  };
+  const addEdge = (from, to, kind) => {
+    if (from === to || !nodes.has(from) || !nodes.has(to)) return;
+    const key = `${from}\0${to}\0${kind}`;
+    if (edgeKeys.has(key)) return;
+    edgeKeys.add(key);
+    edges.push({ from, to, kind });
+  };
+  const fileNode = (p) => addNode({ id: nodeId("file", p), kind: "file", name: path.posix.basename(p), path: p, meta: {} });
+  for (const pkg of model.workspace.packages) {
+    addNode({ id: nodeId("package", pkg.name), kind: "package", name: pkg.name, path: pkg.path, meta: { kind: pkg.kind, ecosystem: pkg.ecosystem } });
+  }
+  for (const pkg of model.workspace.packages) {
+    for (const dep of pkg.internalDependencies) addEdge(nodeId("package", pkg.name), nodeId("package", dep), "depends_on");
+  }
+  const packageAtPath = /* @__PURE__ */ new Map();
+  for (const pkg of model.workspace.packages) if (!packageAtPath.has(pkg.path)) packageAtPath.set(pkg.path, pkg);
+  for (const f of model.frameworks) {
+    const id = addNode({ id: nodeId("framework", `${f.name}@${f.root}`), kind: "framework", name: f.name, path: f.root, meta: { category: f.category, status: f.provenance.status, confidence: f.provenance.confidence } });
+    const owner = packageAtPath.get(f.root);
+    if (owner) addEdge(nodeId("package", owner.name), id, "contains");
+  }
+  for (const r of model.routes) {
+    const id = addNode({ id: nodeId("route", `${r.method} ${r.path} ${r.file}`), kind: "route", name: `${r.method} ${r.path}`, path: r.file, meta: { method: r.method, framework: r.framework, ...r.line ? { line: r.line } : {} } });
+    addEdge(id, fileNode(r.file), "handles");
+  }
+  const entityByName = /* @__PURE__ */ new Map();
+  for (const x of model.dbEntities) {
+    const k = x.name.toLowerCase();
+    if (!entityByName.has(k)) entityByName.set(k, x);
+  }
+  for (const e of model.dbEntities) {
+    const id = addNode({ id: nodeId("entity", `${e.name}@${e.file}`), kind: "entity", name: e.name, path: e.file, meta: { kind: e.kind, fields: e.fields.length, indexes: e.indexes.length } });
+    addEdge(id, fileNode(e.file), "defines");
+    for (const rel of e.relations) {
+      const target = rel.split("\u2192")[1]?.trim();
+      const other = target ? entityByName.get(target.toLowerCase()) : void 0;
+      if (other) addEdge(id, nodeId("entity", `${other.name}@${other.file}`), "depends_on");
+    }
+  }
+  for (const e of model.entryPoints) fileNode(e.path);
+  for (const c of model.commands) {
+    const id = addNode({ id: nodeId("command", `${c.source}:${c.name}`), kind: "command", name: c.name, path: c.source, meta: { purpose: c.purpose, command: c.command.slice(0, 120) } });
+    addEdge(id, fileNode(c.source), "runs");
+  }
+  for (const i of model.infrastructure) addNode({ id: nodeId("infra", `${i.name}@${i.file}`), kind: "infra", name: i.name, path: i.file, meta: { kind: i.kind } });
+  for (const d of model.containers.dockerfiles) addNode({ id: nodeId("infra", `Dockerfile@${d.path}`), kind: "infra", name: "Dockerfile", path: d.path, meta: { kind: "container" } });
+  for (const s of model.containers.services) addNode({ id: nodeId("infra", `service:${s.name}@${s.file}`), kind: "infra", name: s.name, path: s.file, meta: { kind: "service", image: s.image ?? "" } });
+  for (const n of [...nodes.values()].filter((x) => x.kind === "file" && x.path)) {
+    const p = n.path;
+    let owner;
+    for (let i = p.lastIndexOf("/"); i >= 0 && !owner; i = i > 0 ? p.lastIndexOf("/", i - 1) : -1) {
+      const prefix = p.slice(0, i);
+      if (prefix !== ".") owner = packageAtPath.get(prefix);
+    }
+    if (owner) addEdge(nodeId("package", owner.name), n.id, "contains");
+  }
+  const maxImportFiles = opts.maxImportFiles ?? 2e3;
+  const queue = [...nodes.values()].filter((n) => n.kind === "file").map((n) => n.path);
+  const parsed = /* @__PURE__ */ new Set();
+  let head = 0;
+  while (head < queue.length && parsed.size < maxImportFiles) {
+    opts.signal?.throwIfAborted();
+    const p = queue[head++];
+    if (parsed.has(p)) continue;
+    parsed.add(p);
+    const n = { id: nodeId("file", p) };
+    if (!/\.(m|c)?(t|j)sx?$|\.py$/.test(p)) continue;
+    const text = await opts.read(p);
+    if (!text) continue;
+    const specs = [];
+    for (const m of text.matchAll(IMPORT_RE)) specs.push(m[1] ?? m[2] ?? m[3] ?? m[4]);
+    if (p.endsWith(".py")) for (const m of text.matchAll(PY_IMPORT_RE)) specs.push((m[1] ?? m[2]).replace(/\./g, "/"));
+    for (const spec of specs.slice(0, 200)) {
+      const target = resolveImport(p, spec, fileSet);
+      if (!target) continue;
+      addEdge(n.id, fileNode(target), "imports");
+      if (!parsed.has(target)) queue.push(target);
+    }
+  }
+  const byKind = {};
+  for (const n of nodes.values()) byKind[n.kind] = (byKind[n.kind] ?? 0) + 1;
+  return {
+    schemaVersion: 1,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes: [...nodes.values()].sort((a, b) => compare(a.id, b.id)),
+    edges: edges.sort((a, b) => compare(a.from, b.from) || compare(a.to, b.to)),
+    stats: { nodes: nodes.size, edges: edges.length, byKind }
+  };
+}
+async function saveGraph(root, graph) {
+  await writeFileAtomic(path.join(athenaDir(root), GRAPH_FILE), `${JSON.stringify(graph, null, 2)}
+`);
+}
+async function loadGraph(root) {
+  const raw = await readTextIfExists(path.join(athenaDir(root), GRAPH_FILE));
+  if (!raw) return null;
+  try {
+    const parsed = ProjectGraph.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+var indexes = /* @__PURE__ */ new WeakMap();
+function graphIndex(graph) {
+  let idx = indexes.get(graph);
+  if (idx && idx.nodeCount === graph.nodes.length && idx.edgeCount === graph.edges.length) return idx;
+  const byId = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) byId.set(n.id, n);
+  const incident = /* @__PURE__ */ new Map();
+  const add = (id, i) => {
+    const list = incident.get(id);
+    if (!list) incident.set(id, [i]);
+    else if (list[list.length - 1] !== i) list.push(i);
+  };
+  graph.edges.forEach((e, i) => {
+    add(e.from, i);
+    add(e.to, i);
+  });
+  idx = { byId, incident, nodeCount: graph.nodes.length, edgeCount: graph.edges.length };
+  indexes.set(graph, idx);
+  return idx;
+}
+function neighbors(graph, id) {
+  const node = graph.nodes.find((n) => n.id === id);
+  if (!node) return null;
+  const { byId, incident } = graphIndex(graph);
+  const out = [];
+  for (const i of incident.get(id) ?? []) {
+    const e = graph.edges[i];
+    if (e.from === id && byId.has(e.to)) out.push({ edge: e, other: byId.get(e.to), direction: "out" });
+    else if (e.to === id && byId.has(e.from)) out.push({ edge: e, other: byId.get(e.from), direction: "in" });
+  }
+  return { node, edges: out };
+}
+function expandFromFiles(graph, files, depth = 1, limit = 40) {
+  const { byId, incident } = graphIndex(graph);
+  const fileSet = new Set(files);
+  const seed = graph.nodes.filter((n) => n.path && fileSet.has(n.path));
+  const seen = new Set(seed.map((n) => n.id));
+  let frontier = new Set(seen);
+  for (let d = 0; d < depth; d++) {
+    const touched = /* @__PURE__ */ new Set();
+    for (const id of frontier) for (const i of incident.get(id) ?? []) touched.add(i);
+    const next = /* @__PURE__ */ new Set();
+    for (const i of [...touched].sort((a, b) => a - b)) {
+      const e = graph.edges[i];
+      if (frontier.has(e.from) && !seen.has(e.to)) {
+        seen.add(e.to);
+        next.add(e.to);
+      } else if (frontier.has(e.to) && !seen.has(e.from)) {
+        seen.add(e.from);
+        next.add(e.from);
+      }
+    }
+    frontier = next;
+    if (!frontier.size) break;
+  }
+  return [...seen].map((id) => byId.get(id)).filter((n) => Boolean(n)).slice(0, limit);
+}
+
+// src/services/project-session.ts
+import { promises as fs } from "fs";
+import path2 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 = path2.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(path2.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(path2.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 = path2.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 = path2.resolve(root);
+  let s = sessions.get(key);
+  if (!s) {
+    s = new ProjectSession(key);
+    sessions.set(key, s);
+  }
+  return s;
+}
+function releaseProjectSession(root) {
+  sessions.delete(path2.resolve(root));
+}
+
+export {
+  GRAPH_FILE,
+  buildGraph,
+  saveGraph,
+  loadGraph,
+  neighbors,
+  expandFromFiles,
+  projectSession,
+  releaseProjectSession
+};
+//# sourceMappingURL=chunk-PDFQ5BFG.js.map

package/dist/chunk-PR53DT7I.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import {
+  committedAiWarning
+} from "./chunk-RXNRMIZP.js";
+import {
+  whichExecutable
+} from "./chunk-VSYBC3VY.js";
+import {
+  listRules,
+  parseRules
+} from "./chunk-3IS2X2Z7.js";
+import {
+  readRecentEvents
+} from "./chunk-65TSRDQ3.js";
+import {
+  findProjectRoot
+} from "./chunk-KBO7XRBW.js";
+import {
+  ATHENA_VERSION
+} from "./chunk-2R6PXY6Z.js";
+import {
+  gitAvailable,
+  isGitRepo
+} from "./chunk-OLPSEQS5.js";
+import {
+  ADAPTERS
+} from "./chunk-2RS6TA3D.js";
+import {
+  hookCommand
+} from "./chunk-GHFRQAYT.js";
+import {
+  parseBlocks
+} from "./chunk-673EPYYH.js";
+import {
+  KNOWLEDGE_DOCS
+} from "./chunk-FQEGEVLY.js";
+import {
+  athenaDir,
+  loadConfig,
+  readState
+} from "./chunk-2DY4PUR4.js";
+import {
+  readTextIfExists
+} from "./chunk-IQQBAWSM.js";
+
+// src/services/instance.ts
+import { promises as fs } from "fs";
+import path from "path";
+var INSTANCE_FILE = ".server.json";
+async function findRunningInstance(root) {
+  const file = path.join(athenaDir(root), INSTANCE_FILE);
+  const raw = await readTextIfExists(file);
+  if (!raw) return null;
+  let info;
+  try {
+    info = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof info.pid !== "number" || typeof info.port !== "number" || typeof info.token !== "string") return null;
+  try {
+    process.kill(info.pid, 0);
+  } catch {
+    await fs.rm(file, { force: true }).catch(() => {
+    });
+    return null;
+  }
+  try {
+    const host = info.host.includes(":") ? `[${info.host}]` : info.host;
+    const res = await fetch(`http://${host}:${info.port}/api/health`, { signal: AbortSignal.timeout(1500) });
+    const body = await res.json();
+    return body.instanceId === info.instanceId ? info : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/services/doctor.ts
+import { constants, promises as fs2 } from "fs";
+import path2 from "path";
+
+// src/services/time.ts
+function relativeTime(iso, now = Date.now()) {
+  const ms = 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`;
+}
+
+// src/services/doctor.ts
+async function runDoctor(cwd) {
+  const checks = [];
+  const add = (c) => checks.push(c);
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  const nodeOk = major > 22 || major === 22 && minor >= 12;
+  add({ area: "CLI", level: nodeOk ? "ok" : "error", message: `Athena ${ATHENA_VERSION} on Node.js ${process.versions.node} (${process.platform}/${process.arch})`, hint: nodeOk ? void 0 : "Athena requires Node.js >= 22.12" });
+  const root = await findProjectRoot(cwd);
+  const projectRoot = root ?? cwd;
+  if (await gitAvailable()) {
+    const repo = await isGitRepo(projectRoot);
+    add({ area: "Git", level: repo ? "ok" : "warn", message: repo ? "Git repository detected" : "Not a Git repository", hint: repo ? void 0 : "Change detection and knowledge history work best in a Git repository." });
+  } else {
+    add({ area: "Git", level: "warn", message: "git executable not found", hint: "Install Git to enable change detection and knowledge history." });
+  }
+  if (!root) {
+    add({ area: "Project", level: "error", message: "Athena is not initialized here", hint: "Run `athena init` in the project root." });
+    return { checks, root };
+  }
+  add({ area: "Project", level: "ok", message: root });
+  const dir = athenaDir(root);
+  try {
+    await fs2.access(dir, constants.R_OK | constants.W_OK);
+    add({ area: "Knowledge directory", level: "ok", message: ".athena/ is readable and writable" });
+  } catch {
+    add({ area: "Knowledge directory", level: "error", message: ".athena/ is not writable", hint: "Check file permissions." });
+  }
+  const cfg = await loadConfig(root);
+  if (cfg.warning) add({ area: "Configuration", level: "warn", message: cfg.warning });
+  const aiWarning = await committedAiWarning(root);
+  if (aiWarning) add({ area: "Configuration", level: "warn", message: aiWarning.split(": ")[0], hint: aiWarning.slice(aiWarning.indexOf(": ") + 2) });
+  const st = await readState(dir);
+  if (st.kind === "ok") add({ area: "State", level: "ok", message: `state.json valid (analyzed ${relativeTime(st.state.analyzedAt)})` });
+  else if (st.kind === "missing") add({ area: "State", level: "error", message: "state.json missing", hint: "Run `athena analyze`." });
+  else add({ area: "State", level: "error", message: `state.json corrupted: ${st.reason}`, hint: "Run `athena analyze` (the file is backed up and rebuilt)." });
+  const missing = [];
+  const malformed = [];
+  for (const d of KNOWLEDGE_DOCS) {
+    const text = await readTextIfExists(path2.join(dir, d.file));
+    if (text === null) missing.push(d.file);
+    else if (d.id !== "rules" && (text.match(/athena:generated:start/g)?.length ?? 0) !== parseBlocks(text).length) malformed.push(d.file);
+  }
+  add({ area: "Knowledge files", level: missing.length ? "error" : "ok", message: missing.length ? `Missing: ${missing.join(", ")}` : `${KNOWLEDGE_DOCS.length} knowledge files present`, hint: missing.length ? "Run `athena analyze` to regenerate missing files." : void 0 });
+  if (malformed.length) add({ area: "Knowledge files", level: "warn", message: `Unmatched generated-section markers in: ${malformed.join(", ")}`, hint: "Those sections are treated as developer content and will not be refreshed." });
+  const rulesText = await readTextIfExists(path2.join(dir, "rules.md"));
+  if (rulesText !== null) {
+    const rules = listRules(parseRules(rulesText));
+    const enabled = rules.filter((r) => r.enabled).length;
+    add({ area: "Rules", level: rules.length ? "ok" : "warn", message: `${enabled} enabled, ${rules.length - enabled} disabled`, hint: rules.length ? void 0 : "rules.md has no rules. Add some with `athena rules add`." });
+  }
+  const stateAgents = st.kind === "ok" ? st.state.agents : {};
+  for (const a of ADAPTERS) {
+    const configured = stateAgents[a.id]?.configured;
+    if (!configured) {
+      add({ area: a.displayName, level: "info", message: "Integration not configured", hint: `Enable with \`athena agents add ${a.id}\`.` });
+      continue;
+    }
+    for (const c of await a.check(root)) add({ area: a.displayName, level: c.level, message: c.message.replace(/^[^:]+:\s*/, "") });
+  }
+  const hooksConfigured = ADAPTERS.some((a) => a.capabilities.hooks && stateAgents[a.id]?.configured);
+  if (hooksConfigured) {
+    const cmd = hookCommand();
+    const resolved = await whichExecutable(cmd);
+    add(
+      resolved ? { area: "Agent hooks", level: "ok", message: `\`${cmd}\` resolves to ${resolved}` } : { area: "Agent hooks", level: "warn", message: `\`${cmd}\` is not on PATH \u2014 agent hooks cannot report activity`, hint: "Install globally (`npm i -g project-athena`) or set ATHENA_HOOK_COMMAND to an absolute path and re-run `athena agents add`." }
+    );
+    const events = await readRecentEvents(root, 1);
+    add({ area: "Agent hooks", level: "info", message: events.length ? `Last agent event: ${relativeTime(events[0].ts)}` : "No agent activity recorded yet (hooks fire when an agent runs)" });
+  }
+  const running = await findRunningInstance(root);
+  add(
+    running ? { area: "Local server", level: "ok", message: `Running on ${running.host}:${running.port} (pid ${running.pid})`, hint: "Run `athena open` to get the access link." } : { area: "Local server", level: "info", message: "Not running", hint: "Start the web UI with `athena open`." }
+  );
+  if (running && !["127.0.0.1", "::1", "localhost"].includes(running.host)) {
+    add({ area: "Local server", level: "warn", message: `Bound to ${running.host} \u2014 reachable beyond this machine` });
+  }
+  return { checks, root };
+}
+
+export {
+  INSTANCE_FILE,
+  findRunningInstance,
+  runDoctor
+};
+//# sourceMappingURL=chunk-PR53DT7I.js.map

package/dist/chunk-PVCIGUIT.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import {
+  readTextIfExists,
+  writeFileAtomic
+} from "./chunk-IQQBAWSM.js";
+import {
+  ATHENA_DIR
+} from "./chunk-EUPETUWA.js";
+
+// src/core/local-config.ts
+import crypto from "crypto";
+import path from "path";
+import { z } from "zod";
+var LOCAL_CONFIG_FILE = "local.json";
+var LocalConfig = z.object({
+  /** Random per-machine salt for keyed fingerprints of secret findings. Never leaves this machine. */
+  salt: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+  /** AI settings trusted only from machine-local sources (see src/services/ai.ts). */
+  ai: z.object({
+    baseUrl: z.string().optional(),
+    consent: z.boolean().optional()
+  }).optional()
+}).passthrough();
+function localPath(root) {
+  return path.join(root, ATHENA_DIR, LOCAL_CONFIG_FILE);
+}
+async function readLocalConfig(root) {
+  const text = await readTextIfExists(localPath(root)).catch(() => null);
+  if (text === null) return {};
+  try {
+    const parsed = LocalConfig.safeParse(JSON.parse(text));
+    return parsed.success ? parsed.data : {};
+  } catch {
+    return {};
+  }
+}
+async function writeLocalConfig(root, cfg) {
+  const ignoreFile = path.join(root, ATHENA_DIR, ".gitignore");
+  const ignore = await readTextIfExists(ignoreFile);
+  if (!ignore?.split(/\r?\n/).includes(LOCAL_CONFIG_FILE)) {
+    await writeFileAtomic(ignoreFile, `${(ignore ?? "").replace(/\s*$/, "")}${ignore ? "\n" : ""}${LOCAL_CONFIG_FILE}
+`);
+  }
+  await writeFileAtomic(localPath(root), `${JSON.stringify(cfg, null, 2)}
+`);
+}
+async function getOrCreateSalt(root) {
+  const cfg = await readLocalConfig(root);
+  if (cfg.salt) return cfg.salt;
+  const salt = crypto.randomBytes(32).toString("hex");
+  await writeLocalConfig(root, { ...cfg, salt });
+  return salt;
+}
+function keyedFingerprint(salt, value, length = 16) {
+  return crypto.createHmac("sha256", salt).update(value).digest("hex").slice(0, length);
+}
+
+export {
+  LOCAL_CONFIG_FILE,
+  readLocalConfig,
+  getOrCreateSalt,
+  keyedFingerprint
+};
+//# sourceMappingURL=chunk-PVCIGUIT.js.map