@webinson/peer 0.4.5 → 0.4.15

package/README.md

@@ -18,9 +18,19 @@ In a Claude Code thread:
 - `/peer <message>` shares it and passes the message on to the agent as your prompt.
 - `/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.
-- In a shared thread a band above the prompt says `Peer <workspace>` with `/peer stop` to click; after a stop it
-  turns gray with `/peer start`. It is a Claude Code plugin in this package (`mod/`) that `peer install` adds;
-  the desktop app draws it only while you type or a turn runs.
+- A band above the prompt shows the thread's memories (`17 memories`), `Use Elephant` and `Use Jellyfish`, and
+  `● Active` (shared) or `○ Inactive` at the right; hovering a control explains it. The modes decide what memory
+  the thread uses:
+  - **Use Elephant** (shared): your OpenViking memory, recalled with each prompt and saved as the thread goes, on
+    top of Claude Code's own memory. It saves only the turns from the moment it was chosen.
+  - **Inactive** (not shared): Claude Code's own memory alone; OpenViking stays off.
+  - **Use Jellyfish** (shared): no memory at all, neither OpenViking nor Claude Code's own (`MEMORY.md`).
+    `CLAUDE.md` instructions stay.
+
+  Pressing the lit mode again stops sharing (Inactive); pressing either while Inactive shares again. Every thread
+  that is not shared runs without OpenViking. What a thread was already given stays in it after a switch. The
+  band is a Claude Code plugin in this package (`mod/`) that `peer install` adds; the desktop app draws it only
+  while you type or a turn runs.
 - 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

package/bin/peer.mjs

@@ -633,9 +633,196 @@ function addedLines(before, after) {
   return String(after ?? "").split("\n").map((line) => line.trim()).filter((line) => line && !had.has(line) && !line.startsWith("#")).map((line) => line.replace(/^[-*]\s+/, ""));
 }
 
+// A memory's own text as Markdown, for a card that shows it: without the conversation OpenViking quotes under it
+// (`# … ChatLog:`), without its `# Summary` heading and without a first heading that only repeats its name.
+function memoryBody(text, name) {
+  const lines = String(text ?? "").split("\n");
+  const cut = lines.findIndex((line) => /^#+ .*ChatLog/i.test(line.trim()));
+  const kept = (cut >= 0 ? lines.slice(0, cut) : lines).filter((line) => line.trim() !== "# Summary");
+  if (kept[0] && /^# /.test(kept[0]) && kept[0].slice(2).trim().toLowerCase().replace(/[_-]+/g, " ") === String(name).toLowerCase()) kept.shift();
+  return kept.join("\n").replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "").trim().slice(0, 3000);
+}
+
 // Text Claude Code wrote into the turn, not the person: kept by the extraction, flagged so the person sees it.
 const hasSystemText = (text) => /This is how Claude Code surfaces messages|<system-reminder>/.test(String(text ?? ""));
 
+// The thread's own messages as Claude Code keeps them (~/.claude/projects/<project>/<session>.jsonl): the person's
+// prompts with the id their row in the thread has, and when they were sent.
+// What a find in the thread meets, in order: the person's own messages and the agent's written replies, with the
+// Markdown marks a view does not draw taken out, cased alike.
+// Curly quotes count as straight ones and accents as their letters (pamat finds pamäť), as the desktop's find treats them.
+const visible = (text) =>
+  String(text ?? "")
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[\u2018\u2019\u201b\u2032]/g, "'")
+    .replace(/[\u201c\u201d\u201f\u2033]/g, '"')
+    .replace(/[*`#>_~]/g, "")
+    .replace(/\s+/g, " ")
+    .toLowerCase();
+
+function transcriptPrompts(session) {
+  const projects = path.join(CLAUDE, "projects");
+  let file;
+  try {
+    file = fs.readdirSync(projects).map((dir) => path.join(projects, dir, `${session}.jsonl`)).find((f) => fs.existsSync(f));
+  } catch {}
+  if (!file) return [];
+  const prompts = [];
+  const shown = [];
+  for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    // The person's own messages only: not what a skill or a command put in the thread (isMeta), not a command's row.
+    // The agent's replies and the one-line descriptions of its steps are drawn too, and a find meets them.
+    if (row.type === "assistant" && Array.isArray(row.message?.content)) {
+      for (const block of row.message.content) {
+        if (block?.type === "text" && block.text) shown.push(visible(block.text));
+        else if (block?.type === "tool_use" && typeof block.input?.description === "string") shown.push(visible(block.input.description));
+      }
+      continue;
+    }
+    // A command's output (`system`, local_command) is drawn in the thread as well.
+    if (row.type === "system" && typeof row.content === "string") {
+      shown.push(visible(row.content.replace(/<[^>]+>/g, " ")));
+      continue;
+    }
+    if (row.type !== "user" || !row.uuid) continue;
+    const content = row.message?.content;
+    const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter((b) => b?.type === "text").map((b) => b.text).join("\n") : "";
+    // A command's row and its output show in the thread, so they count for a find, but they are not messages.
+    if (row.isMeta || /^\s*<(command-name|local-command)/.test(text)) {
+      if (!row.isMeta || /^\s*<local-command-stdout/.test(text)) shown.push(visible(text.replace(/<[^>]+>/g, " ")));
+      continue;
+    }
+    if (!text) continue;
+    // Pasted text shows as an attachment, so the words a find can meet are the person's own beside it.
+    const own = text.replace(/<pasted_content[^>]*>[\s\S]*?<\/pasted_content[^>]*>/g, "").trim();
+    const keys = [...new Set([promptKey(text), promptKey(own)])].filter(Boolean);
+    if (own) {
+      prompts.push({ id: row.uuid, at: Date.parse(row.timestamp ?? "") || 0, keys, own, shownAt: shown.length });
+      shown.push(visible(own));
+    }
+  }
+  // Each message's find: one of its own lines whole, the one the thread holds the fewest times (the longest of
+  // those), and which match, in the thread's order, is this message. A line, as a find does not match across lines.
+  const count = (needle, upTo = shown.length) => shown.slice(0, upTo).reduce((n, text) => n + text.split(needle).length - 1, 0);
+  for (const prompt of prompts) {
+    const lines = prompt.own.split("\n").map((line) => line.trim().replace(/\s+/g, " ")).filter((line) => visible(line).length >= 3);
+    let best;
+    for (const line of lines) {
+      const times = count(visible(line));
+      if (!best || times < best.times || (times === best.times && line.length > best.line.length)) best = { line, times };
+    }
+    const text = (best?.line ?? findPhrase(prompt.own)).slice(0, 500);
+    prompt.find = { text, match: count(visible(text), prompt.shownAt) + 1 };
+  }
+  return prompts;
+}
+
+// The words a find looks for: the message's first line, at most 60 characters, cut where a word ends.
+function findPhrase(text) {
+  const line = String(text).trim().split("\n")[0].replace(/\s+/g, " ");
+  if (line.length <= 60) return line;
+  const cut = line.slice(0, 60);
+  return cut.slice(0, cut.lastIndexOf(" ") > 30 ? cut.lastIndexOf(" ") : 60);
+}
+
+// One message's text as both sides can match it: its first line, spaces collapsed, cased alike, cut short.
+const promptKey = (text) => String(text ?? "").trim().split("\n")[0].replace(/\s+/g, " ").toLowerCase().slice(0, 80);
+
+// The person's messages a save was made from, in order: OpenViking's copy carries its own ids and the time it was
+// captured, a little after the message was sent.
+async function savedPrompts(ov, archive) {
+  try {
+    const text = await ovRead(ov, `/content/read?uri=${encodeURIComponent(`${archive}/messages.jsonl`)}`);
+    return String(typeof text === "string" ? text : text?.content ?? "")
+      .split("\n")
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter((row) => row?.role === "user")
+      .map((row) => ({ key: promptKey((row.parts ?? []).filter((part) => part.type === "text").map((part) => part.text).join("\n")), at: Date.parse(row.created_at ?? "") || 0 }))
+      .filter((row) => row.key && !row.key.startsWith("<"));
+  } catch {
+    return [];
+  }
+}
+
+// The thread's row for a message OpenViking captured: the latest prompt with the same text sent before the capture.
+function rowFor(prompts, key, capturedAt) {
+  let found;
+  for (const prompt of prompts) if (prompt.keys.includes(key) && (!capturedAt || prompt.at <= capturedAt + 5000)) found = prompt;
+  return found;
+}
+
+// A new memory quotes the message it came from in its ChatLog: `**user [peer=…]**: <the message>`.
+const quotedPrompt = (after) => promptKey(/\*\*user[^*]*\*\*:\s*(.+)/.exec(String(after ?? ""))?.[1] ?? "");
+
+// Where memory went into the thread, as the transcript keeps it: what a hook added at the session's start or with
+// a prompt (OpenViking's <openviking-context>, Peer's <teammates-project-knowledge>), and the agent's own calls of
+// OpenViking's tools. Each under the person's message it came with, where there is one.
+function threadUses(session, prompts) {
+  const projects = path.join(CLAUDE, "projects");
+  let file;
+  try {
+    file = fs.readdirSync(projects).map((dir) => path.join(projects, dir, `${session}.jsonl`)).find((f) => fs.existsSync(f));
+  } catch {}
+  if (!file) return [];
+  const byId = new Map(prompts.map((prompt) => [prompt.id, prompt]));
+  const name = (text) => path.basename(String(text).trim(), ".md").replace(/[_-]+/g, " ");
+  const clean = (text) => plain(String(text).replace(/\*\*/g, "").replace(/`/g, "")).slice(0, 120);
+  const uses = [];
+  let last;
+  for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (byId.has(row.uuid)) last = byId.get(row.uuid);
+    const at = row.timestamp ?? "";
+    const near = (where) => (where === "start" || where === "resume" || !last ? {} : { messageId: last.id, messageText: last.find?.text, messageMatch: last.find?.match });
+    const attachment = row.attachment;
+    if (row.type === "attachment" && attachment?.type === "hook_additional_context") {
+      const text = (attachment.content ?? []).join("\n");
+      const event = String(attachment.hookEvent ?? attachment.hookName ?? "");
+      for (const block of text.matchAll(/<openviking-context([^>]*)>([\s\S]*?)<\/openviking-context>/g)) {
+        const source = /source="(\w+)"/.exec(block[1])?.[1];
+        const where = event.startsWith("SessionStart") ? (source === "resume" ? "resume" : "start") : "prompt";
+        const listed = [...block[2].matchAll(/^\s+- (.+\.md)\s*$/gm)].map((m) => name(m[1]));
+        const recalled = [...block[2].matchAll(/^- \[\S+ \d+%\] (.+)$/gm)].map((m) => (m[1].startsWith("viking://") ? name(m[1]) : clean(m[1])));
+        const items = recalled.length ? recalled : listed;
+        if (items.length) uses.push({ at, where, from: "yours", kind: recalled.length ? "recalled" : "listed", items, ...near(where) });
+      }
+      for (const block of text.matchAll(/<teammates-project-knowledge[^>]*>([\s\S]*?)<\/teammates-project-knowledge>/g)) {
+        const items = [...block[1].matchAll(/^- \[[^\]]+\] (.+)$/gm)].map((m) => clean(m[1]));
+        const where = event.startsWith("SessionStart") ? "start" : "prompt";
+        if (items.length) uses.push({ at, where, from: "team", kind: "recalled", items, ...near(where) });
+      }
+    }
+    // The agent asking OpenViking itself, through its MCP tools (search, find, read, ...).
+    if (row.type === "assistant" && Array.isArray(row.message?.content)) {
+      for (const block of row.message.content) {
+        if (block?.type !== "tool_use" || !/openviking/i.test(String(block.name))) continue;
+        const input = block.input ?? {};
+        const detail = input.query ?? input.pattern ?? input.uri ?? (Array.isArray(input.uris) ? input.uris.join(", ") : "") ?? "";
+        uses.push({ at, where: "tool", from: "yours", kind: String(block.name).split("__").pop(), items: detail ? [clean(String(detail).startsWith("viking://") ? name(detail) : detail)] : [], ...near("tool") });
+      }
+    }
+  }
+  return uses.slice(-200);
+}
+
 async function threadMemories(session) {
   const ov = readJson(OV_CONF);
   if (!ov?.url) return { connected: false, reason: `no OpenViking client config at ${OV_CONF}` };
@@ -644,10 +831,11 @@ async function threadMemories(session) {
   try {
     archives = await ovRead(ov, `/fs/ls?uri=${encodeURIComponent(`${base}/history`)}`);
   } catch (error) {
-    if (/not found|no such|404/i.test(error.message)) return { connected: true, saves: [] };
+    if (/not found|no such|404/i.test(error.message)) return { connected: true, saves: [], uses: threadUses(session, transcriptPrompts(session)) };
     throw error;
   }
   const saves = [];
+  const prompts = transcriptPrompts(session);
   for (const archive of archives.filter((entry) => entry.isDir)) {
     let diff;
     try {
@@ -656,14 +844,35 @@ async function threadMemories(session) {
       continue;
     }
     const ops = diff.operations ?? {};
+    // Which row in the thread each memory belongs to: a new one under the message it quotes (exact); an update or
+    // a removal, which quotes nothing, under the save's last message (only near it).
+    const captured = prompts.length ? await savedPrompts(ov, archive.uri) : [];
+    // An update goes under the save's last message that is the person's own (a skill's or command's text is not).
+    let nearRow;
+    for (const row of [...captured].reverse()) if ((nearRow = rowFor(prompts, row.key, row.at))) break;
+    const quotedRow = (after) => {
+      const key = quotedPrompt(after);
+      const copy = [...captured].reverse().find((row) => row.key === key);
+      return key ? rowFor(prompts, key, copy?.at) : undefined;
+    };
+    // The row's id, and its words as typed: where a surface cannot scroll to the row, its find can look for them.
+    const placed = (row, exact) =>
+      row ? { messageId: row.id, messageText: row.find.text, messageMatch: row.find.match, exact } : nearRow ? { messageId: nearRow.id, messageText: nearRow.find.text, messageMatch: nearRow.find.match, exact: false } : {};
     const items = [
-      ...(ops.adds ?? []).map((op) => ({ change: "added", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.after)], systemText: hasSystemText(op.after) })),
-      ...(ops.updates ?? []).map((op) => ({ change: "updated", type: op.memory_type, name: memoryName(op.uri), lines: addedLines(op.before, op.after), systemText: hasSystemText(op.after) && !hasSystemText(op.before) })),
-      ...(ops.deletes ?? []).map((op) => ({ change: "removed", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.before)], systemText: false })),
+      ...(ops.adds ?? []).map((op) => ({ change: "added", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.after)], systemText: hasSystemText(op.after), ...placed(quotedRow(op.after), true) })),
+      ...(ops.updates ?? []).map((op) => ({ change: "updated", type: op.memory_type, name: memoryName(op.uri), lines: addedLines(op.before, op.after), systemText: hasSystemText(op.after) && !hasSystemText(op.before), ...placed(undefined, false) })),
+      ...(ops.deletes ?? []).map((op) => ({ change: "removed", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.before)], systemText: false, ...placed(undefined, false) })),
     ].map((item) => ({ ...item, name: plain(item.name), lines: item.lines.filter(Boolean).slice(0, 3).map((line) => String(line).replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, 300)) }));
+    // Each memory's text for a card: a new or removed one whole, an update as the lines it added.
+    const bodies = [
+      ...(ops.adds ?? []).map((op) => memoryBody(op.after, memoryName(op.uri))),
+      ...(ops.updates ?? []).map((op) => addedLines(op.before, op.after).slice(0, 12).map((line) => `- ${line}`).join("\n")),
+      ...(ops.deletes ?? []).map((op) => memoryBody(op.before, memoryName(op.uri))),
+    ];
+    items.forEach((item, index) => (item.body = String(bodies[index] ?? "").slice(0, 3000)));
     saves.push({ at: diff.extracted_at ?? archive.modTime, items });
   }
-  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))) };
+  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))), uses: threadUses(session, prompts) };
 }
 
 // ---- team memory: teammates' published project knowledge at the start of a thread ----

package/mod/peer-thread-mark/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-thread-mark",
-  "version": "0.4.11",
+  "version": "0.4.15",
   "description": "Marks a Claude Code thread shared with Peer (/peer) with a band above the prompt, with /peer stop and /peer start; panes for /peer-list, /peer-thread and /peer-all (search your memories)",
   "license": "MIT",
   "types": "./types/index.d.ts"