claude-code-kanban 7.5.0 → 7.6.1

package/plugin/plugins/claude-code-kanban/tests/doorbell.test.ts

@@ -1,6 +1,6 @@
 import type { On } from 'claude-code'
 import { expect, mock, test } from 'claude-code/testing'
-import { boardUrl, RETRY_MS } from '../hooks/doorbell'
+import { boardUrl, parseReply, RETRY_MS } from '../hooks/doorbell'
 
 test('the board URL comes from CCK_URL, else from server.json', async () => {
   expect(boardUrl('http://127.0.0.1:4000/', '{"port":3541}')).toBe('http://127.0.0.1:4000')
@@ -10,7 +10,9 @@ test('the board URL comes from CCK_URL, else from server.json', async () => {
   expect(boardUrl(undefined, undefined)).toBe(undefined)
 })
 
-function engine(on: On, replies: (() => { status: number; events?: string[] })[]) {
+type Reply = { status: number; events?: string[]; seqs?: number[]; board?: string }
+
+function engine(on: On, replies: (() => Reply)[], submit?: () => Promise<unknown>) {
   const urls: string[] = []
   const prompts: string[] = []
   let sessionId = 'sid-1'
@@ -25,11 +27,12 @@ function engine(on: On, replies: (() => { status: number; events?: string[] })[]
     urls.push(e.url)
     const reply = replies.shift()
     if (!reply) return new Promise(() => {})
-    const { status, events = [] } = reply()
-    return { value: { status, ok: status < 300, headers: {}, text: JSON.stringify({ events }) } }
+    const { status, events = [], seqs, board } = reply()
+    return { value: { status, ok: status < 300, headers: {}, text: JSON.stringify({ events, seqs, board }) } }
   })
-  on('prompt.submit', (_$, e) => {
+  on('prompt.submit', async (_$, e) => {
     prompts.push(e.text)
+    if (submit) await submit()
     return { text: e.text }
   })
   return { urls, prompts, clear: () => (sessionId = 'sid-2') }
@@ -58,17 +61,73 @@ test('polls the board, submits a burst as one prompt, and drops the backlog for
   await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
   await clock.settle()
 
+  const base = 'http://127.0.0.1:3541/api/sessions'
   expect(board.prompts).toEqual(['line one\nline two'])
   expect(board.urls).toEqual([
-    'http://127.0.0.1:3541/api/sessions/sid-1/events?wait=25&first=1',
-    'http://127.0.0.1:3541/api/sessions/sid-1/events?wait=25',
+    `${base}/sid-1/events?wait=25&board=&got=0&ack=0&first=1`,
+    `${base}/sid-1/events?wait=25&board=&got=0&ack=0`,
   ])
 
   await clock.advance(RETRY_MS)
   expect(board.urls.slice(2)).toEqual([
-    'http://127.0.0.1:3541/api/sessions/sid-1/events?wait=25',
-    'http://127.0.0.1:3541/api/sessions/sid-2/events?wait=25&first=1',
-    'http://127.0.0.1:3541/api/sessions/sid-2/events?wait=25',
+    `${base}/sid-1/events?wait=25&board=&got=0&ack=0`,
+    `${base}/sid-2/events?wait=25&board=&got=0&ack=0&first=1&prev=sid-1`,
+    `${base}/sid-2/events?wait=25&board=&got=0&ack=0`,
   ])
   expect(board.prompts).toEqual(['line one\nline two', 'after clear'])
 })
+
+test('keeps polling while a submit waits, sends what came in as one prompt, and acks only after the submit', async ($, on) => {
+  const clock = mock.clock(on)
+  let release = () => {}
+  const replies = [
+    () => ({ status: 200, events: ['move'], seqs: [1], board: 'b1' }),
+    () => ({ status: 200, events: ['review one'], seqs: [2], board: 'b1' }),
+    () => ({ status: 200, events: ['review two', 'review one'], seqs: [3, 2], board: 'b1' }),
+  ]
+  let held = true
+  const board = engine(on, replies, () => (held ? new Promise<void>(r => (release = () => ((held = false), r()))) : Promise.resolve()))
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  await clock.settle()
+
+  const base = 'http://127.0.0.1:3541/api/sessions/sid-1/events?wait=25'
+  expect(board.prompts).toEqual(['move'])
+  expect(board.urls).toEqual([
+    `${base}&board=&got=0&ack=0&first=1`,
+    `${base}&board=b1&got=1&ack=0`,
+    `${base}&board=b1&got=2&ack=0`,
+    `${base}&board=b1&got=3&ack=0`,
+  ])
+
+  release()
+  await clock.settle()
+  expect(board.prompts).toEqual(['move', 'review one\nreview two'])
+})
+
+test('acks a submitted line on the next poll', async ($, on) => {
+  const clock = mock.clock(on)
+  const replies = [() => ({ status: 200, events: ['review'], seqs: [4], board: 'b1' }), () => ({ status: 200, board: 'b1' })]
+  const board = engine(on, replies)
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  await clock.settle()
+  expect(board.urls.at(-1)).toContain('board=b1&got=4&ack=4')
+})
+
+test('starts the count again when the board restarts', async ($, on) => {
+  const clock = mock.clock(on)
+  const replies = [
+    () => ({ status: 200, events: ['old'], seqs: [9], board: 'b1' }),
+    () => ({ status: 200, board: 'b1' }),
+    () => ({ status: 200, events: ['new'], seqs: [1], board: 'b2' }),
+  ]
+  const board = engine(on, replies)
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  await clock.settle()
+  expect(board.prompts).toEqual(['old', 'new'])
+  expect(board.urls.at(-1)).toContain('board=b2&got=1&ack=1')
+})
+
+test('reads a reply from a board without acks', () => {
+  expect(parseReply('{"events":["a",3,"b"]}')).toEqual({ lines: [{ text: 'a', seq: undefined }, { text: 'b', seq: undefined }], board: '' })
+  expect(parseReply('{"events":["a"],"seqs":[5],"board":"b1"}')).toEqual({ lines: [{ text: 'a', seq: 5 }], board: 'b1' })
+})

package/plugin/plugins/claude-code-kanban/tests/show.test.ts

@@ -0,0 +1,137 @@
+import type { On, ToolCallArgs } from 'claude-code'
+import { expect, test } from 'claude-code/testing'
+import { boardPort, dropSkillLine, shownText, TOOL } from '../hooks/show'
+
+const CCK_URL = 'http://127.0.0.1:4100'
+const TERMINAL_ID = 'term-1'
+const TOKEN_FILE = 'C:/cfg/.cck/terminal-tokens/4100.json'
+const LISTING = [
+  'The following skills are available for use with the Skill tool:',
+  '',
+  '- claude-code-kanban:dispatch',
+  '- claude-code-kanban:show',
+  '- claude-code-kanban:kanban: Kanban board CLI',
+  '- meta:show-me: Help the user understand the current topic visually',
+].join('\n')
+
+type Reply = { status: number; body: unknown } | Error
+type Request = { url: string; method?: string; headers?: Record<string, string>; body?: unknown }
+
+function engine(on: On, env: Record<string, string>, reply?: Reply) {
+  const registered: string[] = []
+  const requests: Request[] = []
+  const files: Record<string, string> = { [TOKEN_FILE]: '{"token":"tok-abc"}' }
+  on('env.get', (_$, e) => ({ value: { CLAUDE_CONFIG_DIR: 'C:/cfg', ...env }[e.name] }))
+  on('fs.read', (_$, e) => {
+    const text = files[e.path.replaceAll('\\', '/')]
+    if (text === undefined) throw new Error(`ENOENT: ${e.path}`)
+    return { value: text }
+  })
+  on('session.id', () => ({ value: 'sid-1' }))
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('tool.register', (_$, e) => {
+    registered.push(e.name)
+    return { value: { tool: `mcp__claude-code-kanban__${e.name}` } }
+  })
+  on('prompt.attachment', (_$, e) => ({ text: e.text }))
+  on('http.fetch', (_$, e) => {
+    if (!e.url.includes('/show')) return new Promise(() => {})
+    const { method, headers, body } = (e.init ?? {}) as Omit<Request, 'url'>
+    requests.push({ url: e.url, method, headers, body: typeof body === 'string' ? JSON.parse(body) : body })
+    if (!reply) throw new Error('no reply')
+    if (reply instanceof Error) return { deny: reply.message }
+    return { value: { status: reply.status, ok: reply.status < 300, headers: {}, text: JSON.stringify(reply.body) } }
+  })
+  return { registered, requests, files }
+}
+
+const GATE = { CCK_URL, CCK_TERMINAL_ID: TERMINAL_ID }
+const listing = { type: 'skill_listing', text: LISTING, origin: { kind: 'engine' } } as const
+const call = (input: Record<string, unknown>) => ({ tool: TOOL, ...input }) as ToolCallArgs
+
+test('helpers: the port of CCK_URL, the answer line, the listing filter', async () => {
+  expect(boardPort('http://127.0.0.1:4100')).toBe('4100')
+  expect(boardPort('http://localhost:3541/')).toBe('3541')
+  expect(boardPort('http://localhost')).toBe(undefined)
+  expect(shownText({ title: 'Plan', key: 'plan', index: 3, count: 7 })).toBe('Shown "Plan" (plan, 3/7)')
+  expect(shownText({ title: 'Map', key: null, index: 1, count: 1 })).toBe('Shown "Map" (1/1)')
+  expect(shownText({ title: 'Plan', key: 'plan', index: 1, count: 1, path: 'C:/s/p1.md' }, true)).toBe(
+    'Card "Plan" (plan, 1/1) is ready. Write it to C:/s/p1.md; the card refreshes on each save.',
+  )
+  expect(dropSkillLine(LISTING)).toBe(LISTING.replace('- claude-code-kanban:show\n', ''))
+  expect(dropSkillLine('- claude-code-kanban:show: Show a diagram\n- x')).toBe('- x')
+})
+
+test('gate off: no tool, and the skill line is dropped', async ($, on) => {
+  const board = engine(on, { CCK_URL })
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  expect(board.registered).toEqual([])
+  const { text } = await $.prompt.attachment(listing)
+  expect(text).toBe(LISTING.replace('- claude-code-kanban:show\n', ''))
+})
+
+test('gate on: the tool is registered and the skill line stays', async ($, on) => {
+  const board = engine(on, GATE)
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  expect(board.registered).toEqual(['show'])
+  const { text } = await $.prompt.attachment(listing)
+  expect(text).toBe(LISTING)
+})
+
+test('a -p run gets no tool', async ($, on) => {
+  const board = engine(on, GATE)
+  await $.session.start({ cwd: 'C:/proj', surface: null, isInteractive: false })
+  expect(board.registered).toEqual([])
+})
+
+test('posts the body with the terminal token and answers with the position', async ($, on) => {
+  const board = engine(on, GATE, {
+    status: 200,
+    body: { id: 'p1', title: 'Plan', key: 'plan', index: 2, count: 3, replaced: false },
+  })
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  const res = await $.tool.call(call({ title: 'Plan', key: 'plan', kind: 'markdown', file: 'C:/proj/plan.md' }))
+  expect(res.result).toBe('Shown "Plan" (plan, 2/3)')
+  expect(board.requests).toEqual([
+    {
+      url: `${CCK_URL}/api/terminals/${TERMINAL_ID}/show`,
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'x-terminal-token': 'tok-abc' },
+      body: { sessionId: 'sid-1', title: 'Plan', key: 'plan', kind: 'markdown', file: 'C:/proj/plan.md' },
+    },
+  ])
+})
+
+test('a claim sends no file and answers with the file to write', async ($, on) => {
+  const path = 'C:/s/.cck/show/p1.md'
+  const board = engine(on, GATE, { status: 200, body: { id: 'p1', title: 'Plan', key: 'plan', index: 1, count: 1, path } })
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  const res = await $.tool.call(call({ title: 'Plan', key: 'plan' }))
+  expect(res.result).toBe(`Card "Plan" (plan, 1/1) is ready. Write it to ${path}; the card refreshes on each save.`)
+  expect(board.requests[0]?.body).toEqual({ sessionId: 'sid-1', title: 'Plan', key: 'plan' })
+})
+
+test('a 400 answer reaches the model as an error with the server text', async ($, on) => {
+  const error = 'file not found: C:/proj/gone.md'
+  engine(on, GATE, { status: 400, body: { error } })
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  const res = await $.tool.call(call({ title: 'Gone', file: 'C:/proj/gone.md' }))
+  expect(res.deny).toBe(error)
+})
+
+test('a network error reaches the model as an error', async ($, on) => {
+  engine(on, GATE, new Error('connect ECONNREFUSED 127.0.0.1:4100'))
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  const res = await $.tool.call(call({ title: 'Plan' }))
+  expect(res.deny).toContain(`Cannot reach cck at ${CCK_URL}`)
+  expect(res.deny).toContain('ECONNREFUSED')
+})
+
+test('no token file: no request, an error that names the board', async ($, on) => {
+  const board = engine(on, GATE)
+  delete board.files[TOKEN_FILE]
+  await $.session.start({ cwd: 'C:/proj', surface: 'terminal', isInteractive: true })
+  const res = await $.tool.call(call({ title: 'Plan' }))
+  expect(res.deny).toContain('No terminal token')
+  expect(board.requests).toEqual([])
+})