@andypai/agent-kanban 0.6.3 → 0.6.5

package/src/providers/cache-task-mappers.ts

@@ -0,0 +1,123 @@
+import type { Task } from '../types'
+
+export interface JiraTaskRow {
+  id: string
+  key: string
+  summary: string
+  description_text: string
+  status_id: string
+  priority_name: string
+  issue_type_name: string
+  assignee_account_id: string | null
+  assignee_name: string
+  labels: string
+  comment_count: number
+  project_key: string
+  url: string | null
+  created_at: string
+  updated_at: string
+}
+
+export interface LinearTaskRow {
+  id: string
+  identifier: string
+  title: string
+  description: string
+  state_id: string
+  state_position: number
+  priority: number
+  assignee_name: string
+  project_name: string
+  labels: string
+  comment_count: number
+  url: string | null
+  created_at: string
+  updated_at: string
+}
+
+function parseTaskLabels(raw: string): string[] {
+  try {
+    const parsed: unknown = JSON.parse(raw)
+    return Array.isArray(parsed)
+      ? parsed.filter((value): value is string => typeof value === 'string')
+      : []
+  } catch {
+    return []
+  }
+}
+
+function mapJiraPriorityNameToCanonical(name: string): Task['priority'] {
+  switch (name.trim().toLowerCase()) {
+    case 'highest':
+      return 'urgent'
+    case 'high':
+      return 'high'
+    case 'medium':
+      return 'medium'
+    default:
+      return 'low'
+  }
+}
+
+function mapLinearPriority(priority: number): Task['priority'] {
+  switch (priority) {
+    case 1:
+      return 'urgent'
+    case 2:
+      return 'high'
+    case 3:
+      return 'medium'
+    case 0:
+    case 4:
+    default:
+      return 'low'
+  }
+}
+
+export function jiraTaskFromRow(row: JiraTaskRow): Task {
+  return {
+    id: `jira:${row.id}`,
+    providerId: row.id,
+    externalRef: row.key,
+    url: row.url,
+    title: row.summary,
+    description: row.description_text,
+    column_id: row.status_id,
+    position: 0,
+    priority: mapJiraPriorityNameToCanonical(row.priority_name),
+    assignee: row.assignee_name,
+    assignees: row.assignee_name ? [row.assignee_name] : [],
+    labels: parseTaskLabels(row.labels),
+    comment_count: row.comment_count,
+    project: row.project_key,
+    metadata: '{}',
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    version: row.updated_at,
+    source_updated_at: row.updated_at,
+  }
+}
+
+export function linearTaskFromRow(row: LinearTaskRow): Task {
+  return {
+    id: `linear:${row.id}`,
+    providerId: row.id,
+    externalRef: row.identifier,
+    url: row.url,
+    title: row.title,
+    description: row.description,
+    column_id: row.state_id,
+    position: row.state_position,
+    priority: mapLinearPriority(row.priority),
+    assignee: row.assignee_name,
+    assignees: row.assignee_name ? [row.assignee_name] : [],
+    labels: parseTaskLabels(row.labels),
+    comment_count: row.comment_count,
+    project: row.project_name,
+    metadata: '{}',
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    version: row.updated_at,
+    source_updated_at: row.updated_at,
+  }
+}

package/src/providers/factory.ts

@@ -0,0 +1,103 @@
+import type { Database } from 'bun:sqlite'
+import type { Sql } from 'postgres'
+
+import { initSchema, seedDefaultColumns } from '../db'
+import type { ProviderCapabilities } from '../types'
+import type { TrackerConfig } from '../tracker-config'
+import {
+  JIRA_CAPABILITIES,
+  LINEAR_CAPABILITIES,
+  LOCAL_CAPABILITIES,
+  POSTGRES_LOCAL_CAPABILITIES,
+} from './capabilities'
+import { JiraProvider, type JiraProviderConfig } from './jira'
+import { LinearProvider } from './linear'
+import { LocalProvider } from './local'
+import { PostgresJiraProvider } from './postgres-jira'
+import { PostgresLinearProvider } from './postgres-linear'
+import { PostgresLocalProvider } from './postgres-local'
+import type { KanbanProvider } from './types'
+
+export interface InitializableKanbanProvider extends KanbanProvider {
+  initialize(): Promise<void>
+}
+
+export interface ProviderBundle<TProvider extends KanbanProvider = KanbanProvider> {
+  provider: TProvider
+  capabilities: ProviderCapabilities
+}
+
+export interface SqliteProviderOptions {
+  dbPath: string
+  seedLocalColumns?: boolean
+}
+
+function jiraProviderConfig(
+  config: Extract<TrackerConfig, { provider: 'jira' }>,
+): JiraProviderConfig {
+  return {
+    baseUrl: config.baseUrl,
+    email: config.email,
+    apiToken: config.apiToken,
+    projectKey: config.projectKey,
+    ...(config.boardId !== undefined ? { boardId: config.boardId } : {}),
+    defaultIssueType: config.defaultIssueType ?? 'Task',
+    pollingSyncIntervalMs: config.syncIntervalMs,
+  }
+}
+
+export function createSqliteProvider(
+  db: Database,
+  config: TrackerConfig,
+  options: SqliteProviderOptions,
+): ProviderBundle {
+  switch (config.provider) {
+    case 'linear':
+      return {
+        provider: new LinearProvider(db, config.teamId, config.apiKey, config.syncIntervalMs),
+        capabilities: LINEAR_CAPABILITIES,
+      }
+    case 'jira':
+      return {
+        provider: new JiraProvider(db, jiraProviderConfig(config)),
+        capabilities: JIRA_CAPABILITIES,
+      }
+    case 'local':
+      initSchema(db)
+      if (options.seedLocalColumns !== false) {
+        seedDefaultColumns(db, config.defaultColumns)
+      }
+      return {
+        provider: new LocalProvider(db, options.dbPath),
+        capabilities: LOCAL_CAPABILITIES,
+      }
+  }
+}
+
+export function createPostgresProvider(
+  sql: Sql,
+  config: TrackerConfig,
+): ProviderBundle<InitializableKanbanProvider> {
+  switch (config.provider) {
+    case 'linear':
+      return {
+        provider: new PostgresLinearProvider(
+          sql,
+          config.teamId,
+          config.apiKey,
+          config.syncIntervalMs,
+        ),
+        capabilities: LINEAR_CAPABILITIES,
+      }
+    case 'jira':
+      return {
+        provider: new PostgresJiraProvider(sql, jiraProviderConfig(config)),
+        capabilities: JIRA_CAPABILITIES,
+      }
+    case 'local':
+      return {
+        provider: new PostgresLocalProvider(sql, config),
+        capabilities: POSTGRES_LOCAL_CAPABILITIES,
+      }
+  }
+}

package/src/providers/index.ts

@@ -1,10 +1,8 @@
 import type { Database } from 'bun:sqlite'
-import { getDbPath, initSchema, seedDefaultColumns } from '../db'
-import { JiraProvider } from './jira'
-import { LinearProvider } from './linear'
-import { LocalProvider } from './local'
+import { getDbPath } from '../db'
 import type { TrackerConfig } from '../tracker-config'
 import type { KanbanProvider } from './types'
+import { createSqliteProvider } from './factory'
 
 export function createProvider(
   db: Database,
@@ -12,25 +10,6 @@ export function createProvider(
   dbPath = getDbPath(),
   options: { seedLocalColumns?: boolean } = {},
 ): KanbanProvider {
-  if (config.provider === 'linear') {
-    return new LinearProvider(db, config.teamId, config.apiKey, config.syncIntervalMs)
-  }
-
-  if (config.provider === 'jira') {
-    return new JiraProvider(db, {
-      baseUrl: config.baseUrl,
-      email: config.email,
-      apiToken: config.apiToken,
-      projectKey: config.projectKey,
-      ...(config.boardId !== undefined ? { boardId: config.boardId } : {}),
-      defaultIssueType: config.defaultIssueType ?? 'Task',
-      pollingSyncIntervalMs: config.syncIntervalMs,
-    })
-  }
-
-  initSchema(db)
-  if (options.seedLocalColumns !== false) {
-    seedDefaultColumns(db, config.defaultColumns)
-  }
-  return new LocalProvider(db, dbPath)
+  return createSqliteProvider(db, config, { dbPath, seedLocalColumns: options.seedLocalColumns })
+    .provider
 }

package/src/providers/jira-cache.ts

@@ -1,6 +1,9 @@
 import type { Database } from 'bun:sqlite'
+import { normalizeColumnName } from '../column-roles'
 import { ErrorCode, KanbanError } from '../errors'
 import type { BoardView, ProviderTeamInfo, Task } from '../types'
+import { jiraTaskFromRow, type JiraTaskRow } from './cache-task-mappers'
+import { parseProviderTeamInfo } from './team-info'
 
 // Column ids are prefixed to avoid collisions across sources:
 // - board-sourced columns: 'board:<boardId>:<columnName>' with an index suffix
@@ -70,46 +73,51 @@ export function jiraBoardColumnRows(
   })
 }
 
+function ambiguousColumnError(input: string, matches: JiraColumnRow[]): KanbanError {
+  return new KanbanError(
+    ErrorCode.COLUMN_NOT_FOUND,
+    `Jira column name '${input}' is ambiguous; use one of these column ids: ${matches
+      .map((column) => column.id)
+      .join(', ')}`,
+  )
+}
+
 // Resolves a user-supplied column reference to a cached column id, trying
-// (1) exact id, (2) case-insensitive name, (3) raw status id containment.
-// A name that matches multiple columns (possible when Jira returns duplicate
-// board column names) is rejected as ambiguous so the caller picks an id.
+// (1) exact id, (2) case-insensitive name, (3) raw status id containment,
+// (4) separator-insensitive name ('Todo' → 'To Do'). Exact passes (id, name,
+// status id) run before the fuzzy normalized pass so a precise reference is
+// never overridden by a normalized-name collision. Name lookups that match
+// multiple distinct columns (possible when Jira returns duplicate board column
+// names, or when two columns collapse to the same normalized token) are
+// rejected as ambiguous so the caller picks an id.
 export function resolveJiraColumnId(columns: JiraColumnRow[], input: string): string {
   const byId = columns.find((column) => column.id === input)
   if (byId) return byId.id
   const lower = input.toLowerCase()
   const byName = columns.filter((column) => column.name.toLowerCase() === lower)
   if (byName.length === 1) return byName[0]!.id
-  if (byName.length > 1) {
-    throw new KanbanError(
-      ErrorCode.COLUMN_NOT_FOUND,
-      `Jira column name '${input}' is ambiguous; use one of these column ids: ${byName
-        .map((column) => column.id)
-        .join(', ')}`,
-    )
-  }
+  if (byName.length > 1) throw ambiguousColumnError(input, byName)
+  // Exact status-id containment takes precedence over the fuzzy name pass: a raw
+  // status id is an unambiguous reference and must not be shadowed by a column
+  // whose name happens to normalize to the same token.
   const byStatus = columns.find((column) => decodeColumnStatusIds(column).includes(input))
   if (byStatus) return byStatus.id
+  // Status-fallback columns are named after Jira statuses ('To Do', 'In
+  // Progress'), but dispatch triggers pass collapsed strings like 'Todo'. Match
+  // separator-insensitively so the trigger column resolves instead of throwing
+  // COLUMN_NOT_FOUND (which silently strands every ticket in that column). Skip a
+  // token that collapses to empty so punctuation-only input never matches a
+  // separator-only column name.
+  const normalized = normalizeColumnName(input)
+  if (normalized !== '') {
+    const byNormalized = columns.filter((column) => normalizeColumnName(column.name) === normalized)
+    if (byNormalized.length === 1) return byNormalized[0]!.id
+    if (byNormalized.length > 1) throw ambiguousColumnError(input, byNormalized)
+  }
   throw new KanbanError(ErrorCode.COLUMN_NOT_FOUND, `No Jira column matching '${input}'`)
 }
 
-interface JiraIssueRow {
-  id: string
-  key: string
-  summary: string
-  description_text: string
-  status_id: string
-  priority_name: string
-  issue_type_name: string
-  assignee_account_id: string | null
-  assignee_name: string
-  labels: string
-  comment_count: number
-  project_key: string
-  url: string | null
-  created_at: string
-  updated_at: string
-}
+type JiraIssueRow = JiraTaskRow
 
 export function initJiraCacheSchema(db: Database): void {
   db.run(`
@@ -252,27 +260,7 @@ export function saveTeamInfo(db: Database, team: ProviderTeamInfo | null): void
 }
 
 export function loadTeamInfo(db: Database): ProviderTeamInfo | null {
-  const raw = getMeta(db, 'team')
-  if (raw === null) return null
-  try {
-    const parsed = JSON.parse(raw) as unknown
-    if (
-      parsed &&
-      typeof parsed === 'object' &&
-      'id' in parsed &&
-      'key' in parsed &&
-      'name' in parsed &&
-      typeof (parsed as { id: unknown }).id === 'string' &&
-      typeof (parsed as { key: unknown }).key === 'string' &&
-      typeof (parsed as { name: unknown }).name === 'string'
-    ) {
-      const t = parsed as { id: string; key: string; name: string }
-      return { id: t.id, key: t.key, name: t.name }
-    }
-    return null
-  } catch {
-    return null
-  }
+  return parseProviderTeamInfo(getMeta(db, 'team'))
 }
 
 export function loadJiraSyncMeta(db: Database): JiraSyncMeta {
@@ -522,52 +510,6 @@ export function getCachedColumns(db: Database): JiraColumnRow[] {
   return db.query('SELECT * FROM jira_columns ORDER BY position, name').all() as JiraColumnRow[]
 }
 
-function mapPriorityNameToCanonical(name: string): Task['priority'] {
-  switch (name.trim().toLowerCase()) {
-    case 'highest':
-      return 'urgent'
-    case 'high':
-      return 'high'
-    case 'medium':
-      return 'medium'
-    default:
-      return 'low'
-  }
-}
-
-function parseLabels(raw: string): string[] {
-  try {
-    const parsed: unknown = JSON.parse(raw)
-    return Array.isArray(parsed) ? parsed.filter((v): v is string => typeof v === 'string') : []
-  } catch {
-    return []
-  }
-}
-
-function taskFromRow(row: JiraIssueRow): Task {
-  return {
-    id: `jira:${row.id}`,
-    providerId: row.id,
-    externalRef: row.key,
-    url: row.url,
-    title: row.summary,
-    description: row.description_text,
-    column_id: row.status_id,
-    position: 0,
-    priority: mapPriorityNameToCanonical(row.priority_name),
-    assignee: row.assignee_name,
-    assignees: row.assignee_name ? [row.assignee_name] : [],
-    labels: parseLabels(row.labels),
-    comment_count: row.comment_count,
-    project: row.project_key,
-    metadata: '{}',
-    created_at: row.created_at,
-    updated_at: row.updated_at,
-    version: row.updated_at,
-    source_updated_at: row.updated_at,
-  }
-}
-
 function selectIssuesByStatusIds(db: Database, statusIds: string[]): JiraIssueRow[] {
   if (statusIds.length === 0) return []
   const placeholders = statusIds.map((_, i) => `$s${i}`).join(', ')
@@ -589,7 +531,7 @@ export function getCachedBoard(db: Database): BoardView {
   return {
     columns: columns.map((column) => {
       const statusIds = decodeColumnStatusIds(column)
-      const tasks = selectIssuesByStatusIds(db, statusIds).map(taskFromRow)
+      const tasks = selectIssuesByStatusIds(db, statusIds).map(jiraTaskFromRow)
       return {
         id: column.id,
         name: column.name,
@@ -612,7 +554,7 @@ export function getCachedTask(db: Database, lookup: string): Task | null {
        LIMIT 1`,
     )
     .get({ $lookup: normalized }) as JiraIssueRow | null
-  return row ? taskFromRow(row) : null
+  return row ? jiraTaskFromRow(row) : null
 }
 
 export function getCachedTasks(db: Database, params?: { columnId?: string }): Task[] {
@@ -622,13 +564,13 @@ export function getCachedTasks(db: Database, params?: { columnId?: string }): Ta
       .get({ $id: params.columnId }) as Pick<JiraColumnRow, 'status_ids'> | null
     if (!columnRow) return []
     const statusIds = decodeColumnStatusIds(columnRow)
-    return selectIssuesByStatusIds(db, statusIds).map(taskFromRow)
+    return selectIssuesByStatusIds(db, statusIds).map(jiraTaskFromRow)
   }
   return (
     db
       .query('SELECT * FROM jira_issues ORDER BY updated_at DESC, summary ASC')
       .all() as JiraIssueRow[]
-  ).map(taskFromRow)
+  ).map(jiraTaskFromRow)
 }
 
 export function getCachedConfig(db: Database): JiraCacheConfig {