@andypai/agent-kanban 0.2.0 → 0.3.1

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

@@ -0,0 +1,488 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { Database } from 'bun:sqlite'
+import { LinearProvider } from '../providers/linear'
+import {
+  getCachedTasks,
+  initLinearCacheSchema,
+  loadSyncMeta,
+  replaceStates,
+  saveSyncMeta,
+  upsertIssues,
+} from '../providers/linear-cache'
+
+let db: Database
+let originalFetch: typeof fetch
+
+beforeEach(() => {
+  db = new Database(':memory:')
+  initLinearCacheSchema(db)
+  originalFetch = globalThis.fetch
+})
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+})
+
+function linearIssue(
+  overrides: Partial<{
+    id: string
+    identifier: string
+    title: string
+    description: string
+    priority: number
+    url: string
+    createdAt: string
+    updatedAt: string
+    assignee: { id: string; name?: string | null; displayName?: string | null } | null
+    project: { id: string; name: string; url?: string | null; state?: string | null } | null
+    state: { id: string; name: string; position: number }
+    labels: { nodes: Array<{ id: string; name: string }> }
+    comments: {
+      nodes: Array<{ id: string }>
+      pageInfo?: { hasNextPage: boolean; endCursor: string | null }
+    }
+  }> = {},
+) {
+  return {
+    id: 'issue-1',
+    identifier: 'R2P-1',
+    title: 'Linear task',
+    description: '',
+    priority: 2,
+    url: 'https://linear.app/x/issue/R2P-1',
+    createdAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-02T00:00:00Z',
+    assignee: null,
+    project: null,
+    state: { id: 'state-1', name: 'Todo', position: 0 },
+    labels: { nodes: [] },
+    comments: { nodes: [], pageInfo: { hasNextPage: false, endCursor: null } },
+    ...overrides,
+  }
+}
+
+describe('LinearProvider sync', () => {
+  test('resolves a configured team key before querying issues', async () => {
+    const seenIssueTeamIds: string[] = []
+
+    globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as {
+        query: string
+        variables: Record<string, unknown>
+      }
+
+      if (body.query.includes('query TeamSnapshot')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              team: {
+                id: '3ca24047-e954-44e8-b266-c7182410befb',
+                key: 'R2P',
+                name: 'R2pi',
+                states: { nodes: [{ id: 'state-1', name: 'Todo', position: 0 }] },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      if (body.query.includes('query Users')) {
+        return new Response(JSON.stringify({ data: { users: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Projects')) {
+        return new Response(JSON.stringify({ data: { projects: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Issues')) {
+        seenIssueTeamIds.push(String(body.variables.teamId))
+        return new Response(
+          JSON.stringify({
+            data: {
+              issues: {
+                nodes: [],
+                pageInfo: { hasNextPage: false, endCursor: null },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      return new Response(`Unexpected query: ${body.query}`, { status: 500 })
+    }) as unknown as typeof fetch
+
+    const provider = new LinearProvider(db, 'R2P', 'lin_api_test')
+    await provider.getBoard()
+
+    expect(seenIssueTeamIds).toEqual(['3ca24047-e954-44e8-b266-c7182410befb'])
+  })
+
+  test('createTask uses the resolved team UUID from cached sync meta', async () => {
+    replaceStates(db, [{ id: 'state-1', name: 'Todo', position: 0 }])
+    saveSyncMeta(db, {
+      team: { id: '3ca24047-e954-44e8-b266-c7182410befb', key: 'R2P', name: 'R2pi' },
+      lastSyncAt: new Date().toISOString(),
+      lastIssueUpdatedAt: '2026-01-02T00:00:00Z',
+    })
+
+    let createIssueTeamId: string | null = null
+    globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as {
+        query: string
+        variables: { input?: { teamId?: string } }
+      }
+
+      if (body.query.includes('mutation CreateIssue')) {
+        createIssueTeamId = body.variables.input?.teamId ?? null
+        return new Response(
+          JSON.stringify({
+            data: {
+              issueCreate: {
+                success: true,
+                issue: {
+                  id: 'issue-1',
+                  identifier: 'R2P-1',
+                  title: 'Hello',
+                  description: '',
+                  priority: 3,
+                  url: 'https://linear.app/x/issue/R2P-1',
+                  createdAt: '2026-01-01T00:00:00Z',
+                  updatedAt: '2026-01-01T00:00:00Z',
+                  assignee: null,
+                  project: null,
+                  state: { id: 'state-1', name: 'Todo', position: 0 },
+                  labels: { nodes: [] },
+                  comments: {
+                    nodes: [],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                  },
+                },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      return new Response(`Unexpected query: ${body.query}`, { status: 500 })
+    }) as unknown as typeof fetch
+
+    const provider = new LinearProvider(db, 'R2P', 'lin_api_test')
+    const created = await provider.createTask({ title: 'Hello' })
+
+    expect(String(createIssueTeamId)).toBe('3ca24047-e954-44e8-b266-c7182410befb')
+    expect(created.externalRef).toBe('R2P-1')
+  })
+
+  test('periodic full sync prunes cached issues missing from upstream', async () => {
+    replaceStates(db, [{ id: 'state-1', name: 'Todo', position: 0 }])
+    upsertIssues(db, [
+      {
+        id: 'issue-1',
+        identifier: 'R2P-1',
+        title: 'Keep me',
+        stateId: 'state-1',
+        stateName: 'Todo',
+        statePosition: 0,
+        commentCount: 1,
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+      },
+      {
+        id: 'issue-stale',
+        identifier: 'R2P-9',
+        title: 'Delete me',
+        stateId: 'state-1',
+        stateName: 'Todo',
+        statePosition: 0,
+        commentCount: 3,
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+      },
+    ])
+    saveSyncMeta(db, {
+      team: { id: 'team-1', key: 'R2P', name: 'R2pi' },
+      lastSyncAt: '2026-01-01T00:00:00Z',
+      lastFullSyncAt: '2026-01-01T00:00:00Z',
+      lastIssueUpdatedAt: '2026-01-01T00:00:00Z',
+    })
+
+    globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as {
+        query: string
+        variables: Record<string, unknown>
+      }
+
+      if (body.query.includes('query TeamSnapshot')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              team: {
+                id: 'team-1',
+                key: 'R2P',
+                name: 'R2pi',
+                states: { nodes: [{ id: 'state-1', name: 'Todo', position: 0 }] },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      if (body.query.includes('query Users')) {
+        return new Response(JSON.stringify({ data: { users: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Projects')) {
+        return new Response(JSON.stringify({ data: { projects: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Issues')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              issues: {
+                nodes: [linearIssue({ comments: { nodes: [{ id: 'c1' }, { id: 'c2' }] } })],
+                pageInfo: { hasNextPage: false, endCursor: null },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      if (body.query.includes('query IssueHistory')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              issue: {
+                history: {
+                  nodes: [],
+                  pageInfo: { hasNextPage: false, endCursor: null },
+                },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      return new Response(`Unexpected query: ${body.query}`, { status: 500 })
+    }) as unknown as typeof fetch
+
+    const originalDateNow = Date.now
+    Date.now = () => Date.parse('2026-01-01T00:06:00Z')
+
+    try {
+      const provider = new LinearProvider(db, 'R2P', 'lin_api_test')
+      await provider.getBoard()
+    } finally {
+      Date.now = originalDateNow
+    }
+
+    const tasks = getCachedTasks(db)
+    expect(tasks.map((task) => task.externalRef)).toEqual(['R2P-1'])
+    expect(tasks[0]?.comment_count).toBe(2)
+    expect(loadSyncMeta(db).lastFullSyncAt).not.toBeNull()
+  })
+
+  test('polling keeps upstream comment counts instead of resetting them to zero', async () => {
+    upsertIssues(db, [
+      {
+        id: 'issue-1',
+        identifier: 'R2P-1',
+        title: 'Linear task',
+        stateId: 'state-1',
+        stateName: 'Todo',
+        statePosition: 0,
+        commentCount: 4,
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+      },
+    ])
+    saveSyncMeta(db, {
+      team: { id: 'team-1', key: 'R2P', name: 'R2pi' },
+      lastSyncAt: '2026-01-01T00:00:00Z',
+      lastFullSyncAt: '2026-01-01T00:00:00Z',
+      lastIssueUpdatedAt: '2026-01-01T00:00:00Z',
+    })
+
+    globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as {
+        query: string
+      }
+
+      if (body.query.includes('query TeamSnapshot')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              team: {
+                id: 'team-1',
+                key: 'R2P',
+                name: 'R2pi',
+                states: { nodes: [{ id: 'state-1', name: 'Todo', position: 0 }] },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      if (body.query.includes('query Users')) {
+        return new Response(JSON.stringify({ data: { users: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Projects')) {
+        return new Response(JSON.stringify({ data: { projects: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Issues')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              issues: {
+                nodes: [
+                  linearIssue({
+                    comments: {
+                      nodes: Array.from({ length: 7 }, (_, index) => ({ id: `c${index}` })),
+                    },
+                  }),
+                ],
+                pageInfo: { hasNextPage: false, endCursor: null },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      if (body.query.includes('query IssueHistory')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              issue: {
+                history: {
+                  nodes: [],
+                  pageInfo: { hasNextPage: false, endCursor: null },
+                },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      return new Response(`Unexpected query: ${body.query}`, { status: 500 })
+    }) as unknown as typeof fetch
+
+    const originalDateNow = Date.now
+    Date.now = () => Date.parse('2026-01-01T00:06:00Z')
+
+    try {
+      const provider = new LinearProvider(db, 'R2P', 'lin_api_test')
+      const task = await provider.getTask('R2P-1')
+      expect(task.comment_count).toBe(7)
+    } finally {
+      Date.now = originalDateNow
+    }
+  })
+
+  test('recent webhook traffic does not stretch polling beyond the normal interval', async () => {
+    let issueQueries = 0
+
+    saveSyncMeta(db, {
+      team: { id: 'team-1', key: 'R2P', name: 'R2pi' },
+      lastSyncAt: '2026-01-01T00:00:00.000Z',
+      lastFullSyncAt: '2026-01-01T00:00:00.000Z',
+      lastIssueUpdatedAt: '2026-01-01T00:00:00.000Z',
+      lastWebhookAt: '2026-01-01T00:00:30.000Z',
+    })
+
+    globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as {
+        query: string
+        variables: Record<string, unknown>
+      }
+
+      if (body.query.includes('query TeamSnapshot')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              team: {
+                id: 'team-1',
+                key: 'R2P',
+                name: 'R2pi',
+                states: { nodes: [{ id: 'state-1', name: 'Todo', position: 0 }] },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      if (body.query.includes('query Users')) {
+        return new Response(JSON.stringify({ data: { users: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Projects')) {
+        return new Response(JSON.stringify({ data: { projects: { nodes: [] } } }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+
+      if (body.query.includes('query Issues')) {
+        issueQueries += 1
+        expect(body.variables.updatedAfter).toBe('2026-01-01T00:00:00.000Z')
+        return new Response(
+          JSON.stringify({
+            data: {
+              issues: {
+                nodes: [],
+                pageInfo: { hasNextPage: false, endCursor: null },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
+      }
+
+      return new Response(`Unexpected query: ${body.query}`, { status: 500 })
+    }) as unknown as typeof fetch
+
+    const originalDateNow = Date.now
+    Date.now = () => Date.parse('2026-01-01T00:00:31.000Z')
+
+    try {
+      const provider = new LinearProvider(db, 'R2P', 'lin_api_test')
+      await provider.getBoard()
+    } finally {
+      Date.now = originalDateNow
+    }
+
+    expect(issueQueries).toBe(1)
+  })
+})

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

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { Database } from 'bun:sqlite'
+import { initSchema, seedDefaultColumns, addTask } from '../db'
+import { LocalProvider } from '../providers/local'
+
+let db: Database
+let provider: LocalProvider
+
+beforeEach(() => {
+  db = new Database(':memory:')
+  db.run('PRAGMA foreign_keys = ON')
+  initSchema(db)
+  seedDefaultColumns(db)
+  provider = new LocalProvider(db, ':memory:')
+})
+
+describe('LocalProvider.comment', () => {
+  test('creates a stored comment, updates task counts, and advertises comment capability', async () => {
+    const task = addTask(db, 'Comment me')
+
+    const comment = await provider.comment(task.id, 'hello from local')
+
+    expect(comment.task_id).toBe(task.id)
+    expect(comment.body).toBe('hello from local')
+    expect((await provider.getTask(task.id)).comment_count).toBe(1)
+    const activity = await provider.getActivity(10, task.id)
+    expect(activity[0]?.action).toBe('updated')
+    expect(activity[0]?.field_changed).toBe('comment')
+    expect(activity[0]?.new_value).toBe('hello from local')
+
+    const context = await provider.getContext()
+    expect(context.capabilities.comment).toBe(true)
+  })
+
+  test('lists stored comments in creation order', async () => {
+    const task = addTask(db, 'Comment me')
+
+    const first = await provider.comment(task.id, 'first comment')
+    const second = await provider.comment(task.id, 'second comment')
+    const comments = await provider.listComments(task.id)
+
+    expect(comments.map((comment) => comment.id)).toEqual([first.id, second.id])
+    expect(comments.map((comment) => comment.body)).toEqual(['first comment', 'second comment'])
+  })
+
+  test('updates a stored comment body', async () => {
+    const task = addTask(db, 'Comment me')
+    const comment = await provider.comment(task.id, 'hello from local')
+
+    const updated = await provider.updateComment(task.id, comment.id, 'edited local comment')
+
+    expect(updated.id).toBe(comment.id)
+    expect(updated.body).toBe('edited local comment')
+    const activity = await provider.getActivity(10, task.id)
+    expect(activity[0]?.action).toBe('updated')
+    expect(activity[0]?.field_changed).toBe('comment')
+    expect(activity[0]?.old_value).toBe('hello from local')
+    expect(activity[0]?.new_value).toBe('edited local comment')
+  })
+})

package/src/__tests__/mcp-core.test.ts

@@ -0,0 +1,164 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { Database } from 'bun:sqlite'
+import { addTask, initSchema, seedDefaultColumns } from '../db'
+import { createTrackerCore } from '../mcp/core'
+import { TrackerMcpError } from '../mcp/errors'
+import { LocalProvider } from '../providers/local'
+
+interface TestScope {
+  actor: string
+}
+
+let db: Database
+let provider: LocalProvider
+
+beforeEach(() => {
+  db = new Database(':memory:')
+  db.run('PRAGMA foreign_keys = ON')
+  initSchema(db)
+  seedDefaultColumns(db)
+  provider = new LocalProvider(db, ':memory:')
+})
+
+describe('createTrackerCore', () => {
+  test('runs allowed handlers and reports hook metadata', async () => {
+    const task = addTask(db, 'Core task')
+    const hookEvents: Array<{ tool: string; result?: Record<string, unknown> }> = []
+    const core = createTrackerCore<TestScope>({
+      provider,
+      policy: {
+        canReadTicket() {},
+        canPostComment() {},
+        canUpdateComment() {},
+        canMoveTicket() {},
+      },
+      hooks: {
+        onToolResult(event) {
+          hookEvents.push({ tool: event.tool, result: event.result })
+        },
+      },
+    })
+
+    const created = await core.handlers.postComment({
+      scope: { actor: 'agent' },
+      ticketId: task.id,
+      body: 'hello from core',
+    })
+    const updated = await core.handlers.updateComment({
+      scope: { actor: 'agent' },
+      ticketId: task.id,
+      commentId: created.id,
+      body: 'edited by core',
+    })
+    const comments = await core.handlers.listComments({
+      scope: { actor: 'agent' },
+      ticketId: task.id,
+    })
+    await core.handlers.moveTicket({
+      scope: { actor: 'agent' },
+      ticketId: task.id,
+      column: 'in-progress',
+    })
+
+    const inProgressColumn = (await provider.listColumns()).find(
+      (column) => column.name.toLowerCase() === 'in-progress',
+    )
+
+    expect(updated.body).toBe('edited by core')
+    expect(comments).toHaveLength(1)
+    expect(inProgressColumn).toBeDefined()
+    expect((await provider.getTask(task.id)).column_id).toBe(inProgressColumn!.id)
+    expect(hookEvents).toEqual([
+      { tool: 'postComment', result: { commentId: created.id } },
+      { tool: 'updateComment', result: { commentId: created.id } },
+      { tool: 'listComments', result: { commentCount: 1 } },
+      { tool: 'moveTicket', result: { movedTo: 'in-progress' } },
+    ])
+  })
+
+  test('passes the existing comment to update policy and filters listed comments via policy', async () => {
+    const task = addTask(db, 'Core task')
+    const first = await provider.comment(task.id, 'visible comment')
+    await provider.comment(task.id, 'hidden comment')
+    let seenCommentId: string | null = null
+    let seenCommentBody: string | null = null
+
+    const core = createTrackerCore<TestScope>({
+      provider,
+      policy: {
+        canReadTicket() {},
+        canPostComment() {},
+        canUpdateComment(_scope, _ticketId, comment) {
+          seenCommentId = comment.id
+          seenCommentBody = comment.body
+        },
+        canMoveTicket() {},
+        filterComment(_scope, comment) {
+          return comment.body.startsWith('visible')
+        },
+      },
+    })
+
+    const comments = await core.handlers.listComments({
+      scope: { actor: 'agent' },
+      ticketId: task.id,
+    })
+    await core.handlers.updateComment({
+      scope: { actor: 'agent' },
+      ticketId: task.id,
+      commentId: first.id,
+      body: 'edited comment',
+    })
+
+    expect(comments.map((comment) => comment.body)).toEqual(['visible comment'])
+    expect(seenCommentId === first.id).toBe(true)
+    expect(seenCommentBody === 'visible comment').toBe(true)
+  })
+
+  test('normalizes policy denials into TrackerMcpError and reports them through hooks', async () => {
+    const task = addTask(db, 'Core task')
+    const toolErrors: Array<{ tool: string; code: string; message?: string }> = []
+    const core = createTrackerCore<TestScope>({
+      provider,
+      policy: {
+        canReadTicket() {},
+        canPostComment() {},
+        canUpdateComment() {},
+        canMoveTicket() {
+          throw new TrackerMcpError({
+            code: 'policy_denied',
+            publicMessage: 'forbidden_column',
+          })
+        },
+      },
+      hooks: {
+        onToolError(event) {
+          toolErrors.push({
+            tool: event.tool,
+            code: event.errorCode,
+            message: event.error.publicMessage,
+          })
+        },
+      },
+    })
+
+    await expect(
+      core.handlers.moveTicket({
+        scope: { actor: 'agent' },
+        ticketId: task.id,
+        column: 'done',
+      }),
+    ).rejects.toMatchObject({
+      code: 'policy_denied',
+      publicMessage: 'forbidden_column',
+    })
+
+    expect(toolErrors).toEqual([
+      {
+        tool: 'moveTicket',
+        code: 'policy_denied',
+        message: 'forbidden_column',
+      },
+    ])
+  })
+})