@webinson/peer 0.3.1 → 0.4.0

package/README.md

@@ -17,16 +17,21 @@ 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.
+- 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

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,11 +266,16 @@ 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 (!shared) return;

package/package.json

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