tissues 0.6.1 → 0.6.2

package/src/commands/providers.js

@@ -0,0 +1,347 @@
+import { Command } from 'commander'
+import fs from 'node:fs'
+import path from 'node:path'
+import { bold, dim, green, yellow, red, cyan } from '../lib/color.js'
+import { select, input } from '@inquirer/prompts'
+import { loadConfig, userConfigPath } from '../lib/defaults.js'
+import { theme } from '../lib/theme.js'
+import { listProviders, listAllProviders, resolveProviderAdapter, migrateProviderConfig } from '../lib/ai/router.js'
+import { discoverProviders } from '../lib/ai/discovery.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function readUserConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(userConfigPath(), 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeUserConfig(obj) {
+  const filePath = userConfigPath()
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 })
+  fs.writeFileSync(filePath, JSON.stringify(obj, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 })
+}
+
+const PROVIDER_TYPES = {
+  anthropic: 'api',
+  openai: 'api',
+  gemini: 'api',
+  ollama: 'api',
+  'openai-compat': 'api',
+  command: 'cli',
+  'gemini-cli': 'cli',
+  'claude-cli': 'cli',
+  'codex-cli': 'cli',
+  openclaw: 'openclaw',
+}
+
+function providerType(name) {
+  return PROVIDER_TYPES[name] || 'custom'
+}
+
+function statusIcon(configured) {
+  return configured ? green('●') : dim('○')
+}
+
+// ---------------------------------------------------------------------------
+// Dashboard
+// ---------------------------------------------------------------------------
+
+async function showDashboard() {
+  const config = loadConfig()
+  const ai = config.ai || {}
+  const activeProvider = ai.provider || 'anthropic'
+
+  // Discover available providers on this system
+  const discovered = await discoverProviders()
+  const discoveredNames = new Set(discovered.map((d) => d.name))
+
+  // All known providers (built-in + custom)
+  const allProviders = listAllProviders(config)
+
+  console.log(bold('\n  AI Providers\n'))
+
+  // Active provider
+  console.log(`  ${green('●')} ${bold(activeProvider)} ${dim('(active)')}\n`)
+
+  // Built-in providers
+  console.log(dim('  Built-in:'))
+  const builtIn = listProviders()
+  for (const name of builtIn) {
+    if (name === 'command') continue // skip generic command adapter
+    try {
+      const { adapter } = resolveProviderAdapter(config, name)
+      const configured = adapter.isConfigured()
+      const type = providerType(name)
+      const active = name === activeProvider ? ` ${green('← active')}` : ''
+      const disc = discoveredNames.has(name) ? ` ${cyan('discovered')}` : ''
+      console.log(`    ${statusIcon(configured)} ${name} ${dim(`[${type}]`)}${active}${disc}`)
+    } catch {
+      console.log(`    ${dim('○')} ${name} ${dim('[unavailable]')}`)
+    }
+  }
+
+  // Custom providers
+  const customNames = allProviders.filter((n) => !builtIn.includes(n))
+  if (customNames.length > 0) {
+    console.log(dim('\n  Custom:'))
+    for (const name of customNames) {
+      try {
+        const { adapter } = resolveProviderAdapter(config, name)
+        const configured = adapter.isConfigured()
+        const active = name === activeProvider ? ` ${green('← active')}` : ''
+        console.log(`    ${statusIcon(configured)} ${name} ${dim('[custom]')}${active}`)
+      } catch {
+        console.log(`    ${dim('○')} ${name} ${dim('[error]')}`)
+      }
+    }
+  }
+
+  // Discovered but not yet configured
+  const unconfigured = discovered.filter((d) => !allProviders.includes(d.name))
+  if (unconfigured.length > 0) {
+    console.log(dim('\n  Discovered (not configured):'))
+    for (const d of unconfigured) {
+      console.log(`    ${yellow('◌')} ${d.name} ${dim(`[${d.type}]`)} — ${dim(`run: tissues providers add ${d.name}`)}`)
+    }
+  }
+
+  // Routes
+  if (ai.routes?.length) {
+    console.log(dim('\n  Routes:'))
+    for (const rule of ai.routes) {
+      const match = rule.match?.template
+        ? `template:${rule.match.template}`
+        : rule.match?.labels
+          ? `labels:${rule.match.labels.join(',')}`
+          : '?'
+      console.log(`    ${dim('→')} ${match} ${dim('→')} ${rule.provider}${rule.model ? ` (${rule.model})` : ''}`)
+    }
+  }
+
+  console.log()
+}
+
+// ---------------------------------------------------------------------------
+// Add provider
+// ---------------------------------------------------------------------------
+
+async function addProvider(name) {
+  const config = loadConfig()
+  const ai = config.ai || {}
+  const builtIn = listProviders()
+  const activeProvider = ai.provider || 'anthropic'
+
+  if (!name) {
+    // Interactive: discover + let user pick (exclude already-active provider)
+    const discovered = await discoverProviders()
+    const choices = discovered
+      .filter((d) => d.name !== activeProvider) // Don't show the already-active provider
+      .map((d) => ({
+        name: `${d.name} [${d.type}]${d.status === 'configured' ? dim(' (configured)') : ''}`,
+        value: d.name,
+      }))
+    if (choices.length === 0) {
+      console.log(yellow('No new providers discovered. Install a CLI (gemini, claude, codex) or set API keys.'))
+      return
+    }
+    name = await select({
+      message: 'Select a provider to configure:',
+      choices,
+      theme,
+    })
+  }
+
+  if (builtIn.includes(name)) {
+    // Built-in provider — just set as active
+    const current = readUserConfig()
+    if (!current.ai) current.ai = {}
+    current.ai.provider = name
+    writeUserConfig(current)
+    console.log(green(`Set ${bold(name)} as active provider.`))
+    return
+  }
+
+  // CLI or OpenClaw provider that was discovered
+  const discovered = await discoverProviders()
+  const match = discovered.find((d) => d.name === name)
+
+  if (match?.type === 'openclaw') {
+    const current = readUserConfig()
+    if (!current.ai) current.ai = {}
+    current.ai.openclaw = {
+      gatewayUrl: match.config.gatewayUrl,
+      token: match.config.token,
+    }
+    current.ai.provider = 'openclaw'
+    writeUserConfig(current)
+    console.log(green(`Configured OpenClaw gateway and set as active provider.`))
+    return
+  }
+
+  if (match?.type === 'cli') {
+    const current = readUserConfig()
+    if (!current.ai) current.ai = {}
+    current.ai.provider = name
+    writeUserConfig(current)
+    console.log(green(`Set ${bold(name)} as active provider.`))
+    return
+  }
+
+  // Custom provider — prompt for command
+  const command = await input({
+    message: `Shell command for ${name}:`,
+    theme,
+  })
+  if (!command) return
+
+  const current = readUserConfig()
+  if (!current.ai) current.ai = {}
+  if (!current.ai.providers) current.ai.providers = {}
+  current.ai.providers[name] = { command }
+  writeUserConfig(current)
+  console.log(green(`Added custom provider ${bold(name)}.`))
+}
+
+// ---------------------------------------------------------------------------
+// Test provider
+// ---------------------------------------------------------------------------
+
+async function testProvider(name) {
+  const config = loadConfig()
+
+  if (!name) {
+    // Interactive: let user pick from configured providers
+    const allProviders = listAllProviders(config)
+    const discovered = await discoverProviders()
+    const configured = discovered.filter((d) => d.status === 'configured' || allProviders.includes(d.name))
+    
+    if (configured.length === 0) {
+      console.log(yellow('No configured providers to test. Run `tissues providers add` first.'))
+      return
+    }
+    
+    const choices = configured.map((d) => ({
+      name: `${d.name} [${d.type}]`,
+      value: d.name,
+    }))
+    
+    name = await select({
+      message: 'Select a provider to test:',
+      choices,
+      theme,
+    })
+  }
+
+  console.log(dim(`Testing ${name}...`))
+
+  try {
+    const { adapter, model } = resolveProviderAdapter(config, name)
+    if (!adapter.isConfigured()) {
+      console.error(red(`Provider ${name} is not configured.`))
+      process.exitCode = 1
+      return
+    }
+
+    const messages = [
+      { role: 'system', content: 'You are a helpful assistant. Reply in one short sentence.' },
+      { role: 'user', content: 'Say "hello from tissues" and nothing else.' },
+    ]
+    const response = await adapter.complete(messages, { model, maxTokens: 100 })
+    console.log(green('✓ Response:'), response)
+  } catch (err) {
+    console.error(red(`✗ ${err.message}`))
+    process.exitCode = 1
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Remove provider
+// ---------------------------------------------------------------------------
+
+async function removeProvider(name) {
+  const config = loadConfig()
+  const builtIn = listProviders()
+
+  if (!name) {
+    // Interactive: let user pick from custom providers only
+    const customProviders = migrateProviderConfig(config.ai || {})
+    const customNames = Object.keys(customProviders)
+    
+    if (customNames.length === 0) {
+      console.log(yellow('No custom providers to remove.'))
+      return
+    }
+    
+    const choices = customNames.map((n) => ({
+      name: n,
+      value: n,
+    }))
+    
+    name = await select({
+      message: 'Select a provider to remove:',
+      choices,
+      theme,
+    })
+  }
+
+  if (builtIn.includes(name)) {
+    console.error(red(`Cannot remove built-in provider ${name}. Use 'tissues config set ai.provider <other>' to switch.`))
+    process.exitCode = 1
+    return
+  }
+
+  const current = readUserConfig()
+  if (current.ai?.providers?.[name]) {
+    delete current.ai.providers[name]
+    if (current.ai.provider === name) {
+      current.ai.provider = 'anthropic'
+    }
+    writeUserConfig(current)
+    console.log(green(`Removed provider ${bold(name)}.`))
+  } else if (current.ai?.commands?.[name]) {
+    delete current.ai.commands[name]
+    if (current.ai.provider === name) {
+      current.ai.provider = 'anthropic'
+    }
+    writeUserConfig(current)
+    console.log(green(`Removed legacy provider ${bold(name)}.`))
+  } else {
+    console.error(yellow(`Provider ${name} not found in user config.`))
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export const providersCommand = new Command('providers')
+  .description('Manage AI providers — discover, configure, and test')
+  .action(async () => {
+    await showDashboard()
+  })
+
+providersCommand
+  .command('add [name]')
+  .description('Add or auto-configure a provider')
+  .action(async (name) => {
+    await addProvider(name)
+  })
+
+providersCommand
+  .command('test [name]')
+  .description('Send a test prompt to verify a provider works')
+  .action(async (name) => {
+    await testProvider(name)
+  })
+
+providersCommand
+  .command('remove [name]')
+  .description('Remove a custom provider from config')
+  .action(async (name) => {
+    await removeProvider(name)
+  })

package/src/commands/providers.test.js

@@ -0,0 +1,28 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { providersCommand } from './providers.js'
+
+describe('providersCommand', () => {
+  it('is a Commander command', () => {
+    assert.equal(providersCommand.name(), 'providers')
+  })
+
+  it('has description', () => {
+    assert.ok(providersCommand.description().length > 0)
+  })
+
+  it('has add subcommand', () => {
+    const sub = providersCommand.commands.find((c) => c.name() === 'add')
+    assert.ok(sub, 'add subcommand exists')
+  })
+
+  it('has test subcommand', () => {
+    const sub = providersCommand.commands.find((c) => c.name() === 'test')
+    assert.ok(sub, 'test subcommand exists')
+  })
+
+  it('has remove subcommand', () => {
+    const sub = providersCommand.commands.find((c) => c.name() === 'remove')
+    assert.ok(sub, 'remove subcommand exists')
+  })
+})

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)