agentmash 0.3.0

package/clients/cursor/after_file_edit.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// AgentMash client for Cursor's agent hooks.
+//
+// Cursor is the one non-Claude-Code tool whose extension point is a near-exact
+// analogue of the one AgentMash already uses: `afterFileEdit` hands a spawned
+// process the same JSON-on-stdin shape, with `file_path` and an `edits` array of
+// {old_string, new_string}. So this adapter is the Claude Code PostToolUse hook
+// with a different envelope, and it reports into the same room, with the same
+// identity, under the same reliability contract.
+//
+// Verified against https://cursor.com/docs/hooks — see docs/ADAPTERS.md.
+//
+// One script handles three events, dispatched on `hook_event_name`:
+//   beforeSubmitPrompt → cache the prompt as this conversation's task hint
+//   afterFileEdit      → report the edit
+//   sessionEnd         → close the session out
+//
+// What this does NOT do: warn a Cursor agent before it edits a file a teammate
+// just touched. Cursor has `preToolUse`, but its payload for edit tools and its
+// blocking-response schema are not documented well enough to write against
+// without guessing, and guessing here means a wrong advisory in someone's
+// editor. Reporting is one-directional for now, and that is still the half that
+// makes the room honest.
+
+// Installed next to lib.mjs (see docs/ADAPTERS.md); in this checkout lib.mjs
+// lives in hooks/. Try both rather than keeping a second copy in sync.
+const lib = await import(new URL('./lib.mjs', import.meta.url).href).catch(() =>
+  import(new URL('../../hooks/lib.mjs', import.meta.url).href)
+);
+const {
+  armExitGuard,
+  finish,
+  getDeveloper,
+  getGitBranch,
+  httpJson,
+  loadConfig,
+  parseJson,
+  readSessionCache,
+  readStdin,
+  summarizeChange,
+  toRepoRelative,
+  truncate,
+  writeSessionCache,
+} = lib;
+
+armExitGuard();
+
+async function main() {
+  const input = parseJson(await readStdin());
+  if (!input) return;
+
+  // Cursor can have several roots open at once. The first is the one an edit is
+  // reported against; a file outside it keeps its absolute path, same as always.
+  const projectDir = input.workspace_roots?.[0] || process.cwd();
+  const config = loadConfig(projectDir);
+  if (config.disabled || !config.room) return;
+
+  // `conversation_id` is Cursor's stable per-thread id — the same role Claude
+  // Code's session_id plays, so it becomes one row on the dashboard. It is
+  // documented as a base field on every hook payload, but `sessionEnd` is
+  // documented with a `session_id` of its own: if that is what a given Cursor
+  // build sends, falling back keeps the end on the session it belongs to
+  // instead of ending a phantom `unknown` one and leaving the real one active.
+  const sessionId = input.conversation_id || input.session_id || 'unknown';
+  const cache = readSessionCache(sessionId);
+  const event = input.hook_event_name;
+
+  // The payload carries `user_email` (the Cursor account), but identity has to
+  // match whatever the same person's Claude Code hooks and git commits send, or
+  // one teammate shows up as two. git config user.email is that common value.
+  const developer = getDeveloper(config, projectDir);
+
+  const body = {
+    developer,
+    session_id: sessionId,
+    git_branch: getGitBranch(projectDir),
+    timestamp: new Date().toISOString(),
+  };
+  const post = (extra) =>
+    httpJson('POST', `${config.url}/events`, {
+      room: config.room,
+      timeoutMs: config.reportTimeoutMs,
+      body: { ...body, ...extra },
+    });
+
+  if (event === 'beforeSubmitPrompt') {
+    const hint = truncate(input.prompt || '', 200);
+    if (!hint) return;
+    cache.task_hint = hint;
+    writeSessionCache(sessionId, cache);
+    await post({ event_type: 'prompt', tool: 'beforeSubmitPrompt', task_hint: hint });
+    return;
+  }
+
+  if (event === 'sessionEnd') {
+    await post({ event_type: 'session_end', tool: 'sessionEnd', task_hint: cache.task_hint || null });
+    return;
+  }
+
+  if (event !== 'afterFileEdit' || !input.file_path) return;
+
+  await post({
+    event_type: 'edit',
+    tool: 'afterFileEdit',
+    file_path: toRepoRelative(projectDir, input.file_path),
+    task_hint: cache.task_hint || null,
+    // Cursor's `edits` is shaped exactly like Claude Code's MultiEdit input, so
+    // the same summarizer produces the same "+12/-3 lines, touching X".
+    change_summary: summarizeChange('MultiEdit', { edits: input.edits || [] }),
+  });
+}
+
+main()
+  .catch(() => {})
+  .finally(finish);

package/clients/git/post_commit.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+// AgentMash git client — reports the files a commit touched.
+//
+// This is the half of the team Claude Code hooks cannot see: someone on Cursor,
+// someone in vim, someone who never opens an agent at all. It cannot watch work
+// in progress the way an editor hook can (see docs/ADAPTERS.md for exactly what
+// that costs) — it reports where a person landed, not where they are.
+//
+// Invoked in the background by .git/hooks/post-commit, which has already
+// returned control to git. Same contract as every other client: hard timeouts,
+// no retries, exit 0 whatever happens, never a word on stdout.
+//
+//   node git_post_commit.mjs [repo-root] [commit-ish]
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+// Installed at .claude/agentmash/git_post_commit.mjs, next to lib.mjs; in this
+// checkout it sits in clients/git/ instead. Try both rather than duplicating
+// the config, identity and timeout rules that lib.mjs already owns.
+const lib = await import(new URL('./lib.mjs', import.meta.url).href).catch(() =>
+  import(new URL('../../hooks/lib.mjs', import.meta.url).href)
+);
+const { armExitGuard, finish, getDeveloper, getGitBranch, httpJson, loadConfig, truncate } = lib;
+
+// A commit is many events, so this guard is looser than a hook's — but it still
+// bounds a worker that finds a server which accepts connections and never answers.
+armExitGuard(20_000);
+
+// One commit that renames a directory can touch hundreds of files. Reporting all
+// of them buries the room in noise for no extra signal, so take the first slice
+// and say so.
+const MAX_FILES = 50;
+// Whole-run budget. Past this we stop mid-commit rather than keep a background
+// process alive against a wedged server.
+const TOTAL_BUDGET_MS = 10_000;
+// Reserved out of that budget for the session_end, which is the one event the
+// room cannot do without: skip it and `commit-<sha>` sits in the dashboard as an
+// active session for the next hour, which is exactly the lie PROTOCOL.md §4.1
+// forbids. It is one request, and it is the cheapest one in the batch.
+const SESSION_END_RESERVE_MS = 2_500;
+// One connection per event, closed after each (see lib.mjs), so a 300 ms server
+// costs 300 ms per file when posted serially — 50 files does not fit in the
+// budget on any ordinary network. A small pool does, and five in flight from a
+// background process is nothing for a server that already accepts a whole team.
+const EDIT_CONCURRENCY = 5;
+// Bounded memory of what we have already reported. Enough to cover a long
+// afternoon of rebasing; an amend is caught by the tree hash, not by this list.
+const REMEMBERED_COMMITS = 100;
+
+function git(repo, args) {
+  return execFileSync('git', args, {
+    cwd: repo,
+    timeout: 3000,
+    maxBuffer: 8 * 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'ignore'],
+  }).toString();
+}
+
+/**
+ * Where to keep the "already reported" list. The git directory, because it is
+ * per-repository, survives reboots, and is never committed — this is local
+ * bookkeeping, not something a teammate should receive.
+ */
+function reportedFile(repo) {
+  let dir = '.git';
+  try {
+    dir = git(repo, ['rev-parse', '--git-dir']).trim() || '.git';
+  } catch {
+    // not a repo, or git is missing — the caller already bailed if so
+  }
+  return path.resolve(repo, dir, 'agentmash-reported.json');
+}
+
+function readReported(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!Array.isArray(parsed)) return [];
+    // Entries written before this client remembered trees are bare sha strings.
+    return parsed.map((entry) => (typeof entry === 'string' ? { sha: entry } : entry)).filter(Boolean);
+  } catch {
+    return []; // first commit, or a corrupt file we are about to replace
+  }
+}
+
+/**
+ * The protocol promises no deduplication, so being idempotent over our own
+ * re-runs is our job. post-commit fires again for a cherry-pick, and a
+ * reset-then-recommit can reproduce a sha exactly.
+ *
+ * The tree hash is what catches an amend: `git commit --amend -m ...` mints a
+ * new sha for work already in the room, so a sha-keyed list would report it
+ * twice. Same tree, same files, same work — the cost of this is that a commit
+ * which restores an earlier tree exactly (a revert of a revert) goes unreported,
+ * which is a far rarer event than an amend.
+ */
+function alreadyReported(file, sha, tree) {
+  return readReported(file).some((e) => e.sha === sha || (tree && e.tree === tree));
+}
+
+function rememberReported(file, sha, tree) {
+  try {
+    const list = readReported(file);
+    list.push({ sha, tree });
+    fs.writeFileSync(file, JSON.stringify(list.slice(-REMEMBERED_COMMITS)));
+  } catch {
+    // a read-only .git must not break the commit that just happened
+  }
+}
+
+/** `added removed path` per file. Binary files report "-" for both counts. */
+function changedFiles(repo, sha) {
+  const out = git(repo, ['show', '--numstat', '--format=', '--no-renames', sha]);
+  const files = [];
+  for (const line of out.split('\n')) {
+    const m = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+    if (!m) continue;
+    files.push({ added: m[1], removed: m[2], file: m[3].replace(/\\/g, '/') });
+  }
+  return files;
+}
+
+async function main() {
+  const repo = path.resolve(process.argv[2] || process.cwd());
+  const config = loadConfig(repo);
+  if (config.disabled || !config.room) return;
+
+  let head;
+  try {
+    // sha \n parents \n tree \n committer date \n subject
+    head = git(repo, ['log', '-1', '--format=%H%n%P%n%T%n%cI%n%s', process.argv[3] || 'HEAD']).split('\n');
+  } catch {
+    return; // no commits, no git, shallow weirdness — none of it is our business
+  }
+  const [sha, parents, tree, when, ...subjectParts] = head;
+  if (!sha) return;
+
+  // A merge commit's diff is its whole branch. Reporting it would claim the
+  // merger touched every file on it, which is false and drowns the room.
+  if (parents.trim().split(/\s+/).filter(Boolean).length > 1) return;
+
+  const seen = reportedFile(repo);
+  if (alreadyReported(seen, sha, tree)) return;
+
+  let files;
+  try {
+    files = changedFiles(repo, sha);
+  } catch {
+    return;
+  }
+  if (files.length === 0) return;
+
+  const short = sha.slice(0, 7);
+  const truncated = files.length > MAX_FILES;
+  const reporting = files.slice(0, MAX_FILES);
+
+  const developer = getDeveloper(config, repo);
+  const branch = getGitBranch(repo);
+  const timestamp = when || new Date().toISOString();
+  // The commit is finished the moment we can see it, so it gets its own session
+  // id and is closed out below — leaving it "active" would be a lie the
+  // dashboard repeats for an hour.
+  const sessionId = `commit-${short}`;
+  const subject = truncate(subjectParts.join('\n') || `commit ${short}`, 200);
+
+  const post = (body) =>
+    httpJson('POST', `${config.url}/events`, {
+      room: config.room,
+      timeoutMs: config.reportTimeoutMs,
+      body: { developer, session_id: sessionId, git_branch: branch, task_hint: subject, timestamp, ...body },
+    });
+
+  const editDeadline = Date.now() + TOTAL_BUDGET_MS - SESSION_END_RESERVE_MS;
+  const queue = reporting.slice();
+  const note = truncated ? `, ${files.length} files in this commit` : '';
+  const sendOne = async () => {
+    while (queue.length > 0 && Date.now() < editDeadline) {
+      const f = queue.shift();
+      const scale =
+        f.added === '-' || f.removed === '-' ? 'binary file' : `+${f.added}/-${f.removed} lines`;
+      await post({
+        event_type: 'edit',
+        tool: 'git-commit',
+        file_path: f.file,
+        change_summary: `commit ${short} · ${scale}${note}`,
+      });
+    }
+  };
+
+  try {
+    await Promise.all(
+      Array.from({ length: Math.min(EDIT_CONCURRENCY, queue.length) }, sendOne)
+    );
+  } finally {
+    // Always, even when the edits ran out of budget or threw: a half-reported
+    // commit is a small inaccuracy, an unclosed session is a standing one.
+    await post({ event_type: 'session_end', tool: 'git-commit' });
+    rememberReported(seen, sha, tree);
+  }
+}
+
+main()
+  .catch(() => {})
+  .finally(finish);