project-athena 0.2.0 → 0.3.0

package/dist/chunk-32PRS2MG.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import {
+  AnalysisScheduler
+} from "./chunk-XB66PZ6Z.js";
+import {
+  applySync,
+  needsIndexRefreshOnly
+} from "./chunk-TGJUUB44.js";
+import {
+  readExclude
+} from "./chunk-PANVPNYF.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-32PRS2MG.js.map

package/dist/chunk-3IS2X2Z7.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+// src/core/knowledge/rules.ts
+var RULE_RE = /^([-*+])\s+(?:\[(disabled)\]\s+)?(.+?)\s*$/;
+var SECTION_RE = /^##\s+(.+?)\s*#*\s*$/;
+var DISABLED_PREFIX = "[disabled]";
+function parseRules(text) {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const lines = [];
+  let section = "General";
+  let inFence = false;
+  const raw = text.split(/\r?\n/);
+  if (raw.length && raw[raw.length - 1] === "") raw.pop();
+  for (const l of raw) {
+    if (/^\s*(```|~~~)/.test(l)) inFence = !inFence;
+    const sm = !inFence ? SECTION_RE.exec(l) : null;
+    if (sm) section = sm[1];
+    const rm = !inFence ? RULE_RE.exec(l) : null;
+    if (rm && !/^\[[ xX]\]/.test(rm[3])) {
+      lines.push({ kind: "rule", section, text: rm[3], enabled: rm[2] !== "disabled", bullet: rm[1] });
+    } else {
+      lines.push({ kind: "other", raw: l });
+    }
+  }
+  return { lines, eol };
+}
+function serializeRules(doc) {
+  return doc.lines.map((l) => l.kind === "other" ? l.raw : `${l.bullet} ${l.enabled ? "" : `${DISABLED_PREFIX} `}${l.text}`).join(doc.eol) + doc.eol;
+}
+function listRules(doc) {
+  const out = [];
+  for (const l of doc.lines) if (l.kind === "rule") out.push({ index: out.length + 1, section: l.section, text: l.text, enabled: l.enabled });
+  return out;
+}
+function ruleAt(doc, index) {
+  let n = 0;
+  for (const l of doc.lines) if (l.kind === "rule" && ++n === index) return l;
+  throw new RangeError(`No rule #${index} (there are ${n} rules)`);
+}
+function validateRuleText(text) {
+  const t = text.replace(/[\r\n]+/g, " ").trim();
+  if (!t) throw new Error("Rule text cannot be empty");
+  if (t.length > 1e3) throw new Error("Rule text is too long (max 1000 characters)");
+  return t;
+}
+function addRule(doc, section, text) {
+  const clean = validateRuleText(text);
+  const sec = section.replace(/[\r\n#]+/g, " ").trim() || "General";
+  const lines = [...doc.lines];
+  let lastRuleIdx = -1;
+  let headingIdx = -1;
+  lines.forEach((l, i) => {
+    if (l.kind === "other" && SECTION_RE.exec(l.raw)?.[1]?.toLowerCase() === sec.toLowerCase()) headingIdx = i;
+    if (l.kind === "rule" && l.section.toLowerCase() === sec.toLowerCase()) lastRuleIdx = i;
+  });
+  const existingSection = headingIdx >= 0 ? SECTION_RE.exec(lines[headingIdx].raw)?.[1] ?? sec : sec;
+  const rule = { kind: "rule", section: existingSection, text: clean, enabled: true, bullet: "-" };
+  if (lastRuleIdx >= 0) lines.splice(lastRuleIdx + 1, 0, rule);
+  else if (headingIdx >= 0) {
+    let at = headingIdx + 1;
+    while (at < lines.length && lines[at].kind === "other" && lines[at].raw.trim() === "") at++;
+    lines.splice(at, 0, rule);
+  } else {
+    while (lines.length && lines[lines.length - 1].kind === "other" && lines[lines.length - 1].raw.trim() === "") lines.pop();
+    lines.push({ kind: "other", raw: "" }, { kind: "other", raw: `## ${sec}` }, { kind: "other", raw: "" }, rule);
+  }
+  return { ...doc, lines };
+}
+function updateRule(doc, index, patch) {
+  const target = ruleAt(doc, index);
+  return {
+    ...doc,
+    lines: doc.lines.map((l) => l === target ? { ...target, ...patch.text !== void 0 ? { text: validateRuleText(patch.text) } : {}, ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {} } : l)
+  };
+}
+function removeRule(doc, index) {
+  const target = ruleAt(doc, index);
+  return { ...doc, lines: doc.lines.filter((l) => l !== target) };
+}
+
+export {
+  parseRules,
+  serializeRules,
+  listRules,
+  addRule,
+  updateRule,
+  removeRule
+};
+//# sourceMappingURL=chunk-3IS2X2Z7.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-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