@andypai/agent-kanban 0.2.0 → 0.3.0

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

@@ -0,0 +1,187 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { Database } from 'bun:sqlite'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { ErrorCode, KanbanError } from '../errors.ts'
+import { run } from '../index.ts'
+import { createProvider } from '../providers/index.ts'
+
+const ENV_KEYS = [
+  'KANBAN_PROVIDER',
+  'JIRA_BASE_URL',
+  'JIRA_EMAIL',
+  'JIRA_API_TOKEN',
+  'JIRA_PROJECT_KEY',
+  'JIRA_BOARD_ID',
+  'JIRA_ISSUE_TYPE',
+  'LINEAR_API_KEY',
+  'LINEAR_TEAM_ID',
+] as const
+
+const tempRoot = mkdtempSync(join(tmpdir(), 'jira-wiring-'))
+const dbs: Database[] = []
+
+function makeDb(): { db: Database; dbPath: string } {
+  const dir = mkdtempSync(join(tempRoot, 'case-'))
+  const dbPath = join(dir, 'board.db')
+  const db = new Database(dbPath)
+  dbs.push(db)
+  return { db, dbPath }
+}
+
+function setJiraRequiredEnv(): void {
+  process.env['KANBAN_PROVIDER'] = 'jira'
+  process.env['JIRA_BASE_URL'] = 'https://example.atlassian.net'
+  process.env['JIRA_EMAIL'] = 'a@example.com'
+  process.env['JIRA_API_TOKEN'] = 'tok-test'
+  process.env['JIRA_PROJECT_KEY'] = 'ENG'
+}
+
+describe('jira-wiring', () => {
+  let snapshot: Record<string, string | undefined>
+
+  beforeEach(() => {
+    snapshot = {}
+    for (const key of ENV_KEYS) {
+      snapshot[key] = process.env[key]
+      delete process.env[key]
+    }
+  })
+
+  afterEach(() => {
+    for (const key of ENV_KEYS) {
+      const prev = snapshot[key]
+      if (prev === undefined) {
+        delete process.env[key]
+      } else {
+        process.env[key] = prev
+      }
+    }
+  })
+
+  afterAll(() => {
+    for (const db of dbs) {
+      try {
+        db.close()
+      } catch {
+        // ignore
+      }
+    }
+    try {
+      rmSync(tempRoot, { recursive: true, force: true })
+    } catch {
+      // ignore
+    }
+  })
+
+  test('createProvider throws PROVIDER_NOT_CONFIGURED listing missing JIRA_API_TOKEN', () => {
+    const { db, dbPath } = makeDb()
+    process.env['KANBAN_PROVIDER'] = 'jira'
+    process.env['JIRA_BASE_URL'] = 'https://example.atlassian.net'
+    process.env['JIRA_EMAIL'] = 'a@example.com'
+    delete process.env['JIRA_API_TOKEN']
+    process.env['JIRA_PROJECT_KEY'] = 'ENG'
+
+    expect(() => createProvider(db, dbPath)).toThrow(KanbanError)
+    try {
+      createProvider(db, dbPath)
+    } catch (err) {
+      expect((err as KanbanError).code).toBe(ErrorCode.PROVIDER_NOT_CONFIGURED)
+      expect((err as Error).message).toContain('JIRA_API_TOKEN')
+      expect((err as Error).message).toContain('KANBAN_PROVIDER=jira')
+    }
+  })
+
+  test('createProvider throws PROVIDER_NOT_CONFIGURED listing multiple missing vars', () => {
+    const { db, dbPath } = makeDb()
+    process.env['KANBAN_PROVIDER'] = 'jira'
+    process.env['JIRA_BASE_URL'] = 'https://example.atlassian.net'
+    delete process.env['JIRA_EMAIL']
+    delete process.env['JIRA_API_TOKEN']
+    process.env['JIRA_PROJECT_KEY'] = 'ENG'
+
+    let msg = ''
+    let code: string | undefined
+    try {
+      createProvider(db, dbPath)
+    } catch (err) {
+      msg = (err as Error).message
+      code = (err as KanbanError).code
+    }
+    expect(code).toBe(ErrorCode.PROVIDER_NOT_CONFIGURED)
+    expect(msg).toContain('JIRA_EMAIL')
+    expect(msg).toContain('JIRA_API_TOKEN')
+    expect(msg).toContain('are required')
+    expect(msg).toContain('KANBAN_PROVIDER=jira')
+  })
+
+  test('createProvider builds JiraProvider when all four required vars are set', () => {
+    const { db, dbPath } = makeDb()
+    setJiraRequiredEnv()
+    const provider = createProvider(db, dbPath)
+    expect(provider.type).toBe('jira')
+  })
+
+  test('JIRA_BOARD_ID non-numeric falls back to undefined', () => {
+    const { db, dbPath } = makeDb()
+    setJiraRequiredEnv()
+    process.env['JIRA_BOARD_ID'] = 'notanumber'
+    const provider = createProvider(db, dbPath)
+    expect(provider.type).toBe('jira')
+  })
+
+  test('kanban column add under KANBAN_PROVIDER=jira exits with UNSUPPORTED_OPERATION', async () => {
+    const { dbPath } = makeDb()
+    setJiraRequiredEnv()
+    const result = await run(['--db', dbPath, 'column', 'add', 'NewColumn']).catch(
+      (err: unknown) => ({ error: err as KanbanError }),
+    )
+    expect('error' in result).toBe(true)
+    const err = (result as { error: KanbanError }).error
+    expect(err).toBeInstanceOf(KanbanError)
+    expect(err.code).toBe(ErrorCode.UNSUPPORTED_OPERATION)
+    expect(err.message).toContain('Column commands')
+  })
+
+  test('kanban bulk move-all under KANBAN_PROVIDER=jira exits with UNSUPPORTED_OPERATION', async () => {
+    const { dbPath } = makeDb()
+    setJiraRequiredEnv()
+    const result = await run(['--db', dbPath, 'bulk', 'move-all', 'a', 'b']).catch(
+      (err: unknown) => ({ error: err as KanbanError }),
+    )
+    expect('error' in result).toBe(true)
+    const err = (result as { error: KanbanError }).error
+    expect(err).toBeInstanceOf(KanbanError)
+    expect(err.code).toBe(ErrorCode.UNSUPPORTED_OPERATION)
+    expect(err.message).toContain('Bulk commands')
+  })
+
+  test('kanban config set-member under KANBAN_PROVIDER=jira exits with UNSUPPORTED_OPERATION', async () => {
+    const { dbPath } = makeDb()
+    setJiraRequiredEnv()
+    const result = await run([
+      '--db',
+      dbPath,
+      'config',
+      'set-member',
+      'alice',
+      '--role',
+      'human',
+    ]).catch((err: unknown) => ({ error: err as KanbanError }))
+    expect('error' in result).toBe(true)
+    const err = (result as { error: KanbanError }).error
+    expect(err).toBeInstanceOf(KanbanError)
+    expect(err.code).toBe(ErrorCode.UNSUPPORTED_OPERATION)
+    expect(err.message).toContain('Config mutation')
+  })
+
+  test('KANBAN_PROVIDER=linear still builds LinearProvider (regression guard)', () => {
+    const { db, dbPath } = makeDb()
+    process.env['KANBAN_PROVIDER'] = 'linear'
+    process.env['LINEAR_API_KEY'] = 'lin_api_test'
+    process.env['LINEAR_TEAM_ID'] = 'team-test'
+    const provider = createProvider(db, dbPath)
+    expect(provider.type).toBe('linear')
+  })
+})

package/src/__tests__/linear-cache-description-activity.test.ts

@@ -0,0 +1,142 @@
+import { Database } from 'bun:sqlite'
+import { describe, expect, test } from 'bun:test'
+
+import {
+  deleteLinearIssue,
+  getCachedLinearActivity,
+  initLinearCacheSchema,
+  upsertIssues,
+} from '../providers/linear-cache.ts'
+
+function mkIssue(overrides: Partial<Parameters<typeof upsertIssues>[1][0]> = {}) {
+  return {
+    id: 'issue-1',
+    identifier: 'ABC-1',
+    title: 'Task',
+    description: '',
+    priority: 0,
+    assigneeId: null,
+    assigneeName: null,
+    projectId: null,
+    projectName: null,
+    stateId: 'state-1',
+    stateName: 'Todo',
+    statePosition: 0,
+    labels: [],
+    commentCount: 0,
+    url: null,
+    createdAt: '2026-04-19T00:00:00.000Z',
+    updatedAt: '2026-04-19T00:00:00.000Z',
+    ...overrides,
+  }
+}
+
+function freshDb(): Database {
+  const db = new Database(':memory:')
+  initLinearCacheSchema(db)
+  return db
+}
+
+function descriptionRows(db: Database, issueId = 'issue-1') {
+  return getCachedLinearActivity(db, { issueId }).filter((r) => r.item_field === 'description')
+}
+
+describe('upsertIssues description activity', () => {
+  test('emits an activity row when description changes between upserts', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: 'first' })])
+    upsertIssues(db, [mkIssue({ description: 'second', updatedAt: '2026-04-19T00:01:00.000Z' })])
+    const rows = descriptionRows(db)
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.from_value).toBe('first')
+    expect(rows[0]!.to_value).toBe('second')
+    expect(rows[0]!.created_at).toBe('2026-04-19T00:01:00.000Z')
+  })
+
+  test('does not emit on first insert (no prior value to diff)', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: 'hello' })])
+    expect(descriptionRows(db)).toHaveLength(0)
+  })
+
+  test('skips unchanged descriptions', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: 'same' })])
+    upsertIssues(db, [mkIssue({ description: 'same', updatedAt: '2026-04-19T00:01:00.000Z' })])
+    expect(descriptionRows(db)).toHaveLength(0)
+  })
+
+  test('is idempotent when the same updatedAt is replayed', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: 'a' })])
+    const edited = mkIssue({ description: 'b', updatedAt: '2026-04-19T00:01:00.000Z' })
+    upsertIssues(db, [edited])
+    upsertIssues(db, [edited])
+    expect(descriptionRows(db)).toHaveLength(1)
+  })
+
+  test('treats null/undefined descriptions as empty string', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: 'had content' })])
+    upsertIssues(db, [mkIssue({ description: null, updatedAt: '2026-04-19T00:01:00.000Z' })])
+    const rows = descriptionRows(db)
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.from_value).toBe('had content')
+    expect(rows[0]!.to_value).toBe('')
+  })
+
+  test('emits when an empty description is populated', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: '' })])
+    upsertIssues(db, [
+      mkIssue({ description: 'now has content', updatedAt: '2026-04-19T00:01:00.000Z' }),
+    ])
+    const rows = descriptionRows(db)
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.from_value).toBe('')
+    expect(rows[0]!.to_value).toBe('now has content')
+  })
+
+  test('truncates very long description values to cap storage growth', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: 'x'.repeat(10_000) })])
+    upsertIssues(db, [
+      mkIssue({ description: 'y'.repeat(10_000), updatedAt: '2026-04-19T00:01:00.000Z' }),
+    ])
+    const row = descriptionRows(db)[0]!
+    expect(row.from_value!.length).toBeLessThanOrEqual(4096)
+    expect(row.to_value!.length).toBeLessThanOrEqual(4096)
+    expect(row.from_value!.endsWith('…[truncated]')).toBe(true)
+    expect(row.to_value!.endsWith('…[truncated]')).toBe(true)
+  })
+
+  test('preserves existing comment_count when an upsert omits it', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ commentCount: 4 })])
+    upsertIssues(db, [
+      mkIssue({
+        title: 'Task renamed',
+        commentCount: undefined,
+        updatedAt: '2026-04-19T00:01:00.000Z',
+      }),
+    ])
+
+    const row = db
+      .query('SELECT comment_count, title FROM linear_issues WHERE id = $id')
+      .get({ $id: 'issue-1' }) as { comment_count: number; title: string } | null
+
+    expect(row?.title).toBe('Task renamed')
+    expect(row?.comment_count).toBe(4)
+  })
+
+  test('deleteLinearIssue clears cached activity rows for the deleted issue', () => {
+    const db = freshDb()
+    upsertIssues(db, [mkIssue({ description: 'first' })])
+    upsertIssues(db, [mkIssue({ description: 'second', updatedAt: '2026-04-19T00:01:00.000Z' })])
+
+    expect(getCachedLinearActivity(db, { issueId: 'issue-1' })).toHaveLength(1)
+    deleteLinearIssue(db, 'issue-1')
+
+    expect(getCachedLinearActivity(db, { issueId: 'issue-1' })).toHaveLength(0)
+  })
+})

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

@@ -0,0 +1,243 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { Database } from 'bun:sqlite'
+import { LinearProvider } from '../providers/linear.ts'
+import {
+  initLinearCacheSchema,
+  replaceStates,
+  saveSyncMeta,
+  upsertIssues,
+} from '../providers/linear-cache.ts'
+
+let db: Database
+let originalFetch: typeof fetch
+let requests: Array<{ query: string; variables: Record<string, unknown> }>
+
+beforeEach(() => {
+  db = new Database(':memory:')
+  initLinearCacheSchema(db)
+  replaceStates(db, [{ id: 'state-1', name: 'Todo', position: 0 }])
+  upsertIssues(db, [
+    {
+      id: 'issue-1',
+      identifier: 'ENG-1',
+      title: 'Issue 1',
+      stateId: 'state-1',
+      stateName: 'Todo',
+      statePosition: 0,
+      commentCount: 0,
+      createdAt: '2026-01-01T00:00:00Z',
+      updatedAt: '2026-01-02T00:00:00Z',
+    },
+  ])
+  saveSyncMeta(db, {
+    team: { id: 'team-1', key: 'ENG', name: 'Engineering' },
+    lastSyncAt: new Date().toISOString(),
+    lastIssueUpdatedAt: '2026-01-02T00:00:00Z',
+  })
+  originalFetch = globalThis.fetch
+  requests = []
+  globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+    const body = JSON.parse(String(init?.body)) as {
+      query: string
+      variables: Record<string, unknown>
+    }
+    requests.push(body)
+
+    if (body.query.includes('mutation CommentCreate')) {
+      return new Response(
+        JSON.stringify({
+          data: {
+            commentCreate: {
+              success: true,
+              comment: {
+                id: 'comment-1',
+                body: String((body.variables.input as { body: string }).body),
+                createdAt: '2026-01-03T00:00:00Z',
+                updatedAt: '2026-01-03T00:00:00Z',
+                user: { id: 'user-1', displayName: 'Linear User' },
+              },
+            },
+          },
+        }),
+        {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        },
+      )
+    }
+
+    if (body.query.includes('mutation CommentUpdate')) {
+      return new Response(
+        JSON.stringify({
+          data: {
+            commentUpdate: {
+              success: true,
+              comment: {
+                id: String(body.variables.id),
+                body: String((body.variables.input as { body: string }).body),
+                createdAt: '2026-01-03T00:00:00Z',
+                updatedAt: '2026-01-04T00:00:00Z',
+                user: { id: 'user-1', displayName: 'Linear User' },
+              },
+            },
+          },
+        }),
+        {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        },
+      )
+    }
+
+    if (body.query.includes('query Comment(')) {
+      return new Response(
+        JSON.stringify({
+          data: {
+            comment: {
+              id: String(body.variables.id),
+              body: 'one linear comment',
+              createdAt: '2026-01-03T00:00:00Z',
+              updatedAt: '2026-01-05T00:00:00Z',
+              user: { id: 'user-1', displayName: 'Linear User' },
+            },
+          },
+        }),
+        {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        },
+      )
+    }
+
+    if (body.query.includes('query IssueComments')) {
+      return new Response(
+        JSON.stringify({
+          data: {
+            issue: {
+              comments: {
+                nodes: [
+                  {
+                    id: 'comment-1',
+                    body: 'first linear comment',
+                    createdAt: '2026-01-03T00:00:00Z',
+                    updatedAt: '2026-01-03T00:00:00Z',
+                    user: { id: 'user-1', displayName: 'Linear User' },
+                  },
+                  {
+                    id: 'comment-2',
+                    body: 'second linear comment',
+                    createdAt: '2026-01-04T00:00:00Z',
+                    updatedAt: '2026-01-04T00:00:00Z',
+                    user: { id: 'user-2', displayName: 'Reviewer' },
+                  },
+                ],
+                pageInfo: { hasNextPage: false, endCursor: null },
+              },
+            },
+          },
+        }),
+        {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        },
+      )
+    }
+
+    throw new Error(`Unexpected Linear GraphQL query: ${body.query}`)
+  }) as unknown as typeof fetch
+})
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+})
+
+describe('LinearProvider.comment', () => {
+  test('posts the commentCreate mutation and advertises comment capability', async () => {
+    const provider = new LinearProvider(db, 'team-1', 'lin_api_test')
+
+    const comment = await provider.comment('ENG-1', 'hello from linear')
+
+    expect(requests[0]?.query).toContain('mutation CommentCreate')
+    expect(requests[0]?.variables).toEqual({
+      input: {
+        issueId: 'issue-1',
+        body: 'hello from linear',
+      },
+    })
+    expect(comment).toMatchObject({
+      id: 'comment-1',
+      task_id: 'linear:issue-1',
+      body: 'hello from linear',
+      author: 'Linear User',
+    })
+    expect((await provider.getTask('ENG-1')).comment_count).toBe(1)
+
+    const context = await provider.getContext()
+    expect(context.capabilities.comment).toBe(true)
+  })
+
+  test('queries issue comments and normalizes them into TaskComment rows', async () => {
+    const provider = new LinearProvider(db, 'team-1', 'lin_api_test')
+
+    const comments = await provider.listComments('ENG-1')
+
+    expect(requests[0]?.query).toContain('query IssueComments')
+    expect(requests[0]?.variables).toEqual({
+      issueId: 'issue-1',
+      after: null,
+    })
+    expect(comments).toEqual([
+      {
+        id: 'comment-1',
+        task_id: 'linear:issue-1',
+        body: 'first linear comment',
+        author: 'Linear User',
+        created_at: '2026-01-03T00:00:00Z',
+        updated_at: '2026-01-03T00:00:00Z',
+      },
+      {
+        id: 'comment-2',
+        task_id: 'linear:issue-1',
+        body: 'second linear comment',
+        author: 'Reviewer',
+        created_at: '2026-01-04T00:00:00Z',
+        updated_at: '2026-01-04T00:00:00Z',
+      },
+    ])
+  })
+
+  test('queries a single Linear comment by id', async () => {
+    const provider = new LinearProvider(db, 'team-1', 'lin_api_test')
+
+    const comment = await provider.getComment('ENG-1', 'comment-1')
+
+    expect(requests[0]?.query).toContain('query Comment(')
+    expect(requests[0]?.variables).toEqual({ id: 'comment-1' })
+    expect(comment).toMatchObject({
+      id: 'comment-1',
+      task_id: 'linear:issue-1',
+      body: 'one linear comment',
+      author: 'Linear User',
+      updated_at: '2026-01-05T00:00:00Z',
+    })
+  })
+
+  test('posts the commentUpdate mutation with the provided id', async () => {
+    const provider = new LinearProvider(db, 'team-1', 'lin_api_test')
+
+    const comment = await provider.updateComment('ENG-1', 'comment-1', 'edited linear comment')
+
+    expect(requests[0]?.query).toContain('mutation CommentUpdate')
+    expect(requests[0]?.variables).toEqual({
+      id: 'comment-1',
+      input: {
+        body: 'edited linear comment',
+      },
+    })
+    expect(comment).toMatchObject({
+      id: 'comment-1',
+      task_id: 'linear:issue-1',
+      body: 'edited linear comment',
+    })
+  })
+})