tissues 0.6.0 → 0.6.2

package/src/commands/flush.test.js

@@ -0,0 +1,299 @@
+/**
+ * Integration tests for flush.js.
+ *
+ * Tests the five critical flush paths:
+ *   1. Empty outbox → "nothing to flush" message, no exit
+ *   2. All items flush successfully → files deleted, summary printed
+ *   3. Rate limited mid-flush → partial flush, remaining files stay, exit 0
+ *   4. Duplicate found → file deleted, skipped in summary
+ *   5. createIssue() throws → file gets status=failed, continues to next
+ *   6. verifyIssue() returns false → file kept, warning printed
+ *
+ * Requires: --experimental-test-module-mocks (Node 22+)
+ *
+ * Run:
+ *   node --experimental-test-module-mocks --test src/commands/flush.test.js
+ */
+
+import { test, describe, before, after, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+// ---------------------------------------------------------------------------
+// Mutable stubs
+// ---------------------------------------------------------------------------
+
+let mockSafetyAllowed = true
+let mockSafetyCallCount = 0
+let mockSafetyBlockAfter = Infinity  // block after N successful calls
+let mockCreateIssueImpl = () => ({ number: 42, url: 'https://github.com/test/repo/issues/42' })
+let mockVerifyImpl = () => true
+let mockDedupImpl = async () => ({ action: 'allow', results: [] })
+
+// ---------------------------------------------------------------------------
+// Module mocks — must be set up before importing module under test
+// ---------------------------------------------------------------------------
+
+mock.module('../lib/gh.js', {
+  namedExports: {
+    requireAuth: () => {},
+    createIssue: (...args) => mockCreateIssueImpl(...args),
+    verifyIssue: (...args) => mockVerifyImpl(...args),
+    listRepos: () => [],
+    listIssues: () => [],
+    listLabels: () => [],
+  },
+})
+
+mock.module('../lib/safety.js', {
+  namedExports: {
+    checkSafety: () => {
+      mockSafetyCallCount++
+      const allowed = mockSafetyCallCount <= mockSafetyBlockAfter
+      return {
+        allowed,
+        reason: allowed ? undefined : 'Rate limit reached',
+        circuitState: 'closed',
+        rateInfo: {},
+      }
+    },
+    recordSuccess: () => {},
+    recordFailure: () => {},
+  },
+})
+
+mock.module('../lib/dedup.js', {
+  namedExports: {
+    checkDuplicate: async (...args) => mockDedupImpl(...args),
+    recordCreation: async () => {},
+    computeFingerprint: (title, body) =>
+      Buffer.from(title + body).toString('hex').slice(0, 64),
+  },
+})
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+const { flushCommand } = await import('./flush.js')
+const { writeToDrafts, readDrafts, markComplete } = await import('../lib/drafts.js')
+const { store } = await import('../lib/config.js')
+
+// ---------------------------------------------------------------------------
+// Temp dir setup
+// ---------------------------------------------------------------------------
+
+let tmpDir
+let originalCwd
+
+before(() => {
+  originalCwd = process.cwd()
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-flush-test-'))
+  fs.mkdirSync(path.join(tmpDir, '.git'))
+  process.chdir(tmpDir)
+  store.set('activeRepo', 'test/repo')
+})
+
+after(() => {
+  try { process.chdir(originalCwd) } catch { /* ignore */ }
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch { /* ignore */ }
+})
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+class ExitError extends Error {
+  constructor(code) {
+    super(`process.exit(${code})`)
+    this.exitCode = code
+  }
+}
+
+function trapExit() {
+  return mock.method(process, 'exit', (code) => { throw new ExitError(code) })
+}
+
+function resetStubs() {
+  mockSafetyAllowed = true
+  mockSafetyCallCount = 0
+  mockSafetyBlockAfter = Infinity
+  mockCreateIssueImpl = (_repo, _opts) => ({ number: 42, url: 'https://github.com/test/repo/issues/42' })
+  mockVerifyImpl = () => true
+  mockDedupImpl = async () => ({ action: 'allow', results: [] })
+}
+
+async function runFlush(opts = {}) {
+  return flushCommand.parseAsync(['node', 'tissues', 'flush', ...Object.entries(opts).flatMap(([k, v]) => [`--${k}`, v])])
+}
+
+function clearOutbox() {
+  const items = readDrafts(tmpDir)
+  for (const item of items) markComplete(item.id, {}, tmpDir)
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('flush.js integration', () => {
+  before(() => { resetStubs(); clearOutbox() })
+
+  test('empty outbox — exits cleanly with no-op message', async () => {
+    clearOutbox()
+    // Should not throw, should not call createIssue
+    let createCalled = false
+    mockCreateIssueImpl = () => { createCalled = true; return { number: 1, url: '' } }
+
+    await runFlush()
+
+    assert.equal(createCalled, false, 'createIssue should not be called for empty outbox')
+  })
+
+  test('full success — all files deleted, summary shown', async () => {
+    resetStubs()
+    clearOutbox()
+
+    let issueNum = 100
+    mockCreateIssueImpl = (_repo, _opts) => ({
+      number: ++issueNum,
+      url: `https://github.com/test/repo/issues/${issueNum}`,
+    })
+
+    writeToDrafts({ repo: 'test/repo', title: 'Issue Alpha', body: 'body a' }, tmpDir)
+    writeToDrafts({ repo: 'test/repo', title: 'Issue Beta', body: 'body b' }, tmpDir)
+    writeToDrafts({ repo: 'test/repo', title: 'Issue Gamma', body: 'body c' }, tmpDir)
+
+    await runFlush()
+
+    const remaining = readDrafts(tmpDir).filter((i) => i.repo === 'test/repo')
+    assert.equal(remaining.length, 0, 'all outbox files should be deleted after full success')
+  })
+
+  test('rate limited mid-flush — partial flush, remaining files stay, exit 0', async () => {
+    resetStubs()
+    clearOutbox()
+
+    // Allow only the first createIssue call (safety blocks before 2nd)
+    mockSafetyBlockAfter = 1
+
+    writeToDrafts({ repo: 'test/repo', title: 'Partial One', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'test/repo', title: 'Partial Two', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'test/repo', title: 'Partial Three', body: '' }, tmpDir)
+
+    const exitTrap = trapExit()
+    let exitCode = null
+    try {
+      await runFlush()
+    } catch (err) {
+      if (err instanceof ExitError) exitCode = err.exitCode
+      else throw err
+    } finally {
+      exitTrap.mock.restore()
+    }
+
+    assert.equal(exitCode, 0, 'rate-limited flush should exit 0')
+
+    const remaining = readDrafts(tmpDir).filter(
+      (i) => i.repo === 'test/repo' && i.status !== 'failed',
+    )
+    assert.ok(remaining.length > 0, 'some files should remain after partial flush')
+    assert.ok(remaining.length < 3, 'at least one file should have been sent')
+
+    clearOutbox()
+  })
+
+  test('duplicate detected — file deleted, counted as skipped', async () => {
+    resetStubs()
+    clearOutbox()
+
+    mockDedupImpl = async () => ({
+      action: 'block',
+      results: [{ action: 'block', reason: 'Exact match', existingIssue: null }],
+    })
+
+    writeToDrafts({ repo: 'test/repo', title: 'Dupe Issue', body: 'same body' }, tmpDir)
+
+    let createCalled = false
+    mockCreateIssueImpl = () => { createCalled = true; return { number: 1, url: '' } }
+
+    await runFlush()
+
+    assert.equal(createCalled, false, 'createIssue should not be called for duplicates')
+
+    const remaining = readDrafts(tmpDir).filter((i) => i.title === 'Dupe Issue')
+    assert.equal(remaining.length, 0, 'duplicate outbox file should be deleted')
+
+    resetStubs()
+  })
+
+  test('createIssue throws — file gets status=failed, continues to next item', async () => {
+    resetStubs()
+    clearOutbox()
+
+    let callCount = 0
+    mockCreateIssueImpl = (_repo, opts) => {
+      callCount++
+      if (opts.title === 'Will Fail') throw new Error('API error')
+      return { number: 200 + callCount, url: `https://github.com/test/repo/issues/${200 + callCount}` }
+    }
+
+    writeToDrafts({ repo: 'test/repo', title: 'Will Fail', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'test/repo', title: 'Will Succeed', body: '' }, tmpDir)
+
+    await runFlush()
+
+    const all = readDrafts(tmpDir)
+    const failed = all.filter((i) => i.title === 'Will Fail')
+    const succeeded = all.filter((i) => i.title === 'Will Succeed')
+
+    assert.equal(failed.length, 1, 'failed item should remain in outbox')
+    assert.equal(failed[0].status, 'failed', 'failed item should have status=failed')
+    assert.ok(failed[0].error, 'failed item should have error message')
+
+    assert.equal(succeeded.length, 0, 'successful item should be deleted from outbox')
+
+    clearOutbox()
+  })
+
+  test('verifyIssue returns false — file kept as pending', async () => {
+    resetStubs()
+    clearOutbox()
+
+    mockCreateIssueImpl = () => ({ number: 999, url: 'https://github.com/test/repo/issues/999' })
+    mockVerifyImpl = () => false
+
+    writeToDrafts({ repo: 'test/repo', title: 'Unverifiable', body: '' }, tmpDir)
+
+    await runFlush()
+
+    const remaining = readDrafts(tmpDir).filter((i) => i.title === 'Unverifiable')
+    assert.equal(remaining.length, 1, 'unverified file should remain in outbox')
+    assert.equal(remaining[0].status, 'pending', 'status should stay pending, not failed')
+
+    clearOutbox()
+  })
+
+  test('only flushes items for active repo — ignores other repos', async () => {
+    resetStubs()
+    clearOutbox()
+
+    let createCalled = 0
+    mockCreateIssueImpl = (_repo, _opts) => { createCalled++; return { number: createCalled, url: '' } }
+
+    writeToDrafts({ repo: 'test/repo', title: 'Mine', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'other/repo', title: 'Not mine', body: '' }, tmpDir)
+
+    await runFlush()
+
+    assert.equal(createCalled, 1, 'should only create issues for active repo')
+
+    // Other repo item should still be there
+    const other = readDrafts(tmpDir).filter((i) => i.repo === 'other/repo')
+    assert.equal(other.length, 1, 'other-repo item should remain untouched')
+
+    clearOutbox()
+  })
+})

package/src/commands/list.js

@@ -3,7 +3,8 @@ import { search } from '@inquirer/prompts'
 import { store } from '../lib/config.js'
 import { theme } from '../lib/theme.js'
 import { pickRepo } from '../lib/repo-picker.js'
-import { requireAuth, listIssues } from '../lib/gh.js'
+import { requireAuth } from '../lib/gh.js'
+import { ensureFresh } from '../lib/cache.js'
 import { yellow, dim, cyan } from '../lib/color.js'
 import ora from 'ora'
 import { execSync } from 'child_process'
@@ -26,7 +27,7 @@ export const listCommand = new Command('list')
     }
 
     const spinner = ora('Fetching issues...').start()
-    const issues = listIssues(repo)
+    const issues = ensureFresh(repo, 'issues', { state: 'open' })
     spinner.stop()
 
     if (issues.length === 0) {

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