@webinson/peer 0.4.2 → 0.4.5

package/mod/peer-thread-mark/tests/all.test.tsx

@@ -0,0 +1,107 @@
+import { expect, test } from 'claude-code/testing'
+
+const PANE = {
+  plugin: 'peer-thread-mark',
+  component: 'Pane',
+  requestId: 'peer-all-memories',
+  props: { title: 'Your memory', isFocused: false, bodyColumns: 44, placement: 'dock', scroll: { offset: 0, bodyRows: 40 }, view: {} },
+} as const
+
+const row = (n: number) => ({
+  uri: `viking://user/ana/peers/github.com-acme-shop/memories/events/day_${n}.md`,
+  repo: 'github.com-acme-shop',
+  type: 'events',
+  title: `day ${n}`,
+  at: '2026-11-03',
+  lines: n === 1 ? ['The batch limit is 100.'] : [],
+})
+
+test('the search pane lists, searches on Enter, keeps to the repository and pages', async ($, on) => {
+  const settings = { hooks: { UserPromptSubmit: [{ hooks: [{ command: '"/n/node" "/p/peer.mjs" hook prompt # peer-hook' }] }] } }
+  const runs: { argv: string[]; cwd?: string }[] = []
+  on('env.get', (_, e) => ({ value: (e as { name?: string }).name === 'PWD' ? '/work/shop' : '/home' }) as never)
+  on('fs.read', (_, e) => ({ value: String((e as { path?: string }).path ?? '').endsWith('settings.json') ? JSON.stringify(settings) : (() => { throw new Error('none') })() }) as never)
+  on('process.run', (_, e) => {
+    const { argv, init } = e as { argv: string[]; init?: { cwd?: string } }
+    runs.push({ argv, cwd: init?.cwd })
+    const page = Number(argv[argv.indexOf('page') + 1])
+    const text = argv.slice(argv.indexOf('--json') + 1).filter(w => !w.startsWith('--')).slice(0, -2).join(' ')
+    const found = text
+      ? { connected: true, url: 'http://127.0.0.1:1933', repo: argv.includes('--here') ? 'github.com-acme-shop' : '', total: 1, page: 1, pages: 1, rows: [row(1)] }
+      : { connected: true, url: 'http://127.0.0.1:1933', repo: '', total: 23, page, pages: 2, rows: page === 1 ? [row(23), row(22)] : [row(3)] }
+    return { value: { stdout: JSON.stringify(found), stderr: '', exitCode: 0 } } as never
+  })
+  on('session.id', () => ({ value: 's1' }) as never)
+  on('clock.now', () => ({ value: Date.parse('2026-11-10T12:00:00Z') }) as never)
+  on('clock.sleep', () => ({ value: undefined }) as never)
+  on('ui.open', () => ({ value: { isPlaced: true } }) as never)
+  on('command.run', () => ({ text: 'engine' }) as never)
+  let copied = ''
+  on('ui.copy', (_, e) => { copied = (e as { text: string }).text; return { value: { isCopied: true } } as never })
+  on('ui.toast', () => ({ value: undefined }) as never)
+
+  const opened = await $.command.run({ command: 'peer-all', args: '' } as never)
+  expect((opened as { text: string }).text).toContain('in the pane')
+  expect(runs[0]!.argv.slice(2)).toEqual(['all', '--json', 'page', '1'])
+  expect(runs[0]!.cwd).toBe('/work/shop')
+
+  const ui = await $.ui.mount({ ...PANE, surface: 'desktop' })
+  let texts = (await ui.findAll({ type: 'Text' })).map(t => t.text)
+  expect(texts).toContain('Day 23')
+  expect(texts).toContain('23 memories')
+  expect(texts).toContain('1 / 2')
+  expect(texts).not.toContain('Today')
+
+  // Time: unsorted, then newest first, then oldest first, then unsorted again; each press starts at page 1.
+  const sortLabel = async () => (await ui.findAll({ type: 'Button' })).find(b => b.key === 'sort')?.props.label
+  expect(await sortLabel()).toBe('Time')
+  await ui.press({ key: 'sort' } as never)
+  expect(runs.at(-1)!.argv).toContain('--newest')
+  expect(await sortLabel()).toBe('Newest ↓')
+  // Ordered by time, the page falls into days with their counts.
+  expect((await ui.findAll({ type: 'Text' })).map(t => t.text)).toContain('3 Nov')
+  await ui.press({ key: 'sort' } as never)
+  expect(runs.at(-1)!.argv).toContain('--oldest')
+  expect(await sortLabel()).toBe('Oldest ↑')
+  await ui.press({ key: 'sort' } as never)
+  expect(runs.at(-1)!.argv.some(w => w === '--newest' || w === '--oldest')).toBe(false)
+  expect(await sortLabel()).toBe('Time')
+
+  await ui.press({ key: 'next' } as never)
+  expect(runs.at(-1)!.argv.slice(-2)).toEqual(['page', '2'])
+  texts = (await ui.findAll({ type: 'Text' })).map(t => t.text)
+  expect(texts).toContain('Day 3')
+
+  // Typing searches by itself once it pauses: only the last text typed is searched.
+  const before = runs.length
+  await $.ui.input({ plugin: 'peer-thread-mark', key: 'q', text: 'batch li', kind: 'change' })
+  expect(runs.length).toBe(before + 1)
+  expect(runs.at(-1)!.argv.slice(2)).toEqual(['all', '--json', 'batch', 'li', 'page', '1'])
+  await $.ui.input({ plugin: 'peer-thread-mark', key: 'q', text: 'batch limit' })
+  expect(runs.at(-1)!.argv.slice(2)).toEqual(['all', '--json', 'batch', 'limit', 'page', '1'])
+  texts = (await ui.findAll({ type: 'Text' })).map(t => t.text)
+  // The matched line sits under its memory, the searched words drawn bold.
+  expect(texts.some(t => t.includes('limit is 100'))).toBe(true)
+  const bold = (await ui.findAll({ type: 'Text' })).filter(t => t.props.bold === true).map(t => t.text)
+  expect(bold).toContain('batch')
+  expect(bold).toContain('limit')
+
+  await ui.press({ key: 'here' } as never)
+  expect(runs.at(-1)!.argv).toContain('--here')
+  expect(runs.at(-1)!.argv).toContain('batch')
+
+  // A press opens the memory in place; Copy takes its address; a second press closes it.
+  const uri = 'viking://user/ana/peers/github.com-acme-shop/memories/events/day_1.md'
+  await ui.press({ key: uri } as never)
+  await ui.press({ key: `${uri}-copy` } as never)
+  expect(copied).toBe(uri)
+  await ui.press({ key: uri } as never)
+  expect((await ui.findAll({ type: 'Button' })).some(b => b.key === `${uri}-copy`)).toBe(false)
+  await ui.unmount()
+
+  // Mobile has no field: the list still shows.
+  const phone = await $.ui.mount({ ...PANE, surface: 'mobile' })
+  expect(await phone.findAll({ type: 'Input' })).toHaveLength(0)
+  expect((await phone.findAll({ type: 'Text' })).map(t => t.text).some(t => t.includes('limit is 100'))).toBe(true)
+  await phone.unmount()
+})

package/mod/peer-thread-mark/tests/memories.test.tsx

@@ -0,0 +1,54 @@
+import { expect, test } from 'claude-code/testing'
+
+const PANE = {
+  plugin: 'peer-thread-mark',
+  component: 'Pane',
+  requestId: 'peer-thread-memories',
+  props: { title: 'This thread', isFocused: false, bodyColumns: 44, placement: 'dock', scroll: { offset: 0, bodyRows: 40 }, view: {} },
+} as const
+
+const SAVES = {
+  connected: true,
+  loadedAt: 1,
+  saves: [
+    { at: '2026-11-03T13:42:14Z', items: [
+      { change: 'added', type: 'events', name: 'panel scope clarified', lines: ['The panel shows people who share threads.'], systemText: false },
+      { change: 'updated', type: 'entities', name: 'peer', lines: ['Shared threads list people who typed /peer.'], systemText: false },
+    ] },
+    { at: '2026-11-03T13:29:28Z', items: [
+      { change: 'added', type: 'events', name: 'project alpha displayed', lines: ['Studio showed project-alpha.'], systemText: true },
+      { change: 'updated', type: 'entities', name: 'peer', lines: ['older'], systemText: false },
+    ] },
+  ],
+}
+
+test('the memory pane groups by meaning and copies on press', async ($, on) => {
+  const settings = { hooks: { UserPromptSubmit: [{ hooks: [{ command: '"/n/node" "/p/peer.mjs" hook prompt # peer-hook' }] }] } }
+  on('env.get', () => ({ value: '/home' }) as never)
+  on('fs.read', (_, e) => ({ value: String((e as { path?: string }).path ?? '').endsWith('settings.json') ? JSON.stringify(settings) : (() => { throw new Error('none') })() }) as never)
+  on('process.run', () => ({ value: { stdout: JSON.stringify(SAVES), stderr: '', exitCode: 0 } }) as never)
+  on('session.id', () => ({ value: 's1' }) as never)
+  on('clock.now', () => ({ value: 1 }) as never)
+  on('ui.open', () => ({ value: { isPlaced: true } }) as never)
+  on('command.run', () => ({ text: 'engine' }) as never)
+  let copied = ''
+  on('ui.copy', (_, e) => { copied = (e as { text: string }).text; return { value: { isCopied: true } } as never })
+  on('ui.toast', () => ({ value: undefined }) as never)
+  await $.command.run({ command: 'peer-thread', args: '' } as never)
+  for (const surface of ['terminal', 'desktop'] as const) {
+    const ui = await $.ui.mount({ ...PANE, surface })
+    const texts = (await ui.findAll({ type: 'Text' })).map(t => t.text)
+    expect(texts.slice(0, 2)).toEqual(['This thread', '3 memories'])
+    expect(texts.filter(t => t === 'Project alpha displayed')).toHaveLength(1)
+    expect(texts).toContain('Updated')
+    expect(texts.some(t => t.endsWith(':42, 2×'))).toBe(true)
+    // Closed rows show no sentence; a press opens one row with its text and Copy.
+    expect(texts).not.toContain('The panel shows people who share threads.')
+    await ui.press({ key: 'New-2026-11-03T13:42:14Z-0' } as never)
+    expect((await ui.find({ type: 'Text', text: /people who share threads/ }))?.text).toBe('The panel shows people who share threads.')
+    await ui.press({ key: 'New-2026-11-03T13:42:14Z-0-copy' } as never)
+    expect(copied).toBe('Panel scope clarified\nThe panel shows people who share threads.')
+    await ui.press({ key: 'New-2026-11-03T13:42:14Z-0' } as never)
+    await ui.unmount()
+  }
+})

package/mod/peer-thread-mark/types/index.d.ts

@@ -2,8 +2,51 @@
 // (the band then draws nothing).
 export type Shared = { workspace: string; isShared: boolean } | null
 
+// One shared agent thread as the hub lists it (`peer list --json`).
+export type Thread = {
+  session: string
+  repository?: string | null
+  repoKey?: string | null
+  branch?: string | null
+  status: 'active' | 'silent' | 'stopped'
+  working: boolean
+  seenAt: string
+  stoppedAt?: string | null
+}
+
+// What the threads pane shows: the workspace's list as it last loaded, or why it did not; null before the first look.
+export type Board =
+  | {
+      workspace: string
+      you: string
+      people: { email: string; threads: Thread[] }[]
+      silentAfterMins: number
+      stoppedAfterMins: number
+      stoppedShownHours: number
+      loadedAt: number
+    }
+  | { error: string; loadedAt: number }
+  | null
+
+// What this thread saved to the person's own OpenViking, as `peer thread --json` says it; null before the first look.
+export type MemoryItem = { change: 'added' | 'updated' | 'removed'; type: string; name: string; lines: string[]; systemText: boolean }
+export type Memories =
+  | { connected: true; saves: { at: string; items: MemoryItem[] }[]; loadedAt: number }
+  | { connected: false; reason: string; loadedAt: number }
+  | { error: string; loadedAt: number }
+  | null
+
+// The search pane (/peer-all): what was asked, and one page of the person's memories as `peer all --json` gave it.
+// sort: '' is OpenViking's own order; 'new' and 'old' order by the time a memory last changed.
+export type AllQuery = { text: string; here: boolean; page: number; sort: '' | 'new' | 'old' }
+export type MemoryRow = { uri: string; repo: string; type: string; title: string; at: string; lines: string[] }
+export type AllFound =
+  | { connected: true; url: string; repo: string; total: number; page: number; pages: number; rows: MemoryRow[] }
+  | { connected: false; reason: string }
+export type AllMemories = { ask: AllQuery; loading: boolean; found?: AllFound; error?: string } | null
+
 declare module 'claude-code' {
   interface PluginState {
-    'peer-thread-mark': { shared: Shared }
+    'peer-thread-mark': { shared: Shared; board: Shaped<Board>; memories: Shaped<Memories>; all: Shaped<AllMemories>; openMemory: string | null; openAll: string | null }
   }
 }

package/package.json

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