@moreih29/nexus-core 0.13.0 → 0.14.1

package/dist/hooks/agent-bootstrap.js

@@ -0,0 +1,105 @@
+// assets/hooks/agent-bootstrap/handler.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+var CORE_INDEX_SIZE_LIMIT = 2 * 1024;
+function loadValidRoles(cwd) {
+  const agentsDir = join(cwd, "assets/agents");
+  const roles = [];
+  if (existsSync(agentsDir)) {
+    for (const entry of readdirSync(agentsDir, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        roles.push(entry.name);
+    }
+  }
+  return roles;
+}
+function readFirstLine(path) {
+  try {
+    const content = readFileSync(path, "utf-8");
+    const firstNonEmpty = content.split(`
+`).find((l) => l.trim().length > 0) ?? "";
+    return firstNonEmpty.replace(/^#+\s*/, "").slice(0, 80);
+  } catch {
+    return "";
+  }
+}
+function buildCoreIndex(cwd) {
+  const entries = [];
+  for (const sub of [".nexus/memory", ".nexus/context"]) {
+    const absDir = join(cwd, sub);
+    if (!existsSync(absDir))
+      continue;
+    for (const f of readdirSync(absDir, { withFileTypes: true })) {
+      if (!f.isFile() || !f.name.endsWith(".md"))
+        continue;
+      const full = join(absDir, f.name);
+      entries.push({
+        path: `${sub}/${f.name}`,
+        mtime: statSync(full).mtimeMs,
+        line: readFirstLine(full)
+      });
+    }
+  }
+  entries.sort((a, b) => b.mtime - a.mtime);
+  const lines = [];
+  let bytes = 0;
+  for (const e of entries) {
+    const formatted = `- ${e.path}: ${e.line}`;
+    if (bytes + formatted.length + 1 > CORE_INDEX_SIZE_LIMIT)
+      break;
+    lines.push(formatted);
+    bytes += formatted.length + 1;
+  }
+  return lines.length > 0 ? `Available memory/context:
+` + lines.join(`
+`) : "";
+}
+function getResumeCount(cwd, sessionId, agentId) {
+  const trackerPath = join(cwd, ".nexus/state", sessionId, "agent-tracker.json");
+  if (!existsSync(trackerPath))
+    return 0;
+  try {
+    const tracker = JSON.parse(readFileSync(trackerPath, "utf-8"));
+    const entry = Array.isArray(tracker) ? tracker.find((e) => e.agent_id === agentId) : null;
+    return entry?.resume_count ?? 0;
+  } catch {
+    return 0;
+  }
+}
+var handler = async (input) => {
+  if (input.hook_event_name !== "SubagentStart")
+    return;
+  const { cwd, session_id, agent_type, agent_id } = input;
+  const resumeCount = getResumeCount(cwd, session_id, agent_id);
+  if (resumeCount > 0)
+    return;
+  const validRoles = loadValidRoles(cwd);
+  if (!validRoles.includes(agent_type))
+    return;
+  const parts = [];
+  const coreIndex = buildCoreIndex(cwd);
+  if (coreIndex) {
+    parts.push(`<system-notice>
+${coreIndex}
+</system-notice>`);
+  }
+  const rulePath = join(cwd, ".nexus/rules", `${agent_type}.md`);
+  if (existsSync(rulePath)) {
+    const ruleContent = readFileSync(rulePath, "utf-8").trim();
+    if (ruleContent) {
+      parts.push(`<system-notice>
+Custom rule for ${agent_type}:
+${ruleContent}
+</system-notice>`);
+    }
+  }
+  if (parts.length === 0)
+    return;
+  return { additional_context: parts.join(`
+
+`) };
+};
+var handler_default = handler;
+export {
+  handler_default as default
+};

package/dist/hooks/agent-finalize.js

@@ -0,0 +1,164 @@
+// src/shared/json-store.js
+import fs from "node:fs/promises";
+import { constants as fsConstants, appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+var inProcessQueues = new Map;
+async function runWithInProcessLock(filePath, action) {
+  const previous = inProcessQueues.get(filePath) ?? Promise.resolve();
+  let release = () => {};
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const entry = previous.then(() => gate);
+  inProcessQueues.set(filePath, entry);
+  await previous;
+  try {
+    return await action();
+  } finally {
+    release();
+    entry.finally(() => {
+      if (inProcessQueues.get(filePath) === entry) {
+        inProcessQueues.delete(filePath);
+      }
+    });
+  }
+}
+var LOCK_RETRY_INTERVAL_MS = 100;
+var LOCK_MAX_RETRIES = 50;
+var LOCK_STALE_MS = 30000;
+function lockPath(filePath) {
+  return `${filePath}.lock`;
+}
+async function acquireFsLock(filePath) {
+  const lp = lockPath(filePath);
+  for (let attempt = 0;attempt <= LOCK_MAX_RETRIES; attempt++) {
+    try {
+      const fd = await fs.open(lp, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL);
+      await fd.close();
+      return;
+    } catch (err) {
+      const e = err;
+      if (e.code !== "EEXIST")
+        throw err;
+      try {
+        const stat = await fs.stat(lp);
+        const ageMs = Date.now() - stat.mtimeMs;
+        if (ageMs > LOCK_STALE_MS) {
+          await fs.unlink(lp).catch(() => {
+            return;
+          });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (attempt === LOCK_MAX_RETRIES) {
+        throw new Error(`Failed to acquire lock for "${filePath}" after ${LOCK_MAX_RETRIES} retries`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+    }
+  }
+}
+async function releaseFsLock(filePath) {
+  await fs.unlink(lockPath(filePath)).catch(() => {
+    return;
+  });
+}
+async function readJsonFile(filePath, defaultValue) {
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT")
+      return defaultValue;
+    throw err;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return defaultValue;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${randomUUID()}`;
+  await fs.writeFile(tmpPath, JSON.stringify(data, null, 2) + `
+`, "utf8");
+  await fs.rename(tmpPath, filePath);
+}
+async function updateJsonFileLocked(filePath, defaultValue, updater) {
+  return runWithInProcessLock(filePath, async () => {
+    await acquireFsLock(filePath);
+    try {
+      const current = await readJsonFile(filePath, defaultValue);
+      const next = await updater(current);
+      await writeJsonFile(filePath, next);
+      return next;
+    } finally {
+      await releaseFsLock(filePath);
+    }
+  });
+}
+var APPEND_SIZE_WARN_THRESHOLD = 4 * 1024;
+
+// assets/hooks/agent-finalize/handler.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var handler = async (input) => {
+  if (input.hook_event_name !== "SubagentStop")
+    return;
+  const { cwd, session_id, agent_type, agent_id } = input;
+  const lastMessage = (input.last_assistant_message ?? "").slice(0, 500);
+  const sessionDir = join(cwd, ".nexus/state", session_id);
+  const trackerPath = join(sessionDir, "agent-tracker.json");
+  const toolLogPath = join(sessionDir, "tool-log.jsonl");
+  const tasksPath = join(sessionDir, "tasks.json");
+  await updateJsonFileLocked(trackerPath, [], (tracker) => {
+    const entry = tracker.find((e) => e["agent_id"] === agent_id);
+    if (!entry)
+      return tracker;
+    entry["status"] = "completed";
+    entry["stopped_at"] = new Date().toISOString();
+    entry["last_message"] = lastMessage;
+    if (existsSync(toolLogPath)) {
+      const files = new Set;
+      const raw = readFileSync(toolLogPath, "utf-8");
+      for (const line of raw.split(`
+`)) {
+        if (!line.trim())
+          continue;
+        try {
+          const log = JSON.parse(line);
+          if (log["agent_id"] === agent_id && typeof log["file"] === "string") {
+            files.add(log["file"]);
+          }
+        } catch {}
+      }
+      entry["files_touched"] = [...files];
+    }
+    return tracker;
+  });
+  if (!existsSync(tasksPath))
+    return;
+  try {
+    const tasksData = JSON.parse(readFileSync(tasksPath, "utf-8"));
+    const tasks = Array.isArray(tasksData?.["tasks"]) ? tasksData["tasks"] : [];
+    const incomplete = tasks.filter((t) => t["owner"]?.["role"] === agent_type && t["status"] !== "completed");
+    if (incomplete.length === 0)
+      return;
+    const ids = incomplete.map((t) => t["id"]).join(", ");
+    return {
+      additional_context: `<system-notice>
+Subagent "${agent_type}" finished. Tasks still pending with this role: ${ids}. Review status and coordinate remaining subagent delegation.
+</system-notice>`
+    };
+  } catch {
+    return;
+  }
+};
+var handler_default = handler;
+export {
+  handler_default as default
+};

package/dist/hooks/post-tool-telemetry.js

@@ -0,0 +1,55 @@
+// src/shared/json-store.js
+import { constants as fsConstants, appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+var inProcessQueues = new Map;
+var APPEND_SIZE_WARN_THRESHOLD = 4 * 1024;
+function appendJsonLine(filePath, record) {
+  const line = JSON.stringify(record) + `
+`;
+  if (line.length > APPEND_SIZE_WARN_THRESHOLD) {
+    console.error(`[json-store] appendJsonLine line exceeds ${APPEND_SIZE_WARN_THRESHOLD} bytes ` + `(${line.length}) — write may not be atomic on some filesystems. path=${filePath}`);
+  }
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  appendFileSync(filePath, line);
+}
+
+// assets/hooks/post-tool-telemetry/handler.ts
+import { join, resolve, relative } from "node:path";
+var EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "ApplyPatch", "NotebookEdit"]);
+function isWithinMemory(filePath, projectRoot) {
+  const memRoot = resolve(projectRoot, ".nexus/memory");
+  const abs = resolve(filePath);
+  return abs.startsWith(memRoot + "/") || abs === memRoot;
+}
+var handler = async (input) => {
+  if (input.hook_event_name !== "PostToolUse")
+    return;
+  const { cwd, session_id, tool_name, agent_id } = input;
+  const toolInput = input.tool_input ?? {};
+  if (tool_name === "Read") {
+    const filePath = toolInput.file_path;
+    if (filePath && isWithinMemory(filePath, cwd)) {
+      appendJsonLine(join(cwd, ".nexus/memory-access.jsonl"), {
+        path: relative(cwd, resolve(filePath)),
+        accessed_at: new Date().toISOString(),
+        agent: agent_id ?? null
+      });
+    }
+  }
+  if (EDIT_TOOLS.has(tool_name) && agent_id) {
+    const filePath = toolInput.file_path ?? toolInput.notebook_path;
+    if (filePath) {
+      appendJsonLine(join(cwd, ".nexus/state", session_id, "tool-log.jsonl"), {
+        ts: new Date().toISOString(),
+        agent_id,
+        tool: tool_name,
+        file: relative(cwd, resolve(filePath)),
+        status: "ok"
+      });
+    }
+  }
+};
+var handler_default = handler;
+export {
+  handler_default as default
+};