project-athena 0.2.1 → 0.4.0

package/dist/chunk-3XSDI5WF.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import {
+  committedAiWarning
+} from "./chunk-RXNRMIZP.js";
+import {
+  whichExecutable
+} from "./chunk-VSYBC3VY.js";
+import {
+  readRecentEvents
+} from "./chunk-65TSRDQ3.js";
+import {
+  listRules,
+  parseRules
+} from "./chunk-3IS2X2Z7.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-YRIS7ZS6.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-3XSDI5WF.js.map

package/dist/chunk-65TSRDQ3.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import {
+  redact
+} from "./chunk-JCGDR4UV.js";
+import {
+  toPosix
+} from "./chunk-XW3MLHI2.js";
+import {
+  athenaDir
+} from "./chunk-EUPETUWA.js";
+
+// src/services/agent-activity.ts
+import { promises as fs } from "fs";
+import path from "path";
+var ACTIVITY_FILE = ".agent-events.jsonl";
+var ROTATED_ACTIVITY_FILE = ".agent-events.1.jsonl";
+var ROTATE_LOCK = ".agent-events.rotate.lock";
+var MAX_ACTIVITY_BYTES = 512 * 1024;
+function activityFile(root) {
+  return path.join(athenaDir(root), ACTIVITY_FILE);
+}
+function rotatedActivityFile(root) {
+  return path.join(athenaDir(root), ROTATED_ACTIVITY_FILE);
+}
+var MASK = "<redacted>";
+var COMMAND_SECRETS = [
+  // Authorization: Bearer <token> / Basic <b64> (headers, curl -H, etc.)
+  [/(\bauthorization\s*[:=]\s*["']?\s*(?:bearer|basic|token|digest)\s+)[^\s"',;]+/gi, `$1${MASK}`],
+  [/(\bbearer\s+)[A-Za-z0-9._~+/=-]{6,}/gi, `$1${MASK}`],
+  // --password=x, --password x, --passwd "x y"
+  [/(--(?:password|passwd|pass)(?:=|\s+))("[^"]*"|'[^']*'|[^\s"']+)/gi, `$1${MASK}`],
+  // mysql -psecret (attached value; `-p` alone prompts)
+  [/(\b(?:mysql|mysqldump|mysqladmin|mysqlimport|mariadb|mariadb-dump)\b[^|;&\n]*?\s-p)("[^"]*"|'[^']*'|[^\s"']+)/gi, `$1${MASK}`],
+  // scheme://user:password@host
+  [/(\b[a-z][a-z0-9+.-]*:\/\/[^\s:@/]*:)([^\s@/]+)(@)/gi, `$1${MASK}$3`]
+];
+function redactCommandSecrets(text) {
+  let out = text;
+  for (const [re, rep] of COMMAND_SECRETS) out = out.replace(re, rep);
+  return redact(out);
+}
+function sanitizeEvent(root, event) {
+  const rel = (p) => {
+    const abs = path.isAbsolute(p) ? p : path.resolve(root, p);
+    const r = toPosix(path.relative(root, abs));
+    return !r || r.startsWith("..") ? toPosix(p) : r;
+  };
+  const stripRoot = (text) => text.split(`${root}${path.sep}`).join("").split(toPosix(root) + "/").join("");
+  return {
+    ...event,
+    message: redactCommandSecrets(stripRoot(event.message)),
+    command: event.command ? redactCommandSecrets(stripRoot(event.command)) : null,
+    files: event.files.map(rel)
+  };
+}
+async function appendEvent(root, event) {
+  const file = activityFile(root);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.appendFile(file, `${JSON.stringify(sanitizeEvent(root, event))}
+`);
+  await rotateIfNeeded(file);
+}
+async function rotateIfNeeded(file, maxBytes = MAX_ACTIVITY_BYTES) {
+  try {
+    const st = await fs.stat(file);
+    if (st.size < maxBytes) return;
+    const dir = path.dirname(file);
+    const lock = path.join(dir, ROTATE_LOCK);
+    let handle;
+    try {
+      handle = await fs.open(lock, "wx");
+    } catch {
+      const age = await fs.stat(lock).then((l) => Date.now() - l.mtimeMs).catch(() => 0);
+      if (age > 1e4) await fs.rm(lock, { force: true });
+      return;
+    }
+    try {
+      const again = await fs.stat(file).catch(() => null);
+      if (again && again.size >= maxBytes) await fs.rename(file, path.join(dir, ROTATED_ACTIVITY_FILE));
+    } finally {
+      await handle.close();
+      await fs.rm(lock, { force: true });
+    }
+  } catch {
+  }
+}
+function parseEventLines(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const e = JSON.parse(line);
+      if (e && typeof e.id === "string" && typeof e.ts === "string" && typeof e.agent === "string") out.push(e);
+    } catch {
+    }
+  }
+  return out;
+}
+async function readRecentEvents(root, limit = 200) {
+  const current = parseEventLines(await fs.readFile(activityFile(root), "utf8").catch(() => ""));
+  if (current.length >= limit) return current.slice(-limit);
+  const previous = parseEventLines(await fs.readFile(rotatedActivityFile(root), "utf8").catch(() => ""));
+  return [...previous, ...current].slice(-limit);
+}
+function summarizeSessions(events) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const key = `${e.agent}:${e.session ?? "-"}`;
+    const cur = byKey.get(key);
+    byKey.set(key, { agent: e.agent, session: e.session, lastEventAt: e.ts, lastMessage: e.message, events: (cur?.events ?? 0) + 1 });
+  }
+  return [...byKey.values()].sort((a, b) => b.lastEventAt.localeCompare(a.lastEventAt));
+}
+
+export {
+  ACTIVITY_FILE,
+  activityFile,
+  rotatedActivityFile,
+  appendEvent,
+  parseEventLines,
+  readRecentEvents,
+  summarizeSessions
+};
+//# sourceMappingURL=chunk-65TSRDQ3.js.map

package/dist/chunk-673EPYYH.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import {
+  sha256
+} from "./chunk-IQQBAWSM.js";
+
+// src/core/knowledge/managed-blocks.ts
+var START_RE = /<!-- athena:generated:start id=([a-z0-9-]+) hash=([a-f0-9]*) -->\n?/g;
+function blockHash(content) {
+  return sha256(content.trim()).slice(0, 12);
+}
+function renderBlock(section) {
+  const body = section.content.trim();
+  return `<!-- athena:generated:start id=${section.id} hash=${blockHash(body)} -->
+${body}
+<!-- athena:generated:end id=${section.id} -->`;
+}
+function parseBlocks(text) {
+  const blocks = [];
+  START_RE.lastIndex = 0;
+  for (let m = START_RE.exec(text); m; m = START_RE.exec(text)) {
+    const id = m[1];
+    const endMarker = `<!-- athena:generated:end id=${id} -->`;
+    const endIdx = text.indexOf(endMarker, m.index + m[0].length);
+    if (endIdx === -1) continue;
+    blocks.push({ id, hash: m[2], content: text.slice(m.index + m[0].length, endIdx).trim(), start: m.index, end: endIdx + endMarker.length });
+    START_RE.lastIndex = endIdx + endMarker.length;
+  }
+  return blocks;
+}
+function isBlockModified(block) {
+  return blockHash(block.content) !== block.hash;
+}
+function mergeDocument(existing, sections, opts = {}) {
+  const blocks = parseBlocks(existing);
+  const byId = new Map(blocks.map((b) => [b.id, b]));
+  const result = { text: existing, changed: false, preservedModified: [], updated: [], added: [] };
+  const replacements = [];
+  for (const s of sections) {
+    const b = byId.get(s.id);
+    if (!b) continue;
+    if (isBlockModified(b) && !opts.force) {
+      result.preservedModified.push(s.id);
+      continue;
+    }
+    if (b.content === s.content.trim() && !isBlockModified(b)) continue;
+    replacements.push({ start: b.start, end: b.end, text: renderBlock(s) });
+    result.updated.push(s.id);
+  }
+  let text = existing;
+  for (const r of replacements.sort((a, b) => b.start - a.start)) text = text.slice(0, r.start) + r.text + text.slice(r.end);
+  const known = new Set(opts.previouslyKnown ?? []);
+  const toAdd = sections.filter((s) => !byId.has(s.id) && !known.has(s.id));
+  if (toAdd.length) {
+    const insert = toAdd.map((s) => renderBlock(s)).join("\n\n");
+    const marker = opts.insertBefore ? text.indexOf(opts.insertBefore) : -1;
+    text = marker >= 0 ? `${text.slice(0, marker)}${insert}
+
+${text.slice(marker)}` : `${text.replace(/\s*$/, "")}
+
+${insert}
+`;
+    result.added.push(...toAdd.map((s) => s.id));
+  }
+  result.text = text;
+  result.changed = text !== existing;
+  return result;
+}
+var INTEGRATION_START = "<!-- athena:start -->";
+var INTEGRATION_END = "<!-- athena:end -->";
+function upsertIntegrationBlock(existing, body) {
+  const block = `${INTEGRATION_START}
+${body.trim()}
+${INTEGRATION_END}`;
+  if (!existing) return `${block}
+`;
+  const s = existing.indexOf(INTEGRATION_START);
+  const e = existing.indexOf(INTEGRATION_END);
+  if (s !== -1 && e > s) return existing.slice(0, s) + block + existing.slice(e + INTEGRATION_END.length);
+  return `${existing.replace(/\s*$/, "")}
+
+${block}
+`;
+}
+function removeIntegrationBlock(existing) {
+  const s = existing.indexOf(INTEGRATION_START);
+  const e = existing.indexOf(INTEGRATION_END);
+  if (s === -1 || e < s) return existing;
+  const before = existing.slice(0, s).replace(/\s*$/, "");
+  const after = existing.slice(e + INTEGRATION_END.length).replace(/^\s*/, "");
+  const joined = [before, after.replace(/\s*$/, "")].filter(Boolean).join("\n\n");
+  return joined ? `${joined}
+` : "";
+}
+
+export {
+  renderBlock,
+  parseBlocks,
+  isBlockModified,
+  mergeDocument,
+  INTEGRATION_START,
+  INTEGRATION_END,
+  upsertIntegrationBlock,
+  removeIntegrationBlock
+};
+//# sourceMappingURL=chunk-673EPYYH.js.map

package/dist/chunk-7DZK6WSQ.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import {
+  c,
+  dim,
+  isJson,
+  json,
+  line,
+  ok,
+  sym
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import {
+  ADAPTERS
+} from "./chunk-YRIS7ZS6.js";
+import {
+  athenaDir
+} from "./chunk-2DY4PUR4.js";
+import {
+  AthenaError
+} from "./chunk-AD4OZCU2.js";
+
+// src/cli/commands/clean.ts
+import { promises as fs } from "fs";
+import { createInterface } from "readline/promises";
+async function confirm(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${question} ${dim("[y/N]")} `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function cleanCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  if (!opts.yes) {
+    const memory = (await (await import("./memory-VSVNLEJC.js")).memorySummary(root))?.total ?? 0;
+    const memoryNote = memory ? `${memory} project memory ${memory === 1 ? "entry" : "entries"} in .athena/memory/ (shared with your team)` : "";
+    if (!process.stdin.isTTY) throw new AthenaError(`Refusing to delete .athena/${memory ? `, including ${memoryNote},` : ""} without confirmation.`, "Re-run with --yes in non-interactive environments.");
+    line(`This removes ${c.bold(".athena/")} (including rules.md and your Developer Notes)${opts.keepAgents ? "" : " and Athena blocks/files in agent configurations"}.`);
+    if (memory) line(c.yellow(`${sym.warn} It also deletes ${memoryNote}.`));
+    line(dim("If .athena/ is committed to Git you can restore it from history."));
+    if (!await confirm("Continue?")) {
+      line("Cancelled.");
+      return;
+    }
+  }
+  const touched = [];
+  if (!opts.keepAgents) for (const a of ADAPTERS) touched.push(...await a.remove(root));
+  await fs.rm(athenaDir(root), { recursive: true, force: true });
+  if (isJson()) json({ ok: true, removed: [".athena/", ...touched] });
+  else {
+    ok("Removed .athena/");
+    for (const t of touched) ok(`Removed Athena integration from ${t}`);
+  }
+}
+
+export {
+  confirm,
+  cleanCommand
+};
+//# sourceMappingURL=chunk-7DZK6WSQ.js.map

package/dist/chunk-AD4OZCU2.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// src/services/errors.ts
+var EXIT = {
+  OK: 0,
+  ERROR: 1,
+  NOT_AVAILABLE: 2,
+  NOT_INITIALIZED: 3,
+  INTERRUPTED: 130
+};
+var AthenaError = class extends Error {
+  constructor(message, hint, exitCode = EXIT.ERROR, kind, details) {
+    super(message);
+    this.hint = hint;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.name = "AthenaError";
+    this.kind = kind ?? (exitCode === EXIT.NOT_INITIALIZED ? "not-initialized" : "invalid");
+  }
+  hint;
+  exitCode;
+  details;
+  kind;
+};
+var notFound = (message) => new AthenaError(message, void 0, EXIT.ERROR, "not-found");
+var conflict = (message, hint, details) => new AthenaError(message, hint, EXIT.ERROR, "conflict", details);
+
+export {
+  EXIT,
+  AthenaError,
+  notFound,
+  conflict
+};
+//# sourceMappingURL=chunk-AD4OZCU2.js.map

package/dist/chunk-DZDI2HRT.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import {
+  AnalysisScheduler
+} from "./chunk-RVTNSNGK.js";
+import {
+  applySync,
+  needsIndexRefreshOnly
+} from "./chunk-KHMBNT66.js";
+import {
+  readExclude
+} from "./chunk-MPG3IEGB.js";
+import {
+  IgnoreMatcher,
+  factsConfigHash
+} from "./chunk-ELKFRTZT.js";
+import {
+  git
+} from "./chunk-OLPSEQS5.js";
+import {
+  loadConfig
+} from "./chunk-2DY4PUR4.js";
+import {
+  toPosix
+} from "./chunk-XW3MLHI2.js";
+
+// src/services/watch.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { watch as chokidarWatch } from "chokidar";
+async function gitDir(root) {
+  const r = await git(root, ["rev-parse", "--absolute-git-dir"]);
+  return r.ok ? r.stdout.trim() : null;
+}
+async function watchProject(root, opts) {
+  const debounceMs = opts.debounceMs ?? 1500;
+  const maxWaitMs = opts.maxWaitMs ?? 1e4;
+  const { config } = await loadConfig(root);
+  const [matcher, excludeText] = await Promise.all([IgnoreMatcher.load(root, config), readExclude(root)]);
+  const ownScheduler = !opts.scheduler;
+  const scheduler = opts.scheduler ?? new AnalysisScheduler(root);
+  let timer = null;
+  let firstChangeAt = 0;
+  let latest = null;
+  let closed = false;
+  const toRel = (abs) => toPosix(path.relative(root, abs));
+  scheduler.hooks.onStart = (run2) => {
+    if (!closed) opts.onEvent({ type: "planning", paths: run2.paths });
+  };
+  scheduler.hooks.onPlan = async (plan) => {
+    if (closed) return;
+    latest = plan;
+    if (plan.upToDate) {
+      latest = null;
+      if (needsIndexRefreshOnly(plan)) {
+        const result = await applySync(root, plan);
+        opts.onEvent({ type: "refreshed", plan, result });
+      } else {
+        opts.onEvent({ type: "plan", plan });
+      }
+      return;
+    }
+    if (opts.autoApply && !plan.ignored) {
+      const result = await applySync(root, plan);
+      latest = null;
+      opts.onEvent({ type: "applied", plan, result });
+      return;
+    }
+    opts.onEvent({ type: "plan", plan });
+  };
+  const run = async () => {
+    if (closed) return null;
+    firstChangeAt = 0;
+    try {
+      return await scheduler.request({ reason: "watch", supersede: true });
+    } catch (err) {
+      if (!closed && !opts.signal?.aborted && err?.name !== "AbortError") opts.onEvent({ type: "error", error: err });
+      return null;
+    }
+  };
+  const schedule = () => {
+    if (closed) return;
+    const now = Date.now();
+    if (!firstChangeAt) firstChangeAt = now;
+    if (timer) clearTimeout(timer);
+    const wait = Math.max(0, Math.min(debounceMs, firstChangeAt + maxWaitMs - now));
+    timer = setTimeout(() => {
+      timer = null;
+      void run();
+    }, wait);
+  };
+  const onPath = (abs) => {
+    const rel = toRel(abs);
+    if (!rel || rel.startsWith("..")) return;
+    if (rel === ".gitignore" || rel.endsWith("/.gitignore")) {
+      scheduler.setTracking(false);
+      const dir = rel === ".gitignore" ? "" : rel.slice(0, -"/.gitignore".length);
+      void fs.readFile(abs, "utf8").then((text) => matcher.setGitignore(dir, text)).catch(() => matcher.removeGitignore(dir));
+    }
+    scheduler.noteChanges([rel]);
+    opts.onEvent({ type: "changes", paths: [rel] });
+    schedule();
+  };
+  const watcher = chokidarWatch(root, {
+    ignoreInitial: true,
+    persistent: true,
+    followSymlinks: false,
+    ignored: (abs, stats) => {
+      const rel = toRel(abs);
+      if (!rel || rel === ".") return false;
+      if (rel.startsWith("..")) return true;
+      if (rel === ".git" || rel.startsWith(".git/")) return true;
+      if (stats) return matcher.ignores(rel, stats.isDirectory());
+      return matcher.ignores(rel, false) || matcher.ignores(rel, true);
+    }
+  });
+  const ready = new Promise((resolve) => watcher.once("ready", () => resolve()));
+  watcher.on("add", onPath).on("change", onPath).on("unlink", onPath).on("addDir", onPath).on("unlinkDir", onPath);
+  watcher.on("error", (err) => {
+    scheduler.resetBaseline();
+    opts.onEvent({ type: "error", error: err });
+  });
+  let headWatcher = null;
+  const gd = await gitDir(root);
+  let lastHead = null;
+  if (gd) {
+    lastHead = (await git(root, ["rev-parse", "HEAD"])).stdout.trim() || null;
+    headWatcher = chokidarWatch([path.join(gd, "HEAD"), path.join(gd, "refs", "heads")], { ignoreInitial: true, persistent: true, depth: 5 });
+    headWatcher.on("all", () => {
+      void git(root, ["rev-parse", "HEAD"]).then((r) => {
+        const head = r.ok ? r.stdout.trim() : null;
+        if (head && head !== lastHead) {
+          opts.onEvent({ type: "git-head", head: { from: lastHead, to: head } });
+          lastHead = head;
+          schedule();
+        }
+      });
+    });
+    headWatcher.on("error", () => {
+    });
+  }
+  await ready;
+  scheduler.setTracking(true, { configHash: factsConfigHash(config), excludeText });
+  opts.onEvent({ type: "ready" });
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    if (timer) clearTimeout(timer);
+    scheduler.setTracking(false);
+    scheduler.hooks.onStart = void 0;
+    scheduler.hooks.onPlan = void 0;
+    if (ownScheduler) scheduler.close();
+    await Promise.all([watcher.close(), headWatcher?.close()]);
+  };
+  opts.signal?.addEventListener("abort", () => void close(), { once: true });
+  return {
+    planNow: () => {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      return run();
+    },
+    latestPlan: () => latest,
+    close
+  };
+}
+
+export {
+  watchProject
+};
+//# sourceMappingURL=chunk-DZDI2HRT.js.map