@andypai/agent-kanban 0.2.0 → 0.3.1

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

@@ -0,0 +1,304 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { Database } from 'bun:sqlite'
+import {
+  decodeColumnStatusIds,
+  getCachedBoard,
+  getCachedColumns,
+  getCachedConfig,
+  getCachedTask,
+  getCachedTasks,
+  initJiraCacheSchema,
+  loadJiraSyncMeta,
+  replaceJiraColumns,
+  replaceJiraIssueTypes,
+  replaceJiraPriorities,
+  saveJiraSyncMeta,
+  upsertJiraIssues,
+  upsertJiraUsers,
+} from '../providers/jira-cache'
+
+let db: Database
+
+beforeEach(() => {
+  db = new Database(':memory:')
+  initJiraCacheSchema(db)
+})
+
+describe('jira-cache', () => {
+  test('initJiraCacheSchema is idempotent', () => {
+    saveJiraSyncMeta(db, { projectKey: 'SENTINEL' })
+    expect(() => initJiraCacheSchema(db)).not.toThrow()
+    expect(loadJiraSyncMeta(db).projectKey).toBe('SENTINEL')
+  })
+
+  test('sync meta round-trips each key', () => {
+    saveJiraSyncMeta(db, {
+      projectKey: 'ENG',
+      boardId: 42,
+      lastSyncAt: '2026-01-01T00:00:00Z',
+      lastIssueUpdatedAt: '2026-01-02T00:00:00Z',
+    })
+    const loaded = loadJiraSyncMeta(db)
+    expect(loaded.projectKey).toBe('ENG')
+    expect(loaded.boardId).toBe(42)
+    expect(loaded.lastSyncAt).toBe('2026-01-01T00:00:00Z')
+    expect(loaded.lastIssueUpdatedAt).toBe('2026-01-02T00:00:00Z')
+  })
+
+  test('replaceJiraColumns preserves status_ids ordering and source', () => {
+    replaceJiraColumns(db, [
+      {
+        id: 'board:1:To Do',
+        name: 'To Do',
+        position: 0,
+        statusIds: ['10001', '10002', '10003'],
+        source: 'board',
+      },
+    ])
+    const columns = getCachedColumns(db)
+    expect(columns).toHaveLength(1)
+    const col = columns[0]!
+    expect(col.source).toBe('board')
+    expect(decodeColumnStatusIds(col)).toEqual(['10001', '10002', '10003'])
+  })
+
+  test('decodeColumnStatusIds handles 3-element array without ordering loss', () => {
+    expect(decodeColumnStatusIds({ status_ids: JSON.stringify(['c', 'a', 'b']) })).toEqual([
+      'c',
+      'a',
+      'b',
+    ])
+  })
+
+  test('upsertJiraUsers round-trip and active filter', () => {
+    upsertJiraUsers(db, [
+      { accountId: 'a1', displayName: 'Alice', active: true },
+      { accountId: 'a2', displayName: 'Bob', active: true },
+      { accountId: 'a3', displayName: 'Zara', active: false },
+    ])
+    const { users } = getCachedConfig(db)
+    expect(users).toHaveLength(2)
+    expect(users.map((u) => u.displayName).sort()).toEqual(['Alice', 'Bob'])
+    expect(users.every((u) => typeof u.accountId === 'string')).toBe(true)
+  })
+
+  test('upsertJiraIssues round-trip with full Task shape', () => {
+    upsertJiraIssues(db, [
+      {
+        id: '10001',
+        key: 'ENG-1',
+        summary: 'Fix login',
+        descriptionText: 'hello world',
+        statusId: '30',
+        priorityName: 'High',
+        issueTypeName: 'Bug',
+        assigneeAccountId: 'a1',
+        assigneeName: 'Alice',
+        projectKey: 'ENG',
+        url: 'https://jira/browse/ENG-1',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-02T00:00:00Z',
+      },
+    ])
+    const viaKey = getCachedTask(db, 'ENG-1')
+    expect(viaKey).not.toBeNull()
+    expect(viaKey).toMatchObject({
+      id: 'jira:10001',
+      providerId: '10001',
+      externalRef: 'ENG-1',
+      title: 'Fix login',
+      description: 'hello world',
+      column_id: '30',
+      position: 0,
+      priority: 'high',
+      assignee: 'Alice',
+      project: 'ENG',
+      url: 'https://jira/browse/ENG-1',
+      metadata: '{}',
+    })
+    expect(getCachedTask(db, 'jira:10001')).not.toBeNull()
+    expect(getCachedTask(db, '10001')).not.toBeNull()
+  })
+
+  test('getCachedBoard groups issues by many-to-one column-to-status mapping', () => {
+    replaceJiraColumns(db, [
+      {
+        id: 'board:1:In Progress',
+        name: 'In Progress',
+        position: 0,
+        statusIds: ['10001', '10002'],
+        source: 'board',
+      },
+    ])
+    upsertJiraIssues(db, [
+      {
+        id: '1',
+        key: 'ENG-1',
+        summary: 'a',
+        descriptionText: '',
+        statusId: '10001',
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-03T00:00:00Z',
+      },
+      {
+        id: '2',
+        key: 'ENG-2',
+        summary: 'b',
+        descriptionText: '',
+        statusId: '10002',
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-02T00:00:00Z',
+      },
+      {
+        id: '3',
+        key: 'ENG-3',
+        summary: 'c',
+        descriptionText: '',
+        statusId: '99999',
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+      },
+    ])
+    const board = getCachedBoard(db)
+    expect(board.columns).toHaveLength(1)
+    const col = board.columns[0]!
+    expect(col.tasks).toHaveLength(2)
+    const refs = new Set(col.tasks.map((t) => t.externalRef))
+    expect(refs).toEqual(new Set(['ENG-1', 'ENG-2']))
+  })
+
+  test('getCachedTasks({ columnId }) filters to the column status_ids', () => {
+    const columnId = 'board:1:In Progress'
+    replaceJiraColumns(db, [
+      {
+        id: columnId,
+        name: 'In Progress',
+        position: 0,
+        statusIds: ['10001', '10002'],
+        source: 'board',
+      },
+    ])
+    upsertJiraIssues(db, [
+      {
+        id: '1',
+        key: 'ENG-1',
+        summary: 'a',
+        descriptionText: '',
+        statusId: '10001',
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-03T00:00:00Z',
+      },
+      {
+        id: '2',
+        key: 'ENG-2',
+        summary: 'b',
+        descriptionText: '',
+        statusId: '10002',
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-02T00:00:00Z',
+      },
+      {
+        id: '3',
+        key: 'ENG-3',
+        summary: 'c',
+        descriptionText: '',
+        statusId: '99999',
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+      },
+    ])
+    expect(getCachedTasks(db, { columnId })).toHaveLength(2)
+    expect(getCachedTasks(db)).toHaveLength(3)
+  })
+
+  test('priority name mapping is case-insensitive with urgent/high/medium/low fallback', () => {
+    const samples: Array<{ key: string; priority: string; expected: string }> = [
+      { key: 'ENG-1', priority: 'Highest', expected: 'urgent' },
+      { key: 'ENG-2', priority: 'high', expected: 'high' },
+      { key: 'ENG-3', priority: 'MEDIUM', expected: 'medium' },
+      { key: 'ENG-4', priority: 'weird', expected: 'low' },
+      { key: 'ENG-5', priority: '', expected: 'low' },
+    ]
+    upsertJiraIssues(
+      db,
+      samples.map((s, i) => ({
+        id: String(1000 + i),
+        key: s.key,
+        summary: s.key,
+        descriptionText: '',
+        statusId: '10',
+        priorityName: s.priority,
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: `2026-01-0${i + 1}T00:00:00Z`,
+      })),
+    )
+    for (const s of samples) {
+      const task = getCachedTask(db, s.key)
+      expect(task).not.toBeNull()
+      expect(task?.priority as string).toBe(s.expected)
+    }
+  })
+
+  test('saveJiraSyncMeta partial does not clobber prior values; omit=preserve, null=clear', () => {
+    saveJiraSyncMeta(db, { projectKey: 'ENG', boardId: 42 })
+    saveJiraSyncMeta(db, { lastSyncAt: '2026-01-01T00:00:00Z' })
+    let loaded = loadJiraSyncMeta(db)
+    expect(loaded.projectKey).toBe('ENG')
+    expect(loaded.boardId).toBe(42)
+    expect(loaded.lastSyncAt).toBe('2026-01-01T00:00:00Z')
+
+    saveJiraSyncMeta(db, { projectKey: null })
+    loaded = loadJiraSyncMeta(db)
+    expect(loaded.projectKey).toBeNull()
+    expect(loaded.boardId).toBe(42)
+    expect(loaded.lastSyncAt).toBe('2026-01-01T00:00:00Z')
+  })
+
+  test('getCachedConfig returns internal shape, not BoardConfig', () => {
+    upsertJiraUsers(db, [{ accountId: 'a1', displayName: 'Alice' }])
+    replaceJiraPriorities(db, [{ id: '1', name: 'High' }])
+    replaceJiraIssueTypes(db, [{ id: '10000', name: 'Bug' }])
+    saveJiraSyncMeta(db, { projectKey: 'ENG' })
+    const config = getCachedConfig(db)
+    expect(config.projectKey).toBe('ENG')
+    expect(Array.isArray(config.users)).toBe(true)
+    expect(config.users.length).toBeGreaterThan(0)
+    expect(config.users[0]).toEqual({ accountId: 'a1', displayName: 'Alice' })
+    expect(config.priorities.length).toBeGreaterThan(0)
+    expect(config.issueTypes.length).toBeGreaterThan(0)
+    const keys = Object.keys(config)
+    expect(keys).not.toContain('members')
+    expect(keys).not.toContain('discoveredAssignees')
+    expect(keys).not.toContain('discoveredProjects')
+    expect(keys).not.toContain('provider')
+  })
+
+  test('empty status_ids array short-circuits with no SQL error', () => {
+    const columnId = 'board:1:Empty'
+    replaceJiraColumns(db, [
+      { id: columnId, name: 'Empty', position: 0, statusIds: [], source: 'board' },
+    ])
+    upsertJiraIssues(db, [
+      {
+        id: '1',
+        key: 'ENG-1',
+        summary: 'a',
+        descriptionText: '',
+        statusId: '10001',
+        projectKey: 'ENG',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-03T00:00:00Z',
+      },
+    ])
+    const board = getCachedBoard(db)
+    expect(board.columns[0]!.tasks).toEqual([])
+    expect(getCachedTasks(db, { columnId })).toEqual([])
+  })
+})

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

@@ -0,0 +1,169 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { Buffer } from 'node:buffer'
+import { ErrorCode, KanbanError } from '../errors'
+import { JiraClient } from '../providers/jira-client'
+
+const origFetch = globalThis.fetch
+let lastRequest: { url: string; init?: RequestInit } | null = null
+
+afterEach(() => {
+  globalThis.fetch = origFetch
+  lastRequest = null
+})
+
+function stub(response: Response): void {
+  globalThis.fetch = (async (url: string | URL, init?: RequestInit) => {
+    lastRequest = { url: String(url), init }
+    return response
+  }) as unknown as typeof fetch
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  })
+}
+
+function makeClient(): JiraClient {
+  return new JiraClient({
+    baseUrl: 'https://example.atlassian.net/',
+    email: 'user@example.com',
+    apiToken: 'tok123',
+  })
+}
+
+describe('JiraClient', () => {
+  test('auth header format', async () => {
+    stub(jsonResponse({ id: '10000', key: 'ABC', name: 'Alpha' }))
+    const client = makeClient()
+    await client.getProject('ABC')
+    expect(lastRequest).not.toBeNull()
+    const headers = (lastRequest!.init!.headers ?? {}) as Record<string, string>
+    const expected = `Basic ${Buffer.from('user@example.com:tok123').toString('base64')}`
+    expect(headers.Authorization).toBe(expected)
+    expect(headers.Accept).toBe('application/json')
+    expect(headers['Content-Type']).toBe('application/json')
+    expect(lastRequest!.url).toBe('https://example.atlassian.net/rest/api/3/project/ABC')
+  })
+
+  test('happy path getIssue', async () => {
+    const body = {
+      id: '10001',
+      key: 'ABC-1',
+      fields: {
+        summary: 'hello',
+        status: { id: '1', name: 'To Do' },
+        issuetype: { id: '10000', name: 'Task' },
+        created: '2026-01-01T00:00:00.000Z',
+        updated: '2026-01-02T00:00:00.000Z',
+      },
+    }
+    stub(jsonResponse(body))
+    const client = makeClient()
+    const issue = await client.getIssue('ABC-1')
+    expect(issue.key).toBe('ABC-1')
+    expect(issue.fields.summary).toBe('hello')
+    expect(issue.fields.status.name).toBe('To Do')
+  })
+
+  test('401 maps to PROVIDER_AUTH_FAILED', async () => {
+    stub(new Response('', { status: 401 }))
+    const client = makeClient()
+    let err: unknown
+    try {
+      await client.getIssue('ABC-1')
+    } catch (e) {
+      err = e
+    }
+    expect(err).toBeInstanceOf(KanbanError)
+    expect((err as KanbanError).code).toBe(ErrorCode.PROVIDER_AUTH_FAILED)
+  })
+
+  test('403 maps to PROVIDER_AUTH_FAILED', async () => {
+    stub(new Response('', { status: 403 }))
+    const client = makeClient()
+    let err: unknown
+    try {
+      await client.getIssue('ABC-1')
+    } catch (e) {
+      err = e
+    }
+    expect(err).toBeInstanceOf(KanbanError)
+    expect((err as KanbanError).code).toBe(ErrorCode.PROVIDER_AUTH_FAILED)
+  })
+
+  test('429 maps to PROVIDER_RATE_LIMITED', async () => {
+    stub(new Response('', { status: 429 }))
+    const client = makeClient()
+    let err: unknown
+    try {
+      await client.getIssue('ABC-1')
+    } catch (e) {
+      err = e
+    }
+    expect(err).toBeInstanceOf(KanbanError)
+    expect((err as KanbanError).code).toBe(ErrorCode.PROVIDER_RATE_LIMITED)
+  })
+
+  test('400 with errorMessages and errors maps to PROVIDER_UPSTREAM_ERROR', async () => {
+    stub(
+      jsonResponse(
+        {
+          errorMessages: ['Field required'],
+          errors: { summary: 'is required' },
+        },
+        400,
+      ),
+    )
+    const client = makeClient()
+    let err: unknown
+    try {
+      await client.createIssue({ fields: {} })
+    } catch (e) {
+      err = e
+    }
+    expect(err).toBeInstanceOf(KanbanError)
+    const ke = err as KanbanError
+    expect(ke.code).toBe(ErrorCode.PROVIDER_UPSTREAM_ERROR)
+    expect(ke.message).toContain('Field required')
+    expect(ke.message).toContain('summary')
+    expect(ke.message).toContain('is required')
+  })
+
+  test('listIssues pagination passes startAt and maxResults as query params', async () => {
+    stub(jsonResponse({ startAt: 50, maxResults: 100, total: 0, issues: [] }))
+    const client = makeClient()
+    await client.listIssues({
+      jql: 'project = ABC',
+      startAt: 50,
+      maxResults: 100,
+    })
+    expect(lastRequest).not.toBeNull()
+    const url = lastRequest!.url
+    expect(url).toContain('/rest/api/3/search/jql')
+    expect(url).toContain('startAt=50')
+    expect(url).toContain('maxResults=100')
+    // URLSearchParams canonical form uses '+' for spaces and %3D for '='
+    expect(url).toContain('jql=project+%3D+ABC')
+  })
+
+  test('updateIssue succeeds on HTTP 204 without JSON parse', async () => {
+    stub(new Response(null, { status: 204 }))
+    const client = makeClient()
+    const result = await client.updateIssue('ABC-1', {
+      fields: { summary: 'new' },
+    })
+    expect(result).toBeUndefined()
+  })
+
+  test('transitionIssue succeeds on HTTP 204', async () => {
+    stub(new Response(null, { status: 204 }))
+    const client = makeClient()
+    await client.transitionIssue('ABC-1', '11')
+    expect(lastRequest).not.toBeNull()
+    expect(lastRequest!.init!.method).toBe('POST')
+    const sentBody = String(lastRequest!.init!.body)
+    expect(sentBody).toContain('"transition":{"id":"11"}')
+  })
+})