@andypai/agent-kanban 0.6.4 → 0.7.0

package/src/__tests__/local-provider-core.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, test } from 'bun:test'
+
+import { ErrorCode, KanbanError } from '../errors'
+import { LOCAL_CAPABILITIES } from '../providers/capabilities'
+import {
+  LocalProviderCore,
+  type LocalStorePort,
+  type LocalTaskRecord,
+} from '../providers/local-core'
+import type { BoardConfig, BoardMetrics, Column, TaskComment } from '../types'
+import type { CreateTaskInput, TaskListFilters, UpdateTaskInput } from '../providers/types'
+
+const column: Column = {
+  id: 'c_1',
+  name: 'backlog',
+  position: 0,
+  color: null,
+  created_at: '2026-01-01T00:00:00.000Z',
+  updated_at: '2026-01-01T00:00:00.000Z',
+}
+
+const metrics: BoardMetrics = {
+  tasksByColumn: [],
+  tasksByPriority: [],
+  totalTasks: 0,
+  completedTasks: 0,
+  avgCompletionHours: null,
+  recentActivity: [],
+  tasksCreatedThisWeek: 0,
+  inProgressCount: 0,
+  completionPercent: 0,
+  assignees: [],
+  projects: [],
+}
+
+const config: BoardConfig = {
+  members: [],
+  projects: [],
+  provider: 'local',
+  discoveredAssignees: [],
+  discoveredProjects: [],
+}
+
+function localTask(overrides: Partial<LocalTaskRecord> = {}): LocalTaskRecord {
+  return {
+    id: 't_1',
+    title: 'Local task',
+    description: '',
+    column_id: column.id,
+    column_name: column.name,
+    position: 0,
+    priority: 'medium',
+    assignee: 'amy',
+    assignees: [],
+    labels: [],
+    comment_count: 0,
+    project: '',
+    metadata: '{}',
+    revision: 0,
+    created_at: '2026-01-01T00:00:00.000Z',
+    updated_at: '2026-01-01T00:00:00.000Z',
+    version: null,
+    source_updated_at: null,
+    ...overrides,
+  }
+}
+
+class FakeLocalStore implements LocalStorePort {
+  readonly capabilities = LOCAL_CAPABILITIES
+  task = localTask()
+  getTaskCalls = 0
+  getTaskVersionCalls = 0
+  updates: Array<Omit<UpdateTaskInput, 'expectedVersion'>> = []
+
+  getBoard() {
+    return { columns: [{ ...column, tasks: [this.task] }] }
+  }
+
+  listColumns() {
+    return [column]
+  }
+
+  listTasks(_filters: TaskListFilters = {}) {
+    return [this.task]
+  }
+
+  getTask(_idOrRef: string) {
+    this.getTaskCalls += 1
+    return this.task
+  }
+
+  getTaskVersion(_idOrRef: string) {
+    this.getTaskVersionCalls += 1
+    return String(this.task.revision ?? 0)
+  }
+
+  createTask(input: CreateTaskInput) {
+    this.task = localTask({ title: input.title, revision: 0 })
+    return this.task
+  }
+
+  updateTask(_idOrRef: string, input: Omit<UpdateTaskInput, 'expectedVersion'>) {
+    this.updates.push(input)
+    this.task = localTask({
+      ...this.task,
+      ...input,
+      revision: (this.task.revision ?? 0) + 1,
+    })
+    return this.task
+  }
+
+  moveTask(_idOrRef: string, _column: string) {
+    return this.task
+  }
+
+  deleteTask(_idOrRef: string) {
+    return this.task
+  }
+
+  listComments(_idOrRef: string): TaskComment[] {
+    return []
+  }
+
+  getComment(_idOrRef: string, commentId: string): TaskComment {
+    return {
+      id: commentId,
+      task_id: this.task.id,
+      body: '',
+      author: null,
+      created_at: '2026-01-01T00:00:00.000Z',
+      updated_at: '2026-01-01T00:00:00.000Z',
+    }
+  }
+
+  comment(_idOrRef: string, body: string): TaskComment {
+    return {
+      id: 'cm_1',
+      task_id: this.task.id,
+      body,
+      author: null,
+      created_at: '2026-01-01T00:00:00.000Z',
+      updated_at: '2026-01-01T00:00:00.000Z',
+    }
+  }
+
+  updateComment(_idOrRef: string, commentId: string, body: string): TaskComment {
+    return {
+      id: commentId,
+      task_id: this.task.id,
+      body,
+      author: null,
+      created_at: '2026-01-01T00:00:00.000Z',
+      updated_at: '2026-01-02T00:00:00.000Z',
+    }
+  }
+
+  getActivity() {
+    return []
+  }
+
+  getMetrics() {
+    return metrics
+  }
+
+  getConfig() {
+    return config
+  }
+
+  patchConfig() {
+    return config
+  }
+
+  countComments() {
+    return 2
+  }
+
+  countCommentsByTask() {
+    return new Map([[this.task.id, 2]])
+  }
+}
+
+describe('LocalProviderCore', () => {
+  test('normalizes local task identity, comment count, labels, and version fields', async () => {
+    const store = new FakeLocalStore()
+    store.task = {
+      ...localTask({ revision: 3 }),
+      assignees: undefined,
+      labels: undefined,
+      comment_count: undefined,
+      version: undefined,
+      source_updated_at: undefined,
+    } as unknown as LocalTaskRecord
+
+    const provider = new LocalProviderCore(store)
+    const task = await provider.getTask(store.task.id)
+
+    expect(task.providerId).toBe('t_1')
+    expect(task.externalRef).toBe('t_1')
+    expect(task.url).toBeNull()
+    expect(task.assignees).toEqual(['amy'])
+    expect(task.labels).toEqual([])
+    expect(task.comment_count).toBe(2)
+    expect(task.version).toBe('3')
+    expect(task.source_updated_at).toBeNull()
+  })
+
+  test('checks expectedVersion before store update and strips it from the store input', async () => {
+    const store = new FakeLocalStore()
+    store.task = localTask({ revision: 4 })
+    const provider = new LocalProviderCore(store)
+
+    const updated = await provider.updateTask(store.task.id, {
+      title: 'Updated title',
+      expectedVersion: '4',
+    })
+
+    expect(updated.title).toBe('Updated title')
+    expect(store.updates).toEqual([{ title: 'Updated title' }])
+    expect(Object.hasOwn(store.updates[0]!, 'expectedVersion')).toBe(false)
+    expect(store.getTaskVersionCalls).toBe(1)
+    expect(store.getTaskCalls).toBe(0)
+  })
+
+  test('rejects stale expectedVersion without calling the store update', async () => {
+    const store = new FakeLocalStore()
+    store.task = localTask({ revision: 4 })
+    const provider = new LocalProviderCore(store)
+
+    let err: unknown
+    try {
+      await provider.updateTask(store.task.id, {
+        title: 'Stale update',
+        expectedVersion: '3',
+      })
+    } catch (caught) {
+      err = caught
+    }
+
+    expect(err).toBeInstanceOf(KanbanError)
+    expect((err as KanbanError).code).toBe(ErrorCode.CONFLICT)
+    expect(store.updates).toEqual([])
+    expect(store.getTaskVersionCalls).toBe(1)
+    expect(store.getTaskCalls).toBe(0)
+  })
+})

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

@@ -4,6 +4,7 @@ import postgres from 'postgres'
 import { run } from '../index'
 import type { Task } from '../types'
 import { PostgresJiraProvider } from '../providers/postgres-jira'
+import { PostgresJiraCache } from '../providers/postgres-jira-cache'
 
 const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
 const pgTest = databaseUrl ? test : test.skip
@@ -469,6 +470,60 @@ describe('postgres jira provider', () => {
     },
   )
 
+  pgTest('rolls back the whole Jira priority batch when one row fails', async () => {
+    if (!sql) throw new Error('expected postgres test connection')
+    const cache = new PostgresJiraCache(sql)
+    await cache.ready
+    await cache.replacePriorities([{ id: '2', name: 'High' }], true)
+
+    await expect(
+      cache.replacePriorities(
+        [
+          { id: '2', name: 'Highest' },
+          { id: 'broken', name: null as unknown as string },
+        ],
+        true,
+      ),
+    ).rejects.toThrow()
+
+    const rows = await sql<Array<{ id: string; name: string }>>`
+      SELECT id, name FROM jira_priorities ORDER BY id
+    `
+    expect(rows.map((row) => ({ id: row.id, name: row.name }))).toEqual([{ id: '2', name: 'High' }])
+  })
+
+  // A sync batch can repeat an issue id (an issue updated mid-pagination shows
+  // up on two pages); the batched upsert must last-wins instead of erroring
+  // ("ON CONFLICT DO UPDATE command cannot affect row a second time").
+  pgTest('upsertIssues tolerates duplicate issue ids within one batch', async () => {
+    if (!sql) throw new Error('expected postgres test connection')
+    const cache = new PostgresJiraCache(sql)
+    await cache.ready
+
+    const issue = {
+      id: '9001',
+      key: 'ENG-201',
+      summary: 'First occurrence',
+      descriptionText: 'v1',
+      statusId: '10001',
+      projectKey: 'ENG',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-02T00:00:00.000Z',
+    }
+    await cache.upsertIssues([
+      issue,
+      { ...issue, summary: 'Last occurrence wins', updatedAt: '2026-01-03T00:00:00.000Z' },
+    ])
+
+    const [row] = await sql<{ summary: string; updated_at: string }[]>`
+      SELECT summary, updated_at FROM jira_issues WHERE id = '9001'
+    `
+    expect(row).toEqual({
+      summary: 'Last occurrence wins',
+      updated_at: '2026-01-03T00:00:00.000Z',
+    })
+  })
+
   pgTest('concurrent catalog refreshes do not collide on a primary key', async () => {
     if (!sql) throw new Error('expected postgres test connection')
     globalThis.fetch = jiraFetchStub(standardRoutes()).fn

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

@@ -4,6 +4,7 @@ import postgres from 'postgres'
 import { run } from '../index'
 import type { Task, TaskComment } from '../types'
 import { PostgresLinearProvider } from '../providers/postgres-linear'
+import { PostgresLinearCache } from '../providers/postgres-linear-cache'
 
 const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
 const pgTest = databaseUrl ? test : test.skip
@@ -359,4 +360,93 @@ describe('postgres linear provider', () => {
       'label-owner',
     ])
   })
+
+  pgTest('rolls back description activity when Linear issue upsert fails', async () => {
+    if (!sql) throw new Error('expected postgres test connection')
+    const cache = new PostgresLinearCache(sql)
+    await cache.ready
+
+    const issue = {
+      id: 'lin-cache-1',
+      identifier: 'GB-101',
+      title: 'Atomic Linear issue',
+      description: 'old description',
+      priority: 2,
+      assigneeId: null,
+      assigneeName: null,
+      projectId: null,
+      projectName: null,
+      stateId: 'state-todo',
+      stateName: 'Todo',
+      statePosition: 0,
+      labels: ['atomic'],
+      commentCount: 0,
+      url: 'https://linear.app/issue/GB-101',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-02T00:00:00.000Z',
+    }
+    await cache.upsertIssues([issue])
+
+    await expect(
+      cache.upsertIssues([
+        {
+          ...issue,
+          title: 'Should roll back',
+          description: 'new description',
+          stateId: null as unknown as string,
+          updatedAt: '2026-01-03T00:00:00.000Z',
+        },
+      ]),
+    ).rejects.toThrow()
+
+    const [row] = await sql<{ title: string; description: string }[]>`
+      SELECT title, description FROM linear_issues WHERE id = 'lin-cache-1'
+    `
+    expect(row).toEqual({ title: 'Atomic Linear issue', description: 'old description' })
+    const activity = await sql<{ history_id: string }[]>`
+      SELECT history_id FROM linear_activity WHERE issue_id = 'lin-cache-1'
+    `
+    expect(activity).toHaveLength(0)
+  })
+
+  // Linear's updatedAt-ordered pagination can return the same issue on two
+  // pages of one sync; the batched upsert must last-wins instead of erroring
+  // ("ON CONFLICT DO UPDATE command cannot affect row a second time").
+  pgTest('upsertIssues tolerates duplicate issue ids within one batch', async () => {
+    if (!sql) throw new Error('expected postgres test connection')
+    const cache = new PostgresLinearCache(sql)
+    await cache.ready
+
+    const issue = {
+      id: 'lin-dup-1',
+      identifier: 'GB-201',
+      title: 'First occurrence',
+      description: 'v1',
+      priority: 2,
+      assigneeId: null,
+      assigneeName: null,
+      projectId: null,
+      projectName: null,
+      stateId: 'state-todo',
+      stateName: 'Todo',
+      statePosition: 0,
+      labels: [],
+      commentCount: 0,
+      url: null,
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-02T00:00:00.000Z',
+    }
+    await cache.upsertIssues([
+      issue,
+      { ...issue, title: 'Last occurrence wins', updatedAt: '2026-01-03T00:00:00.000Z' },
+    ])
+
+    const [row] = await sql<{ title: string; updated_at: string }[]>`
+      SELECT title, updated_at FROM linear_issues WHERE id = 'lin-dup-1'
+    `
+    expect(row).toEqual({
+      title: 'Last occurrence wins',
+      updated_at: '2026-01-03T00:00:00.000Z',
+    })
+  })
 })

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

@@ -206,6 +206,32 @@ describe('postgres local provider', () => {
     }
   })
 
+  // Exercises the real Postgres getTaskVersion path behind the shared core's
+  // optimistic-version check (the core conflict tests run against a fake store).
+  pgTest('update with stale expectedVersion throws CONFLICT through Postgres storage', async () => {
+    const runtime = await openKanbanRuntime()
+    try {
+      const created = await runtime.provider.createTask({ title: 'Versioned task' })
+      await runtime.provider.updateTask(created.id, { title: 'bumped' })
+
+      await expect(
+        runtime.provider.updateTask(created.id, {
+          title: 'stale write',
+          expectedVersion: created.version ?? undefined,
+        }),
+      ).rejects.toMatchObject({ code: 'CONFLICT' })
+
+      const matched = await runtime.provider.updateTask(created.id, {
+        title: 'fresh write',
+        expectedVersion: '1',
+      })
+      expect(matched.title).toBe('fresh write')
+      expect(matched.version).toBe('2')
+    } finally {
+      await runtime.close()
+    }
+  })
+
   pgTest('migrates a pre-existing tasks table missing project/labels/revision', async () => {
     // Simulate an older Postgres-local database created before project, labels,
     // and revision columns existed. CREATE TABLE IF NOT EXISTS would not add

package/src/__tests__/provider-sync-core.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test } from 'bun:test'
+import type { Task } from '../types'
+import {
+  applyTaskFilters,
+  mapWithConcurrency,
+  maxSyncTimestamp,
+  parseSyncTimestamp,
+  SyncGate,
+  syncStatusFromMeta,
+} from '../providers/sync-core'
+
+function task(overrides: Partial<Task>): Task {
+  return {
+    id: overrides.id ?? 't_1',
+    providerId: overrides.providerId ?? overrides.id ?? 't_1',
+    title: overrides.title ?? 'Task',
+    description: '',
+    column_id: overrides.column_id ?? 'todo',
+    position: overrides.position ?? 0,
+    priority: overrides.priority ?? 'low',
+    assignee: overrides.assignee ?? '',
+    assignees: overrides.assignees ?? [],
+    labels: overrides.labels ?? [],
+    comment_count: overrides.comment_count ?? 0,
+    project: overrides.project ?? '',
+    metadata: '{}',
+    created_at: overrides.created_at ?? '2026-01-01T00:00:00Z',
+    updated_at: overrides.updated_at ?? '2026-01-01T00:00:00Z',
+    version: overrides.version ?? overrides.updated_at ?? '2026-01-01T00:00:00Z',
+    source_updated_at:
+      overrides.source_updated_at ?? overrides.updated_at ?? '2026-01-01T00:00:00Z',
+    url: overrides.url,
+    externalRef: overrides.externalRef,
+  }
+}
+
+describe('provider sync core helpers', () => {
+  test('SyncGate shares throttle and background-managed suppression rules', () => {
+    const gate = new SyncGate(30_000)
+    const syncedAt = '2026-01-01T00:00:00.000Z'
+    const justAfterSync = Date.parse('2026-01-01T00:00:10.000Z')
+    const afterThrottle = Date.parse('2026-01-01T00:00:31.000Z')
+
+    expect(
+      gate.shouldSkip({ force: false, viaWarmer: false, lastSyncAt: syncedAt, now: justAfterSync }),
+    ).toBe(true)
+    expect(
+      gate.shouldSkip({ force: true, viaWarmer: false, lastSyncAt: syncedAt, now: justAfterSync }),
+    ).toBe(false)
+    expect(
+      gate.shouldSkip({
+        force: false,
+        viaWarmer: false,
+        lastSyncAt: syncedAt,
+        now: afterThrottle,
+      }),
+    ).toBe(false)
+
+    gate.setBackgroundManaged(true)
+    expect(
+      gate.shouldSkip({
+        force: false,
+        viaWarmer: false,
+        lastSyncAt: syncedAt,
+        now: afterThrottle,
+      }),
+    ).toBe(true)
+    expect(
+      gate.shouldSkip({
+        force: false,
+        viaWarmer: true,
+        lastSyncAt: syncedAt,
+        now: afterThrottle,
+      }),
+    ).toBe(false)
+  })
+
+  test('applyTaskFilters centralizes priority, assignee, project, sort, and limit behavior', () => {
+    const tasks = [
+      task({
+        id: 'older',
+        title: 'Zulu',
+        priority: 'high',
+        assignee: 'Ada',
+        project: 'Core',
+        updated_at: '2026-01-01T00:00:00Z',
+      }),
+      task({
+        id: 'newer',
+        title: 'Alpha',
+        priority: 'high',
+        assignee: 'Ada',
+        project: 'Core',
+        updated_at: '2026-01-02T00:00:00Z',
+      }),
+      task({
+        id: 'other',
+        title: 'Beta',
+        priority: 'low',
+        assignee: 'Grace',
+        project: 'Ops',
+        updated_at: '2026-01-03T00:00:00Z',
+      }),
+    ]
+
+    expect(
+      applyTaskFilters(tasks, {
+        priority: 'high',
+        assignee: 'Ada',
+        project: 'Core',
+        sort: 'updated',
+        limit: 1,
+      }).map((item) => item.id),
+    ).toEqual(['newer'])
+    expect(applyTaskFilters(tasks, { sort: 'title' }).map((item) => item.id)).toEqual([
+      'newer',
+      'other',
+      'older',
+    ])
+  })
+
+  test('mapWithConcurrency preserves order while bounding in-flight work', async () => {
+    let inFlight = 0
+    let maxInFlight = 0
+    const results = await mapWithConcurrency([1, 2, 3, 4, 5], 2, async (item) => {
+      inFlight += 1
+      maxInFlight = Math.max(maxInFlight, inFlight)
+      await new Promise((resolve) => setTimeout(resolve, 2))
+      inFlight -= 1
+      return item * 2
+    })
+
+    expect(results).toEqual([2, 4, 6, 8, 10])
+    expect(maxInFlight).toBe(2)
+  })
+
+  test('timestamp helpers and sync status projection keep provider metadata behavior shared', () => {
+    expect(parseSyncTimestamp('not-a-date')).toBe(0)
+    expect(maxSyncTimestamp('2026-01-02T00:00:00Z', '2026-01-01T00:00:00Z')).toBe(
+      '2026-01-02T00:00:00Z',
+    )
+    expect(
+      syncStatusFromMeta({
+        lastSyncAt: 'sync',
+        lastFullSyncAt: 'full',
+        lastWebhookAt: null,
+      }),
+    ).toEqual({ lastSyncAt: 'sync', lastFullSyncAt: 'full', lastWebhookAt: null })
+  })
+})

package/src/__tests__/provider-team-info.test.ts

@@ -0,0 +1,37 @@
+import { Database } from 'bun:sqlite'
+import { describe, expect, test } from 'bun:test'
+
+import { initLinearCacheSchema, loadSyncMeta } from '../providers/linear-cache'
+import { parseProviderTeamInfo } from '../providers/team-info'
+
+describe('parseProviderTeamInfo', () => {
+  test('accepts the persisted provider team shape', () => {
+    expect(
+      parseProviderTeamInfo(JSON.stringify({ id: 'team-1', key: 'ENG', name: 'Engineering' })),
+    ).toEqual({
+      id: 'team-1',
+      key: 'ENG',
+      name: 'Engineering',
+    })
+  })
+
+  test('rejects corrupt or incomplete metadata', () => {
+    expect(parseProviderTeamInfo(null)).toBeNull()
+    expect(parseProviderTeamInfo('not json')).toBeNull()
+    expect(parseProviderTeamInfo(JSON.stringify({ id: 'team-1', key: 'ENG' }))).toBeNull()
+    expect(
+      parseProviderTeamInfo(JSON.stringify({ id: 'team-1', key: 42, name: 'Engineering' })),
+    ).toBeNull()
+  })
+
+  test('Linear sync metadata degrades corrupt team JSON to null', () => {
+    const db = new Database(':memory:')
+    initLinearCacheSchema(db)
+    db.query('INSERT INTO linear_sync_meta (key, value) VALUES ($key, $value)').run({
+      $key: 'team',
+      $value: 'not json',
+    })
+
+    expect(loadSyncMeta(db).team).toBeNull()
+  })
+})

package/src/__tests__/ui-board-slice.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from 'bun:test'
+
+import { defaultCapabilities } from '../../ui/src/store/capabilities'
+
+// The type annotation guarantees key completeness; this pins the values so a
+// default can't quietly flip back to true and reintroduce the pre-bootstrap
+// flash of provider-gated actions.
+describe('UI capability defaults', () => {
+  test('every provider capability starts closed until bootstrap loads', () => {
+    for (const [capability, enabled] of Object.entries(defaultCapabilities)) {
+      expect({ capability, enabled }).toEqual({ capability, enabled: false })
+    }
+  })
+})