@andypai/agent-kanban 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andypai/agent-kanban",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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__/board-utils.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, test } from 'bun:test'
-import { replaceTask, upsertTaskInColumn } from '../../ui/src/components/boardUtils'
+import {
+  moveTaskInBoard,
+  replaceTask,
+  upsertTaskInColumn,
+} from '../../ui/src/components/boardUtils'
 import type { BoardView, Task } from '../../ui/src/types'
 
 function makeTask(
@@ -97,4 +101,36 @@ describe('boardUtils', () => {
     expect(nextBoard.columns[0]!.tasks.map((task) => task.id)).toEqual(['t-1', 'tmp-1', 't-2'])
     expect(nextBoard.columns[0]!.tasks[0]!.title).toBe('First edited')
   })
+
+  test('moveTaskInBoard accepts a column id when column names repeat', () => {
+    const board: BoardView = {
+      columns: [
+        {
+          id: 'board:1006:Backlog',
+          name: 'Backlog',
+          position: 0,
+          color: null,
+          created_at: '',
+          updated_at: '',
+          tasks: [
+            makeTask({ id: 't-1', title: 'First', column_id: 'board:1006:Backlog', position: 0 }),
+          ],
+        },
+        {
+          id: 'board:1006:Backlog:1',
+          name: 'Backlog',
+          position: 1,
+          color: null,
+          created_at: '',
+          updated_at: '',
+          tasks: [],
+        },
+      ],
+    }
+
+    const nextBoard = moveTaskInBoard(board, 't-1', 'board:1006:Backlog:1')
+
+    expect(nextBoard.columns[0]!.tasks).toEqual([])
+    expect(nextBoard.columns[1]!.tasks.map((task) => task.id)).toEqual(['t-1'])
+  })
 })

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

@@ -229,6 +229,35 @@ describe('JiraProvider read path', () => {
     expect(decodeColumnStatusIds(cols[0]!)).toEqual(['10001', '10002'])
   })
 
+  test('sync keeps duplicate Jira board column names as distinct cached columns', async () => {
+    const { provider } = makeProviderWithBoard(
+      standardRoutes({
+        boardCfg: {
+          id: 1006,
+          name: 'ENG Board',
+          columnConfig: {
+            columns: [
+              { name: 'Backlog', statuses: [{ id: '10001' }] },
+              { name: 'Backlog', statuses: [{ id: '10002' }] },
+            ],
+          },
+        },
+      }),
+      1006,
+    )
+
+    await provider.getBoard()
+
+    const cols = getCachedColumns(db)
+    expect(cols.map((column) => column.id)).toEqual(['board:1006:Backlog', 'board:1006:Backlog:1'])
+    expect(cols.map((column) => decodeColumnStatusIds(column))).toEqual([['10001'], ['10002']])
+    await expect(provider.listTasks({ column: 'Backlog' })).rejects.toMatchObject({
+      code: ErrorCode.COLUMN_NOT_FOUND,
+      message: expect.stringContaining('ambiguous'),
+    })
+    expect(await provider.listTasks({ column: 'board:1006:Backlog' })).toEqual([])
+  })
+
   test('sync populates columns from statuses when boardId is absent', async () => {
     const { provider } = makeProvider(standardRoutes({}))
     await provider.getBoard()

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

@@ -67,7 +67,7 @@ function makeIssue(
   }
 }
 
-function standardRoutes(): StubRoute[] {
+function standardRoutes(opts: { boardCfg?: unknown } = {}): StubRoute[] {
   const issues = [makeIssue()]
   const comments: Record<
     string,
@@ -100,6 +100,19 @@ function standardRoutes(): StubRoute[] {
       match: (url) => url.includes('/rest/api/3/project/ENG'),
       handler: () => jsonResponse(projectFixture),
     },
+    {
+      match: (url) => url.includes('/rest/agile/1.0/board/'),
+      handler: () =>
+        jsonResponse(
+          opts.boardCfg ?? {
+            id: 1006,
+            name: 'ENG Board',
+            columnConfig: {
+              columns: [{ name: 'Done', statuses: [{ id: '10' }, { id: '20' }] }],
+            },
+          },
+        ),
+    },
     {
       match: (url) => url.includes('/rest/api/3/user/assignable/search'),
       handler: () => jsonResponse([{ accountId: 'a1', displayName: 'Alice', active: true }]),
@@ -334,6 +347,51 @@ describe('postgres jira provider', () => {
     expect(body.fields?.labels).toEqual(['garage-smoke', 'garage-owner-local'])
   })
 
+  pgTest('keeps duplicate Jira board column names as distinct cached columns', async () => {
+    expect(sql).not.toBeNull()
+    if (!sql) throw new Error('expected postgres test connection')
+    const stub = jiraFetchStub(
+      standardRoutes({
+        boardCfg: {
+          id: 1006,
+          name: 'ENG Board',
+          columnConfig: {
+            columns: [
+              { name: 'Backlog', statuses: [{ id: '10' }] },
+              { name: 'Backlog', statuses: [{ id: '20' }] },
+            ],
+          },
+        },
+      }),
+    )
+    globalThis.fetch = stub.fn
+    const provider = new PostgresJiraProvider(sql, {
+      baseUrl: 'https://example.atlassian.net',
+      email: 'user@example.com',
+      apiToken: 'token',
+      projectKey: 'ENG',
+      boardId: 1006,
+    })
+
+    const board = await provider.getBoard()
+
+    expect(board.columns.map((column) => column.id)).toEqual([
+      'board:1006:Backlog',
+      'board:1006:Backlog:1',
+    ])
+    expect(board.columns.map((column) => column.tasks.map((task) => task.externalRef))).toEqual([
+      ['ENG-1'],
+      [],
+    ])
+    await expect(provider.listTasks({ column: 'Backlog' })).rejects.toMatchObject({
+      code: 'COLUMN_NOT_FOUND',
+      message: expect.stringContaining('ambiguous'),
+    })
+    expect(
+      (await provider.listTasks({ column: 'board:1006:Backlog' })).map((task) => task.id),
+    ).toEqual(['jira:10001'])
+  })
+
   pgTest('moves Jira tasks through Postgres storage', async () => {
     const moved = expectOk<Task>(await run(['task', 'move', 'ENG-1', 'Done']))
 

package/src/providers/jira-cache.ts

@@ -1,8 +1,10 @@
 import type { Database } from 'bun:sqlite'
+import { ErrorCode, KanbanError } from '../errors'
 import type { BoardView, ProviderTeamInfo, Task } from '../types'
 
 // Column ids are prefixed to avoid collisions across sources:
-// - board-sourced columns: 'board:<boardId>:<columnName>'
+// - board-sourced columns: 'board:<boardId>:<columnName>' with an index suffix
+//   only when Jira returns duplicate board column names
 // - status-fallback columns: 'status:<statusId>'
 // The provider (T04) picks ONE source per sync, so mixed-source boards
 // do not occur in practice.
@@ -30,6 +32,67 @@ export interface JiraCacheConfig {
   issueTypes: Array<{ id: string; name: string }>
 }
 
+export interface JiraBoardColumnInput {
+  name: string
+  statuses: Array<{ id: string }>
+}
+
+export function jiraBoardColumnRows(
+  boardId: number,
+  columns: JiraBoardColumnInput[],
+): Array<{
+  id: string
+  name: string
+  position: number
+  statusIds: string[]
+  source: 'board'
+}> {
+  const seen = new Set<string>()
+  return columns.map((column, index) => {
+    const baseId = `board:${boardId}:${column.name}`
+    let id = baseId
+    if (seen.has(id)) {
+      id = `${baseId}:${index}`
+      let suffix = 2
+      while (seen.has(id)) {
+        id = `${baseId}:${index}:${suffix}`
+        suffix += 1
+      }
+    }
+    seen.add(id)
+    return {
+      id,
+      name: column.name,
+      position: index,
+      statusIds: column.statuses.map((status) => status.id),
+      source: 'board',
+    }
+  })
+}
+
+// Resolves a user-supplied column reference to a cached column id, trying
+// (1) exact id, (2) case-insensitive name, (3) raw status id containment.
+// A name that matches multiple columns (possible when Jira returns duplicate
+// board column names) is rejected as ambiguous so the caller picks an id.
+export function resolveJiraColumnId(columns: JiraColumnRow[], input: string): string {
+  const byId = columns.find((column) => column.id === input)
+  if (byId) return byId.id
+  const lower = input.toLowerCase()
+  const byName = columns.filter((column) => column.name.toLowerCase() === lower)
+  if (byName.length === 1) return byName[0]!.id
+  if (byName.length > 1) {
+    throw new KanbanError(
+      ErrorCode.COLUMN_NOT_FOUND,
+      `Jira column name '${input}' is ambiguous; use one of these column ids: ${byName
+        .map((column) => column.id)
+        .join(', ')}`,
+    )
+  }
+  const byStatus = columns.find((column) => decodeColumnStatusIds(column).includes(input))
+  if (byStatus) return byStatus.id
+  throw new KanbanError(ErrorCode.COLUMN_NOT_FOUND, `No Jira column matching '${input}'`)
+}
+
 interface JiraIssueRow {
   id: string
   key: string

package/src/providers/jira.ts

@@ -32,6 +32,8 @@ import {
   getCachedTask,
   getCachedTasks,
   initJiraCacheSchema,
+  jiraBoardColumnRows,
+  resolveJiraColumnId,
   loadJiraSyncMeta,
   loadTeamInfo,
   pruneJiraIssuesMissingUpstream,
@@ -122,13 +124,7 @@ export class JiraProvider implements KanbanProvider {
     if (this.config.boardId !== undefined) {
       const boardCfg = await this.client.getBoardColumns(this.config.boardId)
       const boardId = this.config.boardId
-      const rows = boardCfg.columnConfig.columns.map((col, i) => ({
-        id: `board:${boardId}:${col.name}`,
-        name: col.name,
-        position: i,
-        statusIds: col.statuses.map((s) => s.id),
-        source: 'board' as const,
-      }))
+      const rows = jiraBoardColumnRows(boardId, boardCfg.columnConfig.columns)
       replaceJiraColumns(this.db, rows)
     } else {
       const statusCats = await this.client.getProjectStatuses(project.key)
@@ -275,18 +271,7 @@ export class JiraProvider implements KanbanProvider {
   }
 
   private resolveColumnId(input: string): string {
-    const columns = getCachedColumns(this.db)
-    // Priority 1: exact id.
-    const byId = columns.find((c) => c.id === input)
-    if (byId) return byId.id
-    // Priority 2: case-insensitive name.
-    const lower = input.toLowerCase()
-    const byName = columns.find((c) => c.name.toLowerCase() === lower)
-    if (byName) return byName.id
-    // Priority 3: status_ids containment (raw status id).
-    const byStatus = columns.find((c) => decodeColumnStatusIds(c).includes(input))
-    if (byStatus) return byStatus.id
-    throw new KanbanError(ErrorCode.COLUMN_NOT_FOUND, `No Jira column matching '${input}'`)
+    return resolveJiraColumnId(getCachedColumns(this.db), input)
   }
 
   private async buildBoardConfig(): Promise<BoardConfig> {

package/src/providers/postgres-jira.ts

@@ -14,7 +14,13 @@ import type {
   TaskComment,
 } from '../types'
 import { JIRA_CAPABILITIES } from './capabilities'
-import { decodeColumnStatusIds, type JiraActivityRow, type JiraColumnRow } from './jira-cache'
+import {
+  decodeColumnStatusIds,
+  jiraBoardColumnRows,
+  resolveJiraColumnId,
+  type JiraActivityRow,
+  type JiraColumnRow,
+} from './jira-cache'
 import { adfToPlainText, plainTextToAdf, type AdfDocument } from './jira-adf'
 import { JiraClient, normalizeJiraLabels, type JiraComment, type JiraIssue } from './jira-client'
 import type { JiraProviderConfig } from './jira'
@@ -605,15 +611,7 @@ export class PostgresJiraProvider implements KanbanProvider {
     if (this.config.boardId !== undefined) {
       const boardCfg = await this.client.getBoardColumns(this.config.boardId)
       const boardId = this.config.boardId
-      await this.replaceColumns(
-        boardCfg.columnConfig.columns.map((column, index) => ({
-          id: `board:${boardId}:${column.name}`,
-          name: column.name,
-          position: index,
-          statusIds: column.statuses.map((status) => status.id),
-          source: 'board' as const,
-        })),
-      )
+      await this.replaceColumns(jiraBoardColumnRows(boardId, boardCfg.columnConfig.columns))
     } else {
       const statusCats = await this.client.getProjectStatuses(project.key)
       const seen = new Set<string>()
@@ -741,15 +739,7 @@ export class PostgresJiraProvider implements KanbanProvider {
   }
 
   private async resolveColumnId(input: string): Promise<string> {
-    const columns = await this.getColumns()
-    const byId = columns.find((column) => column.id === input)
-    if (byId) return byId.id
-    const lower = input.toLowerCase()
-    const byName = columns.find((column) => column.name.toLowerCase() === lower)
-    if (byName) return byName.id
-    const byStatus = columns.find((column) => decodeColumnStatusIds(column).includes(input))
-    if (byStatus) return byStatus.id
-    throw new KanbanError(ErrorCode.COLUMN_NOT_FOUND, `No Jira column matching '${input}'`)
+    return resolveJiraColumnId(await this.getColumns(), input)
   }
 
   private async buildBoardConfig(): Promise<BoardConfig> {