project-athena 0.3.0 → 0.5.0

package/dist/{open-2QSZKKUG.js → open-LJMOB6U2.js}

@@ -1,32 +1,9 @@
 #!/usr/bin/env node
-import {
-  configureAgents,
-  listAgents,
-  removeAgents
-} from "./chunk-JY6BFIJJ.js";
-import {
-  getRelevantContext,
-  graphSummary,
-  refreshGraph
-} from "./chunk-CXUTYCZX.js";
-import {
-  runSecurityScan
-} from "./chunk-LMOFZNTQ.js";
-import {
-  reviewChanges
-} from "./chunk-EF6GHOIN.js";
-import {
-  buildStatus
-} from "./chunk-ZB7LC6FP.js";
 import {
   INSTANCE_FILE,
   findRunningInstance,
   runDoctor
-} from "./chunk-PR53DT7I.js";
-import {
-  aiStatus
-} from "./chunk-RXNRMIZP.js";
-import "./chunk-VSYBC3VY.js";
+} from "./chunk-L2EHJCH4.js";
 import {
   contentHash,
   docAtRevision,
@@ -39,8 +16,39 @@ import {
   rulesUpdate,
   saveDoc,
   searchDocs
-} from "./chunk-LEMPCNAY.js";
-import "./chunk-3IS2X2Z7.js";
+} from "./chunk-56EXAGTM.js";
+import {
+  configureAgents,
+  listAgents,
+  removeAgents
+} from "./chunk-RQKGT2EK.js";
+import {
+  watchProject
+} from "./chunk-6OSQMXUP.js";
+import {
+  AnalysisScheduler
+} from "./chunk-X7EYOAEX.js";
+import {
+  getRelevantContext,
+  graphSummary,
+  refreshGraph
+} from "./chunk-GYQG4Q2N.js";
+import {
+  aiStatus
+} from "./chunk-WUIC65QO.js";
+import {
+  runSecurityScan,
+  saveScan
+} from "./chunk-4IIBVTBS.js";
+import "./chunk-IDODPGTX.js";
+import "./chunk-UMWX4UTK.js";
+import {
+  reviewChanges
+} from "./chunk-C25FDXOO.js";
+import "./chunk-Y6SDMZET.js";
+import {
+  buildStatus
+} from "./chunk-3KFOI2X4.js";
 import {
   ACTIVITY_FILE,
   activityFile,
@@ -48,16 +56,25 @@ import {
   readRecentEvents,
   rotatedActivityFile,
   summarizeSessions
-} from "./chunk-65TSRDQ3.js";
+} from "./chunk-P4TRQMES.js";
 import {
   printHeader
 } from "./chunk-SHKXELUX.js";
 import {
-  watchProject
-} from "./chunk-32PRS2MG.js";
-import {
-  AnalysisScheduler
-} from "./chunk-XB66PZ6Z.js";
+  MEMORY_DIR,
+  MEMORY_FILES,
+  MEMORY_KINDS,
+  MEMORY_STATUSES,
+  addMemory,
+  confirmMemory,
+  forgetMemory,
+  getMemory,
+  listMemory,
+  memoryDir,
+  supersedeMemory,
+  updateMemory
+} from "./chunk-F65QINMR.js";
+import "./chunk-3IS2X2Z7.js";
 import {
   c,
   dim,
@@ -76,28 +93,30 @@ import {
   applySync,
   ignorePlan,
   staleForCheck
-} from "./chunk-TGJUUB44.js";
+} from "./chunk-PZPMWCXS.js";
 import {
   projectSession,
   releaseProjectSession
-} from "./chunk-PDFQ5BFG.js";
+} from "./chunk-GU3ZX2J7.js";
 import "./chunk-GR4DL2VM.js";
 import {
   runPipeline
-} from "./chunk-SJOOXO34.js";
-import {
-  SCAN_FILE,
-  saveScan
-} from "./chunk-PANVPNYF.js";
-import "./chunk-ELKFRTZT.js";
+} from "./chunk-4FETKOY3.js";
 import {
   ATHENA_VERSION
 } from "./chunk-2R6PXY6Z.js";
+import {
+  SCAN_FILE
+} from "./chunk-44EGCEB2.js";
 import "./chunk-PVCIGUIT.js";
-import "./chunk-OLPSEQS5.js";
-import "./chunk-JCGDR4UV.js";
-import "./chunk-2RS6TA3D.js";
+import "./chunk-ELKFRTZT.js";
+import "./chunk-AKOI4VTD.js";
+import "./chunk-SVTEJYMS.js";
+import "./chunk-QCC4VJUH.js";
+import "./chunk-WWQ5NKEC.js";
+import "./chunk-YRIS7ZS6.js";
 import "./chunk-GHFRQAYT.js";
+import "./chunk-INT3IGMQ.js";
 import "./chunk-673EPYYH.js";
 import {
   KNOWLEDGE_DOCS,
@@ -113,7 +132,6 @@ import {
   AthenaError,
   notFound
 } from "./chunk-AD4OZCU2.js";
-import "./chunk-INT3IGMQ.js";
 import "./chunk-XW3MLHI2.js";
 import "./chunk-EUPETUWA.js";
 
@@ -121,8 +139,8 @@ import "./chunk-EUPETUWA.js";
 import { execFile } from "child_process";
 
 // src/server/instance.ts
-import { promises as fs6 } from "fs";
-import path4 from "path";
+import { promises as fs7 } from "fs";
+import path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/server/app.ts
@@ -568,6 +586,111 @@ function registerGraphRoutes({ app, root, events, state }) {
   });
 }
 
+// src/server/routes/memory.ts
+import { promises as fs2 } from "fs";
+import path from "path";
+var memoryWriteKey = (file) => `memory/${file}`;
+var ID = "^m-[a-z0-9]{4,16}$";
+var idParams = { type: "object", required: ["id"], additionalProperties: false, properties: { id: { type: "string", pattern: ID } } };
+var fields = {
+  title: { type: "string", maxLength: 1e3 },
+  details: { type: "string", maxLength: 1e4 },
+  files: { type: "array", maxItems: 50, items: { type: "string", maxLength: 500 } },
+  tags: { type: "array", maxItems: 30, items: { type: "string", maxLength: 100 } },
+  evidence: { type: "string", maxLength: 2e3 }
+};
+function memoryCounts(entries) {
+  return {
+    total: entries.length,
+    unreviewed: entries.filter((e) => e.status === "unreviewed").length,
+    confirmed: entries.filter((e) => e.status === "confirmed").length,
+    superseded: entries.filter((e) => e.status === "superseded").length,
+    stale: entries.filter((e) => e.stale).length,
+    flagged: entries.filter((e) => e.flags.length > 0).length
+  };
+}
+function registerMemoryRoutes({ app, root, events, recentWrites }) {
+  const recordWrites = async () => {
+    for (const file of Object.values(MEMORY_FILES)) {
+      const text = await fs2.readFile(path.join(memoryDir(root), file), "utf8").catch(() => null);
+      if (text !== null) recentWrites.set(memoryWriteKey(file), contentHash(text));
+    }
+  };
+  const changed = async (action, id, message) => {
+    await recordWrites();
+    events.emit({ source: "web-ui", type: "memory.changed", level: "success", message, data: { action, id } });
+  };
+  app.get(
+    "/api/memory",
+    {
+      schema: {
+        querystring: {
+          type: "object",
+          additionalProperties: false,
+          properties: { kind: { type: "string", enum: [...MEMORY_KINDS] }, status: { type: "string", enum: [...MEMORY_STATUSES] }, stale: { type: "string", enum: ["true", "false"] } }
+        }
+      }
+    },
+    async (req) => {
+      const all = await listMemory(root);
+      const { kind, status, stale } = req.query;
+      const entries = all.filter((e) => (!kind || e.kind === kind) && (!status || e.status === status) && (stale === void 0 || e.stale === (stale === "true")));
+      return { entries, counts: memoryCounts(all) };
+    }
+  );
+  app.get("/api/memory/:id", { schema: { params: idParams } }, async (req) => getMemory(root, req.params.id));
+  app.post(
+    "/api/memory",
+    {
+      schema: {
+        body: {
+          type: "object",
+          required: ["kind", "title"],
+          additionalProperties: false,
+          properties: { kind: { type: "string", enum: [...MEMORY_KINDS] }, ...fields, supersedes: { type: "string", pattern: ID } }
+        }
+      }
+    },
+    async (req, reply) => {
+      const entry = await addMemory(root, req.body, "developer");
+      await changed("add", entry.id, `Added memory: ${entry.title}`);
+      return reply.code(201).send(entry);
+    }
+  );
+  app.post("/api/memory/:id/confirm", { schema: { params: idParams } }, async (req) => {
+    const entry = await confirmMemory(root, req.params.id);
+    await changed("confirm", entry.id, `Confirmed memory: ${entry.title}`);
+    return entry;
+  });
+  app.post(
+    "/api/memory/:id/supersede",
+    { schema: { params: idParams, body: { type: "object", required: ["by"], additionalProperties: false, properties: { by: { type: "string", pattern: ID } } } } },
+    async (req) => {
+      const { id } = req.params;
+      const { by } = req.body;
+      await getMemory(root, id);
+      if (id !== by && !(await listMemory(root)).some((e) => e.id === by)) throw new AthenaError(`Cannot supersede ${id}: no memory with id ${by}.`);
+      const entry = await supersedeMemory(root, id, by);
+      await changed("supersede", entry.id, `Memory ${id} superseded by ${by}`);
+      return entry;
+    }
+  );
+  app.patch(
+    "/api/memory/:id",
+    { schema: { params: idParams, body: { type: "object", minProperties: 1, additionalProperties: false, properties: fields } } },
+    async (req) => {
+      const entry = await updateMemory(root, req.params.id, req.body);
+      await changed("edit", entry.id, `Edited memory: ${entry.title}`);
+      return entry;
+    }
+  );
+  app.delete("/api/memory/:id", { schema: { params: idParams } }, async (req) => {
+    await forgetMemory(root, req.params.id);
+    await changed("forget", req.params.id, `Forgot memory ${req.params.id}`);
+    return { ok: true };
+  });
+}
+
 // src/server/routes/review.ts
 function registerReviewRoutes({ app, root, scheduler }) {
   app.get("/api/review", async (req) => {
@@ -711,11 +834,11 @@ function registerSessionRoutes({ app, root, instanceId, getStatus }) {
 }
 
 // src/server/routes/static.ts
-import { promises as fs3 } from "fs";
+import { promises as fs4 } from "fs";
 
 // src/server/static.ts
-import { promises as fs2 } from "fs";
-import path from "path";
+import { promises as fs3 } from "fs";
+import path2 from "path";
 var TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -731,20 +854,20 @@ var TYPES = {
 };
 async function buildAssetMap(webDir) {
   try {
-    await fs2.access(path.join(webDir, "index.html"));
+    await fs3.access(path2.join(webDir, "index.html"));
   } catch {
     return null;
   }
   const map = /* @__PURE__ */ new Map();
   async function walk(dir) {
-    for (const ent of await fs2.readdir(dir, { withFileTypes: true })) {
-      const abs = path.join(dir, ent.name);
+    for (const ent of await fs3.readdir(dir, { withFileTypes: true })) {
+      const abs = path2.join(dir, ent.name);
       if (ent.isDirectory()) await walk(abs);
       else if (ent.isFile()) {
-        const ext = path.extname(ent.name).toLowerCase();
+        const ext = path2.extname(ent.name).toLowerCase();
         const type = TYPES[ext];
         if (!type) continue;
-        const urlPath = `/${path.relative(webDir, abs).split(path.sep).join("/")}`;
+        const urlPath = `/${path2.relative(webDir, abs).split(path2.sep).join("/")}`;
         map.set(urlPath, { abs, type, immutable: urlPath.startsWith("/assets/") });
       }
     }
@@ -763,7 +886,7 @@ function registerStaticRoutes(app, assets) {
   const sendAsset = async (reply, urlPath) => {
     if (!assets) return reply.code(503).type("text/html; charset=utf-8").send(MISSING_UI_HTML);
     const asset = assets.get(urlPath) ?? assets.get("/index.html");
-    const body = await fs3.readFile(asset.abs);
+    const body = await fs4.readFile(asset.abs);
     reply.header("Cache-Control", asset.immutable ? "public, max-age=31536000, immutable" : "no-cache");
     return reply.type(asset.type).send(body);
   };
@@ -785,8 +908,8 @@ function registerStaticRoutes(app, assets) {
 }
 
 // src/server/routes/sync.ts
-import { promises as fs4 } from "fs";
-import path2 from "path";
+import { promises as fs5 } from "fs";
+import path3 from "path";
 function summarizePlan(plan) {
   if (!plan) return null;
   return { ...plan, documents: plan.documents.map(({ diff: _diff, ...rest }) => rest) };
@@ -824,7 +947,7 @@ function registerSyncRoutes(ctx) {
     try {
       const result = await ctx.scheduler.exclusive(() => applySync(root, plan));
       for (const d of plan.documents) {
-        const text = await fs4.readFile(path2.join(athenaDir(root), d.file), "utf8").catch(() => null);
+        const text = await fs5.readFile(path3.join(athenaDir(root), d.file), "utf8").catch(() => null);
         if (text !== null) ctx.recentWrites.set(d.file, contentHash(text));
       }
       state.currentPlan = null;
@@ -950,8 +1073,8 @@ var SseHub = class {
 };
 
 // src/server/watchers.ts
-import { promises as fs5, watch } from "fs";
-import path3 from "path";
+import { promises as fs6, watch } from "fs";
+import path4 from "path";
 function watchKnowledgeDir(ctx, feed) {
   const { events, recentWrites } = ctx;
   let docsWatcher = null;
@@ -974,7 +1097,7 @@ function watchKnowledgeDir(ctx, feed) {
         name,
         setTimeout(async () => {
           pending.delete(name);
-          const text = await fs5.readFile(path3.join(dir, name), "utf8").catch(() => null);
+          const text = await fs6.readFile(path4.join(dir, name), "utf8").catch(() => null);
           const hash = text === null ? null : contentHash(text);
           if (hash && recentWrites.get(name) === hash) return;
           ctx.invalidateStatus();
@@ -992,6 +1115,73 @@ function watchKnowledgeDir(ctx, feed) {
     for (const t of pending.values()) clearTimeout(t);
   };
 }
+var MEMORY_FILE_NAMES = new Set(Object.values(MEMORY_FILES));
+function watchMemoryDir(ctx, debounceMs = 150) {
+  const { events, recentWrites } = ctx;
+  const dir = memoryDir(ctx.root);
+  const pending = /* @__PURE__ */ new Map();
+  let memWatcher = null;
+  let parentWatcher = null;
+  let stopped = false;
+  const onChange = (name) => {
+    clearTimeout(pending.get(name));
+    pending.set(
+      name,
+      setTimeout(async () => {
+        pending.delete(name);
+        const text = await fs6.readFile(path4.join(dir, name), "utf8").catch(() => null);
+        const hash = text === null ? null : contentHash(text);
+        const key = memoryWriteKey(name);
+        if ((recentWrites.get(key) ?? null) === hash) return;
+        if (hash) recentWrites.set(key, hash);
+        else recentWrites.delete(key);
+        if (stopped) return;
+        events.emit({ source: "filesystem", type: "memory.changed", level: "info", message: text === null ? `memory/${name} was deleted on disk` : `memory/${name} changed on disk`, data: { action: "external", file: name } });
+      }, debounceMs)
+    );
+  };
+  const attach = () => {
+    if (memWatcher || stopped) return true;
+    try {
+      memWatcher = watch(dir, { persistent: false }, (_type, filename) => {
+        const name = filename?.toString();
+        if (name && MEMORY_FILE_NAMES.has(name)) onChange(name);
+      });
+      memWatcher.on("error", () => {
+      });
+    } catch {
+      return false;
+    }
+    for (const name of MEMORY_FILE_NAMES) onChange(name);
+    return true;
+  };
+  void Promise.all(
+    [...MEMORY_FILE_NAMES].map(async (name) => {
+      const text = await fs6.readFile(path4.join(dir, name), "utf8").catch(() => null);
+      if (text !== null && !recentWrites.has(memoryWriteKey(name))) recentWrites.set(memoryWriteKey(name), contentHash(text));
+    })
+  ).then(() => {
+    if (stopped || attach()) return;
+    try {
+      parentWatcher = watch(athenaDir(ctx.root), { persistent: false }, (_type, filename) => {
+        if (filename?.toString() === MEMORY_DIR && attach()) {
+          parentWatcher?.close();
+          parentWatcher = null;
+        }
+      });
+      parentWatcher.on("error", () => {
+      });
+    } catch {
+      parentWatcher = null;
+    }
+  });
+  return () => {
+    stopped = true;
+    memWatcher?.close();
+    parentWatcher?.close();
+    for (const t of pending.values()) clearTimeout(t);
+  };
+}
 async function watchProjectFiles(ctx, debounceMs) {
   const { events, state } = ctx;
   try {
@@ -1108,9 +1298,11 @@ async function createServer(opts) {
   registerContextRoutes(ctx);
   registerGraphRoutes(ctx);
   registerActivityRoutes(ctx);
+  registerMemoryRoutes(ctx);
   registerEventRoutes(app, hub);
   registerStaticRoutes(app, assets);
   const stopDocsWatcher = watchKnowledgeDir(ctx, feed);
+  const stopMemoryWatcher = watchMemoryDir(ctx, opts.watchDebounceMs === void 0 ? void 0 : Math.min(opts.watchDebounceMs, 150));
   await feed.seed();
   if (opts.watch) await watchProjectFiles(ctx, opts.watchDebounceMs);
   return {
@@ -1123,6 +1315,7 @@ async function createServer(opts) {
       ctx.state.watcher = null;
       ctx.scheduler.close();
       stopDocsWatcher();
+      stopMemoryWatcher();
       events.close();
       await app.close();
       hub.close();
@@ -1151,8 +1344,8 @@ async function findAvailablePort(host, start = DEFAULT_PORT, attempts = 100) {
 
 // src/server/instance.ts
 function defaultWebDir() {
-  const here = path4.dirname(fileURLToPath(import.meta.url));
-  return path4.basename(here) === "dist" ? path4.join(here, "web") : path4.resolve(here, "../../dist/web");
+  const here = path5.dirname(fileURLToPath(import.meta.url));
+  return path5.basename(here) === "dist" ? path5.join(here, "web") : path5.resolve(here, "../../dist/web");
 }
 function browserUrl(info) {
   const host = info.host.includes(":") ? `[${info.host}]` : info.host;
@@ -1168,8 +1361,8 @@ async function startServer(opts) {
   const server = await createServer({ root: opts.root, token, host, port, webDir: opts.webDir ?? defaultWebDir(), allowRemote: opts.allowRemote, watch: opts.watch ?? true });
   await server.app.listen({ host, port });
   const info = { pid: process.pid, host, port, instanceId: server.instanceId, token, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  const file = path4.join(athenaDir(opts.root), INSTANCE_FILE);
-  await fs6.writeFile(file, `${JSON.stringify(info, null, 2)}
+  const file = path5.join(athenaDir(opts.root), INSTANCE_FILE);
+  await fs7.writeFile(file, `${JSON.stringify(info, null, 2)}
 `, { mode: 384 });
   await ensureGitignored(opts.root, INSTANCE_FILE);
   return {
@@ -1178,16 +1371,16 @@ async function startServer(opts) {
     url: browserUrl(info),
     async close() {
       const current = await readTextIfExists(file);
-      if (current && current.includes(server.instanceId)) await fs6.rm(file, { force: true });
+      if (current && current.includes(server.instanceId)) await fs7.rm(file, { force: true });
       await server.close();
     }
   };
 }
 async function ensureGitignored(root, entry) {
-  const file = path4.join(athenaDir(root), ".gitignore");
+  const file = path5.join(athenaDir(root), ".gitignore");
   const text = await readTextIfExists(file) ?? "";
   if (text.split(/\r?\n/).includes(entry)) return;
-  await fs6.writeFile(file, `${text}${text.endsWith("\n") || !text ? "" : "\n"}${entry}
+  await fs7.writeFile(file, `${text}${text.endsWith("\n") || !text ? "" : "\n"}${entry}
 `);
 }
 
@@ -1256,4 +1449,4 @@ export {
   openBrowser,
   openCommand
 };
-//# sourceMappingURL=open-2QSZKKUG.js.map
+//# sourceMappingURL=open-LJMOB6U2.js.map