@andypai/agent-kanban 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andypai/agent-kanban",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Agent-friendly kanban board CLI. Manage tasks via bash commands, parse structured JSON output.",
   "homepage": "https://github.com/abpai/agent-kanban#readme",
   "repository": {

package/src/__tests__/jira-adf.test.ts

@@ -1,5 +1,31 @@
 import { describe, expect, test } from 'bun:test'
-import { adfToPlainText, plainTextToAdf, type AdfDocument } from '../providers/jira-adf'
+import {
+  adfToPlainText,
+  plainTextToAdf,
+  type AdfBulletListNode,
+  type AdfCodeBlockNode,
+  type AdfDocument,
+  type AdfInlineNode,
+  type AdfParagraphNode,
+} from '../providers/jira-adf'
+
+function firstParagraphContent(doc: AdfDocument): AdfInlineNode[] {
+  const paragraph = doc.content[0] as AdfParagraphNode
+  expect(paragraph.type).toBe('paragraph')
+  return paragraph.content ?? []
+}
+
+function firstCodeBlock(doc: AdfDocument): AdfCodeBlockNode {
+  const code = doc.content[0] as AdfCodeBlockNode
+  expect(code.type).toBe('codeBlock')
+  return code
+}
+
+function firstBulletList(doc: AdfDocument): AdfBulletListNode {
+  const list = doc.content[0] as AdfBulletListNode
+  expect(list.type).toBe('bulletList')
+  return list
+}
 
 describe('plainTextToAdf / adfToPlainText', () => {
   test('empty doc round-trip', () => {
@@ -154,7 +180,7 @@ describe('plainTextToAdf / adfToPlainText', () => {
     expect(adfToPlainText(doc)).toBe('before\n\nafter')
   })
 
-  test('inline text marks are stripped on read', () => {
+  test('strong + link marks survive on read as markdown', () => {
     const doc: AdfDocument = {
       version: 1,
       type: 'doc',
@@ -163,12 +189,240 @@ describe('plainTextToAdf / adfToPlainText', () => {
           type: 'paragraph',
           content: [
             { type: 'text', text: 'bold', marks: [{ type: 'strong' }] },
-            { type: 'text', text: ' normal' },
+            { type: 'text', text: ' ' },
+            {
+              type: 'text',
+              text: 'click',
+              marks: [{ type: 'link', attrs: { href: 'https://example.com' } }],
+            },
+          ],
+        },
+      ],
+    }
+    expect(adfToPlainText(doc)).toBe('**bold** [click](https://example.com)')
+  })
+
+  test('write path emits **bold** as a strong mark', () => {
+    const input = 'hello **world**'
+    const doc = plainTextToAdf(input)
+    expect(firstParagraphContent(doc)).toEqual([
+      { type: 'text', text: 'hello ' },
+      { type: 'text', text: 'world', marks: [{ type: 'strong' }] },
+    ])
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('write path emits [label](https://...) as a link mark', () => {
+    const input = 'see [docs](https://example.com/x)'
+    const doc = plainTextToAdf(input)
+    expect(firstParagraphContent(doc)).toEqual([
+      { type: 'text', text: 'see ' },
+      {
+        type: 'text',
+        text: 'docs',
+        marks: [{ type: 'link', attrs: { href: 'https://example.com/x' } }],
+      },
+    ])
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('write path emits side-by-side bold and link as adjacent text nodes', () => {
+    const input = '**PR opened** — [repo#1](https://github.com/o/r/pull/1)'
+    const doc = plainTextToAdf(input)
+    expect(firstParagraphContent(doc)).toEqual([
+      { type: 'text', text: 'PR opened', marks: [{ type: 'strong' }] },
+      { type: 'text', text: ' — ' },
+      {
+        type: 'text',
+        text: 'repo#1',
+        marks: [{ type: 'link', attrs: { href: 'https://github.com/o/r/pull/1' } }],
+      },
+    ])
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('write path bolds bullet item field-name prefix', () => {
+    const input = '- **Marker:** drift:HUMAN REVIEW:516652'
+    const doc = plainTextToAdf(input)
+    const list = firstBulletList(doc)
+    const itemParagraph = list.content[0]!.content[0] as AdfParagraphNode
+    const itemContent = itemParagraph.content ?? []
+    expect(itemContent).toEqual([
+      { type: 'text', text: 'Marker:', marks: [{ type: 'strong' }] },
+      { type: 'text', text: ' drift:HUMAN REVIEW:516652' },
+    ])
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('inline tokenizer does NOT run inside fenced code blocks', () => {
+    const input = '```ts\nconst s = "**not bold** [x](https://e.com)"\n```'
+    const doc = plainTextToAdf(input)
+    const code = firstCodeBlock(doc)
+    const codeContent = code.content ?? []
+    expect(codeContent).toHaveLength(1)
+    expect(codeContent[0]?.text).toBe('const s = "**not bold** [x](https://e.com)"')
+    expect(codeContent[0]?.marks).toBeUndefined()
+    expect(adfToPlainText(doc)).toBe(input)
+  })
+
+  test('read: code block text marks stay literal', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'codeBlock',
+          content: [
+            { type: 'text', text: '**not bold**', marks: [{ type: 'strong' }] },
+            {
+              type: 'text',
+              text: '\nhttps://example.com',
+              marks: [{ type: 'link', attrs: { href: 'https://example.com' } }],
+            },
+          ],
+        },
+      ],
+    }
+    expect(adfToPlainText(doc)).toBe('```\n**not bold**\nhttps://example.com\n```')
+  })
+
+  test('non-http link target is left as literal text (no link mark)', () => {
+    const input = 'see [docs](mailto:dev@example.com)'
+    const doc = plainTextToAdf(input)
+    expect(firstParagraphContent(doc)).toEqual([{ type: 'text', text: input }])
+  })
+
+  test('read: paragraph containing inlineCard emits the URL inline', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', text: 'Repo: ' },
+            { type: 'inlineCard', attrs: { url: 'https://github.com/abpai/garage-band' } },
+          ],
+        },
+      ],
+    }
+    expect(adfToPlainText(doc)).toBe('Repo: https://github.com/abpai/garage-band')
+  })
+
+  test('read: split strong field label keeps colon inside markdown', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', text: 'Repo', marks: [{ type: 'strong' }] },
+            { type: 'text', text: ': ' },
+            { type: 'inlineCard', attrs: { url: 'https://github.com/abpai/garage-band' } },
+          ],
+        },
+      ],
+    }
+    expect(adfToPlainText(doc)).toBe('**Repo:** https://github.com/abpai/garage-band')
+  })
+
+  test('read: blockCard renders as a standalone block with the URL', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        { type: 'paragraph', content: [{ type: 'text', text: 'before' }] },
+        { type: 'blockCard', attrs: { url: 'https://github.com/abpai/garage-band' } },
+        { type: 'paragraph', content: [{ type: 'text', text: 'after' }] },
+      ],
+    }
+    expect(adfToPlainText(doc)).toBe('before\n\nhttps://github.com/abpai/garage-band\n\nafter')
+  })
+
+  test('read: embedCard also emits its URL', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [{ type: 'embedCard', attrs: { url: 'https://example.com/embed' } }],
+    }
+    expect(adfToPlainText(doc)).toBe('https://example.com/embed')
+  })
+
+  test('read: DXS-12-shaped description preserves smart-link Repo URL', () => {
+    // Captured shape from a real Jira description where a user pasted a URL
+    // and Jira auto-converted it to an inlineCard. Before the fix,
+    // adfToPlainText returned "Repo: " with the URL silently dropped.
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', text: 'Repo', marks: [{ type: 'strong' }] },
+            { type: 'text', text: ': ' },
+            { type: 'inlineCard', attrs: { url: 'https://github.com/abpai/garage-band' } },
+          ],
+        },
+        {
+          type: 'paragraph',
+          content: [{ type: 'text', text: 'Please make one minimal change.' }],
+        },
+        {
+          type: 'heading',
+          attrs: { level: 3 },
+          content: [{ type: 'text', text: 'Acceptance criteria:' }],
+        },
+        {
+          type: 'bulletList',
+          content: [
+            {
+              type: 'listItem',
+              content: [
+                {
+                  type: 'paragraph',
+                  content: [{ type: 'text', text: 'Change only SMOKE_TEST_TASK.md.' }],
+                },
+              ],
+            },
+            {
+              type: 'listItem',
+              content: [
+                {
+                  type: 'paragraph',
+                  content: [{ type: 'text', text: 'Increment current_count by exactly one.' }],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    }
+    const out = adfToPlainText(doc)
+    expect(out).toContain('Repo:')
+    expect(out).toContain('https://github.com/abpai/garage-band')
+    // Repo line carries the URL — agents grepping for the URL recover it.
+    const repoLine = out.split('\n').find((l) => l.includes('Repo:'))
+    expect(repoLine).toBe('**Repo:** https://github.com/abpai/garage-band')
+  })
+
+  test('read: hardBreak between text runs emits newline', () => {
+    const doc: AdfDocument = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', text: 'first line' },
+            { type: 'hardBreak' },
+            { type: 'text', text: 'second line' },
           ],
         },
       ],
     }
-    expect(adfToPlainText(doc)).toBe('bold normal')
+    expect(adfToPlainText(doc)).toBe('first line\nsecond line')
   })
 
   test('bullet item containing digits-dot substring is still a bullet', () => {

package/src/__tests__/jira-provider-read.test.ts

@@ -67,13 +67,14 @@ function makeIssue(opts: {
   updated?: string
   summary?: string
   assignee?: { accountId: string; displayName: string } | null
+  description?: unknown
 }): Record<string, unknown> {
   return {
     id: opts.id,
     key: opts.key,
     fields: {
       summary: opts.summary ?? opts.key,
-      description: null,
+      description: opts.description ?? null,
       status: { id: opts.statusId, name: 'Status ' + opts.statusId },
       issuetype: { id: '10000', name: 'Bug' },
       priority: { id: '2', name: 'High' },
@@ -429,6 +430,51 @@ describe('JiraProvider read path', () => {
     expect(byPrefixed.externalRef).toBe('ENG-1')
   })
 
+  test('description ADF with an inlineCard smart-link preserves the URL through getTask', async () => {
+    // Regression for the DXS-12 shape: a user pastes
+    // `Repo: https://github.com/abpai/garage-band` in the description, Jira
+    // auto-converts the URL to an inlineCard, and the previous
+    // adfToPlainText silently dropped attrs.url.
+    const description = {
+      version: 1,
+      type: 'doc',
+      content: [
+        {
+          type: 'paragraph',
+          content: [
+            { type: 'text', text: 'Repo', marks: [{ type: 'strong' }] },
+            { type: 'text', text: ': ' },
+            { type: 'inlineCard', attrs: { url: 'https://github.com/abpai/garage-band' } },
+          ],
+        },
+        {
+          type: 'paragraph',
+          content: [{ type: 'text', text: 'Increment SMOKE_TEST_TASK.md by 1.' }],
+        },
+      ],
+    }
+    const searchHandler: StubHandler = () =>
+      jsonResponse({
+        startAt: 0,
+        maxResults: 100,
+        total: 1,
+        issues: [
+          makeIssue({
+            id: '20001',
+            key: 'ENG-12',
+            statusId: '10001',
+            description,
+          }),
+        ],
+      })
+    const { provider } = makeProvider(standardRoutes({ searchHandler }))
+    await provider.getBoard()
+    const task = await provider.getTask('ENG-12')
+    expect(task.description).toContain('Repo:')
+    expect(task.description).toContain('https://github.com/abpai/garage-band')
+    expect(task.description.split('\n')[0]).toBe('**Repo:** https://github.com/abpai/garage-band')
+  })
+
   test('getBootstrap returns provider=jira and the adapted BoardConfig', async () => {
     const { provider } = makeProvider(standardRoutes({}))
     const result = await provider.getBootstrap()

package/src/providers/jira-adf.ts

@@ -2,14 +2,14 @@
 //
 // This module is intentionally dependency-free: no imports from the rest of the
 // provider stack, no bun:sqlite, no fetch. It models only the subset of ADF
-// that agent-kanban round-trips through plain text:
+// that agent-kanban writes, plus a few Jira nodes it must preserve on read:
 //
-//   doc > { paragraph | bulletList | orderedList | codeBlock | heading }
-//   paragraph / heading / codeBlock > text(inline)
+//   doc > { paragraph | bulletList | orderedList | codeBlock | heading | card }
+//   paragraph / heading / codeBlock > text(inline) | inlineCard | hardBreak
 //   bulletList / orderedList > listItem > paragraph > text
 //
-// Unknown node types are tolerated on the read path (skipped silently) and
-// never emitted on the write path.
+// Other unknown node types are tolerated on the read path (skipped silently)
+// and never emitted on the write path.
 
 export interface AdfDocument {
   version: 1
@@ -17,10 +17,15 @@ export interface AdfDocument {
   content: AdfBlockNode[]
 }
 
+export interface AdfMark {
+  type: string
+  attrs?: Record<string, unknown>
+}
+
 export interface AdfTextNode {
   type: 'text'
   text: string
-  marks?: unknown[]
+  marks?: AdfMark[]
 }
 
 export interface AdfUnknownInlineNode {
@@ -92,7 +97,7 @@ function paragraphFromText(text: string): AdfParagraphNode {
   }
   return {
     type: 'paragraph',
-    content: [{ type: 'text', text }],
+    content: tokenizeInline(text),
   }
 }
 
@@ -103,6 +108,39 @@ function listItemFromText(text: string): AdfListItemNode {
   }
 }
 
+const INLINE_MARK = /\*\*([^*\n]+)\*\*|\[([^\]\n]+)\]\((https?:\/\/[^)\s]+)\)/g
+
+function tokenizeInline(text: string): AdfTextNode[] {
+  const out: AdfTextNode[] = []
+  INLINE_MARK.lastIndex = 0
+  let cursor = 0
+  for (const match of text.matchAll(INLINE_MARK)) {
+    const start = match.index ?? 0
+    if (start > cursor) {
+      out.push({ type: 'text', text: text.slice(cursor, start) })
+    }
+    const boldText = match[1]
+    if (boldText !== undefined) {
+      out.push({
+        type: 'text',
+        text: boldText,
+        marks: [{ type: 'strong' }],
+      })
+    } else {
+      out.push({
+        type: 'text',
+        text: match[2]!,
+        marks: [{ type: 'link', attrs: { href: match[3]! } }],
+      })
+    }
+    cursor = start + match[0].length
+  }
+  if (cursor < text.length) {
+    out.push({ type: 'text', text: text.slice(cursor) })
+  }
+  return out
+}
+
 export function plainTextToAdf(text: string): AdfDocument {
   if (text.length === 0) {
     return { version: 1, type: 'doc', content: [] }
@@ -211,18 +249,79 @@ export function plainTextToAdf(text: string): AdfDocument {
   return { version: 1, type: 'doc', content: blocks }
 }
 
-function inlineText(nodes: AdfInlineNode[] | undefined): string {
+function inlineText(
+  nodes: AdfInlineNode[] | undefined,
+  opts: { renderMarks?: boolean } = {},
+): string {
   if (!nodes) return ''
+  const renderMarks = opts.renderMarks ?? true
   let out = ''
-  for (const node of nodes) {
+  for (let i = 0; i < nodes.length; i += 1) {
+    const node = nodes[i]!
     if (node.type === 'text') {
-      out += (node as AdfTextNode).text
+      const textNode = node as AdfTextNode
+      if (!renderMarks) {
+        out += textNode.text
+        continue
+      }
+      const nextNode = nodes[i + 1]
+      const labelColon = readPlainTextLeadingColon(nextNode)
+      if (labelColon && hasMark(textNode, 'strong')) {
+        out += renderTextNode({ ...textNode, text: `${textNode.text}:` })
+        out += labelColon.remainder
+        i += 1
+        continue
+      }
+      out += renderTextNode(textNode)
+      continue
     }
-    // Unknown inline nodes (mentions, emoji, hardBreak, etc.) are skipped.
+    if (node.type === 'inlineCard') {
+      const url = readCardUrl(node)
+      if (url) out += url
+      continue
+    }
+    if (node.type === 'hardBreak') {
+      out += '\n'
+      continue
+    }
+    // Other unknown inline nodes (mentions, emoji, etc.) are skipped.
+  }
+  return out
+}
+
+function hasMark(node: AdfTextNode, type: string): boolean {
+  return node.marks?.some((m) => m.type === type) ?? false
+}
+
+function readPlainTextLeadingColon(node: AdfInlineNode | undefined): { remainder: string } | null {
+  if (!node || node.type !== 'text') return null
+  const textNode = node as AdfTextNode
+  if (textNode.marks && textNode.marks.length > 0) return null
+  if (!textNode.text.startsWith(':')) return null
+  return { remainder: textNode.text.slice(1) }
+}
+
+function renderTextNode(node: AdfTextNode): string {
+  if (!node.marks || node.marks.length === 0) return node.text
+  const link = node.marks.find((m) => m.type === 'link')
+  let out = node.text
+  if (link) {
+    const href = link.attrs?.['href']
+    if (typeof href === 'string' && href.length > 0) out = `[${out}](${href})`
+  }
+  if (hasMark(node, 'strong')) {
+    out = `**${out}**`
   }
   return out
 }
 
+function readCardUrl(node: AdfInlineNode | AdfBlockNode): string | null {
+  const attrs = (node as { attrs?: Record<string, unknown> }).attrs
+  if (!attrs) return null
+  const url = attrs['url']
+  return typeof url === 'string' && url.length > 0 ? url : null
+}
+
 function listItemInnerText(item: AdfListItemNode): string {
   // Each list item wraps a paragraph (or nested blocks). We flatten to the
   // first paragraph's inline text, which is all the write path produces.
@@ -252,12 +351,17 @@ function renderBlock(node: AdfBlockNode): string | null {
     case 'codeBlock': {
       const code = node as AdfCodeBlockNode
       const language = code.attrs?.language ?? ''
-      const body = inlineText(code.content)
+      const body = inlineText(code.content, { renderMarks: false })
       const fence = language.length > 0 ? `\`\`\`${language}` : '```'
       return `${fence}\n${body}\n\`\`\``
     }
     case 'heading':
       return inlineText((node as AdfHeadingNode).content)
+    case 'blockCard':
+    case 'embedCard': {
+      const url = readCardUrl(node)
+      return url ?? null
+    }
     default:
       // Unknown block node — skip entirely, never throw.
       return null