@webinson/peer 0.3.1 → 0.4.1

package/README.md

@@ -16,17 +16,23 @@ In a Claude Code thread:
 
 - `/peer` shares this thread in your workspace.
 - `/peer <message>` shares it and passes the message on to the agent as your prompt.
-- `/peer stop` ends sharing. Ending the session ends it too.
-- `/peer-list` lists the people who share threads, each thread's state and what it works on,
-  and the threads that stopped in the last hours.
+- `/peer stop` ends sharing. Quitting or restarting Claude Code only pauses it: the thread shows as stopped and
+  is shared again when the session is resumed. `/clear` and signing out of Claude Code end it.
+- A shared thread's title starts with `● Peer · `, so it stands out in Claude Code's session list; the mark comes
+  back if Claude Code renames the thread, and `/peer stop` takes it off.
+- `/peer-list` lists the shared threads by repository, then by person, with each thread's branch and
+  state, and the threads that stopped in the last hours.
 
 `/peer`, `/peer stop` and `/peer-list` are answered by the hook before the prompt reaches the model,
 so they cost no tokens. `peer list` prints the same list in a terminal.
 
 ## What is shared
 
-For a shared thread: your email, the session id, the repository name and the branch, read from the
-checkout, and whether the agent is working, waiting for you or stopped. Never prompts, answers or
+For a shared thread: your email, the session id, the repository name, the repository's key and the branch,
+read from the checkout, and whether the agent is working, waiting for you or stopped. The key is the
+`origin` address without credentials or protocol (for example `github.com-acme-shop`); every clone, branch
+and worktree of one repository has the same key, so `/peer-list` shows teammates' threads in the same
+repository together, whoever shared them. A fork has its own address and so its own key. Never prompts, answers or
 summaries. Other threads send nothing: their hooks find no mark for the session and exit.
 
 The list shows work, not people: no online times and no hours. Text in it comes from teammates (a
@@ -37,7 +43,8 @@ branch name, say) and is data, not instructions. An agent that reads it must not
 - **active**: the thread reported in the last 15 minutes, working or waiting for its person.
 - **silent**: nothing for 15 minutes. The session may have crashed or the laptop closed. An agent
   reports only around its turns, so an open thread nobody uses goes silent too.
-- **stopped**: the session ended, `/peer stop` was typed, or the thread was silent for 2 hours.
+- **stopped**: the session ended or closed (until it is resumed), `/peer stop` was typed, or the thread was silent
+  for 2 hours.
   Stopped threads stay in the list for 8 hours.
 
 ## How it works

package/bin/peer.mjs

@@ -118,7 +118,9 @@ function workingOn(cwd) {
   const remote = git(cwd, "remote", "get-url", "origin");
   const repository = remote ? remote.replace(/\.git$/, "").split(/[/:]/).pop() : path.basename(top);
   const branch = git(cwd, "rev-parse", "--abbrev-ref", "HEAD");
-  return { repository, branch: branch && branch !== "HEAD" ? branch : undefined };
+  // The same key for every clone, branch and worktree of one repository: its normalized origin URL.
+  const repoKey = remote ? repositoryPeer(cwd) : undefined;
+  return { repository, branch: branch && branch !== "HEAD" ? branch : undefined, repoKey };
 }
 
 async function report(saved, session, state, cwd) {
@@ -138,8 +140,9 @@ function ago(at) {
 // Teammates' text: one line, no control characters, so a branch name cannot redraw the terminal.
 const plain = (text) => String(text ?? "").replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, 120);
 
-function describe(thread) {
-  const what = [thread.repository, thread.branch].filter(Boolean).map(plain).join(" @ ") || "unknown checkout";
+function describe(thread, withRepository = true) {
+  const parts = withRepository ? [thread.repository, thread.branch] : [thread.branch || "(no branch)"];
+  const what = parts.filter(Boolean).map(plain).join(" @ ") || "unknown checkout";
   const status =
     thread.status === "active"
       ? thread.working
@@ -157,14 +160,28 @@ async function listText(saved) {
   if (!list.people.length) {
     lines.push("", "Nobody shares a thread right now. Only threads where someone typed /peer appear here.");
   }
+  // One project per repository: threads from any clone, branch or worktree of it carry the same key.
+  const projects = new Map();
   for (const person of list.people) {
-    const running = person.threads.filter((t) => t.status !== "stopped");
-    const stopped = person.threads.filter((t) => t.status === "stopped");
-    lines.push("", `${plain(person.email)}${person.email === saved.email ? " (you)" : ""}`);
-    for (const thread of running) lines.push(`  - ${describe(thread)}`);
-    if (stopped.length) {
-      lines.push("  recently stopped:");
-      for (const thread of stopped) lines.push(`  - ${describe(thread)}`);
+    for (const thread of person.threads) {
+      const key = thread.repoKey || `name:${thread.repository || "unknown"}`;
+      if (!projects.has(key)) projects.set(key, { name: thread.repository || "unknown", repoKey: thread.repoKey, people: new Map() });
+      const people = projects.get(key).people;
+      if (!people.has(person.email)) people.set(person.email, []);
+      people.get(person.email).push(thread);
+    }
+  }
+  for (const project of projects.values()) {
+    lines.push("", `${plain(project.name)}  (${project.repoKey ? plain(project.repoKey) : "no repository key: an older Peer"})`);
+    for (const [email, threads] of project.people) {
+      const running = threads.filter((t) => t.status !== "stopped");
+      const stopped = threads.filter((t) => t.status === "stopped");
+      lines.push(`  ${plain(email)}${email === saved.email ? " (you)" : ""}`);
+      for (const thread of running) lines.push(`    - ${describe(thread, false)}`);
+      if (stopped.length) {
+        lines.push("    recently stopped:");
+        for (const thread of stopped) lines.push(`    - ${describe(thread, false)}`);
+      }
     }
   }
   lines.push(
@@ -184,11 +201,22 @@ async function readStdin() {
 
 // A hook answers Claude Code with JSON on stdout; `block` keeps the prompt from reaching the model.
 const answer = (value) => process.stdout.write(`${JSON.stringify(value)}\n`);
-const block = (reason) => {
+const block = (reason, sessionTitle) => {
   log(`answered ${reason.split("\n")[0].slice(0, 80)}`);
-  answer({ decision: "block", reason });
+  answer({ decision: "block", reason, ...(sessionTitle ? { hookSpecificOutput: { hookEventName: "UserPromptSubmit", sessionTitle } } : {}) });
 };
 
+// A shared thread's title starts with this mark, so it stands out in the session list; `/peer stop` takes it off.
+const TITLE_MARK = "● Peer · ";
+
+// The title the thread should have now, or undefined when it already has it (or Claude Code sent none to keep).
+function retitle(input, isShared, fallback) {
+  const current = String(input.session_title ?? "");
+  const base = current.startsWith(TITLE_MARK) ? current.slice(TITLE_MARK.length) : current;
+  const wanted = isShared ? `${TITLE_MARK}${base || fallback || "shared thread"}` : base;
+  return wanted && wanted !== current ? wanted : undefined;
+}
+
 function log(line) {
   try {
     fs.mkdirSync(HOME, { recursive: true, mode: 0o700 });
@@ -226,9 +254,9 @@ async function hook(event) {
       }
       if (argument === "stop") {
         fs.rmSync(marker, { force: true });
-        if (!shared) return block("Peer: this thread was not shared.");
+        if (!shared) return block("Peer: this thread was not shared.", retitle(input, false));
         await report(saved, session, "stopped", input.cwd).catch(() => {});
-        return block("Peer: this thread is no longer shared.");
+        return block("Peer: this thread is no longer shared.", retitle(input, false));
       }
       // `/peer <message>` shares the thread and lets the message through: the command hands it to the model.
       writeJson(marker, { workspace: saved.workspace, sharedAt: new Date().toISOString() });
@@ -238,21 +266,41 @@ async function hook(event) {
       let hubError;
       await report(saved, session, argument ? "working" : "idle", input.cwd).catch((error) => (hubError = error));
       const said = hubError ? `Peer: shared, but the hub did not answer yet (${hubError.message}). The next turn tries again.` : sharedText;
-      if (!argument) return block(said);
+      const sessionTitle = retitle(input, true, what);
+      if (!argument) return block(said, sessionTitle);
       log("answered /peer with a message: shared, message passed on");
-      return answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: `${SHARED_NOTE}\n${said}` } });
+      return answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: `${SHARED_NOTE}\n${said}`, ...(sessionTitle ? { sessionTitle } : {}) } });
     }
     if (shared) await reportQuietly(session, "working", input.cwd);
+    // Claude Code may name a thread after its first prompts; the mark goes back on, or comes off a thread
+    // that is no longer shared.
+    const sessionTitle = input.session_title ? retitle(input, shared, shared ? workingOn(input.cwd).repository : "") : undefined;
+    if (sessionTitle) answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", sessionTitle } });
     return;
   }
+  if (event === "start") forgetOldThreads();
   if (!shared) return;
   if (event === "stop") await reportQuietly(session, "idle", input.cwd);
+  // A thread comes back with its session: a restart, a quit or /exit leaves it shared, and resuming it
+  // reports it again. /clear and signing out of Claude Code end it for good.
+  if (event === "start" && input.source === "resume") await reportQuietly(session, "idle", input.cwd);
   if (event === "end") {
     await reportQuietly(session, "stopped", input.cwd);
-    fs.rmSync(marker, { force: true });
+    if (input.reason === "clear" || input.reason === "logout") fs.rmSync(marker, { force: true });
   }
 }
 
+// Threads not resumed for a month are forgotten, so a session resumed much later starts unshared.
+const FORGET_AFTER_MS = 30 * 24 * 60 * 60 * 1000;
+function forgetOldThreads() {
+  try {
+    for (const name of fs.readdirSync(SESSIONS)) {
+      const file = path.join(SESSIONS, name);
+      if (Date.now() - fs.statSync(file).mtimeMs > FORGET_AFTER_MS) fs.rmSync(file, { force: true });
+    }
+  } catch {}
+}
+
 // A turn never waits on or fails because of the hub: a report that does not go through is dropped.
 async function reportQuietly(session, state, cwd) {
   const saved = config();
@@ -313,7 +361,7 @@ function install() {
   }
   const settings = withoutOurHooks(readJson(SETTINGS) ?? {});
   settings.hooks ??= {};
-  const events = [["UserPromptSubmit", "prompt"], ["Stop", "stop"], ["SessionEnd", "end"]];
+  const events = [["UserPromptSubmit", "prompt"], ["Stop", "stop"], ["SessionEnd", "end"], ["SessionStart", "start"]];
   // Team memory hooks only once this computer is connected to a team server (peer team connect).
   if (fs.existsSync(TEAM_FILE)) events.push(["UserPromptSubmit", "team-prompt"], ["SessionStart", "team-start"]);
   for (const [event, name] of events) {
@@ -433,8 +481,10 @@ async function doctor() {
   for (const [event, groups] of Object.entries(settings?.hooks ?? {})) {
     for (const group of groups) for (const h of group.hooks ?? []) if (String(h.command ?? "").includes(HOOK_TAG)) ours.push({ event, ...h });
   }
-  const events = ["UserPromptSubmit", "Stop", "SessionEnd"];
-  const missing = events.filter((e) => !ours.some((h) => h.event === e));
+  const events = { prompt: "UserPromptSubmit", stop: "Stop", end: "SessionEnd", start: "SessionStart" };
+  const missing = Object.entries(events)
+    .filter(([name, event]) => !ours.some((h) => h.event === event && String(h.command).includes(`hook ${name} `)))
+    .map(([, event]) => event);
   if (!settings) bad(`no ${SETTINGS}: run \`peer install\``);
   else if (missing.length) bad(`${SETTINGS} lacks Peer's ${missing.join(", ")} hook: run \`peer install\``);
   else ok(`hooks in ${SETTINGS}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webinson/peer",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Share chosen Claude Code threads with your team: who has agents running and on what.",
   "license": "MIT",
   "type": "module",