@andypai/agent-kanban 0.2.0 → 0.3.0

package/src/providers/linear-cache.ts

@@ -14,7 +14,9 @@ export interface LinearStateRow {
 export interface LinearSyncMeta {
   team: ProviderTeamInfo | null
   lastSyncAt: string | null
+  lastFullSyncAt: string | null
   lastIssueUpdatedAt: string | null
+  lastWebhookAt: string | null
 }
 
 export function initLinearCacheSchema(db: Database): void {
@@ -66,6 +68,8 @@ export function initLinearCacheSchema(db: Database): void {
       state_id TEXT NOT NULL,
       state_name TEXT NOT NULL,
       state_position INTEGER NOT NULL DEFAULT 0,
+      labels TEXT NOT NULL DEFAULT '[]',
+      comment_count INTEGER NOT NULL DEFAULT 0,
       url TEXT,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
@@ -73,6 +77,81 @@ export function initLinearCacheSchema(db: Database): void {
   `)
   db.run('CREATE INDEX IF NOT EXISTS idx_linear_issues_state_id ON linear_issues(state_id)')
   db.run('CREATE INDEX IF NOT EXISTS idx_linear_issues_updated_at ON linear_issues(updated_at)')
+  db.run(`
+    CREATE TABLE IF NOT EXISTS linear_activity (
+      issue_id TEXT NOT NULL,
+      history_id TEXT NOT NULL,
+      item_field TEXT NOT NULL,
+      from_value TEXT,
+      to_value TEXT,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (issue_id, history_id, item_field)
+    )
+  `)
+  db.run(
+    'CREATE INDEX IF NOT EXISTS linear_activity_created_at_idx ON linear_activity(created_at DESC)',
+  )
+  migrateLinearCacheSchema(db)
+}
+
+export interface LinearActivityRow {
+  issue_id: string
+  history_id: string
+  item_field: string
+  from_value: string | null
+  to_value: string | null
+  created_at: string
+}
+
+export function saveLinearActivity(db: Database, rows: LinearActivityRow[]): void {
+  if (rows.length === 0) return
+  const stmt = db.prepare(
+    `INSERT OR IGNORE INTO linear_activity
+     (issue_id, history_id, item_field, from_value, to_value, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  )
+  const tx = db.transaction((items: LinearActivityRow[]) => {
+    for (const r of items) {
+      stmt.run(r.issue_id, r.history_id, r.item_field, r.from_value, r.to_value, r.created_at)
+    }
+  })
+  tx(rows)
+}
+
+export function getCachedLinearActivity(
+  db: Database,
+  params: { issueId?: string; limit?: number } = {},
+): LinearActivityRow[] {
+  const limit = params.limit ?? 100
+  if (params.issueId) {
+    return db
+      .query(
+        `SELECT issue_id, history_id, item_field, from_value, to_value, created_at
+         FROM linear_activity
+         WHERE issue_id = $issueId
+         ORDER BY created_at DESC
+         LIMIT $limit`,
+      )
+      .all({ $issueId: params.issueId, $limit: limit }) as LinearActivityRow[]
+  }
+  return db
+    .query(
+      `SELECT issue_id, history_id, item_field, from_value, to_value, created_at
+       FROM linear_activity
+       ORDER BY created_at DESC
+       LIMIT $limit`,
+    )
+    .all({ $limit: limit }) as LinearActivityRow[]
+}
+
+function migrateLinearCacheSchema(db: Database): void {
+  const cols = db.query('PRAGMA table_info(linear_issues)').all() as { name: string }[]
+  if (!cols.some((c) => c.name === 'labels')) {
+    db.run("ALTER TABLE linear_issues ADD COLUMN labels TEXT NOT NULL DEFAULT '[]'")
+  }
+  if (!cols.some((c) => c.name === 'comment_count')) {
+    db.run('ALTER TABLE linear_issues ADD COLUMN comment_count INTEGER NOT NULL DEFAULT 0')
+  }
 }
 
 function setMeta(db: Database, key: string, value: string): void {
@@ -82,6 +161,10 @@ function setMeta(db: Database, key: string, value: string): void {
   ).run({ $key: key, $value: value })
 }
 
+function deleteMeta(db: Database, key: string): void {
+  db.query('DELETE FROM linear_sync_meta WHERE key = $key').run({ $key: key })
+}
+
 function getMeta(db: Database, key: string): string | null {
   const row = db.query('SELECT value FROM linear_sync_meta WHERE key = $key').get({
     $key: key,
@@ -89,10 +172,31 @@ function getMeta(db: Database, key: string): string | null {
   return row?.value ?? null
 }
 
-export function saveSyncMeta(db: Database, meta: LinearSyncMeta): void {
-  if (meta.team) setMeta(db, 'team', JSON.stringify(meta.team))
-  if (meta.lastSyncAt) setMeta(db, 'lastSyncAt', meta.lastSyncAt)
-  if (meta.lastIssueUpdatedAt) setMeta(db, 'lastIssueUpdatedAt', meta.lastIssueUpdatedAt)
+const META_KEYS = [
+  'team',
+  'lastSyncAt',
+  'lastFullSyncAt',
+  'lastIssueUpdatedAt',
+  'lastWebhookAt',
+] as const
+type MetaKey = (typeof META_KEYS)[number]
+
+export function saveSyncMeta(db: Database, meta: Partial<LinearSyncMeta>): void {
+  for (const key of META_KEYS) {
+    if (!Object.prototype.hasOwnProperty.call(meta, key)) continue
+    const value = (meta as Record<MetaKey, unknown>)[key]
+    if (value === null) {
+      deleteMeta(db, key)
+      continue
+    }
+    if (key === 'team') {
+      setMeta(db, key, JSON.stringify(value))
+      continue
+    }
+    if (typeof value === 'string') {
+      setMeta(db, key, value)
+    }
+  }
 }
 
 export function loadSyncMeta(db: Database): LinearSyncMeta {
@@ -100,7 +204,9 @@ export function loadSyncMeta(db: Database): LinearSyncMeta {
   return {
     team: teamRaw ? (JSON.parse(teamRaw) as ProviderTeamInfo) : null,
     lastSyncAt: getMeta(db, 'lastSyncAt'),
+    lastFullSyncAt: getMeta(db, 'lastFullSyncAt'),
     lastIssueUpdatedAt: getMeta(db, 'lastIssueUpdatedAt'),
+    lastWebhookAt: getMeta(db, 'lastWebhookAt'),
   }
 }
 
@@ -173,6 +279,16 @@ export function upsertProjects(
   }
 }
 
+// Bound per-value storage so repeated edits to a long description can't balloon the cache.
+const ACTIVITY_VALUE_MAX_CHARS = 4096
+const ACTIVITY_TRUNCATION_SUFFIX = '…[truncated]'
+const ACTIVITY_VALUE_BUDGET = ACTIVITY_VALUE_MAX_CHARS - ACTIVITY_TRUNCATION_SUFFIX.length
+
+function clampActivityValue(value: string): string {
+  if (value.length <= ACTIVITY_VALUE_MAX_CHARS) return value
+  return value.slice(0, ACTIVITY_VALUE_BUDGET) + ACTIVITY_TRUNCATION_SUFFIX
+}
+
 export function upsertIssues(
   db: Database,
   issues: Array<{
@@ -188,18 +304,24 @@ export function upsertIssues(
     stateId: string
     stateName: string
     statePosition: number
+    labels?: string[] | null
+    commentCount?: number | null
     url?: string | null
     createdAt: string
     updatedAt: string
   }>,
 ): void {
-  const stmt = db.prepare(
+  if (issues.length === 0) return
+  const upsertStmt = db.prepare(
     `INSERT INTO linear_issues (
       id, identifier, title, description, priority, assignee_id, assignee_name,
-      project_id, project_name, state_id, state_name, state_position, url, created_at, updated_at
+      project_id, project_name, state_id, state_name, state_position, labels, comment_count,
+      url, created_at, updated_at
     ) VALUES (
       $id, $identifier, $title, $description, $priority, $assignee_id, $assignee_name,
-      $project_id, $project_name, $state_id, $state_name, $state_position, $url, $created_at, $updated_at
+      $project_id, $project_name, $state_id, $state_name, $state_position, $labels,
+      CASE WHEN $comment_count_provided = 1 THEN $comment_count ELSE 0 END,
+      $url, $created_at, $updated_at
     )
     ON CONFLICT(id) DO UPDATE SET
       identifier = excluded.identifier,
@@ -213,29 +335,105 @@ export function upsertIssues(
       state_id = excluded.state_id,
       state_name = excluded.state_name,
       state_position = excluded.state_position,
+      labels = excluded.labels,
+      comment_count = CASE
+        WHEN $comment_count_provided = 1 THEN excluded.comment_count
+        ELSE linear_issues.comment_count
+      END,
       url = excluded.url,
       created_at = excluded.created_at,
       updated_at = excluded.updated_at`,
   )
-  for (const issue of issues) {
-    stmt.run({
-      $id: issue.id,
-      $identifier: issue.identifier,
-      $title: issue.title,
-      $description: issue.description ?? '',
-      $priority: issue.priority ?? 0,
-      $assignee_id: issue.assigneeId ?? null,
-      $assignee_name: issue.assigneeName ?? '',
-      $project_id: issue.projectId ?? null,
-      $project_name: issue.projectName ?? '',
-      $state_id: issue.stateId,
-      $state_name: issue.stateName,
-      $state_position: issue.statePosition,
-      $url: issue.url ?? null,
-      $created_at: issue.createdAt,
-      $updated_at: issue.updatedAt,
-    })
-  }
+  const existingDescStmt = db.prepare(
+    'SELECT description FROM linear_issues WHERE id = $id LIMIT 1',
+  )
+  const activityStmt = db.prepare(
+    `INSERT OR IGNORE INTO linear_activity
+     (issue_id, history_id, item_field, from_value, to_value, created_at)
+     VALUES ($issue_id, $history_id, $item_field, $from_value, $to_value, $created_at)`,
+  )
+  const run = db.transaction(() => {
+    for (const issue of issues) {
+      const nextDescription = issue.description ?? ''
+      const hasCommentCount = issue.commentCount !== undefined && issue.commentCount !== null
+      const prior = existingDescStmt.get({ $id: issue.id }) as { description: string } | null
+      if (prior && prior.description !== nextDescription) {
+        activityStmt.run({
+          $issue_id: issue.id,
+          $history_id: `desc:${issue.updatedAt}`,
+          $item_field: 'description',
+          $from_value: clampActivityValue(prior.description),
+          $to_value: clampActivityValue(nextDescription),
+          $created_at: issue.updatedAt,
+        })
+      }
+      upsertStmt.run({
+        $id: issue.id,
+        $identifier: issue.identifier,
+        $title: issue.title,
+        $description: nextDescription,
+        $priority: issue.priority ?? 0,
+        $assignee_id: issue.assigneeId ?? null,
+        $assignee_name: issue.assigneeName ?? '',
+        $project_id: issue.projectId ?? null,
+        $project_name: issue.projectName ?? '',
+        $state_id: issue.stateId,
+        $state_name: issue.stateName,
+        $state_position: issue.statePosition,
+        $labels: JSON.stringify(issue.labels ?? []),
+        $comment_count: issue.commentCount ?? 0,
+        $comment_count_provided: hasCommentCount ? 1 : 0,
+        $url: issue.url ?? null,
+        $created_at: issue.createdAt,
+        $updated_at: issue.updatedAt,
+      })
+    }
+  })
+  run()
+}
+
+export function deleteLinearIssue(db: Database, idOrIdentifier: string): void {
+  db.query(
+    `DELETE FROM linear_activity
+     WHERE issue_id = $value
+        OR issue_id IN (SELECT id FROM linear_issues WHERE identifier = $value)`,
+  ).run({
+    $value: idOrIdentifier,
+  })
+  db.query('DELETE FROM linear_issues WHERE id = $v OR identifier = $v').run({
+    $v: idOrIdentifier,
+  })
+}
+
+export function pruneLinearIssues(db: Database, liveIssueIds: string[]): void {
+  const keep = new Set(liveIssueIds)
+  const staleIssueIds = (db.query('SELECT id FROM linear_issues').all() as { id: string }[])
+    .map((row) => row.id)
+    .filter((issueId) => !keep.has(issueId))
+  if (staleIssueIds.length === 0) return
+
+  const run = db.transaction((issueIds: string[]) => {
+    for (const issueId of issueIds) {
+      deleteLinearIssue(db, issueId)
+    }
+  })
+
+  run(staleIssueIds)
+}
+
+export function adjustLinearIssueCommentCount(
+  db: Database,
+  idOrIdentifier: string,
+  delta: number,
+): void {
+  db.query(
+    `UPDATE linear_issues
+        SET comment_count = MAX(0, comment_count + $delta)
+      WHERE id = $value OR identifier = $value`,
+  ).run({
+    $delta: delta,
+    $value: idOrIdentifier,
+  })
 }
 
 export function getCachedColumns(db: Database): LinearStateRow[] {
@@ -257,7 +455,7 @@ function mapPriority(priority: number): Task['priority'] {
   }
 }
 
-function taskFromRow(row: {
+interface LinearIssueRow {
   id: string
   identifier: string
   title: string
@@ -267,10 +465,23 @@ function taskFromRow(row: {
   priority: number
   assignee_name: string
   project_name: string
+  labels: string
+  comment_count: number
   url: string | null
   created_at: string
   updated_at: string
-}): Task {
+}
+
+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: LinearIssueRow): Task {
   return {
     id: `linear:${row.id}`,
     providerId: row.id,
@@ -282,10 +493,15 @@ function taskFromRow(row: {
     position: row.state_position,
     priority: mapPriority(row.priority),
     assignee: row.assignee_name,
+    assignees: row.assignee_name ? [row.assignee_name] : [],
+    labels: parseLabels(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,
   }
 }
 
@@ -301,20 +517,7 @@ export function getCachedBoard(db: Database): BoardView {
              WHERE state_id = $state_id
              ORDER BY updated_at DESC, title ASC`,
           )
-          .all({ $state_id: column.id }) as Array<{
-          id: string
-          identifier: string
-          title: string
-          description: string
-          state_id: string
-          state_position: number
-          priority: number
-          assignee_name: string
-          project_name: string
-          url: string | null
-          created_at: string
-          updated_at: string
-        }>
+          .all({ $state_id: column.id }) as LinearIssueRow[]
       ).map(taskFromRow),
     })),
   }
@@ -328,39 +531,15 @@ export function getCachedTask(db: Database, lookup: string): Task | null {
        WHERE id = $lookup OR identifier = $lookup
        LIMIT 1`,
     )
-    .get({ $lookup: normalized }) as {
-    id: string
-    identifier: string
-    title: string
-    description: string
-    state_id: string
-    state_position: number
-    priority: number
-    assignee_name: string
-    project_name: string
-    url: string | null
-    created_at: string
-    updated_at: string
-  } | null
+    .get({ $lookup: normalized }) as LinearIssueRow | null
   return row ? taskFromRow(row) : null
 }
 
 export function getCachedTasks(db: Database): Task[] {
   return (
-    db.query('SELECT * FROM linear_issues ORDER BY updated_at DESC, title ASC').all() as Array<{
-      id: string
-      identifier: string
-      title: string
-      description: string
-      state_id: string
-      state_position: number
-      priority: number
-      assignee_name: string
-      project_name: string
-      url: string | null
-      created_at: string
-      updated_at: string
-    }>
+    db
+      .query('SELECT * FROM linear_issues ORDER BY updated_at DESC, title ASC')
+      .all() as LinearIssueRow[]
   ).map(taskFromRow)
 }