tissues 0.6.0 → 0.6.2

package/src/commands/storage.js

@@ -0,0 +1,167 @@
+/**
+ * Storage manager command — inspect and manage all cached/stored data.
+ */
+
+import { Command } from 'commander'
+import { confirm } from '@inquirer/prompts'
+import { store } from '../lib/config.js'
+import { theme } from '../lib/theme.js'
+import {
+  getStorageOverview,
+  getIssueBreakdown,
+  clearCachedData,
+  exportStorageJson,
+  formatBytes,
+  timeAgo,
+} from '../lib/storage.js'
+import { bold, dim, cyan, green, yellow, red } from '../lib/color.js'
+
+// ---------------------------------------------------------------------------
+// Display helpers
+// ---------------------------------------------------------------------------
+
+function padRight(str, len) {
+  return (str + ' '.repeat(len)).slice(0, len)
+}
+
+function printOverview(overview) {
+  const { database, files, totalDiskUsage } = overview
+
+  console.log(bold('\nDatabase'))
+  console.log(`  Path:         ${dim(database.path)}`)
+  console.log(`  Size:         ${formatBytes(database.size)}`)
+
+  const tableOrder = [
+    'fingerprints', 'idempotency_keys',
+    'cached_issues', 'cached_labels', 'cached_repos',
+    'circuit_breaker', 'rate_events', 'sync_meta',
+  ]
+
+  for (const name of tableOrder) {
+    const info = database.tables[name]
+    if (!info) continue
+    const rowStr = padRight(`${info.rows} rows`, 14)
+    const syncStr = info.lastSync ? `last: ${timeAgo(info.lastSync)}` : ''
+    console.log(`  ${padRight(name, 18)} ${rowStr} ${dim(syncStr)}`)
+  }
+
+  console.log(bold('\nFiles'))
+  if (files.drafts.count > 0) {
+    console.log(`  Drafts:       ${files.drafts.count} file${files.drafts.count === 1 ? '' : 's'}     ${formatBytes(files.drafts.totalSize)}`)
+  }
+  if (files.images.count > 0) {
+    console.log(`  Images:       ${files.images.count} file${files.images.count === 1 ? '' : 's'}     ${formatBytes(files.images.totalSize)}`)
+  }
+  if (files.templates.count > 0) {
+    console.log(`  Templates:    ${files.templates.count} file${files.templates.count === 1 ? '' : 's'}`)
+  }
+  if (files.enhancements.count > 0) {
+    console.log(`  Enhancements: ${files.enhancements.count} file${files.enhancements.count === 1 ? '' : 's'}`)
+  }
+  if (files.drafts.count + files.images.count + files.templates.count + files.enhancements.count === 0) {
+    console.log(dim('  (none)'))
+  }
+
+  console.log(`\n  ${bold('Total disk usage:')} ${formatBytes(totalDiskUsage)}`)
+  console.log()
+}
+
+function printIssueBreakdown(breakdown) {
+  if (breakdown.length === 0) {
+    console.log(dim('\n  No cached issues.\n'))
+    return
+  }
+
+  console.log(bold('\nCached Issues'))
+  for (const entry of breakdown) {
+    const total = entry.open + entry.closed
+    const sync = entry.lastSync ? timeAgo(entry.lastSync) : 'never'
+    console.log(`  ${cyan(entry.repo)}`)
+    console.log(`    ${entry.open} open, ${entry.closed} closed (${total} total)   last sync: ${dim(sync)}`)
+  }
+  console.log()
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export const storageCommand = new Command('storage')
+  .description('Inspect and manage cached data')
+  .argument('[category]', 'Drill-down category (issues, labels, fingerprints)')
+  .option('--repo <repo>', 'Scope to a specific repo')
+  .option('--json', 'Output as JSON')
+  .action(async (category, opts) => {
+    const repo = opts.repo || store.get('activeRepo') || undefined
+
+    if (opts.json) {
+      const data = exportStorageJson({ repo })
+      console.log(JSON.stringify(data, null, 2))
+      return
+    }
+
+    if (category === 'issues') {
+      const breakdown = getIssueBreakdown()
+      printIssueBreakdown(breakdown)
+      return
+    }
+
+    const overview = getStorageOverview({ repo })
+    printOverview(overview)
+  })
+
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+
+const clearCommand = new Command('clear')
+  .description('Clear cached data')
+  .argument('<target>', 'What to clear (issues, labels, repos, fingerprints, all)')
+  .option('--repo <repo>', 'Scope to a specific repo')
+  .option('--include-safety', 'Also reset circuit breaker and rate events')
+  .option('--force', 'Skip confirmation')
+  .action(async (target, opts) => {
+    const validTargets = ['issues', 'labels', 'repos', 'fingerprints', 'all']
+    if (!validTargets.includes(target)) {
+      console.error(red(`Invalid target: ${target}`))
+      console.error(dim(`Valid targets: ${validTargets.join(', ')}`))
+      process.exit(1)
+    }
+
+    const repo = opts.repo || undefined
+    const scope = repo ? ` for ${cyan(repo)}` : ''
+
+    if (!opts.force) {
+      const msg = target === 'all'
+        ? `Clear ALL cached data${scope}?${opts.includeSafety ? ' (including safety data)' : ''}`
+        : `Clear cached ${target}${scope}?`
+      const ok = await confirm({ message: msg, default: false, theme })
+      if (!ok) {
+        console.log(dim('Aborted.'))
+        return
+      }
+    }
+
+    const { cleared } = clearCachedData(target, {
+      repo,
+      includeSafety: opts.includeSafety || false,
+    })
+
+    if (cleared.length > 0) {
+      console.log(green('Cleared: ') + cleared.join(', '))
+    } else {
+      console.log(dim('Nothing to clear.'))
+    }
+  })
+
+const exportCommand = new Command('export')
+  .description('Export storage metadata as JSON')
+  .option('--repo <repo>', 'Scope to a specific repo')
+  .action((opts) => {
+    const repo = opts.repo || store.get('activeRepo') || undefined
+    const data = exportStorageJson({ repo })
+    console.log(JSON.stringify(data, null, 2))
+  })
+
+storageCommand.addCommand(clearCommand)
+storageCommand.addCommand(exportCommand)

package/src/commands/sync.js

@@ -0,0 +1,225 @@
+/**
+ * Sync command — manual one-shot sync + background daemon management.
+ */
+
+import { Command } from 'commander'
+import { fork } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { store } from '../lib/config.js'
+import { requireAuth } from '../lib/gh.js'
+import { syncIssues, syncLabels, syncRepos } from '../lib/cache.js'
+import { pickRepo } from '../lib/repo-picker.js'
+import { green, yellow, red, dim, cyan, bold } from '../lib/color.js'
+import ora from 'ora'
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'tissues')
+const PID_FILE = path.join(CONFIG_DIR, 'sync.pid')
+const STATUS_FILE = path.join(CONFIG_DIR, 'sync-status.json')
+
+// ---------------------------------------------------------------------------
+// Daemon helpers
+// ---------------------------------------------------------------------------
+
+function readPid() {
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10)
+    // Check if process is alive
+    process.kill(pid, 0)
+    return pid
+  } catch {
+    // Clean up stale PID file
+    try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+    return null
+  }
+}
+
+function readStatus() {
+  try {
+    return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function recordActivity() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  const status = readStatus() || {}
+  status.lastActivity = new Date().toISOString()
+  fs.writeFileSync(STATUS_FILE, JSON.stringify(status, null, 2), 'utf8')
+}
+
+// ---------------------------------------------------------------------------
+// Main sync command (one-shot)
+// ---------------------------------------------------------------------------
+
+export const syncCommand = new Command('sync')
+  .description('Sync issues, labels, and repos to local cache')
+  .option('--repo <repo>', 'Repository to sync (default: active repo)')
+  .option('--force', 'Force full sync, ignore freshness')
+  .option('--quiet', 'Suppress output')
+  .action(async (opts) => {
+    requireAuth()
+
+    let repo = opts.repo || store.get('activeRepo')
+    if (!repo) {
+      console.log(yellow('No active repo. Pick one:\n'))
+      repo = await pickRepo()
+      console.log()
+    }
+
+    const log = opts.quiet ? () => {} : console.log
+
+    // Sync repos
+    const repoSpinner = opts.quiet ? null : ora('Syncing repos...').start()
+    try {
+      const result = syncRepos({ force: opts.force })
+      if (repoSpinner) repoSpinner.succeed(`Repos: ${result.synced} cached`)
+    } catch (err) {
+      if (repoSpinner) repoSpinner.warn(`Repos sync failed: ${err.message}`)
+    }
+
+    // Sync labels
+    const labelSpinner = opts.quiet ? null : ora('Syncing labels...').start()
+    try {
+      const result = syncLabels(repo, { force: opts.force })
+      if (labelSpinner) labelSpinner.succeed(`Labels: ${result.synced} cached`)
+    } catch (err) {
+      if (labelSpinner) labelSpinner.warn(`Labels sync failed: ${err.message}`)
+    }
+
+    // Sync issues (incremental)
+    const issueSpinner = opts.quiet ? null : ora('Syncing issues...').start()
+    try {
+      const result = syncIssues(repo, { force: opts.force })
+      if (issueSpinner) issueSpinner.succeed(`Issues: ${result.synced} synced (${result.total} total)`)
+    } catch (err) {
+      if (issueSpinner) issueSpinner.warn(`Issues sync failed: ${err.message}`)
+    }
+
+    log()
+    log(green('Sync complete.'))
+  })
+
+// ---------------------------------------------------------------------------
+// Daemon subcommands
+// ---------------------------------------------------------------------------
+
+const startCommand = new Command('start')
+  .description('Start the background sync daemon')
+  .action(() => {
+    const existing = readPid()
+    if (existing) {
+      console.log(yellow(`Daemon already running (PID ${existing}).`))
+      return
+    }
+
+    const __dirname = path.dirname(fileURLToPath(import.meta.url))
+    const daemonScript = path.join(__dirname, '..', 'daemon', 'sync.js')
+
+    const child = fork(daemonScript, [], {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.unref()
+
+    console.log(green(`Sync daemon started (PID ${child.pid}).`))
+    console.log(dim('Run `tissues sync status` to check on it.'))
+  })
+
+const stopCommand = new Command('stop')
+  .description('Stop the background sync daemon')
+  .action(() => {
+    const pid = readPid()
+    if (!pid) {
+      console.log(dim('No daemon running.'))
+      return
+    }
+
+    try {
+      process.kill(pid, 'SIGTERM')
+      console.log(green(`Daemon stopped (PID ${pid}).`))
+    } catch (err) {
+      console.warn(yellow(`Could not stop daemon: ${err.message}`))
+      // Clean up stale PID file
+      try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+    }
+  })
+
+const restartCommand = new Command('restart')
+  .description('Restart the background sync daemon')
+  .action(async () => {
+    // Stop
+    const pid = readPid()
+    if (pid) {
+      try {
+        process.kill(pid, 'SIGTERM')
+        console.log(dim(`Stopped daemon (PID ${pid}).`))
+        // Brief wait for cleanup
+        await new Promise(r => setTimeout(r, 500))
+      } catch { /* ok */ }
+    }
+
+    // Start
+    const __dirname = path.dirname(fileURLToPath(import.meta.url))
+    const daemonScript = path.join(__dirname, '..', 'daemon', 'sync.js')
+
+    const child = fork(daemonScript, [], {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.unref()
+
+    console.log(green(`Sync daemon restarted (PID ${child.pid}).`))
+  })
+
+const statusCommand = new Command('status')
+  .description('Show background sync daemon status')
+  .action(() => {
+    const pid = readPid()
+    const status = readStatus()
+
+    if (!pid && !status) {
+      console.log(dim('No daemon has been started.'))
+      console.log(dim('Run `tissues sync start` to begin background syncing.'))
+      return
+    }
+
+    console.log(bold('\nSync Daemon'))
+    if (pid) {
+      console.log(`  Status:     ${green('running')} (PID ${pid})`)
+    } else {
+      console.log(`  Status:     ${dim(status?.status || 'stopped')}`)
+    }
+
+    if (status) {
+      if (status.startedAt) console.log(`  Started:    ${dim(status.startedAt)}`)
+      if (status.lastSync) console.log(`  Last sync:  ${dim(status.lastSync)}`)
+      if (status.nextSync) console.log(`  Next sync:  ${dim(status.nextSync)}`)
+      if (status.lastError) console.log(`  Last error: ${red(status.lastError)}`)
+
+      if (status.perRepoStats) {
+        console.log(bold('\n  Per-repo stats:'))
+        for (const [repo, stats] of Object.entries(status.perRepoStats)) {
+          if (stats.status === 'ok') {
+            console.log(`    ${cyan(repo)}: ${stats.issues} issues, ${stats.labels} labels`)
+          } else if (stats.status === 'error') {
+            console.log(`    ${cyan(repo)}: ${red(stats.error)}`)
+          } else if (stats.status === 'skipped') {
+            console.log(`    ${cyan(repo)}: ${yellow(stats.reason)}`)
+          }
+        }
+      }
+    }
+    console.log()
+  })
+
+syncCommand.addCommand(startCommand)
+syncCommand.addCommand(stopCommand)
+syncCommand.addCommand(restartCommand)
+syncCommand.addCommand(statusCommand)
+
+// Export recordActivity for use in preAction hook
+export { recordActivity }

package/src/daemon/sync.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+/**
+ * Background sync daemon for tissues.
+ *
+ * Keeps the local cache warm by periodically syncing issues, labels,
+ * and repos in the background. Runs as a detached child process.
+ *
+ * PID file: ~/.config/tissues/sync.pid
+ * Status file: ~/.config/tissues/sync-status.json
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { syncIssues, syncLabels, syncRepos } from '../lib/cache.js'
+import { getToken } from '../lib/gh.js'
+import { loadConfig } from '../lib/defaults.js'
+import { store } from '../lib/config.js'
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'tissues')
+const PID_FILE = path.join(CONFIG_DIR, 'sync.pid')
+const STATUS_FILE = path.join(CONFIG_DIR, 'sync-status.json')
+
+// ---------------------------------------------------------------------------
+// Status file operations
+// ---------------------------------------------------------------------------
+
+function readStatus() {
+  try {
+    return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeStatus(updates) {
+  const current = readStatus()
+  const merged = { ...current, ...updates }
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  fs.writeFileSync(STATUS_FILE, JSON.stringify(merged, null, 2), 'utf8')
+}
+
+// ---------------------------------------------------------------------------
+// Adaptive interval
+// ---------------------------------------------------------------------------
+
+function getInterval(config) {
+  const syncConfig = config.sync || {}
+  const baseInterval = (syncConfig.interval || 300) * 1000
+
+  if (!syncConfig.adaptiveInterval) return baseInterval
+
+  const status = readStatus()
+  const lastActivity = status.lastActivity ? new Date(status.lastActivity).getTime() : 0
+  const idle = Date.now() - lastActivity
+
+  const THIRTY_MIN = 30 * 60 * 1000
+  const TWO_HOURS = 2 * 60 * 60 * 1000
+  const EIGHT_HOURS = 8 * 60 * 60 * 1000
+
+  if (idle < THIRTY_MIN) return 2 * 60 * 1000   // Active: every 2 min
+  if (idle < TWO_HOURS) return 5 * 60 * 1000     // Normal: every 5 min
+  if (idle < EIGHT_HOURS) return 15 * 60 * 1000  // Idle: every 15 min
+  return 60 * 60 * 1000                           // Sleep: every 60 min
+}
+
+// ---------------------------------------------------------------------------
+// Sync cycle
+// ---------------------------------------------------------------------------
+
+const failureCounts = new Map()  // repo -> consecutive failure count
+const SKIP_THRESHOLD = 5
+const SKIP_DURATION = 60 * 60 * 1000  // 1 hour
+const skipUntil = new Map()
+
+async function syncCycle(config) {
+  // Auth check
+  const token = getToken()
+  if (!token) {
+    writeStatus({ lastError: 'Not authenticated', lastErrorAt: new Date().toISOString() })
+    return
+  }
+
+  const syncConfig = config.sync || {}
+  const repos = syncConfig.repos?.length
+    ? syncConfig.repos
+    : [store.get('activeRepo')].filter(Boolean)
+
+  if (repos.length === 0) {
+    writeStatus({ lastError: 'No repos configured', lastErrorAt: new Date().toISOString() })
+    return
+  }
+
+  const perRepoStats = {}
+
+  for (const repo of repos) {
+    // Check skip
+    const skipTime = skipUntil.get(repo)
+    if (skipTime && Date.now() < skipTime) {
+      perRepoStats[repo] = { status: 'skipped', reason: 'too many failures' }
+      continue
+    }
+
+    try {
+      const issueResult = syncIssues(repo)
+      const labelResult = syncLabels(repo)
+      perRepoStats[repo] = {
+        status: 'ok',
+        issues: issueResult.synced,
+        labels: labelResult.synced,
+      }
+      failureCounts.set(repo, 0)
+    } catch (err) {
+      const count = (failureCounts.get(repo) || 0) + 1
+      failureCounts.set(repo, count)
+      perRepoStats[repo] = { status: 'error', error: err.message }
+
+      if (count >= SKIP_THRESHOLD) {
+        skipUntil.set(repo, Date.now() + SKIP_DURATION)
+        perRepoStats[repo].skippedUntil = new Date(Date.now() + SKIP_DURATION).toISOString()
+      }
+    }
+  }
+
+  // Sync repos list (global, not per-repo)
+  try {
+    syncRepos()
+  } catch {
+    // Non-fatal
+  }
+
+  writeStatus({
+    lastSync: new Date().toISOString(),
+    perRepoStats,
+    lastError: null,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Main loop
+// ---------------------------------------------------------------------------
+
+async function main() {
+  // Write PID
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  fs.writeFileSync(PID_FILE, String(process.pid), 'utf8')
+
+  writeStatus({
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    status: 'running',
+  })
+
+  // Graceful shutdown
+  const cleanup = () => {
+    writeStatus({ status: 'stopped', stoppedAt: new Date().toISOString() })
+    try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+    process.exit(0)
+  }
+  process.on('SIGTERM', cleanup)
+  process.on('SIGINT', cleanup)
+
+  // Run first cycle immediately
+  const config = loadConfig()
+  await syncCycle(config)
+
+  // Schedule recurring
+  const schedule = () => {
+    const freshConfig = loadConfig()
+    const interval = getInterval(freshConfig)
+    writeStatus({ nextSync: new Date(Date.now() + interval).toISOString() })
+    setTimeout(async () => {
+      await syncCycle(freshConfig)
+      schedule()
+    }, interval)
+  }
+  schedule()
+}
+
+main().catch(err => {
+  writeStatus({ status: 'crashed', error: err.message, crashedAt: new Date().toISOString() })
+  try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+  process.exit(1)
+})

package/src/lib/ai/adapters/claude-cli.js

@@ -0,0 +1,55 @@
+import { execFile } from 'node:child_process'
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_TIMEOUT_MS = 120_000
+
+/**
+ * Adapter for the Claude Code CLI (anthropic claude-code).
+ * Uses: claude --print 'prompt' --model MODEL --dangerously-skip-permissions
+ */
+export class ClaudeCliAdapter extends BaseAdapter {
+  get name() {
+    return 'claude-cli'
+  }
+
+  isConfigured() {
+    return !!this.config.binary
+  }
+
+  async complete(messages, opts = {}) {
+    const binary = this.config.binary || 'claude'
+    const model = opts.model || this.config.model || null
+    const timeoutMs = this.config.timeout || DEFAULT_TIMEOUT_MS
+
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user')
+    const promptText = lastUserMsg?.content || ''
+
+    // Build system context from system messages
+    const systemParts = messages.filter((m) => m.role === 'system').map((m) => m.content)
+    const fullPrompt = systemParts.length
+      ? `${systemParts.join('\n\n')}\n\n${promptText}`
+      : promptText
+
+    const args = ['--print', fullPrompt, '--dangerously-skip-permissions']
+    if (model) args.push('--model', model)
+
+    return new Promise((resolve, reject) => {
+      execFile(binary, args, {
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024,
+      }, (err, stdout, stderr) => {
+        if (err) {
+          const msg = stderr?.trim() || err.message
+          reject(new Error(`claude-cli error: ${this.sanitizeErrorBody(msg)}`))
+          return
+        }
+        const text = stdout.trim()
+        if (!text) {
+          reject(new Error('claude-cli returned no output'))
+          return
+        }
+        resolve(text)
+      })
+    })
+  }
+}