project-athena 0.2.1 → 0.4.0

package/dist/chunk-OLPSEQS5.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+
+// src/core/git/git.ts
+import { spawn } from "child_process";
+var DEFAULT_MAX_BYTES = 32 * 1024 * 1024;
+var MAX_STDERR_BYTES = 64 * 1024;
+function git(cwd, args, opts = {}) {
+  const o = typeof opts === "number" ? { timeoutMs: opts } : opts;
+  const timeoutMs = o.timeoutMs ?? 15e3;
+  const maxBytes = o.maxBytes ?? DEFAULT_MAX_BYTES;
+  return new Promise((resolve) => {
+    if (o.signal?.aborted) {
+      resolve({ ok: false, code: null, stdout: "", stderr: "", aborted: true });
+      return;
+    }
+    const out = [];
+    const err = [];
+    let outBytes = 0;
+    let errBytes = 0;
+    let overflow = false;
+    let timedOut = false;
+    let aborted = false;
+    let settled = false;
+    const child = spawn("git", args, {
+      cwd,
+      windowsHide: true,
+      stdio: [o.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" }
+    });
+    const kill = () => {
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill();
+    }, timeoutMs);
+    const onAbort = () => {
+      aborted = true;
+      kill();
+    };
+    o.signal?.addEventListener("abort", onAbort, { once: true });
+    const finish = (code, spawnError) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      o.signal?.removeEventListener("abort", onAbort);
+      let stderr = Buffer.concat(err).toString("utf8");
+      if (spawnError) stderr = stderr || spawnError.message;
+      if (overflow) stderr = `${stderr}${stderr ? "\n" : ""}output exceeded ${maxBytes} bytes`;
+      if (timedOut) stderr = `${stderr}${stderr ? "\n" : ""}timed out after ${timeoutMs} ms`;
+      const failed = overflow || timedOut || aborted || Boolean(spawnError);
+      resolve({
+        ok: !failed && code === 0,
+        code: failed ? null : code,
+        stdout: Buffer.concat(out).toString("utf8"),
+        stderr,
+        ...overflow ? { overflow } : {},
+        ...aborted ? { aborted } : {},
+        ...timedOut ? { timedOut } : {}
+      });
+    };
+    child.stdout.on("data", (chunk) => {
+      if (overflow) return;
+      outBytes += chunk.length;
+      if (outBytes > maxBytes) {
+        overflow = true;
+        kill();
+        return;
+      }
+      out.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (errBytes >= MAX_STDERR_BYTES) return;
+      errBytes += chunk.length;
+      err.push(chunk);
+    });
+    child.on("error", (e) => finish(null, e));
+    child.on("close", (code) => finish(code));
+    if (o.input !== void 0) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(o.input);
+    }
+  });
+}
+var GitCommandError = class extends Error {
+  constructor(args, result) {
+    const detail = result.stderr.trim().split("\n").filter(Boolean).slice(-1)[0]?.slice(0, 300);
+    super(`git ${args.find((a) => !a.startsWith("-") && !a.includes("=")) ?? args[0]} failed${detail ? `: ${detail}` : result.code !== null ? ` (exit ${result.code})` : ""}`);
+    this.args = args;
+    this.result = result;
+    this.name = "GitCommandError";
+  }
+  args;
+  result;
+};
+async function gitOrThrow(cwd, args, opts = {}) {
+  const r = await git(cwd, args, opts);
+  if (r.aborted) throw opts.signal?.reason ?? new Error("Aborted");
+  if (!r.ok) throw new GitCommandError(args, r);
+  return r.stdout;
+}
+var availability = null;
+function gitAvailable(opts = {}) {
+  if (availability) return availability;
+  const p = git(process.cwd(), ["--version"], { signal: opts.signal }).then((r) => {
+    if (r.aborted && availability === p) availability = null;
+    return r.ok;
+  });
+  availability = p;
+  return p;
+}
+async function isGitRepo(cwd, opts = {}) {
+  const r = await git(cwd, ["rev-parse", "--is-inside-work-tree"], { signal: opts.signal });
+  return r.ok && r.stdout.trim() === "true";
+}
+var HISTORY_DAYS = 180;
+var HISTORY_MAX_COMMITS = 2e3;
+var AUTHOR_MARK = "";
+async function gitInfo(cwd, opts = {}) {
+  const { signal } = opts;
+  const days = opts.historyDays ?? HISTORY_DAYS;
+  const maxCommits = opts.maxCommits ?? HISTORY_MAX_COMMITS;
+  const run = (args) => git(cwd, args, { signal });
+  const [available, isRepo, branch, head, date, log] = await Promise.all([
+    gitAvailable({ signal }),
+    isGitRepo(cwd, { signal }),
+    run(["rev-parse", "--abbrev-ref", "HEAD"]),
+    run(["rev-parse", "HEAD"]),
+    run(["log", "-1", "--format=%cI"]),
+    run(["log", `--since=${days}.days`, `--max-count=${maxCommits}`, "--no-merges", `--format=${AUTHOR_MARK}%aN`, "--name-only", "--relative", "--", "."])
+  ]);
+  signal?.throwIfAborted();
+  const info = { available, isRepo: false, hotspots: [] };
+  if (!info.available) return info;
+  info.isRepo = isRepo;
+  if (!info.isRepo) return info;
+  if (branch.ok) info.branch = branch.stdout.trim();
+  if (head.ok) info.head = head.stdout.trim();
+  if (date.ok && date.stdout.trim()) info.lastCommitDate = date.stdout.trim();
+  if (log.ok) {
+    const authors = /* @__PURE__ */ new Set();
+    const counts = /* @__PURE__ */ new Map();
+    for (const line of log.stdout.split("\n")) {
+      if (line.startsWith(AUTHOR_MARK)) {
+        authors.add(line.slice(1));
+        continue;
+      }
+      const p = line.trim();
+      if (!p || p === ".athena" || p.startsWith(".athena/")) continue;
+      const dir = p.includes("/") ? p.split("/").slice(0, 2).join("/") : ".";
+      counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    info.contributorCount = authors.size;
+    info.hotspots = [...counts.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).slice(0, 10).map(([path, commits]) => ({ path, commits }));
+  }
+  return info;
+}
+async function workingChanges(cwd, opts = {}) {
+  const [r, prefix] = await Promise.all([git(cwd, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."], { signal: opts.signal }), repoPrefix(cwd, opts)]);
+  if (!r.ok) return null;
+  const out = [];
+  const parts = r.stdout.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    const code = entry.slice(0, 2);
+    const p = entry.slice(3);
+    if (code.includes("R")) {
+      out.push({ path: p, status: "renamed", from: parts[++i] });
+    } else if (code === "??") out.push({ path: p, status: "untracked" });
+    else if (code.includes("D")) out.push({ path: p, status: "deleted" });
+    else if (code.includes("A")) out.push({ path: p, status: "added" });
+    else if (code.includes("M")) out.push({ path: p, status: "modified" });
+    else out.push({ path: p, status: "other" });
+  }
+  return stripPrefix(out, prefix);
+}
+async function repoPrefix(cwd, opts = {}) {
+  const r = await git(cwd, ["rev-parse", "--show-prefix"], { signal: opts.signal });
+  return r.ok ? r.stdout.trim() : "";
+}
+function stripPrefix(files, prefix) {
+  if (!prefix) return files;
+  return files.filter((f) => f.path.startsWith(prefix)).map((f) => ({ ...f, path: f.path.slice(prefix.length), from: f.from?.startsWith(prefix) ? f.from.slice(prefix.length) : f.from }));
+}
+function parseNameStatusZ(stdout) {
+  const out = [];
+  const parts = stdout.split("\0").filter(Boolean);
+  for (let i = 0; i < parts.length; i++) {
+    const code = parts[i];
+    if (code.startsWith("R") || code.startsWith("C")) {
+      const from = parts[++i];
+      const to = parts[++i];
+      if (to === void 0) break;
+      out.push(code.startsWith("R") ? { path: to, status: "renamed", from } : { path: to, status: "added" });
+    } else {
+      const p = parts[++i];
+      if (p === void 0) break;
+      out.push({ path: p, status: code === "A" ? "added" : code === "D" ? "deleted" : code === "M" ? "modified" : "other" });
+    }
+  }
+  return out;
+}
+function isSafeRef(ref) {
+  return /^[A-Za-z0-9][\w./@^~-]{0,119}$/.test(ref);
+}
+async function headMovement(cwd, from, to, limit = 20, opts = {}) {
+  if (!/^[0-9a-f]{7,64}$/i.test(from) || !/^[0-9a-f]{7,64}$/i.test(to)) return null;
+  if (from === to) return { commits: [], diverged: false, truncated: false };
+  const { signal } = opts;
+  const exists = await git(cwd, ["cat-file", "-e", `${from}^{commit}`], { signal });
+  if (!exists.ok) return { commits: [], diverged: true, truncated: false };
+  const [ancestor, log] = await Promise.all([git(cwd, ["merge-base", "--is-ancestor", from, to], { signal }), git(cwd, ["log", `-n${limit + 1}`, "--format=%H%x1f%s", `${from}..${to}`], { signal })]);
+  if (!log.ok) return null;
+  const commits = log.stdout.split("\n").filter(Boolean).map((l) => {
+    const [sha, subject] = l.split("");
+    return { sha, subject: subject ?? "" };
+  });
+  return { commits: commits.slice(0, limit), diverged: !ancestor.ok, truncated: commits.length > limit };
+}
+function parseStatusV2Z(stdout) {
+  const out = [];
+  const parts = stdout.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const rec = parts[i];
+    if (!rec) continue;
+    const kind = rec[0];
+    if (kind === "?" || kind === "!") {
+      out.push({ kind, path: rec.slice(2), submodule: false });
+      continue;
+    }
+    if (kind === "#") continue;
+    if (kind !== "1" && kind !== "2" && kind !== "u") return null;
+    const fields = kind === "1" ? 8 : kind === "2" ? 9 : 10;
+    let at = 0;
+    for (let f = 0; f < fields && at >= 0; f++) at = rec.indexOf(" ", at + 1);
+    if (at < 0) return null;
+    const sub = rec.split(" ", 3)[2] ?? "N...";
+    const entry = { kind, path: rec.slice(at + 1), submodule: sub.startsWith("S") };
+    if (kind === "2") entry.from = parts[++i];
+    out.push(entry);
+  }
+  return out;
+}
+async function statusV2(cwd, opts = {}) {
+  const r = await git(cwd, ["status", "--porcelain=v2", "-z", "--untracked-files=all", "--ignore-submodules=none", "--", "."], { signal: opts.signal });
+  return r.ok ? parseStatusV2Z(r.stdout) : null;
+}
+
+export {
+  git,
+  GitCommandError,
+  gitOrThrow,
+  gitAvailable,
+  isGitRepo,
+  gitInfo,
+  workingChanges,
+  parseNameStatusZ,
+  isSafeRef,
+  headMovement,
+  statusV2
+};
+//# sourceMappingURL=chunk-OLPSEQS5.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

package/dist/chunk-QCC4VJUH.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+// src/core/model/project-model.ts
+import { z as z2 } from "zod";
+
+// src/core/model/fact.ts
+import { z } from "zod";
+var FactStatus = z.enum(["FACT", "DETECTED", "INFERRED", "UNKNOWN"]);
+var Confidence = z.enum(["high", "medium", "low"]);
+var FactSource = z.enum(["code", "config", "filesystem", "git", "developer", "ai"]);
+var Evidence = z.object({
+  /** Repo-relative POSIX path. */
+  file: z.string(),
+  line: z.number().int().positive().optional(),
+  detail: z.string().optional()
+});
+var Provenance = z.object({
+  status: FactStatus,
+  confidence: Confidence,
+  source: FactSource,
+  evidence: z.array(Evidence)
+});
+function detected(source, evidence, confidence = "high") {
+  return { status: "DETECTED", confidence, source, evidence };
+}
+function inferred(source, evidence, confidence = "medium") {
+  return { status: "INFERRED", confidence, source, evidence };
+}
+function fact(source, evidence) {
+  return { status: "FACT", confidence: "high", source, evidence };
+}
+
+// src/core/model/project-model.ts
+var Named = z2.object({ name: z2.string(), provenance: Provenance });
+var Language = z2.object({
+  name: z2.string(),
+  files: z2.number().int(),
+  bytes: z2.number().int()
+});
+var Framework = Named.extend({
+  category: z2.enum(["frontend", "backend", "fullstack", "mobile", "desktop", "orm", "testing", "other"]),
+  version: z2.string().optional(),
+  /** Workspace package root (repo-relative) this belongs to; "." for root. */
+  root: z2.string()
+});
+var Manifest = z2.object({
+  path: z2.string(),
+  ecosystem: z2.string(),
+  name: z2.string().optional(),
+  version: z2.string().optional(),
+  dependencies: z2.array(z2.string()),
+  devDependencies: z2.array(z2.string())
+});
+var WorkspacePackage = z2.object({
+  name: z2.string(),
+  path: z2.string(),
+  kind: z2.enum(["app", "package", "root", "unknown"]),
+  ecosystem: z2.string(),
+  /** Names of other workspace packages this one depends on. */
+  internalDependencies: z2.array(z2.string())
+});
+var Command = z2.object({
+  name: z2.string(),
+  command: z2.string(),
+  source: z2.string(),
+  purpose: z2.enum(["dev", "build", "test", "lint", "format", "start", "migrate", "deploy", "other"])
+});
+var Route = z2.object({
+  method: z2.string(),
+  path: z2.string(),
+  framework: z2.string(),
+  file: z2.string(),
+  line: z2.number().int().optional(),
+  provenance: Provenance
+});
+var DbEntity = z2.object({
+  name: z2.string(),
+  kind: z2.enum(["table", "model", "collection"]),
+  fields: z2.array(z2.object({ name: z2.string(), type: z2.string().optional(), attributes: z2.array(z2.string()) })),
+  indexes: z2.array(z2.string()),
+  relations: z2.array(z2.string()),
+  file: z2.string(),
+  provenance: Provenance
+});
+var Database = Named.extend({ kind: z2.enum(["engine", "orm", "driver", "service"]) });
+var EnvVar = z2.object({
+  name: z2.string(),
+  /** Where the name was seen. Values are NEVER recorded. */
+  references: z2.array(z2.string()),
+  secretLike: z2.boolean()
+});
+var SecretFinding = z2.object({
+  type: z2.string(),
+  file: z2.string(),
+  line: z2.number().int(),
+  /**
+   * Keyed fingerprint (HMAC with the machine-local salt in .athena/local.json, or a
+   * per-process key) — allows dedup without storing the secret. Never a plain hash
+   * of the value, and never written to committed files.
+   */
+  fingerprint: z2.string()
+});
+var CiJob = z2.object({ system: z2.string(), file: z2.string(), name: z2.string(), commands: z2.array(z2.string()) });
+var ContainerService = z2.object({
+  name: z2.string(),
+  image: z2.string().optional(),
+  ports: z2.array(z2.string()),
+  dependsOn: z2.array(z2.string()),
+  file: z2.string()
+});
+var TestInfo = z2.object({
+  frameworks: z2.array(Named),
+  testFileCount: z2.number().int(),
+  testDirs: z2.array(z2.string()),
+  coverageConfigs: z2.array(z2.string()),
+  /** Workspace packages that contain source files but zero detected test files (structural, not coverage). */
+  packagesWithoutTests: z2.array(z2.string())
+});
+var GitInfo = z2.object({
+  available: z2.boolean(),
+  isRepo: z2.boolean(),
+  branch: z2.string().optional(),
+  head: z2.string().optional(),
+  lastCommitDate: z2.string().optional(),
+  contributorCount: z2.number().int().optional(),
+  hotspots: z2.array(z2.object({ path: z2.string(), commits: z2.number().int() }))
+});
+var ProjectModel = z2.object({
+  schemaVersion: z2.literal(1),
+  name: z2.string(),
+  description: z2.string().optional(),
+  root: z2.string(),
+  stats: z2.object({
+    filesScanned: z2.number().int(),
+    skippedBinary: z2.number().int(),
+    skippedLarge: z2.number().int(),
+    skippedUnreadable: z2.number().int()
+  }),
+  topLevelDirs: z2.array(z2.string()),
+  languages: z2.array(Language),
+  manifests: z2.array(Manifest),
+  packageManagers: z2.array(Named),
+  buildSystems: z2.array(Named),
+  workspace: z2.object({
+    isMonorepo: z2.boolean(),
+    tool: z2.string().optional(),
+    packages: z2.array(WorkspacePackage)
+  }),
+  frameworks: z2.array(Framework),
+  entryPoints: z2.array(z2.object({ path: z2.string(), provenance: Provenance })),
+  commands: z2.array(Command),
+  databases: z2.array(Database),
+  dbEntities: z2.array(DbEntity),
+  migrations: z2.array(z2.object({ path: z2.string(), tool: z2.string(), count: z2.number().int() })),
+  routes: z2.array(Route),
+  apiSpecs: z2.array(z2.object({ path: z2.string(), kind: z2.enum(["openapi", "graphql", "grpc"]) })),
+  auth: z2.array(Named.extend({ kind: z2.enum(["library", "provider", "hashing", "middleware", "token"]) })),
+  containers: z2.object({ dockerfiles: z2.array(z2.object({ path: z2.string(), baseImages: z2.array(z2.string()), exposedPorts: z2.array(z2.string()) })), services: z2.array(ContainerService) }),
+  infrastructure: z2.array(Named.extend({ kind: z2.string(), file: z2.string() })),
+  ci: z2.array(CiJob),
+  tests: TestInfo,
+  env: z2.object({ vars: z2.array(EnvVar), envFilesPresent: z2.array(z2.string()) }),
+  security: z2.object({
+    secrets: z2.array(SecretFinding),
+    tooling: z2.array(Named),
+    /** Libraries/middleware relevant to web security controls (helmet, cors, csrf...). */
+    controls: z2.array(Named)
+  }),
+  caching: z2.array(Named),
+  queues: z2.array(Named),
+  observability: z2.array(Named),
+  git: GitInfo,
+  warnings: z2.array(z2.string())
+});
+function emptyModel(name, root) {
+  return {
+    schemaVersion: 1,
+    name,
+    root,
+    stats: { filesScanned: 0, skippedBinary: 0, skippedLarge: 0, skippedUnreadable: 0 },
+    topLevelDirs: [],
+    languages: [],
+    manifests: [],
+    packageManagers: [],
+    buildSystems: [],
+    workspace: { isMonorepo: false, packages: [] },
+    frameworks: [],
+    entryPoints: [],
+    commands: [],
+    databases: [],
+    dbEntities: [],
+    migrations: [],
+    routes: [],
+    apiSpecs: [],
+    auth: [],
+    containers: { dockerfiles: [], services: [] },
+    infrastructure: [],
+    ci: [],
+    tests: { frameworks: [], testFileCount: 0, testDirs: [], coverageConfigs: [], packagesWithoutTests: [] },
+    env: { vars: [], envFilesPresent: [] },
+    security: { secrets: [], tooling: [], controls: [] },
+    caching: [],
+    queues: [],
+    observability: [],
+    git: { available: false, isRepo: false, hotspots: [] },
+    warnings: []
+  };
+}
+
+export {
+  detected,
+  inferred,
+  fact,
+  ProjectModel,
+  emptyModel
+};
+//# sourceMappingURL=chunk-QCC4VJUH.js.map

package/dist/chunk-QLW657NT.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import {
+  readRecentEvents,
+  summarizeSessions
+} from "./chunk-65TSRDQ3.js";
+import {
+  ADAPTERS,
+  applyChanges,
+  resolveAdapters
+} from "./chunk-YRIS7ZS6.js";
+import {
+  athenaDir,
+  readState,
+  writeState
+} from "./chunk-2DY4PUR4.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+
+// src/services/agents.ts
+function resolve(names) {
+  try {
+    return names.length === 1 && names[0] === "all" ? ADAPTERS : resolveAdapters(names);
+  } catch (err) {
+    throw new AthenaError(err.message);
+  }
+}
+async function listAgents(root) {
+  const st = await readState(athenaDir(root));
+  const sessions = summarizeSessions(await readRecentEvents(root, 500));
+  const out = [];
+  for (const a of ADAPTERS) {
+    const presence = await a.detectPresence(root);
+    const s = st.kind === "ok" ? st.state.agents[a.id] : void 0;
+    const checks = s?.configured ? await a.check(root) : [];
+    const hooksInstalled = a.capabilities.hooks && checks.some((c) => c.ok && /hooks installed/i.test(c.message));
+    const mine = sessions.filter((x) => x.agent === a.id);
+    out.push({
+      id: a.id,
+      name: a.displayName,
+      configured: Boolean(s?.configured),
+      configuredAt: s?.configuredAt ?? null,
+      files: s?.files ?? [],
+      detectedInProject: presence.detectedInProject,
+      evidence: presence.evidence,
+      note: a.supportNote,
+      capabilities: a.capabilities,
+      checks,
+      activityObservation: !a.capabilities.hooks ? "unsupported" : hooksInstalled ? "hooks" : "not-configured",
+      lastActivityAt: mine[0]?.lastEventAt ?? null,
+      observedEvents: mine.reduce((n, x) => n + x.events, 0)
+    });
+  }
+  return out;
+}
+async function configureAgents(root, names) {
+  const st = await readState(athenaDir(root));
+  if (st.kind !== "ok") throw new AthenaError("state.json is missing or corrupted.", "Run `athena analyze` first.");
+  const adapters = resolve(names);
+  const results = [];
+  for (const a of adapters) {
+    const planned = await a.plan({ root, projectName: st.state.projectName });
+    await applyChanges(root, planned);
+    st.state.agents[a.id] = { configured: true, files: planned.map((p) => p.path), configuredAt: (/* @__PURE__ */ new Date()).toISOString() };
+    results.push({ id: a.id, files: planned.map((p) => ({ path: p.path, action: p.action })) });
+  }
+  await writeState(athenaDir(root), st.state);
+  return results;
+}
+async function removeAgents(root, names) {
+  const st = await readState(athenaDir(root));
+  const removed = [];
+  const targets = resolve(names);
+  for (const a of targets) {
+    removed.push(...await a.remove(root));
+    if (st.kind === "ok") delete st.state.agents[a.id];
+  }
+  if (st.kind === "ok") {
+    for (const a of ADAPTERS) {
+      const s = st.state.agents[a.id];
+      if (!s?.configured || targets.includes(a) || !s.files.some((f) => removed.includes(f))) continue;
+      const planned = await a.plan({ root, projectName: st.state.projectName });
+      await applyChanges(root, planned.filter((p) => removed.includes(p.path)));
+    }
+    await writeState(athenaDir(root), st.state);
+  }
+  return removed;
+}
+
+export {
+  listAgents,
+  configureAgents,
+  removeAgents
+};
+//# sourceMappingURL=chunk-QLW657NT.js.map