@andypai/agent-kanban 0.3.4 → 0.3.5

package/src/provider-runtime.ts

@@ -0,0 +1,110 @@
+import { Database } from 'bun:sqlite'
+import postgres from 'postgres'
+
+import { getDbPath, migrateSchema, openDb } from './db'
+import { unsupportedOperation } from './providers/errors'
+import { createProvider } from './providers/index'
+import { PostgresJiraProvider } from './providers/postgres-jira'
+import { PostgresLinearProvider } from './providers/postgres-linear'
+import { PostgresLocalProvider } from './providers/postgres-local'
+import type { KanbanProvider } from './providers/types'
+import { resolveKanbanStorageConfig } from './storage-config'
+import type { KanbanStorageConfig } from './storage-config'
+import { trackerConfigFromEnv, type TrackerConfig } from './tracker-config'
+
+export interface KanbanRuntime {
+  provider: KanbanProvider
+  dbPath: string
+  trackerConfig: TrackerConfig
+  sqliteDb?: Database
+  syncIntervalMs?: number
+  close(): Promise<void>
+}
+
+export async function openKanbanRuntime(
+  opts: { dbPath?: string; storage?: KanbanStorageConfig; tracker?: TrackerConfig } = {},
+): Promise<KanbanRuntime> {
+  const dbPath = opts.dbPath ?? getDbPath()
+  const storage =
+    opts.storage ?? resolveKanbanStorageConfig(process.env, { defaultSqlitePath: dbPath })
+  const trackerConfig = opts.tracker ?? trackerConfigFromEnv(process.env)
+
+  if (storage.mode === 'postgres') {
+    const sql = postgres(storage.databaseUrl, { max: 5, onnotice: () => {} })
+    if (trackerConfig.provider === 'local') {
+      const provider = new PostgresLocalProvider(sql, trackerConfig)
+      await provider.initialize()
+      return {
+        provider,
+        dbPath,
+        trackerConfig,
+        syncIntervalMs: trackerConfig.syncIntervalMs,
+        async close() {
+          await sql.end({ timeout: 1 })
+        },
+      }
+    }
+    if (trackerConfig.provider === 'jira') {
+      const provider = new PostgresJiraProvider(sql, {
+        baseUrl: trackerConfig.baseUrl,
+        email: trackerConfig.email,
+        apiToken: trackerConfig.apiToken,
+        projectKey: trackerConfig.projectKey,
+        ...(trackerConfig.boardId !== undefined ? { boardId: trackerConfig.boardId } : {}),
+        defaultIssueType: trackerConfig.defaultIssueType ?? 'Task',
+        pollingSyncIntervalMs: trackerConfig.syncIntervalMs,
+      })
+      await provider.initialize()
+      return {
+        provider,
+        dbPath,
+        trackerConfig,
+        syncIntervalMs: trackerConfig.syncIntervalMs,
+        async close() {
+          await sql.end({ timeout: 1 })
+        },
+      }
+    }
+    if (trackerConfig.provider === 'linear') {
+      const provider = new PostgresLinearProvider(
+        sql,
+        trackerConfig.teamId,
+        trackerConfig.apiKey,
+        trackerConfig.syncIntervalMs,
+      )
+      await provider.initialize()
+      return {
+        provider,
+        dbPath,
+        trackerConfig,
+        syncIntervalMs: trackerConfig.syncIntervalMs,
+        async close() {
+          await sql.end({ timeout: 1 })
+        },
+      }
+    }
+    try {
+      const _exhaustive: never = trackerConfig
+      unsupportedOperation(
+        `KANBAN_STORAGE=postgres currently supports KANBAN_PROVIDER=local, linear, or jira in agent-kanban.`,
+      )
+      void _exhaustive
+    } catch (err) {
+      await sql.end({ timeout: 1 })
+      throw err
+    }
+  }
+
+  const db = openDb(storage.sqlitePath)
+  migrateSchema(db)
+  return {
+    provider: createProvider(db, trackerConfig, storage.sqlitePath),
+    dbPath: storage.sqlitePath,
+    trackerConfig,
+    sqliteDb: db,
+    syncIntervalMs: trackerConfig.syncIntervalMs,
+    async close() {
+      db.close()
+    },
+  }
+}

package/src/providers/index.ts

@@ -1,52 +1,29 @@
 import type { Database } from 'bun:sqlite'
 import { getDbPath, initSchema, seedDefaultColumns } from '../db'
-import { providerNotConfigured } from './errors'
 import { JiraProvider } from './jira'
 import { LinearProvider } from './linear'
 import { LocalProvider } from './local'
+import type { TrackerConfig } from '../tracker-config'
 import type { KanbanProvider } from './types'
-import { resolvePollingSyncIntervalMs } from '../sync-config'
 
-export function createProvider(db: Database, dbPath = getDbPath()): KanbanProvider {
-  const providerType = (process.env['KANBAN_PROVIDER'] ?? 'local') as 'local' | 'linear' | 'jira'
-
-  if (providerType === 'linear') {
-    const apiKey = process.env['LINEAR_API_KEY']
-    const teamId = process.env['LINEAR_TEAM_ID']
-    if (!apiKey || !teamId) {
-      providerNotConfigured(
-        'LINEAR_API_KEY and LINEAR_TEAM_ID are required when KANBAN_PROVIDER=linear',
-      )
-    }
-    return new LinearProvider(db, teamId!, apiKey!, resolvePollingSyncIntervalMs())
+export function createProvider(
+  db: Database,
+  config: TrackerConfig,
+  dbPath = getDbPath(),
+): KanbanProvider {
+  if (config.provider === 'linear') {
+    return new LinearProvider(db, config.teamId, config.apiKey, config.syncIntervalMs)
   }
 
-  if (providerType === 'jira') {
-    const baseUrl = process.env['JIRA_BASE_URL']
-    const email = process.env['JIRA_EMAIL']
-    const apiToken = process.env['JIRA_API_TOKEN']
-    const projectKey = process.env['JIRA_PROJECT_KEY']
-    const missing: string[] = []
-    if (!baseUrl) missing.push('JIRA_BASE_URL')
-    if (!email) missing.push('JIRA_EMAIL')
-    if (!apiToken) missing.push('JIRA_API_TOKEN')
-    if (!projectKey) missing.push('JIRA_PROJECT_KEY')
-    if (missing.length > 0) {
-      providerNotConfigured(
-        `${missing.join(', ')} ${missing.length === 1 ? 'is' : 'are'} required when KANBAN_PROVIDER=jira`,
-      )
-    }
-    const boardIdRaw = process.env['JIRA_BOARD_ID']
-    const boardId = boardIdRaw ? Number.parseInt(boardIdRaw, 10) : undefined
-    const defaultIssueType = process.env['JIRA_ISSUE_TYPE'] ?? 'Task'
+  if (config.provider === 'jira') {
     return new JiraProvider(db, {
-      baseUrl: baseUrl!,
-      email: email!,
-      apiToken: apiToken!,
-      projectKey: projectKey!,
-      boardId: Number.isFinite(boardId) ? boardId : undefined,
-      defaultIssueType,
-      pollingSyncIntervalMs: resolvePollingSyncIntervalMs(),
+      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,
     })
   }
 

package/src/providers/jira.ts

@@ -49,7 +49,7 @@ import type {
   TaskListFilters,
   UpdateTaskInput,
 } from './types'
-import { resolvePollingSyncIntervalMs } from '../sync-config'
+import { DEFAULT_POLLING_SYNC_INTERVAL_MS } from '../sync-config'
 
 const FULL_RECONCILE_INTERVAL_MS = 5 * 60_000
 
@@ -92,7 +92,7 @@ export class JiraProvider implements KanbanProvider {
     client?: JiraClient,
   ) {
     initJiraCacheSchema(db)
-    this.pollingSyncIntervalMs = config.pollingSyncIntervalMs ?? resolvePollingSyncIntervalMs()
+    this.pollingSyncIntervalMs = config.pollingSyncIntervalMs ?? DEFAULT_POLLING_SYNC_INTERVAL_MS
     this.client =
       client ??
       new JiraClient({

package/src/providers/linear.ts

@@ -41,7 +41,7 @@ import type {
   TaskListFilters,
   UpdateTaskInput,
 } from './types'
-import { resolvePollingSyncIntervalMs } from '../sync-config'
+import { DEFAULT_POLLING_SYNC_INTERVAL_MS } from '../sync-config'
 
 const FULL_RECONCILIATION_INTERVAL_MS = 5 * 60_000
 
@@ -81,7 +81,7 @@ export class LinearProvider implements KanbanProvider {
     private readonly db: Database,
     private readonly teamId: string,
     apiKey: string,
-    private readonly pollingSyncIntervalMs = resolvePollingSyncIntervalMs(),
+    private readonly pollingSyncIntervalMs = DEFAULT_POLLING_SYNC_INTERVAL_MS,
   ) {
     initLinearCacheSchema(db)
     this.client = new LinearClient(apiKey)