tissues 0.6.0 → 0.6.2

package/src/lib/cache.js

@@ -0,0 +1,408 @@
+/**
+ * Local SQLite cache for issues, labels, and repos.
+ *
+ * Eliminates redundant network calls by storing GitHub data locally.
+ * Uses incremental sync for issues (since-based) and full-replace for
+ * labels and repos.
+ */
+
+import { getDb } from './db.js'
+import { fetchIssuesApi, fetchLabelsApi, listIssues, listLabels, listRepos } from './gh.js'
+
+// ---------------------------------------------------------------------------
+// Staleness TTLs (milliseconds)
+// ---------------------------------------------------------------------------
+
+const TTL = {
+  issues_open:   { fresh: 2 * 60 * 1000, stale: 10 * 60 * 1000 },
+  issues_closed: { fresh: 24 * 60 * 60 * 1000, stale: 7 * 24 * 60 * 60 * 1000 },
+  labels:        { fresh: 15 * 60 * 1000, stale: 60 * 60 * 1000 },
+  repos:         { fresh: 30 * 60 * 1000, stale: 2 * 60 * 60 * 1000 },
+}
+
+// ---------------------------------------------------------------------------
+// Sync metadata CRUD
+// ---------------------------------------------------------------------------
+
+/**
+ * Get sync metadata for a repo+resource pair.
+ *
+ * @param {string} repo
+ * @param {string} resource
+ * @returns {{ lastSyncedAt: string|null, lastCursor: string|null } | null}
+ */
+export function getSyncMeta(repo, resource) {
+  const db = getDb()
+  const row = db.prepare(
+    'SELECT last_synced_at, last_cursor FROM sync_meta WHERE repo = ? AND resource = ?',
+  ).get(repo, resource)
+  if (!row) return null
+  return { lastSyncedAt: row.last_synced_at, lastCursor: row.last_cursor }
+}
+
+/**
+ * Update sync metadata for a repo+resource pair.
+ *
+ * @param {string} repo
+ * @param {string} resource
+ * @param {{ lastSyncedAt?: string, lastCursor?: string }} meta
+ */
+export function setSyncMeta(repo, resource, meta) {
+  const db = getDb()
+  db.prepare(`
+    INSERT INTO sync_meta (repo, resource, last_synced_at, last_cursor)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(repo, resource) DO UPDATE SET
+      last_synced_at = COALESCE(?, last_synced_at),
+      last_cursor = COALESCE(?, last_cursor)
+  `).run(
+    repo, resource,
+    meta.lastSyncedAt || null, meta.lastCursor || null,
+    meta.lastSyncedAt || null, meta.lastCursor || null,
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Freshness checks
+// ---------------------------------------------------------------------------
+
+/**
+ * Check freshness of cached data for a repo+resource.
+ *
+ * @param {string} repo
+ * @param {string} resource - 'issues' | 'labels' | 'repos'
+ * @returns {'fresh' | 'stale' | 'expired' | 'empty'}
+ */
+export function checkFreshness(repo, resource) {
+  const meta = getSyncMeta(repo, resource)
+  if (!meta || !meta.lastSyncedAt) {
+    // Check if we have any rows at all
+    const db = getDb()
+    let count = 0
+    if (resource === 'issues') {
+      count = db.prepare('SELECT COUNT(*) as cnt FROM cached_issues WHERE repo = ?').get(repo)?.cnt || 0
+    } else if (resource === 'labels') {
+      count = db.prepare('SELECT COUNT(*) as cnt FROM cached_labels WHERE repo = ?').get(repo)?.cnt || 0
+    } else if (resource === 'repos') {
+      count = db.prepare('SELECT COUNT(*) as cnt FROM cached_repos').get()?.cnt || 0
+    }
+    return count > 0 ? 'expired' : 'empty'
+  }
+
+  const syncedAt = new Date(meta.lastSyncedAt + 'Z').getTime()
+  const age = Date.now() - syncedAt
+  const ttlKey = resource === 'issues' ? 'issues_open' : resource
+  const ttl = TTL[ttlKey]
+  if (!ttl) return 'expired'
+
+  if (age <= ttl.fresh) return 'fresh'
+  if (age <= ttl.stale) return 'stale'
+  return 'expired'
+}
+
+// ---------------------------------------------------------------------------
+// Cache read operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Get cached issues for a repo.
+ *
+ * @param {string} repo
+ * @param {{ state?: string, limit?: number }} [opts]
+ * @returns {Array<{ number: number, title: string, body: string|null, state: string, labels: string[], url: string|null, author: string|null, createdAt: string|null, updatedAt: string|null }>}
+ */
+export function getCachedIssues(repo, opts = {}) {
+  const db = getDb()
+  const { state = 'open', limit = 500 } = opts
+  const rows = db.prepare(
+    `SELECT number, title, body, state, labels, url, author, created_at, updated_at
+     FROM cached_issues
+     WHERE repo = ? AND state = ?
+     ORDER BY updated_at DESC
+     LIMIT ?`,
+  ).all(repo, state, limit)
+
+  return rows.map(r => ({
+    number: r.number,
+    title: r.title,
+    body: r.body,
+    state: r.state,
+    labels: JSON.parse(r.labels || '[]'),
+    url: r.url,
+    author: r.author,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+  }))
+}
+
+/**
+ * Get cached labels for a repo.
+ *
+ * @param {string} repo
+ * @returns {string[]}
+ */
+export function getCachedLabels(repo) {
+  const db = getDb()
+  const rows = db.prepare(
+    'SELECT name FROM cached_labels WHERE repo = ? ORDER BY name',
+  ).all(repo)
+  return rows.map(r => r.name)
+}
+
+/**
+ * Get cached repos.
+ *
+ * @returns {string[]}
+ */
+export function getCachedRepos() {
+  const db = getDb()
+  const rows = db.prepare(
+    'SELECT name_with_owner FROM cached_repos ORDER BY name_with_owner',
+  ).all()
+  return rows.map(r => r.name_with_owner)
+}
+
+// ---------------------------------------------------------------------------
+// Sync operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Sync issues for a repo using incremental `since`-based fetching.
+ * Uses `gh api` with `since` parameter to fetch only changed issues.
+ *
+ * @param {string} repo
+ * @param {{ force?: boolean }} [opts]
+ * @returns {{ synced: number, total: number }}
+ */
+export function syncIssues(repo, opts = {}) {
+  const db = getDb()
+  const meta = opts.force ? null : getSyncMeta(repo, 'issues')
+  const since = meta?.lastCursor || undefined
+
+  let totalSynced = 0
+  let maxUpdatedAt = since || ''
+  let page = 1
+
+  while (true) {
+    const issues = fetchIssuesApi(repo, { since, state: 'all', perPage: 100, page })
+    if (issues.length === 0) break
+
+    const upsert = db.prepare(`
+      INSERT INTO cached_issues (repo, number, title, body, state, labels, url, author, created_at, updated_at, closed_at, synced_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(repo, number) DO UPDATE SET
+        title = excluded.title,
+        body = excluded.body,
+        state = excluded.state,
+        labels = excluded.labels,
+        url = excluded.url,
+        author = excluded.author,
+        updated_at = excluded.updated_at,
+        closed_at = excluded.closed_at,
+        synced_at = datetime('now')
+    `)
+
+    const upsertMany = db.transaction((items) => {
+      for (const issue of items) {
+        const labels = JSON.stringify((issue.labels || []).map(l => typeof l === 'string' ? l : l.name))
+        upsert.run(
+          repo,
+          issue.number,
+          issue.title,
+          issue.body || null,
+          issue.state || 'open',
+          labels,
+          issue.html_url || null,
+          issue.user?.login || null,
+          issue.created_at || null,
+          issue.updated_at || null,
+          issue.closed_at || null,
+        )
+        if (issue.updated_at && issue.updated_at > maxUpdatedAt) {
+          maxUpdatedAt = issue.updated_at
+        }
+      }
+    })
+
+    upsertMany(issues)
+    totalSynced += issues.length
+
+    if (issues.length < 100) break
+    page++
+  }
+
+  const now = new Date().toISOString().replace('Z', '')
+  setSyncMeta(repo, 'issues', {
+    lastSyncedAt: now,
+    lastCursor: maxUpdatedAt || now,
+  })
+
+  const total = db.prepare(
+    'SELECT COUNT(*) as cnt FROM cached_issues WHERE repo = ?',
+  ).get(repo)?.cnt || 0
+
+  return { synced: totalSynced, total }
+}
+
+/**
+ * Sync labels for a repo (full-replace strategy).
+ *
+ * @param {string} repo
+ * @param {{ force?: boolean }} [opts]
+ * @returns {{ synced: number }}
+ */
+export function syncLabels(repo, opts = {}) {
+  const db = getDb()
+
+  // Fetch all labels via API
+  const allLabels = []
+  let page = 1
+  while (true) {
+    const batch = fetchLabelsApi(repo, { perPage: 100, page })
+    allLabels.push(...batch)
+    if (batch.length < 100) break
+    page++
+  }
+
+  // Full replace in transaction
+  const sync = db.transaction(() => {
+    db.prepare('DELETE FROM cached_labels WHERE repo = ?').run(repo)
+    const insert = db.prepare(
+      `INSERT INTO cached_labels (repo, name, color, description, synced_at)
+       VALUES (?, ?, ?, ?, datetime('now'))`,
+    )
+    for (const label of allLabels) {
+      insert.run(repo, label.name, label.color, label.description)
+    }
+  })
+  sync()
+
+  const now = new Date().toISOString().replace('Z', '')
+  setSyncMeta(repo, 'labels', { lastSyncedAt: now })
+
+  return { synced: allLabels.length }
+}
+
+/**
+ * Sync repos (full-replace strategy).
+ *
+ * @param {{ force?: boolean }} [opts]
+ * @returns {{ synced: number }}
+ */
+export function syncRepos(opts = {}) {
+  const db = getDb()
+  const repos = listRepos({ limit: 200 })
+
+  const sync = db.transaction(() => {
+    db.prepare('DELETE FROM cached_repos').run()
+    const insert = db.prepare(
+      `INSERT INTO cached_repos (name_with_owner, synced_at) VALUES (?, datetime('now'))`,
+    )
+    for (const r of repos) {
+      insert.run(r)
+    }
+  })
+  sync()
+
+  const now = new Date().toISOString().replace('Z', '')
+  setSyncMeta('_global', 'repos', { lastSyncedAt: now })
+
+  return { synced: repos.length }
+}
+
+// ---------------------------------------------------------------------------
+// ensureFresh — the main API for consumers
+// ---------------------------------------------------------------------------
+
+/**
+ * Ensure cached data is fresh, syncing if needed, and return it.
+ *
+ * @param {string} repo - repo for issues/labels, ignored for repos
+ * @param {string} resource - 'issues' | 'labels' | 'repos'
+ * @param {{ acceptStale?: boolean, force?: boolean, state?: string, limit?: number }} [opts]
+ * @returns {Array} cached data
+ */
+export function ensureFresh(repo, resource, opts = {}) {
+  const { acceptStale = true, force = false } = opts
+  const effectiveRepo = resource === 'repos' ? '_global' : repo
+
+  if (!force) {
+    const freshness = checkFreshness(effectiveRepo, resource)
+    if (freshness === 'fresh') {
+      return readFromCache(repo, resource, opts)
+    }
+    if (freshness === 'stale' && acceptStale) {
+      return readFromCache(repo, resource, opts)
+    }
+  }
+
+  // Need to sync
+  try {
+    if (resource === 'issues') {
+      syncIssues(repo, { force })
+    } else if (resource === 'labels') {
+      syncLabels(repo, { force })
+    } else if (resource === 'repos') {
+      syncRepos({ force })
+    }
+  } catch {
+    // Sync failed — return stale data if available, else fall back to live fetch
+    const cached = readFromCache(repo, resource, opts)
+    if (cached.length > 0) return cached
+
+    // Last resort: live fetch (original behavior)
+    return liveFallback(repo, resource, opts)
+  }
+
+  return readFromCache(repo, resource, opts)
+}
+
+/**
+ * Read from cache based on resource type.
+ * @private
+ */
+function readFromCache(repo, resource, opts) {
+  if (resource === 'issues') return getCachedIssues(repo, opts)
+  if (resource === 'labels') return getCachedLabels(repo)
+  if (resource === 'repos') return getCachedRepos()
+  return []
+}
+
+/**
+ * Live fallback when cache is empty and sync fails.
+ * @private
+ */
+function liveFallback(repo, resource, opts) {
+  if (resource === 'issues') {
+    return listIssues(repo, { limit: opts?.limit || 100 })
+  }
+  if (resource === 'labels') {
+    return listLabels(repo)
+  }
+  if (resource === 'repos') {
+    return listRepos({ limit: 200 })
+  }
+  return []
+}
+
+/**
+ * Upsert a single issue into the cache (e.g. after creation).
+ *
+ * @param {string} repo
+ * @param {{ number: number, title: string, url?: string, labels?: string[], state?: string }} issue
+ */
+export function upsertCachedIssue(repo, issue) {
+  const db = getDb()
+  const labels = JSON.stringify(issue.labels || [])
+  db.prepare(`
+    INSERT INTO cached_issues (repo, number, title, state, labels, url, synced_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+    ON CONFLICT(repo, number) DO UPDATE SET
+      title = excluded.title,
+      state = COALESCE(excluded.state, state),
+      labels = excluded.labels,
+      url = COALESCE(excluded.url, url),
+      synced_at = datetime('now'),
+      updated_at = datetime('now')
+  `).run(repo, issue.number, issue.title, issue.state || 'open', labels, issue.url || null)
+}

package/src/lib/db.js

@@ -42,6 +42,8 @@ function getDbPath() {
   return path.join(home, '.config', 'tissues', 'tissues.db')
 }
 
+export { getDbPath }
+
 const DB_PATH = getDbPath()
 
 // ---------------------------------------------------------------------------
@@ -92,6 +94,46 @@ CREATE TABLE IF NOT EXISTS _meta (
   key   TEXT PRIMARY KEY,
   value TEXT NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS cached_issues (
+  repo        TEXT NOT NULL,
+  number      INTEGER NOT NULL,
+  title       TEXT NOT NULL,
+  body        TEXT,
+  state       TEXT NOT NULL DEFAULT 'open',
+  labels      TEXT DEFAULT '[]',
+  url         TEXT,
+  author      TEXT,
+  created_at  TEXT,
+  updated_at  TEXT,
+  closed_at   TEXT,
+  synced_at   TEXT DEFAULT (datetime('now')),
+  PRIMARY KEY (repo, number)
+);
+CREATE INDEX IF NOT EXISTS idx_ci_repo_state ON cached_issues(repo, state);
+CREATE INDEX IF NOT EXISTS idx_ci_repo_updated ON cached_issues(repo, updated_at);
+
+CREATE TABLE IF NOT EXISTS cached_labels (
+  repo        TEXT NOT NULL,
+  name        TEXT NOT NULL,
+  color       TEXT,
+  description TEXT,
+  synced_at   TEXT DEFAULT (datetime('now')),
+  PRIMARY KEY (repo, name)
+);
+
+CREATE TABLE IF NOT EXISTS cached_repos (
+  name_with_owner TEXT PRIMARY KEY,
+  synced_at       TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS sync_meta (
+  repo        TEXT NOT NULL,
+  resource    TEXT NOT NULL,
+  last_synced_at TEXT,
+  last_cursor TEXT,
+  PRIMARY KEY (repo, resource)
+);
 `
 
 // ---------------------------------------------------------------------------

package/src/lib/dedup.js

@@ -1,10 +1,6 @@
 import crypto from 'node:crypto'
 import { checkFingerprint, storeFingerprint, checkIdempotencyKey, storeIdempotencyKey } from './db.js'
-import { listIssues } from './gh.js'
-
-/** @type {Map<string, { issues: Array, fetchedAt: number }>} */
-const issuesCache = new Map()
-const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+import { ensureFresh, upsertCachedIssue } from './cache.js'
 
 /**
  * Normalize text for comparison: lowercase, replace non-alphanumeric with
@@ -45,59 +41,54 @@ export function computeIdempotencyKey({ agent, trigger, issueType, repo }) {
   return crypto.createHash('sha256').update(raw).digest('hex')
 }
 
+const STOP_WORDS = new Set([
+  'a','an','the','in','on','at','to','for','of','with','by','from',
+  'is','are','was','were','be','been','being','has','have','had',
+  'do','does','did','will','would','could','should','can','may',
+  'not','no','but','or','and','if','then','so','as','it','its',
+  'this','that','we','our','i','my','you','your','they','their',
+])
+
 /**
- * Compute Levenshtein distance between two strings.
+ * Tokenize text: normalize, split on spaces, remove stop words.
  *
- * @param {string} a
- * @param {string} b
- * @returns {number}
+ * @param {string} text
+ * @returns {string[]}
  */
-function levenshteinDistance(a, b) {
-  const m = a.length
-  const n = b.length
-  const dp = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)])
-  for (let j = 0; j <= n; j++) dp[0][j] = j
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i][j] =
-        a[i - 1] === b[j - 1]
-          ? dp[i - 1][j - 1]
-          : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
-    }
-  }
-  return dp[m][n]
+function tokenize(text) {
+  return normalizeText(text)
+    .split(' ')
+    .filter(w => w.length > 0 && !STOP_WORDS.has(w))
 }
 
 /**
- * Compute similarity between two strings as a value in [0, 1].
- * 1.0 means identical, 0.0 means completely different.
+ * Compute Jaccard similarity between two strings based on token sets.
+ * Tokens are words with stop words removed.
+ * Returns a value in [0, 1]: 1.0 = identical token sets, 0.0 = no overlap.
  *
  * @param {string} a
  * @param {string} b
  * @returns {number}
  */
-export function levenshteinSimilarity(a, b) {
-  if (a === b) return 1
-  const maxLen = Math.max(a.length, b.length)
-  if (maxLen === 0) return 1
-  return 1 - levenshteinDistance(a, b) / maxLen
+export function jaccardSimilarity(a, b) {
+  const setA = new Set(tokenize(a))
+  const setB = new Set(tokenize(b))
+  if (setA.size === 0 && setB.size === 0) return 1
+  if (setA.size === 0 || setB.size === 0) return 0
+  let intersection = 0
+  for (const w of setA) if (setB.has(w)) intersection++
+  const union = new Set([...setA, ...setB]).size
+  return intersection / union
 }
 
 /**
- * Fetch open issues for a repo, using a session-level cache that expires after
- * 5 minutes.
+ * Get open issues for a repo from the SQLite cache, syncing if stale.
  *
  * @param {string} repo
  * @returns {Promise<Array>}
  */
 async function getCachedIssues(repo) {
-  const cached = issuesCache.get(repo)
-  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
-    return cached.issues
-  }
-  const issues = listIssues(repo)
-  issuesCache.set(repo, { issues, fetchedAt: Date.now() })
-  return issues
+  return ensureFresh(repo, 'issues', { state: 'open', acceptStale: true })
 }
 
 /**
@@ -167,12 +158,16 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
     })
   }
 
-  // Layer 3: fuzzy title match
-  const normalizedTitle = normalizeText(title)
+  // Layer 3: fuzzy title match (token-set Jaccard)
+  const newTokens = tokenize(title)
+  const isShortTitle = newTokens.length <= 2
   const openIssues = await getCachedIssues(repo)
   for (const issue of openIssues) {
-    const similarity = levenshteinSimilarity(normalizedTitle, normalizeText(issue.title))
-    if (similarity >= 0.90) {
+    const similarity = jaccardSimilarity(title, issue.title)
+    // Short-title guard: ≤2 meaningful tokens require exact match to block, ≥0.80 to warn
+    const blockThreshold = isShortTitle ? 1.0 : 0.80
+    const warnThreshold = isShortTitle ? 0.80 : 0.50
+    if (similarity >= blockThreshold) {
       results.push({
         action: 'block',
         reason: `Fuzzy title match (similarity ${(similarity * 100).toFixed(1)}%) with existing issue`,
@@ -183,7 +178,7 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
         },
       })
       break
-    } else if (similarity >= 0.75) {
+    } else if (similarity >= warnThreshold) {
       results.push({
         action: 'warn',
         reason: `Fuzzy title is similar (similarity ${(similarity * 100).toFixed(1)}%) to existing issue`,
@@ -226,9 +221,10 @@ export async function recordCreation(repo, { title, body, issueNumber, url, idem
     await storeIdempotencyKey(idempotencyKey, repo, issueNumber)
   }
 
-  // Atomically append to the issues cache so back-to-back runs catch duplicates
-  const cached = issuesCache.get(repo)
-  if (cached) {
-    cached.issues.unshift({ number: issueNumber, title, url: url ?? null })
+  // Upsert into SQLite cache so back-to-back runs catch duplicates immediately
+  try {
+    upsertCachedIssue(repo, { number: issueNumber, title, url: url ?? null })
+  } catch {
+    // Non-fatal — cache upsert failure shouldn't abort
   }
 }