tissues 0.6.0 → 0.6.2

package/src/lib/storage.js

@@ -0,0 +1,298 @@
+/**
+ * Data-gathering functions for the storage overview.
+ *
+ * Provides row counts, file counts, sizes, and freshness info
+ * for all persistent data tissues stores.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { getDb, getDbPath } from './db.js'
+import { getSyncMeta } from './cache.js'
+import { findRepoRoot } from './defaults.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if a table exists in the database.
+ *
+ * @param {string} tableName
+ * @returns {boolean}
+ */
+function tableExists(tableName) {
+  try {
+    const db = getDb()
+    const row = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+    ).get(tableName)
+    return !!row
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Count rows in a table, optionally filtered.
+ *
+ * @param {string} table
+ * @param {string} [where]
+ * @param {any[]} [params]
+ * @returns {number}
+ */
+function countRows(table, where, params = []) {
+  if (!tableExists(table)) return 0
+  try {
+    const db = getDb()
+    const sql = where
+      ? `SELECT COUNT(*) as cnt FROM ${table} WHERE ${where}`
+      : `SELECT COUNT(*) as cnt FROM ${table}`
+    return db.prepare(sql).get(...params)?.cnt || 0
+  } catch {
+    return 0
+  }
+}
+
+/**
+ * Get the size of a file in bytes, or 0 if it doesn't exist.
+ *
+ * @param {string} filePath
+ * @returns {number}
+ */
+function fileSize(filePath) {
+  try {
+    return fs.statSync(filePath).size
+  } catch {
+    return 0
+  }
+}
+
+/**
+ * Count files in a directory (non-recursive).
+ *
+ * @param {string} dir
+ * @param {string} [ext] - filter by extension
+ * @returns {{ count: number, totalSize: number }}
+ */
+function countFiles(dir, ext) {
+  try {
+    if (!fs.existsSync(dir)) return { count: 0, totalSize: 0 }
+    const entries = fs.readdirSync(dir)
+    const files = ext ? entries.filter(f => f.endsWith(ext)) : entries
+    let totalSize = 0
+    for (const f of files) {
+      totalSize += fileSize(path.join(dir, f))
+    }
+    return { count: files.length, totalSize }
+  } catch {
+    return { count: 0, totalSize: 0 }
+  }
+}
+
+/**
+ * Format a relative time string (e.g. "2 min ago", "3 hours ago").
+ *
+ * @param {string|null} isoDate
+ * @returns {string}
+ */
+export function timeAgo(isoDate) {
+  if (!isoDate) return 'never'
+  const ms = Date.now() - new Date(isoDate + (isoDate.endsWith('Z') ? '' : 'Z')).getTime()
+  if (ms < 0) return 'just now'
+  const sec = Math.floor(ms / 1000)
+  if (sec < 60) return `${sec}s ago`
+  const min = Math.floor(sec / 60)
+  if (min < 60) return `${min} min ago`
+  const hr = Math.floor(min / 60)
+  if (hr < 24) return `${hr} hour${hr === 1 ? '' : 's'} ago`
+  const days = Math.floor(hr / 24)
+  return `${days} day${days === 1 ? '' : 's'} ago`
+}
+
+/**
+ * Format bytes as a human-readable string.
+ *
+ * @param {number} bytes
+ * @returns {string}
+ */
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0 B'
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+}
+
+// ---------------------------------------------------------------------------
+// Overview data gathering
+// ---------------------------------------------------------------------------
+
+/**
+ * Gather a full storage overview.
+ *
+ * @param {{ repo?: string }} [opts]
+ * @returns {object}
+ */
+export function getStorageOverview(opts = {}) {
+  const dbPath = getDbPath()
+  const dbSize = fileSize(dbPath)
+  const repoRoot = findRepoRoot()
+
+  // Table row counts
+  const fingerprints = countRows('fingerprints')
+  const idempotencyKeys = countRows('idempotency_keys')
+  const circuitBreakers = countRows('circuit_breaker')
+  const rateEvents = countRows('rate_events')
+  const cachedIssues = countRows('cached_issues')
+  const cachedLabels = countRows('cached_labels')
+  const cachedRepos = countRows('cached_repos')
+  const syncMeta = countRows('sync_meta')
+
+  // Sync freshness
+  const repo = opts.repo || null
+  const issuesMeta = repo ? getSyncMeta(repo, 'issues') : null
+  const labelsMeta = repo ? getSyncMeta(repo, 'labels') : null
+  const reposMeta = getSyncMeta('_global', 'repos')
+
+  // File counts
+  const tissuesDir = repoRoot ? path.join(repoRoot, '.tissues') : null
+  const draftsDir = tissuesDir ? path.join(tissuesDir, 'drafts') : null
+  const imagesDir = tissuesDir ? path.join(tissuesDir, 'images') : null
+  const templatesDir = tissuesDir ? path.join(tissuesDir, 'templates') : null
+  const enhancementsDir = tissuesDir ? path.join(tissuesDir, 'enhancements') : null
+
+  const drafts = draftsDir ? countFiles(draftsDir, '.json') : { count: 0, totalSize: 0 }
+  const images = imagesDir ? countFiles(imagesDir) : { count: 0, totalSize: 0 }
+  const templates = templatesDir ? countFiles(templatesDir, '.md') : { count: 0, totalSize: 0 }
+  const enhancements = enhancementsDir ? countFiles(enhancementsDir, '.md') : { count: 0, totalSize: 0 }
+
+  const totalDiskUsage = dbSize + drafts.totalSize + images.totalSize + templates.totalSize + enhancements.totalSize
+
+  return {
+    database: {
+      path: dbPath,
+      size: dbSize,
+      tables: {
+        fingerprints: { rows: fingerprints, lastSync: null },
+        idempotency_keys: { rows: idempotencyKeys },
+        circuit_breaker: { rows: circuitBreakers },
+        rate_events: { rows: rateEvents },
+        cached_issues: { rows: cachedIssues, lastSync: issuesMeta?.lastSyncedAt || null },
+        cached_labels: { rows: cachedLabels, lastSync: labelsMeta?.lastSyncedAt || null },
+        cached_repos: { rows: cachedRepos, lastSync: reposMeta?.lastSyncedAt || null },
+        sync_meta: { rows: syncMeta },
+      },
+    },
+    files: {
+      drafts,
+      images,
+      templates,
+      enhancements,
+    },
+    totalDiskUsage,
+    repoRoot,
+  }
+}
+
+/**
+ * Get per-repo issue cache breakdown.
+ *
+ * @returns {Array<{ repo: string, open: number, closed: number, lastSync: string|null }>}
+ */
+export function getIssueBreakdown() {
+  if (!tableExists('cached_issues')) return []
+  try {
+    const db = getDb()
+    const repos = db.prepare(
+      "SELECT DISTINCT repo FROM cached_issues ORDER BY repo",
+    ).all()
+
+    return repos.map(r => {
+      const open = db.prepare(
+        "SELECT COUNT(*) as cnt FROM cached_issues WHERE repo = ? AND state = 'open'",
+      ).get(r.repo)?.cnt || 0
+      const closed = db.prepare(
+        "SELECT COUNT(*) as cnt FROM cached_issues WHERE repo = ? AND state = 'closed'",
+      ).get(r.repo)?.cnt || 0
+      const meta = getSyncMeta(r.repo, 'issues')
+      return {
+        repo: r.repo,
+        open,
+        closed,
+        lastSync: meta?.lastSyncedAt || null,
+      }
+    })
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Clear cached data by target.
+ *
+ * @param {'issues' | 'labels' | 'repos' | 'fingerprints' | 'all'} target
+ * @param {{ repo?: string, includeSafety?: boolean }} [opts]
+ * @returns {{ cleared: string[] }}
+ */
+export function clearCachedData(target, opts = {}) {
+  const db = getDb()
+  const cleared = []
+  const repo = opts.repo
+
+  const clearTable = (table, repoCol) => {
+    if (!tableExists(table)) return
+    if (repo && repoCol) {
+      db.prepare(`DELETE FROM ${table} WHERE ${repoCol} = ?`).run(repo)
+    } else {
+      db.prepare(`DELETE FROM ${table}`).run()
+    }
+    cleared.push(table)
+  }
+
+  if (target === 'issues' || target === 'all') {
+    clearTable('cached_issues', 'repo')
+    if (repo) {
+      db.prepare("DELETE FROM sync_meta WHERE repo = ? AND resource = 'issues'").run(repo)
+    } else {
+      db.prepare("DELETE FROM sync_meta WHERE resource = 'issues'").run()
+    }
+  }
+
+  if (target === 'labels' || target === 'all') {
+    clearTable('cached_labels', 'repo')
+    if (repo) {
+      db.prepare("DELETE FROM sync_meta WHERE repo = ? AND resource = 'labels'").run(repo)
+    } else {
+      db.prepare("DELETE FROM sync_meta WHERE resource = 'labels'").run()
+    }
+  }
+
+  if (target === 'repos' || target === 'all') {
+    clearTable('cached_repos', null)
+    db.prepare("DELETE FROM sync_meta WHERE resource = 'repos'").run()
+  }
+
+  if (target === 'fingerprints' || target === 'all') {
+    clearTable('fingerprints', 'repo')
+    clearTable('idempotency_keys', 'repo')
+  }
+
+  if (target === 'all' && opts.includeSafety) {
+    clearTable('circuit_breaker', 'repo')
+    clearTable('rate_events', 'repo')
+  }
+
+  return { cleared }
+}
+
+/**
+ * Export all storage metadata as JSON (for debugging).
+ *
+ * @param {{ repo?: string }} [opts]
+ * @returns {object}
+ */
+export function exportStorageJson(opts = {}) {
+  const overview = getStorageOverview(opts)
+  const issueBreakdown = getIssueBreakdown()
+  return { ...overview, issueBreakdown }
+}

package/src/lib/templates.test.js

@@ -0,0 +1,207 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { listTemplates, loadTemplate, renderTemplate } from './templates.js'
+
+// ---------------------------------------------------------------------------
+// renderTemplate — pure function, no file I/O
+// ---------------------------------------------------------------------------
+
+describe('renderTemplate', () => {
+  test('replaces a single variable', () => {
+    const result = renderTemplate('Hello {{name}}!', { name: 'World' })
+    assert.equal(result, 'Hello World!')
+  })
+
+  test('replaces multiple different variables', () => {
+    const result = renderTemplate('{{greeting}} {{name}}', { greeting: 'Hi', name: 'Alice' })
+    assert.equal(result, 'Hi Alice')
+  })
+
+  test('leaves unknown variables intact', () => {
+    const result = renderTemplate('Hello {{unknown}}!', {})
+    assert.equal(result, 'Hello {{unknown}}!')
+  })
+
+  test('leaves null/undefined variable values intact', () => {
+    const result = renderTemplate('{{a}} {{b}}', { a: null, b: undefined })
+    assert.equal(result, '{{a}} {{b}}')
+  })
+
+  test('replaces the same variable multiple times', () => {
+    const result = renderTemplate('{{x}} and {{x}}', { x: 'foo' })
+    assert.equal(result, 'foo and foo')
+  })
+
+  test('handles numeric variable values', () => {
+    const result = renderTemplate('Count: {{n}}', { n: 42 })
+    assert.equal(result, 'Count: 42')
+  })
+
+  test('no substitution when template has no placeholders', () => {
+    const result = renderTemplate('Plain text body.', { anything: 'value' })
+    assert.equal(result, 'Plain text body.')
+  })
+
+  test('handles empty template string', () => {
+    const result = renderTemplate('', { key: 'val' })
+    assert.equal(result, '')
+  })
+
+  test('renders description placeholder used in built-in templates', () => {
+    const body = '## Summary\n\n{{description}}\n\n## Details'
+    const result = renderTemplate(body, { description: 'A short description.' })
+    assert.equal(result, '## Summary\n\nA short description.\n\n## Details')
+  })
+
+  test('multiple standard template variables', () => {
+    const body = '{{title}} by {{agent}} on {{date}} in {{repo}}'
+    const result = renderTemplate(body, {
+      title: 'Fix bug',
+      agent: 'bot',
+      date: '2025-01-01',
+      repo: 'owner/repo',
+    })
+    assert.equal(result, 'Fix bug by bot on 2025-01-01 in owner/repo')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// loadTemplate — built-in templates (no file system required for these)
+// ---------------------------------------------------------------------------
+
+describe('loadTemplate – built-in templates', () => {
+  // Use a temp dir with .git so findRepoRoot() resolves there and no
+  // repo-level template files interfere.
+  let tmpDir
+
+  test('loads the default template', () => {
+    const tpl = loadTemplate('default', os.tmpdir())
+    assert.equal(tpl.key, 'default')
+    assert.ok(tpl.body.includes('{{description}}'))
+    // source may be 'built-in' or 'user' if the user has a custom default template
+    assert.ok(['built-in', 'user'].includes(tpl.source))
+  })
+
+  test('loads the bug template', () => {
+    const tpl = loadTemplate('bug', os.tmpdir())
+    assert.equal(tpl.key, 'bug')
+    assert.ok(tpl.name.length > 0)
+    assert.ok(tpl.body.includes('{{description}}'))
+    assert.equal(tpl.source, 'built-in')
+  })
+
+  test('loads the feature template', () => {
+    const tpl = loadTemplate('feature', os.tmpdir())
+    assert.equal(tpl.key, 'feature')
+    assert.equal(tpl.source, 'built-in')
+  })
+
+  test('throws for unknown template name', () => {
+    assert.throws(
+      () => loadTemplate('does-not-exist', os.tmpdir()),
+      /Template "does-not-exist" not found/
+    )
+  })
+
+  test('returned object has key, name, body, source properties', () => {
+    const tpl = loadTemplate('bug', os.tmpdir())
+    assert.ok('key' in tpl)
+    assert.ok('name' in tpl)
+    assert.ok('body' in tpl)
+    assert.ok('source' in tpl)
+    assert.equal(typeof tpl.body, 'string')
+    assert.ok(tpl.body.length > 0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// loadTemplate – repo template overrides built-in
+// ---------------------------------------------------------------------------
+
+describe('loadTemplate – repo templates override built-in', () => {
+  let tmpDir
+
+  test('repo template shadows built-in when file exists', () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-tpl-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'templates'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'templates', 'bug.md'),
+      '## Custom Bug Template\n\n{{description}}\n'
+    )
+
+    const tpl = loadTemplate('bug', tmpDir)
+    assert.equal(tpl.source, 'repo')
+    assert.ok(tpl.body.includes('Custom Bug Template'))
+
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  test('repo template name extracted from file front-matter if present', () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-tpl-name-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'templates'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'templates', 'custom.md'),
+      'name: My Custom Template\n\n## Body\n\n{{description}}\n'
+    )
+
+    const tpl = loadTemplate('custom', tmpDir)
+    assert.equal(tpl.source, 'repo')
+    assert.equal(tpl.name, 'My Custom Template')
+
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listTemplates
+// ---------------------------------------------------------------------------
+
+describe('listTemplates', () => {
+  test('returns an array', () => {
+    const list = listTemplates(os.tmpdir())
+    assert.ok(Array.isArray(list))
+  })
+
+  test('includes all built-in template keys', () => {
+    const list = listTemplates(os.tmpdir())
+    const builtInKeys = list.filter((t) => t.source === 'built-in').map((t) => t.key)
+    for (const key of ['default', 'bug', 'feature']) {
+      assert.ok(builtInKeys.includes(key), `missing built-in template: ${key}`)
+    }
+  })
+
+  test('each item has key, name, source properties', () => {
+    const list = listTemplates(os.tmpdir())
+    for (const item of list) {
+      assert.ok('key' in item, 'missing key')
+      assert.ok('name' in item, 'missing name')
+      assert.ok('source' in item, 'missing source')
+    }
+  })
+
+  test('repo templates appear before built-ins in the list', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-list-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'templates'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'templates', 'bug.md'),
+      '## Repo Bug\n\n{{description}}\n'
+    )
+
+    try {
+      const list = listTemplates(tmpDir)
+      const repoIdx = list.findIndex((t) => t.source === 'repo' && t.key === 'bug')
+      const builtInIdx = list.findIndex((t) => t.source === 'built-in' && t.key === 'bug')
+      assert.ok(repoIdx >= 0, 'repo template not found in list')
+      assert.ok(builtInIdx >= 0, 'built-in template not found in list')
+      assert.ok(repoIdx < builtInIdx, 'repo template should appear before built-in in list')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})