@andypai/agent-kanban 0.3.3 → 0.3.5

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

@@ -0,0 +1,315 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import postgres from 'postgres'
+
+import { run } from '../index'
+import type { Task } from '../types'
+
+const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
+const pgTest = databaseUrl ? test : test.skip
+
+type FetchInit = RequestInit | undefined
+type StubCall = { url: string; init?: FetchInit }
+type StubHandler = (url: string, init?: FetchInit) => Response | Promise<Response>
+type StubRoute = { match: (url: string) => boolean; handler: StubHandler }
+
+function jiraFetchStub(routes: StubRoute[]): {
+  fn: typeof fetch
+  calls: StubCall[]
+} {
+  const calls: StubCall[] = []
+  const fn = (async (input: string | URL | Request, init?: FetchInit) => {
+    const url =
+      typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url
+    calls.push({ url, init })
+    for (const route of routes) {
+      if (route.match(url)) return route.handler(url, init)
+    }
+    return new Response('route not stubbed: ' + url, { status: 500 })
+  }) as unknown as typeof fetch
+  return { fn, calls }
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  })
+}
+
+const projectFixture = { id: '10000', key: 'ENG', name: 'Engineering' }
+
+function makeIssue(
+  overrides: Partial<{
+    id: string
+    key: string
+    summary: string
+    updated: string
+  }> = {},
+): Record<string, unknown> {
+  return {
+    id: overrides.id ?? '10001',
+    key: overrides.key ?? 'ENG-1',
+    fields: {
+      summary: overrides.summary ?? 'Postgres cached Jira issue',
+      description: null,
+      status: { id: '10', name: 'To Do' },
+      issuetype: { id: '10000', name: 'Task' },
+      priority: { id: '2', name: 'High' },
+      assignee: { accountId: 'a1', displayName: 'Alice' },
+      labels: ['garage'],
+      comment: { total: 0 },
+      created: '2026-01-01T00:00:00Z',
+      updated: overrides.updated ?? '2026-01-02T00:00:00Z',
+      project: { id: '10000', key: 'ENG' },
+    },
+  }
+}
+
+function standardRoutes(): StubRoute[] {
+  const issues = [makeIssue()]
+  const comments: Record<
+    string,
+    Array<{ id: string; body: unknown; created: string; updated: string }>
+  > = {}
+  const setIssueStatus = (issueKey: string, statusId: string, name: string): void => {
+    const issue = issues.find((candidate) => String(candidate.key) === issueKey) as
+      | { fields?: { status?: { id: string; name: string }; updated?: string } }
+      | undefined
+    if (!issue?.fields?.status) return
+    issue.fields.status = { id: statusId, name }
+    issue.fields.updated = '2026-01-06T00:00:00Z'
+  }
+  return [
+    {
+      match: (url) => url.includes('/rest/api/3/project/ENG/statuses'),
+      handler: () =>
+        jsonResponse([
+          {
+            id: 'cat-1',
+            name: 'To Do',
+            statuses: [
+              { id: '10', name: 'To Do' },
+              { id: '20', name: 'Done' },
+            ],
+          },
+        ]),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/project/ENG'),
+      handler: () => jsonResponse(projectFixture),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/user/assignable/search'),
+      handler: () => jsonResponse([{ accountId: 'a1', displayName: 'Alice', active: true }]),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/priority'),
+      handler: () => jsonResponse([{ id: '2', name: 'High' }]),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/issuetype/project'),
+      handler: () => jsonResponse([{ id: '10000', name: 'Task' }]),
+    },
+    {
+      match: (url) => url.endsWith('/rest/api/3/issue'),
+      handler: async (_url, init) => {
+        const body = JSON.parse(String(init?.body ?? '{}')) as {
+          fields?: { summary?: string }
+        }
+        const issue = makeIssue({
+          id: '10002',
+          key: 'ENG-2',
+          summary: body.fields?.summary ?? 'Created issue',
+          updated: '2026-01-03T00:00:00Z',
+        })
+        issues.push(issue)
+        return jsonResponse(
+          { id: '10002', key: 'ENG-2', self: 'https://example/rest/api/3/issue/10002' },
+          201,
+        )
+      },
+    },
+    {
+      match: (url) => /\/rest\/api\/3\/issue\/ENG-\d+\/comment$/.test(new URL(url).pathname),
+      handler: async (url, init) => {
+        const issueKey = new URL(url).pathname.match(/\/issue\/(ENG-\d+)\/comment/)![1]!
+        if (init?.method === 'POST') {
+          const body = JSON.parse(String(init.body ?? '{}')) as { body?: unknown }
+          const row = {
+            id: `comment-${(comments[issueKey]?.length ?? 0) + 1}`,
+            body: body.body,
+            created: '2026-01-04T00:00:00Z',
+            updated: '2026-01-04T00:00:00Z',
+          }
+          comments[issueKey] = [...(comments[issueKey] ?? []), row]
+          return jsonResponse(row, 201)
+        }
+        return jsonResponse({
+          startAt: 0,
+          maxResults: 100,
+          total: comments[issueKey]?.length ?? 0,
+          comments: comments[issueKey] ?? [],
+        })
+      },
+    },
+    {
+      match: (url) =>
+        /\/rest\/api\/3\/issue\/ENG-\d+\/comment\/comment-\d+$/.test(new URL(url).pathname),
+      handler: async (url, init) => {
+        const [, issueKey, commentId] = new URL(url).pathname.match(
+          /\/issue\/(ENG-\d+)\/comment\/(comment-\d+)$/,
+        )!
+        const rows = comments[issueKey!] ?? []
+        const existing = rows.find((row) => row.id === commentId)
+        if (!existing) return jsonResponse({ errorMessages: ['missing'] }, 404)
+        if (init?.method === 'PUT') {
+          const body = JSON.parse(String(init.body ?? '{}')) as { body?: unknown }
+          existing.body = body.body
+          existing.updated = '2026-01-05T00:00:00Z'
+        }
+        return jsonResponse(existing)
+      },
+    },
+    {
+      match: (url) => /\/rest\/api\/3\/issue\/ENG-\d+\/transitions$/.test(new URL(url).pathname),
+      handler: async (url, init) => {
+        const issueKey = new URL(url).pathname.match(/\/issue\/(ENG-\d+)\/transitions$/)![1]!
+        if (init?.method === 'POST') {
+          setIssueStatus(issueKey, '20', 'Done')
+          return new Response(null, { status: 204 })
+        }
+        return jsonResponse({
+          transitions: [{ id: 'move-done', name: 'Done', to: { id: '20', name: 'Done' } }],
+        })
+      },
+    },
+    {
+      match: (url) => /\/rest\/api\/3\/issue\/[^/]+\/changelog/.test(url),
+      handler: () =>
+        jsonResponse({
+          startAt: 0,
+          maxResults: 100,
+          total: 0,
+          isLast: true,
+          values: [],
+        }),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/search/jql'),
+      handler: () =>
+        jsonResponse({
+          startAt: 0,
+          maxResults: 100,
+          total: issues.length,
+          issues,
+        }),
+    },
+  ]
+}
+
+function expectOk<T>(result: Awaited<ReturnType<typeof run>>): T {
+  expect(result.exitCode).toBe(0)
+  expect(result.output.ok).toBe(true)
+  if (!result.output.ok) throw new Error('expected successful CLI output')
+  return result.output.data as T
+}
+
+describe('postgres jira provider', () => {
+  let previousEnv: Record<string, string | undefined>
+  let previousFetch: typeof fetch
+  let sql: postgres.Sql | null = null
+
+  beforeEach(async () => {
+    previousFetch = globalThis.fetch
+    previousEnv = {
+      KANBAN_STORAGE: process.env['KANBAN_STORAGE'],
+      KANBAN_DATABASE_URL: process.env['KANBAN_DATABASE_URL'],
+      KANBAN_PROVIDER: process.env['KANBAN_PROVIDER'],
+      JIRA_BASE_URL: process.env['JIRA_BASE_URL'],
+      JIRA_EMAIL: process.env['JIRA_EMAIL'],
+      JIRA_API_TOKEN: process.env['JIRA_API_TOKEN'],
+      JIRA_PROJECT_KEY: process.env['JIRA_PROJECT_KEY'],
+    }
+
+    process.env['KANBAN_STORAGE'] = 'postgres'
+    process.env['KANBAN_DATABASE_URL'] = databaseUrl
+    process.env['KANBAN_PROVIDER'] = 'jira'
+    process.env['JIRA_BASE_URL'] = 'https://example.atlassian.net'
+    process.env['JIRA_EMAIL'] = 'user@example.com'
+    process.env['JIRA_API_TOKEN'] = 'token'
+    process.env['JIRA_PROJECT_KEY'] = 'ENG'
+
+    if (databaseUrl) {
+      sql = postgres(databaseUrl, { max: 1, onnotice: () => {} })
+      await sql`DROP TABLE IF EXISTS jira_activity`
+      await sql`DROP TABLE IF EXISTS jira_issues`
+      await sql`DROP TABLE IF EXISTS jira_issue_types`
+      await sql`DROP TABLE IF EXISTS jira_priorities`
+      await sql`DROP TABLE IF EXISTS jira_users`
+      await sql`DROP TABLE IF EXISTS jira_columns`
+      await sql`DROP TABLE IF EXISTS jira_sync_meta`
+    }
+
+    globalThis.fetch = jiraFetchStub(standardRoutes()).fn
+  })
+
+  afterEach(async () => {
+    globalThis.fetch = previousFetch
+    if (sql) {
+      await sql.end({ timeout: 1 })
+      sql = null
+    }
+    for (const [key, value] of Object.entries(previousEnv)) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+  })
+
+  pgTest('lists Jira tasks from a shared Postgres cache through the CLI path', async () => {
+    const tasks = expectOk<Task[]>(await run(['task', 'list', '-c', 'To Do']))
+
+    expect(tasks).toHaveLength(1)
+    expect(tasks[0]).toMatchObject({
+      id: 'jira:10001',
+      externalRef: 'ENG-1',
+      title: 'Postgres cached Jira issue',
+      priority: 'high',
+      assignee: 'Alice',
+      project: 'ENG',
+    })
+  })
+
+  pgTest('creates Jira tasks and writes comments through Postgres storage', async () => {
+    const created = expectOk<Task>(
+      await run(['task', 'add', 'Created through Postgres Jira', '-p', 'high', '-a', 'Alice']),
+    )
+
+    expect(created).toMatchObject({
+      id: 'jira:10002',
+      externalRef: 'ENG-2',
+      title: 'Created through Postgres Jira',
+      priority: 'high',
+      assignee: 'Alice',
+    })
+
+    const comment = expectOk(await run(['comment', 'add', 'ENG-2', 'Garage projection comment']))
+    expect(comment).toMatchObject({
+      id: 'comment-1',
+      task_id: 'jira:10002',
+      body: 'Garage projection comment',
+    })
+
+    const comments = expectOk(await run(['comment', 'list', 'ENG-2']))
+    expect(comments).toHaveLength(1)
+  })
+
+  pgTest('moves Jira tasks through Postgres storage', async () => {
+    const moved = expectOk<Task>(await run(['task', 'move', 'ENG-1', 'Done']))
+
+    expect(moved).toMatchObject({
+      id: 'jira:10001',
+      externalRef: 'ENG-1',
+      column_id: '20',
+    })
+  })
+})

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

@@ -0,0 +1,309 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import postgres from 'postgres'
+
+import { run } from '../index'
+import type { Task, TaskComment } from '../types'
+
+const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
+const pgTest = databaseUrl ? test : test.skip
+
+type StubIssue = {
+  id: string
+  identifier: string
+  title: string
+  description: string
+  priority: number
+  url: string
+  createdAt: string
+  updatedAt: string
+  assignee: { id: string; name: string; displayName: string } | null
+  project: { id: string; name: string; url: string; state: string } | null
+  state: { id: string; name: string; position: number }
+  labels: { nodes: Array<{ id: string; name: string }> }
+  comments: { nodes: Array<{ id: string }>; pageInfo: { hasNextPage: boolean; endCursor: null } }
+}
+
+type StubComment = {
+  id: string
+  body: string
+  createdAt: string
+  updatedAt: string
+  user: { id: string; name: string; displayName: string }
+}
+
+function expectOk<T>(result: Awaited<ReturnType<typeof run>>): T {
+  expect(result.exitCode).toBe(0)
+  expect(result.output.ok).toBe(true)
+  if (!result.output.ok) throw new Error('expected successful CLI output')
+  return result.output.data as T
+}
+
+function makeIssue(overrides: Partial<StubIssue> = {}): StubIssue {
+  return {
+    id: overrides.id ?? 'lin-1',
+    identifier: overrides.identifier ?? 'GB-1',
+    title: overrides.title ?? 'Postgres cached Linear issue',
+    description: overrides.description ?? 'Cached in Postgres',
+    priority: overrides.priority ?? 2,
+    url: overrides.url ?? 'https://linear.app/issue/GB-1',
+    createdAt: overrides.createdAt ?? '2026-01-01T00:00:00.000Z',
+    updatedAt: overrides.updatedAt ?? '2026-01-02T00:00:00.000Z',
+    assignee: overrides.assignee ?? { id: 'user-1', name: 'Alice', displayName: 'Alice' },
+    project: overrides.project ?? {
+      id: 'proj-1',
+      name: 'Garage',
+      url: 'https://linear.app/project/garage',
+      state: 'started',
+    },
+    state: overrides.state ?? { id: 'state-todo', name: 'Todo', position: 0 },
+    labels: overrides.labels ?? { nodes: [{ id: 'label-1', name: 'garage' }] },
+    comments: overrides.comments ?? {
+      nodes: [],
+      pageInfo: { hasNextPage: false, endCursor: null },
+    },
+  }
+}
+
+function linearFetchStub(): typeof fetch {
+  const commentsByIssue = new Map<string, StubComment[]>()
+  const issues: StubIssue[] = [makeIssue()]
+  const states = [
+    { id: 'state-todo', name: 'Todo', position: 0, color: '#888', type: 'unstarted' },
+    { id: 'state-done', name: 'Done', position: 1, color: '#0a0', type: 'completed' },
+  ]
+  const team = { id: 'team-1', key: 'GB', name: 'Garage Band', states: { nodes: states } }
+  const users = {
+    nodes: [
+      { id: 'user-1', name: 'Alice', displayName: 'Alice', active: true },
+      { id: 'user-2', name: 'Bob', displayName: 'Bob', active: true },
+    ],
+  }
+  const projects = {
+    nodes: [
+      { id: 'proj-1', name: 'Garage', url: 'https://linear.app/project/garage', state: 'started' },
+    ],
+  }
+
+  return (async (_input: string | URL | Request, init?: RequestInit) => {
+    const body = JSON.parse(String(init?.body ?? '{}')) as {
+      query: string
+      variables?: Record<string, unknown>
+    }
+    const query = body.query
+    const variables = body.variables ?? {}
+
+    if (query.includes('query TeamSnapshot')) {
+      return Response.json({ data: { team } })
+    }
+    if (query.includes('query Users')) {
+      return Response.json({ data: { users } })
+    }
+    if (query.includes('query Projects')) {
+      return Response.json({ data: { projects } })
+    }
+    if (query.includes('query Issues')) {
+      return Response.json({
+        data: {
+          issues: {
+            nodes: issues,
+            pageInfo: { hasNextPage: false, endCursor: null },
+          },
+        },
+      })
+    }
+    if (query.includes('mutation CreateIssue')) {
+      const input = variables.input as {
+        title: string
+        description?: string
+        priority?: number
+        stateId?: string
+        assigneeId?: string
+        projectId?: string
+      }
+      const state = states.find((candidate) => candidate.id === input.stateId) ?? states[0]!
+      const issue = makeIssue({
+        id: 'lin-2',
+        identifier: 'GB-2',
+        title: input.title,
+        description: input.description ?? '',
+        priority: input.priority ?? 0,
+        state,
+        assignee: users.nodes.find((user) => user.id === input.assigneeId) ?? null,
+        project: projects.nodes.find((project) => project.id === input.projectId) ?? null,
+        updatedAt: '2026-01-03T00:00:00.000Z',
+      })
+      issues.push(issue)
+      return Response.json({ data: { issueCreate: { success: true, issue } } })
+    }
+    if (query.includes('mutation UpdateIssue')) {
+      const issue = issues.find((candidate) => candidate.id === variables.id)
+      const input = variables.input as { stateId?: string; title?: string }
+      if (issue) {
+        if (input.stateId) {
+          const state = states.find((candidate) => candidate.id === input.stateId)
+          if (state) issue.state = state
+        }
+        if (input.title) issue.title = input.title
+        issue.updatedAt = '2026-01-04T00:00:00.000Z'
+      }
+      return Response.json({ data: { issueUpdate: { success: true } } })
+    }
+    if (query.includes('query IssueComments')) {
+      const issueId = String(variables.issueId)
+      return Response.json({
+        data: {
+          issue: {
+            comments: {
+              nodes: commentsByIssue.get(issueId) ?? [],
+              pageInfo: { hasNextPage: false, endCursor: null },
+            },
+          },
+        },
+      })
+    }
+    if (query.includes('query Comment')) {
+      const comment = [...commentsByIssue.values()]
+        .flat()
+        .find((candidate) => candidate.id === variables.id)
+      return Response.json({ data: { comment: comment ?? null } })
+    }
+    if (query.includes('mutation CommentCreate')) {
+      const input = variables.input as { issueId: string; body: string }
+      const row: StubComment = {
+        id: `comment-${(commentsByIssue.get(input.issueId)?.length ?? 0) + 1}`,
+        body: input.body,
+        createdAt: '2026-01-05T00:00:00.000Z',
+        updatedAt: '2026-01-05T00:00:00.000Z',
+        user: { id: 'user-1', name: 'Alice', displayName: 'Alice' },
+      }
+      commentsByIssue.set(input.issueId, [...(commentsByIssue.get(input.issueId) ?? []), row])
+      return Response.json({ data: { commentCreate: { success: true, comment: row } } })
+    }
+    if (query.includes('mutation CommentUpdate')) {
+      const row = [...commentsByIssue.values()]
+        .flat()
+        .find((candidate) => candidate.id === variables.id)
+      if (row) {
+        row.body = (variables.input as { body: string }).body
+        row.updatedAt = '2026-01-06T00:00:00.000Z'
+      }
+      return Response.json({ data: { commentUpdate: { success: true, comment: row ?? null } } })
+    }
+    if (query.includes('query IssueHistory')) {
+      return Response.json({
+        data: {
+          issue: {
+            history: {
+              nodes: [],
+              pageInfo: { hasNextPage: false, endCursor: null },
+            },
+          },
+        },
+      })
+    }
+    if (query.includes('query IssueTeam')) {
+      return Response.json({ data: { issue: { team: { id: 'team-1', key: 'GB' } } } })
+    }
+
+    return Response.json({ errors: [{ message: 'unhandled Linear query' }] }, { status: 500 })
+  }) as typeof fetch
+}
+
+describe('postgres linear provider', () => {
+  let previousEnv: Record<string, string | undefined>
+  let previousFetch: typeof fetch
+  let sql: postgres.Sql | null = null
+
+  beforeEach(async () => {
+    previousFetch = globalThis.fetch
+    previousEnv = {
+      KANBAN_STORAGE: process.env['KANBAN_STORAGE'],
+      KANBAN_DATABASE_URL: process.env['KANBAN_DATABASE_URL'],
+      KANBAN_PROVIDER: process.env['KANBAN_PROVIDER'],
+      LINEAR_API_KEY: process.env['LINEAR_API_KEY'],
+      LINEAR_TEAM_ID: process.env['LINEAR_TEAM_ID'],
+    }
+    process.env['KANBAN_STORAGE'] = 'postgres'
+    process.env['KANBAN_DATABASE_URL'] = databaseUrl
+    process.env['KANBAN_PROVIDER'] = 'linear'
+    process.env['LINEAR_API_KEY'] = 'linear-key'
+    process.env['LINEAR_TEAM_ID'] = 'GB'
+
+    if (databaseUrl) {
+      sql = postgres(databaseUrl, { max: 1, onnotice: () => {} })
+      await sql`DROP TABLE IF EXISTS linear_activity`
+      await sql`DROP TABLE IF EXISTS linear_issues`
+      await sql`DROP TABLE IF EXISTS linear_projects`
+      await sql`DROP TABLE IF EXISTS linear_users`
+      await sql`DROP TABLE IF EXISTS linear_states`
+      await sql`DROP TABLE IF EXISTS linear_sync_meta`
+    }
+    globalThis.fetch = linearFetchStub()
+  })
+
+  afterEach(async () => {
+    globalThis.fetch = previousFetch
+    if (sql) {
+      await sql.end({ timeout: 1 })
+      sql = null
+    }
+    for (const [key, value] of Object.entries(previousEnv)) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+  })
+
+  pgTest('lists Linear tasks from a shared Postgres cache through the CLI path', async () => {
+    const tasks = expectOk<Task[]>(await run(['task', 'list', '-c', 'Todo']))
+
+    expect(tasks).toHaveLength(1)
+    expect(tasks[0]).toMatchObject({
+      id: 'linear:lin-1',
+      externalRef: 'GB-1',
+      title: 'Postgres cached Linear issue',
+      priority: 'high',
+      assignee: 'Alice',
+      project: 'Garage',
+    })
+  })
+
+  pgTest('creates, moves, and comments on Linear tasks through Postgres storage', async () => {
+    const created = expectOk<Task>(
+      await run([
+        'task',
+        'add',
+        'Created through Postgres Linear',
+        '-d',
+        'from the public CLI path',
+        '-p',
+        'medium',
+        '-a',
+        'Alice',
+        '--project',
+        'Garage',
+      ]),
+    )
+
+    expect(created).toMatchObject({
+      id: 'linear:lin-2',
+      externalRef: 'GB-2',
+      title: 'Created through Postgres Linear',
+      priority: 'medium',
+    })
+
+    const moved = expectOk<Task>(await run(['task', 'move', 'GB-2', 'Done']))
+    expect(moved.column_id).toBe('state-done')
+
+    const comment = expectOk<TaskComment>(
+      await run(['comment', 'add', 'GB-2', 'Garage projection comment']),
+    )
+    expect(comment).toMatchObject({
+      id: 'comment-1',
+      task_id: 'linear:lin-2',
+      body: 'Garage projection comment',
+    })
+
+    const comments = expectOk<TaskComment[]>(await run(['comment', 'list', 'GB-2']))
+    expect(comments).toHaveLength(1)
+  })
+})