AgentHub/server/lib/agent-edits.js

/**
 * @file agent-edits.js
 * @description The files a Claude subagent wrote or edited, read from its own
 * transcript (`agent-<id>.jsonl`), so the parent's chat can count them in its
 * turn's "Edited N files" card (issue #86: a skill that hands its work to
 * subagents showed only the parent's own edits). Each file's +/- lines come
 * from the same `patchCounts` the chat uses; a failed call counts nothing; a
 * subagent's own subagents are folded in, `MAX_DEPTH` levels down. The file is
 * read through `readLines` (a member's transcript only as that member's), and
 * the answer is cached by path + size + mtime, so a finished subagent is read
 * once however often its parent's chat is polled.
 * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
 */

const fs = require("node:fs");
const { patchCounts, agentInfo } = require("./transcript-message");
const {
  getSubagentTranscriptPath,
  findSubagentTranscriptPath,
  getSnapshotSubagentTranscriptPath,
} = require("./claude-home");

const EDIT_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
const MAX_DEPTH = 3;
const CACHE_MAX = 500;
// path → { key: "<size>:<mtime>", edits, agents }
const cache = new Map();

/** One transcript's own edits and the subagents it started. */
async function scan(file) {
  const { readLines } = require("./run-as");
  const pending = new Map(); // tool_use id → file path
  const edits = new Map(); // path → { added, removed, counted }
  const agents = [];
  for await (const line of readLines(file)) {
    if (!line.trim()) continue;
    let entry;
    try {
      entry = JSON.parse(line);
    } catch {
      continue;
    }
    const content = entry.message?.content;
    if (!Array.isArray(content)) continue;
    if (entry.type === "assistant") {
      for (const b of content) {
        if (b?.type !== "tool_use" || !EDIT_TOOLS.has(b.name) || !b.id) continue;
        const p = b.input?.file_path ?? b.input?.notebook_path;
        if (typeof p === "string" && p) pending.set(b.id, p);
      }
    } else if (entry.type === "user") {
      for (const b of content) {
        if (b?.type !== "tool_result") continue;
        const agent = agentInfo(entry.toolUseResult);
        if (agent) agents.push(agent.id);
        const p = pending.get(b.tool_use_id);
        if (!p || b.is_error) continue;
        const diff = patchCounts(entry.toolUseResult);
        const f = edits.get(p) ?? { added: 0, removed: 0, counted: false };
        f.added += diff?.added ?? 0;
        f.removed += diff?.removed ?? 0;
        f.counted ||= !!diff;
        edits.set(p, f);
      }
    }
  }
  return { edits, agents };
}

async function scanCached(file) {
  const st = await fs.promises.stat(file);
  const key = `${st.size}:${st.mtimeMs}`;
  const hit = cache.get(file);
  if (hit && hit.key === key) return hit;
  const fresh = { key, ...(await scan(file)) };
  cache.delete(file);
  cache.set(file, fresh);
  if (cache.size > CACHE_MAX) cache.delete(cache.keys().next().value);
  return fresh;
}

const transcriptOf = (sessionId, cwd, agentId) =>
  getSubagentTranscriptPath(sessionId, cwd, agentId) ||
  findSubagentTranscriptPath(sessionId, agentId, null, cwd) ||
  getSnapshotSubagentTranscriptPath(sessionId, agentId);

/**
 * The files subagent `agentId` of session `sessionId` (and its own subagents)
 * changed, as `[{ path, added, removed, counted }]` in first-edit order; an
 * empty list when its transcript cannot be found or read.
 */
async function agentEdits(sessionId, cwd, agentId, depth = 0, seen = new Set()) {
  if (seen.has(agentId)) return [];
  seen.add(agentId);
  let file;
  let got;
  try {
    file = transcriptOf(sessionId, cwd, agentId);
    if (!file) return [];
    got = await scanCached(file);
  } catch {
    return [];
  }
  const out = new Map();
  const add = (p, f) => {
    const o = out.get(p) ?? { added: 0, removed: 0, counted: false };
    o.added += f.added;
    o.removed += f.removed;
    o.counted ||= f.counted;
    out.set(p, o);
  };
  got.edits.forEach((f, p) => add(p, f));
  if (depth < MAX_DEPTH) {
    for (const id of got.agents) {
      for (const f of await agentEdits(sessionId, cwd, id, depth + 1, seen)) add(f.path, f);
    }
  }
  return [...out].map(([path, f]) => ({ path, ...f }));
}

/** Puts `edits` on every Agent/Task result in `messages` (in place). */
async function attachAgentEdits(messages, sessionId, cwd) {
  for (const m of messages) {
    for (const c of m.content ?? []) {
      if (c.type !== "tool_result" || !c.agent?.id || c.is_error) continue;
      const edits = await agentEdits(sessionId, cwd, c.agent.id);
      if (edits.length) c.edits = edits;
    }
  }
}

module.exports = { agentEdits, attachAgentEdits, _cache: cache };