project-athena 0.2.1 → 0.3.0

package/dist/chunk-CXUTYCZX.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import {
+  listRules,
+  parseRules
+} from "./chunk-3IS2X2Z7.js";
+import {
+  GRAPH_FILE,
+  buildGraph,
+  expandFromFiles,
+  projectSession,
+  saveGraph
+} from "./chunk-PDFQ5BFG.js";
+import {
+  analyzeProject
+} from "./chunk-PANVPNYF.js";
+import {
+  parseBlocks
+} from "./chunk-673EPYYH.js";
+import {
+  KNOWLEDGE_DOCS,
+  RELEVANCE_MAP
+} from "./chunk-FQEGEVLY.js";
+import {
+  athenaDir
+} from "./chunk-2DY4PUR4.js";
+import {
+  readTextIfExists
+} from "./chunk-IQQBAWSM.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+
+// src/core/context/context-engine.ts
+var AREA_KEYWORDS = [
+  { id: "database", words: /\b(database|db|schema|migration|migrate|sql|query|queries|table|column|index|prisma|orm|entity|model|postgres|mysql|mongo|supabase)\b/i },
+  { id: "api", words: /\b(api|endpoint|route|router|controller|handler|rest|graphql|grpc|request|response|webhook|http|status code)\b/i },
+  { id: "auth", words: /\b(auth|authentication|authorization|login|logout|session|token|jwt|oauth|sso|permission|role|rbac|acl|password|mfa|2fa)\b/i },
+  { id: "security", words: /\b(security|secure|vulnerab|xss|csrf|ssrf|injection|sanitiz|escape|secret|credential|encrypt|audit|cors|rate limit)\b/i },
+  { id: "testing", words: /\b(test|tests|testing|spec|coverage|e2e|unit|integration|mock|fixture|vitest|jest|pytest|playwright|cypress)\b/i },
+  { id: "performance", words: /\b(performance|perf|slow|fast|latency|cache|caching|queue|worker|background job|optimi[sz]|n\+1|bottleneck|memory|profil)\b/i },
+  { id: "deployment", words: /\b(deploy|deployment|docker|container|kubernetes|k8s|ci|cd|pipeline|release|env var|environment variable|infra|terraform|vercel|hosting)\b/i },
+  { id: "debugging", words: /\b(bug|debug|error|exception|crash|stack trace|failing|broken|regression|log|logging|troubleshoot)\b/i },
+  { id: "architecture", words: /\b(architecture|structure|module|package|refactor|boundary|layer|service layer|dependency|monorepo|design)\b/i },
+  { id: "code-review", words: /\b(review|pull request|pr|merge|checklist|convention|style guide)\b/i },
+  { id: "project", words: /\b(setup|install|build|command|script|getting started|onboard|dependency|dependencies|tooling)\b/i }
+];
+var UI_WORDS = /\b(ui|css|style|styling|layout|component|button|form|page|responsive|dark mode|design|frontend|tailwind)\b/i;
+var SMALL_WORDS = /\b(typo|rename|comment|whitespace|format|wording|copy|spelling)\b/i;
+var STOP = /* @__PURE__ */ new Set(["the", "and", "for", "with", "that", "this", "from", "into", "add", "new", "use", "using", "make", "need", "should", "when", "what", "where", "which", "must", "have", "has", "are", "was", "can", "will", "our", "their", "its", "not", "all", "any", "get", "set", "run"]);
+function tokenize(task) {
+  return [...new Set(task.toLowerCase().match(/[a-z0-9_./-]{3,}/g) ?? [])].filter((w) => !STOP.has(w));
+}
+function mentionedFiles(task, knownFiles) {
+  const candidates = task.match(/[\w./-]+\.[a-z]{1,5}\b/gi) ?? [];
+  const out = [];
+  for (const c of candidates) {
+    const norm = c.replace(/^\.\//, "");
+    const exact = knownFiles.find((f) => f === norm || f.endsWith(`/${norm}`));
+    if (exact) out.push(exact);
+  }
+  return [...new Set(out)];
+}
+function selectContext(opts) {
+  const task = opts.task.trim();
+  const words = tokenize(task);
+  const maxChars = opts.maxChars ?? 12e3;
+  const areas = /* @__PURE__ */ new Map();
+  const bump = (id, score, why) => {
+    const cur = areas.get(id) ?? { id, score: 0, why: [] };
+    cur.score += score;
+    if (!cur.why.includes(why)) cur.why.push(why);
+    areas.set(id, cur);
+  };
+  for (const { id, words: re } of AREA_KEYWORDS) {
+    const hit = task.match(re);
+    if (hit) bump(id, 10, `task mentions "${hit[0]}"`);
+  }
+  if (UI_WORDS.test(task)) {
+    for (const id of ["project", "architecture"]) bump(id, 6, "frontend/UI task");
+  }
+  if (!areas.size && !SMALL_WORDS.test(task)) {
+    for (const id of RELEVANCE_MAP.find((r) => r.task.startsWith("New feature")).docs) bump(id, 3, "no specific area detected \u2014 using the broad feature set");
+  }
+  if (areas.has("database") || areas.has("api") || areas.has("auth")) {
+    bump("security", 4, "security implications of data/API changes");
+    bump("testing", 3, "tests for changed behavior");
+  }
+  const knownFiles = opts.graph?.nodes.filter((n) => n.path).map((n) => n.path) ?? [];
+  const files = mentionedFiles(task, knownFiles);
+  const graphNodes = opts.graph ? expandFromFiles(opts.graph, files, 1, 30) : [];
+  for (const n of graphNodes) {
+    if (n.kind === "route") bump("api", 5, `task touches route ${n.name}`);
+    if (n.kind === "entity") bump("database", 5, `task touches entity ${n.name}`);
+  }
+  if (opts.graph) {
+    for (const n of opts.graph.nodes) {
+      if (graphNodes.some((g) => g.id === n.id)) continue;
+      const hay = `${n.name} ${n.path ?? ""}`.toLowerCase();
+      if (words.some((w) => w.length > 3 && hay.includes(w))) {
+        graphNodes.push(n);
+        if (graphNodes.length >= 40) break;
+      }
+    }
+  }
+  const ranked = [...areas.values()].sort((a, b) => b.score - a.score);
+  const sections = [];
+  for (const area of ranked) {
+    const doc = opts.documents.find((d) => d.id === area.id);
+    if (!doc) continue;
+    for (const s of doc.sections) {
+      if (s.id === "about") continue;
+      const text = s.content.toLowerCase();
+      const matches = words.filter((w) => text.includes(w)).length;
+      const score = area.score + matches * 2;
+      sections.push({ doc: doc.id, file: doc.file, section: s.id, content: s.content, score });
+    }
+  }
+  sections.sort((a, b) => b.score - a.score);
+  let used = 0;
+  const kept = [];
+  let truncated = false;
+  for (const s of sections) {
+    if (used + s.content.length > maxChars) {
+      truncated = true;
+      continue;
+    }
+    kept.push(s);
+    used += s.content.length;
+  }
+  const rules = opts.rulesMarkdown ? listRules(parseRules(opts.rulesMarkdown)).filter((r) => r.enabled) : [];
+  return {
+    task,
+    areas: ranked,
+    sections: kept.sort((a, b) => a.doc.localeCompare(b.doc) || b.score - a.score),
+    rules,
+    graphNodes: graphNodes.slice(0, 40),
+    mentionedFiles: files,
+    truncated,
+    approxChars: used
+  };
+}
+function documentSections(markdown) {
+  const blocks = parseBlocks(markdown);
+  const sections = blocks.map((b) => ({ id: b.id, content: b.content }));
+  const last = blocks.at(-1);
+  const tail = last ? markdown.slice(last.end) : markdown;
+  const notes = tail.replace(/^#+ Developer Notes\s*/im, "").replace(/<!--[\s\S]*?-->/g, "").trim();
+  if (notes) sections.push({ id: "developer-notes", content: `## Developer Notes
+
+${notes}` });
+  return sections;
+}
+function formatContext(ctx) {
+  const out = [`# Athena context for: ${ctx.task}`, ""];
+  out.push("_Selected deterministically from this project's knowledge. Statements keep their FACT/DETECTED/INFERRED/UNKNOWN labels; verify anything not marked FACT or DETECTED._", "");
+  if (ctx.rules.length) {
+    out.push("## Project rules (always apply)", "");
+    for (const r of ctx.rules) out.push(`- [${r.section}] ${r.text}`);
+    out.push("");
+  }
+  if (ctx.areas.length) {
+    out.push(`## Why these documents`, "");
+    for (const a of ctx.areas) out.push(`- **${KNOWLEDGE_DOCS.find((d) => d.id === a.id).file}** \u2014 ${a.why.join("; ")}`);
+    out.push("");
+  }
+  if (ctx.mentionedFiles.length || ctx.graphNodes.length) {
+    out.push("## Related code (from the project graph)", "");
+    for (const f of ctx.mentionedFiles) out.push(`- file: \`${f}\` (named in the task)`);
+    for (const n of ctx.graphNodes.filter((n2) => !ctx.mentionedFiles.includes(n2.path ?? ""))) {
+      out.push(`- ${n.kind}: ${n.name}${n.path ? ` (\`${n.path}\`)` : ""}`);
+    }
+    out.push("");
+  }
+  let currentDoc = "";
+  for (const s of ctx.sections) {
+    if (s.doc !== currentDoc) {
+      currentDoc = s.doc;
+      out.push(`## From ${s.file}`, "");
+    }
+    out.push(s.content.trim(), "");
+  }
+  if (ctx.truncated) out.push("_Some lower-ranked sections were omitted to stay within the context budget._");
+  return out.join("\n");
+}
+
+// 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
+  });
+}
+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 {
+  formatContext,
+  refreshGraph,
+  getGraph,
+  getRelevantContext,
+  graphSummary
+};
+//# sourceMappingURL=chunk-CXUTYCZX.js.map

package/dist/chunk-DOQMAZL5.js

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+import {
+  HR,
+  PALETTE,
+  box,
+  columns,
+  footer,
+  gradient,
+  mix,
+  padEnd,
+  paint,
+  printHeader,
+  termWidth,
+  truncate,
+  width
+} from "./chunk-SHKXELUX.js";
+import {
+  bullet,
+  c,
+  dim,
+  isJson,
+  isQuiet,
+  isTTY,
+  json,
+  line,
+  ok,
+  sym,
+  unicode,
+  warn
+} from "./chunk-Z6QWMJLK.js";
+import {
+  resolveCwd
+} from "./chunk-XFN7UZCS.js";
+import {
+  runPipeline
+} from "./chunk-SJOOXO34.js";
+import {
+  ADAPTERS,
+  resolveAdapters
+} from "./chunk-2RS6TA3D.js";
+import {
+  KNOWLEDGE_DOCS
+} from "./chunk-FQEGEVLY.js";
+import {
+  readState
+} from "./chunk-2DY4PUR4.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+
+// src/cli/commands/init.ts
+import path from "path";
+
+// src/cli/ui/dashboard.ts
+import pc from "picocolors";
+var C = PALETTE;
+var accent = (s) => paint(PALETTE.amber, s, true);
+var warnText = (s) => paint(PALETTE.amber, s);
+function sectionTitle(title) {
+  const total = termWidth();
+  const head = `  ${paint(PALETTE.violet, unicode ? "\u2726" : "*", true)} ${gradient(title, [PALETTE.cyan, PALETTE.violet], true)} `;
+  const rest = Math.max(0, total - width(head) - 2);
+  return [head + paint(PALETTE.blue, HR.repeat(rest))];
+}
+function rows(items) {
+  const labelW = Math.max(...items.map(([l]) => l.length)) + 2;
+  return (w) => items.map(([label, value]) => pc.dim(padEnd(label, labelW)) + padEnd(value ? paint(PALETTE.cyan, value) : pc.dim("Not detected"), w - labelW));
+}
+function fileTree(root, files) {
+  const nameW = Math.max(...files.map((f) => f.name.length)) + 2;
+  return (w) => [
+    pc.bold(root),
+    ...files.map((f, i) => {
+      const branch = unicode ? i === files.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : i === files.length - 1 ? "`-- " : "|-- ";
+      const name = f.highlight ? paint(PALETTE.amber, padEnd(f.name, nameW)) : padEnd(f.name, nameW);
+      return padEnd(pc.dim(branch) + name + pc.dim(f.note ? `# ${f.note}` : ""), w);
+    })
+  ];
+}
+function wrapCode(text, w) {
+  const out = [];
+  let cur = "";
+  for (const word of text.split(" ")) {
+    if (cur && cur.length + 1 + word.length > w) {
+      out.push(cur);
+      cur = word;
+    } else cur = cur ? `${cur} ${word}` : word;
+  }
+  if (cur) out.push(cur);
+  let inCode = false;
+  return out.map(
+    (l) => l.split("`").map((part, i) => {
+      if (i > 0) inCode = !inCode;
+      return inCode ? paint(PALETTE.cyan, part) : part;
+    }).join("")
+  );
+}
+function wrapLines(text, indent = 2) {
+  const w = Math.max(20, termWidth() - 1);
+  const out = [];
+  let cur = "";
+  for (const word of text.split(" ")) {
+    if (cur && cur.length + 1 + word.length > w) {
+      out.push(cur);
+      cur = " ".repeat(indent) + word;
+    } else cur = cur ? `${cur} ${word}` : word;
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+function numbered(steps) {
+  return (w) => steps.flatMap((s, i) => {
+    const badge = paint(PALETTE.green, ` ${i + 1} `, true);
+    const [first = "", ...rest] = wrapCode(s, Math.max(10, w - 5));
+    return [`${badge}  ${first}`, ...rest.map((r) => `     ${r}`)];
+  });
+}
+function quote(text) {
+  return (w) => {
+    const lines = wrapCode(`\u201C${text}\u201D`, Math.max(10, w - 6)).map((l) => pc.italic(l));
+    return box([...lines, paint(PALETTE.cyan, `\u2014 Sabarivasan`)], Math.min(w, Math.max(...lines.map(width)) + 6), { color: PALETTE.slate, padX: 2 });
+  };
+}
+function renderBody(body, w) {
+  const parts = Array.isArray(body) && body.length && typeof body[0] !== "string" ? body : [body];
+  return parts.flatMap((p) => typeof p === "function" ? p(w) : p);
+}
+function panels(list) {
+  const total = termWidth();
+  const title = (p) => `${paint(p.color, unicode ? p.icon : "*", true)} ${paint(p.color, p.title, true)}`;
+  if (total >= 120) {
+    const gap = 2;
+    const avail = total - gap * (list.length - 1) - 1;
+    const weights = [0.36, 0.32, 0.32];
+    const widths = list.map((_, i) => Math.floor(avail * (weights[i] ?? 1 / list.length)));
+    const bodies = list.map((p, i) => renderBody(p.body, widths[i] - 4));
+    const h = Math.max(...bodies.map((b) => b.length));
+    const boxes = list.map((p, i) => box([title(p), "", ...bodies[i], ...Array(h - bodies[i].length).fill("")], widths[i], { color: p.color, padX: 1 }));
+    return columns(boxes, widths, gap);
+  }
+  const w = Math.min(total - 1, 100);
+  return list.flatMap((p, i) => [...i ? [""] : [], ...box([title(p), "", ...renderBody(p.body, w - 4)], w, { color: p.color })]);
+}
+
+// src/cli/ui/stages.ts
+import pc2 from "picocolors";
+var STAGES = [
+  { id: "scan", label: "Scanning project structure" },
+  { id: "detect", label: "Detecting stack, database, API & auth" },
+  { id: "git", label: "Reading Git metadata" },
+  { id: "finalize", label: "Redacting secrets & validating" },
+  { id: "write", label: "Generating documentation" },
+  { id: "agents", label: "Configuring AI agents" }
+];
+var STAGE_ALIASES = { analyze: "scan" };
+var FRAMES = unicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["-", "\\", "|", "/"];
+var BAR_STOPS = [PALETTE.green, PALETTE.cyan, PALETTE.blue, PALETTE.violet];
+var StageBoard = class {
+  state = new Map(STAGES.map((s) => [s.id, "pending"]));
+  started = /* @__PURE__ */ new Map();
+  elapsed = /* @__PURE__ */ new Map();
+  results = /* @__PURE__ */ new Map();
+  current = null;
+  frame = 0;
+  drawn = 0;
+  timer = null;
+  live = isTTY && !isJson() && !isQuiet();
+  enabled = !isJson() && !isQuiet();
+  restoreCursor = () => process.stdout.write("\x1B[?25h");
+  start() {
+    if (!this.live) return;
+    process.stdout.write("\x1B[?25l");
+    process.once("exit", this.restoreCursor);
+    this.render();
+    this.timer = setInterval(() => {
+      this.frame++;
+      this.render();
+    }, 80);
+    this.timer.unref();
+  }
+  /** Accepts raw pipeline stage names; unknown names are ignored. */
+  enter(raw) {
+    const id = STAGE_ALIASES[raw] ?? raw;
+    if (!this.state.has(id) || this.current === id) return;
+    this.closeCurrent("done");
+    this.current = id;
+    this.state.set(id, "running");
+    this.started.set(id, performance.now());
+  }
+  finish(results) {
+    this.closeCurrent("done");
+    for (const [id, st] of this.state) if (st === "pending") this.state.set(id, "skipped");
+    for (const [id, r] of Object.entries(results)) this.results.set(id, r);
+    this.stop();
+  }
+  fail() {
+    this.closeCurrent("failed");
+    this.stop();
+  }
+  closeCurrent(to) {
+    if (!this.current) return;
+    this.state.set(this.current, to);
+    this.elapsed.set(this.current, performance.now() - this.started.get(this.current));
+    this.current = null;
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (!this.enabled) return;
+    if (this.live) {
+      this.render();
+      this.restoreCursor();
+      process.removeListener("exit", this.restoreCursor);
+    } else for (const l of this.lines()) line(l);
+  }
+  render() {
+    const rows2 = this.lines();
+    let s = this.drawn ? `\x1B[${this.drawn}F` : "";
+    for (const r of rows2) s += `\x1B[2K${r}
+`;
+    process.stdout.write(s);
+    this.drawn = rows2.length;
+  }
+  lines() {
+    const total = termWidth();
+    const showBar = total >= 100;
+    const barW = total >= 130 ? 26 : 18;
+    return STAGES.map((s, i) => {
+      const st = this.state.get(s.id);
+      const icon = st === "done" ? paint(PALETTE.green, sym.ok, true) : st === "running" ? paint(PALETTE.cyan, FRAMES[this.frame % FRAMES.length]) : st === "failed" ? pc2.red(sym.err) : pc2.dim(st === "skipped" ? "\u2013" : sym.ring);
+      const label = st === "pending" || st === "skipped" ? pc2.dim(s.label) : s.label;
+      const ms = this.elapsed.get(s.id) ?? (st === "running" ? performance.now() - this.started.get(s.id) : void 0);
+      const time = st === "skipped" ? pc2.dim("skipped") : ms === void 0 ? "" : pc2.dim(ms < 1e3 ? `${Math.max(1, Math.round(ms))}ms` : `${(ms / 1e3).toFixed(1)}s`);
+      const r = this.results.get(s.id);
+      const result = r ? r.tone === "warn" ? paint(PALETTE.amber, `${sym.warn} ${r.text}`) : r.tone === "dim" ? pc2.dim(r.text) : `${paint(PALETTE.green, sym.ok)} ${r.text}` : "";
+      const bar = showBar ? `${this.bar(st, barW, i)}  ` : "";
+      return truncate(`  ${icon}  ${padEnd(label, 40)}${bar}${padEnd(time, 8)}${result}`, total - 1);
+    });
+  }
+  bar(st, w, row) {
+    const fill = unicode ? "\u2501" : "#";
+    const track = unicode ? "\u2500" : "-";
+    if (st === "done") return paint(mix(BAR_STOPS, row / (STAGES.length - 1)), fill.repeat(w));
+    if (st === "failed") return pc2.red(fill.repeat(w));
+    if (st !== "running") return pc2.dim(track.repeat(w));
+    const seg = 6;
+    const span = w - seg;
+    const t = this.frame % (span * 2);
+    const pos = t <= span ? t : span * 2 - t;
+    return pc2.dim(track.repeat(pos)) + paint(PALETTE.cyan, fill.repeat(seg)) + pc2.dim(track.repeat(w - pos - seg));
+  }
+};
+
+// src/cli/commands/init.ts
+function parseAgentsOption(value, disabled) {
+  if (disabled) return [];
+  if (value === void 0) return void 0;
+  if (value.trim().toLowerCase() === "all") return [...ADAPTERS];
+  if (value.trim().toLowerCase() === "none") return [];
+  try {
+    return resolveAdapters(value.split(","));
+  } catch (err) {
+    throw new AthenaError(err.message);
+  }
+}
+async function initCommand(opts) {
+  const root = await resolveCwd(opts);
+  const existing = await readState(path.join(root, ".athena"));
+  if (existing.kind === "ok") {
+    throw new AthenaError("Athena is already initialized in this project.", "Run `athena analyze` to refresh knowledge, or `athena clean` to start over.");
+  }
+  const agents = parseAgentsOption(opts.agents, opts.noAgents);
+  printHeader();
+  const result = await runWithProgress(root, { mode: "init", dryRun: opts.dryRun, agents, signal: opts.signal });
+  if (isJson()) {
+    json(summarize(result, root, Boolean(opts.dryRun)));
+    return;
+  }
+  printSummary(result, Boolean(opts.dryRun), "init");
+}
+async function runWithProgress(root, o) {
+  const board = new StageBoard();
+  board.start();
+  try {
+    const result = await runPipeline({
+      root,
+      mode: o.mode,
+      dryRun: o.dryRun,
+      force: o.force,
+      agents: o.agents,
+      signal: o.signal,
+      onStage: (stage) => board.enter(stage)
+    });
+    board.finish(stageResults(result, o.mode, Boolean(o.dryRun)));
+    return result;
+  } catch (err) {
+    board.fail();
+    throw err;
+  }
+}
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function stageResults(result, mode, dryRun) {
+  const m = result.analysis.model;
+  const skipped = m.stats.skippedBinary + m.stats.skippedLarge + m.stats.skippedUnreadable;
+  const found = [
+    m.frameworks.length && plural(new Set(m.frameworks.map((f) => f.name)).size, "framework"),
+    m.dbEntities.length && plural(m.dbEntities.length, "entity").replace("entitys", "entities"),
+    m.routes.length && plural(m.routes.length, "route"),
+    m.auth.length && "auth"
+  ].filter(Boolean);
+  const changed = result.docs.filter((d) => d.status !== "unchanged").length;
+  const agents = result.agentChanges.map((a) => a.adapter.displayName);
+  return {
+    scan: { text: `Found ${plural(m.stats.filesScanned, "file")}${skipped ? ` \xB7 ${skipped} skipped` : ""}` },
+    detect: found.length ? { text: found.join(" \xB7 ") } : { text: "No frameworks detected", tone: "dim" },
+    git: m.git.isRepo ? { text: `On ${m.git.branch ?? "detached HEAD"}${m.git.head ? ` @ ${m.git.head.slice(0, 7)}` : ""}` } : { text: m.git.available ? "Not a Git repository" : "Git not installed", tone: "dim" },
+    finalize: m.security.secrets.length ? { text: `${plural(m.security.secrets.length, "potential secret")} (values redacted)`, tone: "warn" } : { text: "No likely secrets found" },
+    write: dryRun ? { text: "Dry run \u2014 nothing written", tone: "dim" } : { text: mode === "init" ? `${plural(result.docs.length, "document")} generated` : changed ? `${changed} updated \xB7 ${result.docs.length - changed} unchanged` : "Already up to date" },
+    agents: agents.length ? { text: agents.join(", ") } : { text: "None configured", tone: "dim" }
+  };
+}
+var DOC_NOTES = {
+  "project.md": "Project overview",
+  "architecture.md": "System architecture",
+  "database.md": "Database schema",
+  "api.md": "API reference",
+  "auth.md": "Authentication flow",
+  "security.md": "Security analysis",
+  "testing.md": "Testing strategy",
+  "debugging.md": "Debugging guide",
+  "performance.md": "Performance notes",
+  "code-review.md": "Review checklist",
+  "deployment.md": "Deployment guide",
+  "rules.md": "Your project rules"
+};
+function printSummary(result, dryRun, mode) {
+  const m = result.analysis.model;
+  if (isQuiet()) {
+    for (const w of m.warnings) warn(w);
+    for (const n of result.notes) warn(n);
+    for (const d of result.docs.filter((x) => x.preservedModified.length)) warn(`${d.file}: kept your edits in ${d.preservedModified.join(", ")}`);
+    const changed = result.docs.filter((d) => d.status !== "unchanged").map((d) => d.file);
+    line(dryRun ? "Dry run: nothing written." : changed.length ? `Updated: ${changed.join(", ")}` : "Knowledge up to date.");
+    return;
+  }
+  const uniq = (xs) => [...new Set(xs)];
+  const list = (xs, n = 4) => uniq(xs).slice(0, n).join(" \xB7 ");
+  line();
+  for (const l of sectionTitle(dryRun ? "Dry Run Complete" : "Analysis Complete!")) line(l);
+  line(`  Analyzed ${accent(String(m.stats.filesScanned))} files in ${accent(`${(result.analysis.durationMs / 1e3).toFixed(1)}s`)}`);
+  line();
+  const overview = [
+    ["Project", `${m.name}${m.languages[0] ? ` \xB7 ${list(m.languages.map((l) => l.name), 3)}` : ""}`],
+    ["Frameworks", list(m.frameworks.map((f) => f.name), 5)],
+    ["Workspace", m.workspace.isMonorepo ? `monorepo \xB7 ${plural(m.workspace.packages.length, "package")}` : ""],
+    ["Database", m.databases.length + m.dbEntities.length ? [list(m.databases.map((d) => d.name), 3), m.dbEntities.length ? plural(m.dbEntities.length, "entity").replace("entitys", "entities") : ""].filter(Boolean).join(" \xB7 ") : ""],
+    ["API", m.routes.length + m.apiSpecs.length ? [m.routes.length ? plural(m.routes.length, "route") : "", m.apiSpecs.length ? plural(m.apiSpecs.length, "spec") : ""].filter(Boolean).join(" \xB7 ") : ""],
+    ["Auth", list(m.auth.map((a) => a.name), 3)],
+    ["Testing", m.tests.frameworks.length + m.tests.testFileCount ? [list(m.tests.frameworks.map((f) => f.name), 3), plural(m.tests.testFileCount, "test file")].filter(Boolean).join(" \xB7 ") : ""],
+    ["Deployment", [m.containers.dockerfiles.length ? "Docker" : "", ...uniq(m.ci.map((j) => j.system)), ...uniq(m.infrastructure.filter((i) => i.kind === "hosting").map((i) => i.name))].filter(Boolean).slice(0, 4).join(" \xB7 ")],
+    ["Security", m.security.secrets.length ? warnText(`${plural(m.security.secrets.length, "potential secret")} \u2014 see security.md`) : "No likely secrets matched"]
+  ];
+  const files = dryRun ? ["Would create .athena/ with:", ...[...KNOWLEDGE_DOCS.map((d) => d.file), "model.json", "state.json"].map((f) => `  ${f}`)] : fileTree(
+    ".athena/",
+    result.docs.map((d) => ({ name: d.file, note: mode === "init" ? DOC_NOTES[d.file] ?? "" : d.status, highlight: mode === "analyze" && d.status !== "unchanged" }))
+  );
+  const configured = result.agentChanges.length > 0;
+  const steps = dryRun ? ["Run `athena init` without --dry-run to write the files"] : mode === "init" ? [
+    "Review `.athena/rules.md` and enable the rules that apply",
+    "Run `athena open` to browse and edit in the web UI",
+    configured ? "Your agents now read `.athena/` \u2014 watch with `athena activity`" : "Connect an agent: `athena agents add claude-code`",
+    "After code changes run `athena sync` to keep docs current",
+    "Guides and docs: https://athena.sabari.me \xB7 star us on GitHub \u2605"
+  ] : ["Review changes with `git diff .athena/`", "Run `athena open` to browse in the web UI", "Use `athena sync --watch` to stay current"];
+  for (const l of panels([
+    { title: "Project Overview", icon: "\u25C6", color: C.blue, body: rows(overview) },
+    { title: mode === "init" ? "Generated Files" : "Knowledge Files", icon: "\u25A4", color: C.violet, body: files },
+    { title: "Next Steps", icon: "\u279C", color: C.green, body: mode === "init" && !dryRun ? [numbered(steps), [""], quote("Better documentation leads to better software.")] : numbered(steps) }
+  ]))
+    line(l);
+  const preserved = result.docs.filter((d) => d.preservedModified.length);
+  const notes = [
+    ...m.warnings.slice(0, 5).map((w) => () => warn(c.yellow(w))),
+    ...m.warnings.length > 5 ? [() => line(dim(`  +${m.warnings.length - 5} more warnings (see .athena/project.md)`))] : [],
+    ...preserved.map((d) => () => warn(`${d.file}: kept your edits in ${d.preservedModified.join(", ")} ${dim("(use --force to regenerate)")}`)),
+    ...(dryRun ? [] : result.agentChanges).map(({ adapter, changes }) => () => {
+      const touched = changes.filter((c2) => c2.action !== "unchanged").map((c2) => `${c2.path} (${c2.action})`);
+      ok(`${adapter.displayName} integration${dim(` \u2014 ${touched.length ? touched.join(", ") : changes.map((c2) => c2.path).join(", ") + " (unchanged)"}`)}`);
+    }),
+    ...mode === "init" && !dryRun ? (() => {
+      const unconfigured = ADAPTERS.filter((a) => !result.agentChanges.some((c2) => c2.adapter.id === a.id));
+      const text = `Not configured (not detected in this project): ${unconfigured.map((a) => a.id).join(", ")}. Add one with \`athena agents add <id>\`.`;
+      return unconfigured.length ? [() => wrapLines(text).forEach((l) => line(dim(l)))] : [];
+    })() : [],
+    ...dryRun ? result.agentChanges.flatMap(({ adapter, changes }) => changes.map((ch) => () => bullet(`${adapter.displayName}: would ${ch.action} ${ch.path}`))) : [],
+    ...result.notes.map((n) => () => warn(n))
+  ];
+  if (notes.length) {
+    line();
+    for (const print of notes) print();
+  }
+  line();
+  const lines = dryRun ? footer("Dry run \u2014 nothing was written.", "Re-run without --dry-run to create .athena/", "warn") : mode === "init" ? footer("Athena is ready!", `Your project intelligence is ready in ${accent(".athena/")}`) : footer("Analysis complete.", `Knowledge in ${accent(".athena/")} is up to date with your code`);
+  for (const l of lines) line(l);
+}
+function summarize(result, root, dryRun) {
+  const m = result.analysis.model;
+  return {
+    root,
+    dryRun,
+    project: m.name,
+    filesScanned: m.stats.filesScanned,
+    durationMs: result.analysis.durationMs,
+    languages: m.languages.slice(0, 5).map((l) => l.name),
+    frameworks: [...new Set(m.frameworks.map((f) => f.name))],
+    monorepo: m.workspace.isMonorepo,
+    databases: m.databases.map((d) => d.name),
+    entities: m.dbEntities.length,
+    routes: m.routes.length,
+    testFiles: m.tests.testFileCount,
+    potentialSecrets: m.security.secrets.length,
+    documents: result.docs.map((d) => ({ file: d.file, status: d.status, preservedModified: d.preservedModified })),
+    agents: result.agentChanges.map((a) => ({ id: a.adapter.id, files: a.changes.map((c2) => ({ path: c2.path, action: c2.action })) })),
+    warnings: m.warnings,
+    notes: result.notes
+  };
+}
+
+export {
+  parseAgentsOption,
+  initCommand,
+  runWithProgress,
+  printSummary,
+  summarize
+};
+//# sourceMappingURL=chunk-DOQMAZL5.js.map