tissues 0.6.1 → 0.6.2

package/src/lib/safety.test.js

@@ -0,0 +1,217 @@
+/**
+ * Tests for safety.js
+ *
+ * safety.js depends heavily on db.js (SQLite). These tests focus on the
+ * pure/isolated behaviors: formatCooldownRemaining logic is internal, so we
+ * test the exported interface surface that does NOT require a live DB.
+ *
+ * For the DB-dependent functions (checkSafety, recordSuccess, recordFailure,
+ * getSafetyStatus, forceReset) we use a real SQLite DB in a temp directory so
+ * the tests remain self-contained and clean up after themselves.
+ */
+
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+// ---------------------------------------------------------------------------
+// Set up an isolated temp directory that looks like a git repo so db.js
+// writes tissues.db there instead of into the project root.
+// ---------------------------------------------------------------------------
+
+let tmpDir
+
+before(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-safety-test-'))
+  // Create .git so findRepoRootForDb resolves here
+  fs.mkdirSync(path.join(tmpDir, '.git'))
+  // Point the process cwd so db.js resolves correctly when the module is loaded
+  process.chdir(tmpDir)
+})
+
+after(() => {
+  // Restore cwd to something safe
+  try { process.chdir(os.tmpdir()) } catch { /* ignore */ }
+  // Clean up temp dir
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch { /* ignore */ }
+})
+
+// Import AFTER before() sets up tmpDir so db.js picks up the right cwd.
+// Node ESM caches modules so we import lazily in each test instead.
+// We use dynamic import inside the tests to defer resolution.
+// However, since ESM imports are hoisted, we need a workaround:
+// we define a helper that loads the module on demand via dynamic import.
+async function getSafety() {
+  return import('./safety.js')
+}
+
+async function getDb() {
+  return import('./db.js')
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('checkSafety – allowed when no events recorded', () => {
+  test('returns allowed=true and circuitState=closed for fresh repo/agent', async () => {
+    const { checkSafety } = await getSafety()
+    const result = checkSafety('test/repo-fresh', 'agent-alpha')
+    assert.equal(result.allowed, true)
+    assert.equal(result.circuitState, 'closed')
+    assert.ok(result.rateInfo)
+  })
+
+  test('rateInfo contains rate counters', async () => {
+    const { checkSafety } = await getSafety()
+    const result = checkSafety('test/repo-fresh2', 'agent-beta')
+    assert.ok('agentHourCount' in result.rateInfo)
+    assert.ok('agentBurstCount' in result.rateInfo)
+    assert.ok('globalHourCount' in result.rateInfo)
+  })
+})
+
+describe('checkSafety – rate limit enforcement', () => {
+  test('blocks when per-agent hourly limit is reached', async () => {
+    const { checkSafety } = await getSafety()
+    const { recordRateEvent } = await getDb()
+    const repo = 'test/repo-hourly'
+    const agent = 'agent-hourly'
+
+    // Simulate maxPerHour (default 10) create events
+    for (let i = 0; i < 10; i++) {
+      recordRateEvent(repo, agent, 'create')
+    }
+
+    const result = checkSafety(repo, agent)
+    assert.equal(result.allowed, false)
+    assert.ok(result.reason.includes('Hourly rate limit'))
+    assert.equal(result.circuitState, 'closed')
+  })
+
+  test('blocks when burst limit is reached', async () => {
+    const { checkSafety } = await getSafety()
+    const { recordRateEvent } = await getDb()
+    const repo = 'test/repo-burst'
+    const agent = 'agent-burst'
+
+    // Simulate burstLimit (default 5) create events in burst window
+    for (let i = 0; i < 5; i++) {
+      recordRateEvent(repo, agent, 'create')
+    }
+
+    const result = checkSafety(repo, agent)
+    assert.equal(result.allowed, false)
+    assert.ok(result.reason.includes('Burst rate limit') || result.reason.includes('Hourly rate limit'))
+  })
+
+  test('custom config overrides default limits', async () => {
+    const { checkSafety } = await getSafety()
+    const { recordRateEvent } = await getDb()
+    const repo = 'test/repo-custom'
+    const agent = 'agent-custom'
+
+    // Record 2 events — should be blocked with maxPerHour=2
+    recordRateEvent(repo, agent, 'create')
+    recordRateEvent(repo, agent, 'create')
+
+    const result = checkSafety(repo, agent, { maxPerHour: 2, burstLimit: 10 })
+    assert.equal(result.allowed, false)
+    assert.ok(result.reason.includes('Hourly rate limit'))
+  })
+})
+
+describe('checkSafety – circuit breaker', () => {
+  test('circuit is open after being tripped', async () => {
+    const { checkSafety } = await getSafety()
+    const { tripCircuit } = await getDb()
+    const repo = 'test/repo-circuit'
+    const agent = 'agent-circuit'
+
+    tripCircuit(repo, agent, 30)
+
+    const result = checkSafety(repo, agent)
+    assert.equal(result.allowed, false)
+    assert.equal(result.circuitState, 'open')
+    assert.ok(result.reason.includes('Circuit breaker is open'))
+  })
+
+  test('circuit resets to closed after forceReset', async () => {
+    const { checkSafety, forceReset } = await getSafety()
+    const { tripCircuit } = await getDb()
+    const repo = 'test/repo-reset'
+    const agent = 'agent-reset'
+
+    tripCircuit(repo, agent, 30)
+    forceReset(repo, agent)
+
+    const result = checkSafety(repo, agent)
+    assert.equal(result.circuitState, 'closed')
+    assert.equal(result.allowed, true)
+  })
+})
+
+describe('recordSuccess', () => {
+  test('recording success does not throw', async () => {
+    const { recordSuccess } = await getSafety()
+    assert.doesNotThrow(() => recordSuccess('test/repo-ok', 'agent-ok'))
+  })
+
+  test('recording success increments rate event count', async () => {
+    const { recordSuccess } = await getSafety()
+    const { countRecentEvents } = await getDb()
+    const repo = 'test/repo-success-count'
+    const agent = 'agent-sc'
+
+    const before = countRecentEvents(repo, agent, 60)
+    recordSuccess(repo, agent)
+    const after = countRecentEvents(repo, agent, 60)
+    assert.equal(after, before + 1)
+  })
+})
+
+describe('recordFailure', () => {
+  test('recording failures does not throw', async () => {
+    const { recordFailure } = await getSafety()
+    assert.doesNotThrow(() => recordFailure('test/repo-fail', 'agent-fail'))
+  })
+
+  test('circuit trips after tripThreshold failures', async () => {
+    const { recordFailure, checkSafety } = await getSafety()
+    const repo = 'test/repo-trip'
+    const agent = 'agent-trip'
+    const config = { tripThreshold: 3, cooldownMinutes: 30 }
+
+    recordFailure(repo, agent, config)
+    recordFailure(repo, agent, config)
+    recordFailure(repo, agent, config) // should trip
+
+    const result = checkSafety(repo, agent)
+    assert.equal(result.circuitState, 'open')
+    assert.equal(result.allowed, false)
+  })
+})
+
+describe('getSafetyStatus', () => {
+  test('returns a formatted string with status info', async () => {
+    const { getSafetyStatus } = await getSafety()
+    const status = getSafetyStatus('test/repo-status', 'agent-status')
+    assert.ok(typeof status === 'string')
+    assert.ok(status.includes('Circuit breaker'))
+    assert.ok(status.includes('Hourly'))
+    assert.ok(status.includes('Burst'))
+  })
+
+  test('shows OPEN in status when circuit is tripped', async () => {
+    const { getSafetyStatus } = await getSafety()
+    const { tripCircuit } = await getDb()
+    const repo = 'test/repo-status-open'
+    const agent = 'agent-status-open'
+
+    tripCircuit(repo, agent, 30)
+    const status = getSafetyStatus(repo, agent)
+    assert.ok(status.includes('OPEN'))
+  })
+})

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 }
+}