tissues 0.6.0 → 0.6.2

package/src/commands/create.test.js

@@ -0,0 +1,381 @@
+/**
+ * Integration tests for the outbox wiring in create.js.
+ *
+ * These tests verify that the outbox file is written, kept, or deleted
+ * correctly across the four critical paths:
+ *
+ *   1. Safety blocked → file stays pending, process exits 0
+ *   2. createIssue() throws → file gets status='failed'
+ *   3. verifyIssue() returns false → file stays pending
+ *   4. Full success → file deleted
+ *
+ * Requires: --experimental-test-module-mocks (Node 22+)
+ *
+ * Run:
+ *   node --experimental-test-module-mocks --test src/commands/create.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 — each test overrides these before calling runCreate
+// ---------------------------------------------------------------------------
+
+let mockSafetyAllowed = true
+let mockSafetyReason = ''
+let mockCreateIssueResult = { number: 42, url: 'https://github.com/test/repo/issues/42' }
+let mockCreateIssueThrows = null  // set to an Error to simulate failure
+let mockVerifyResult = true
+let mockDedupResult = { action: 'allow', results: [] }
+
+// ---------------------------------------------------------------------------
+// Mock modules — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+mock.module('../lib/gh.js', {
+  namedExports: {
+    requireAuth: () => {},
+    createIssue: (_repo, _opts) => {
+      if (mockCreateIssueThrows) throw mockCreateIssueThrows
+      return mockCreateIssueResult
+    },
+    verifyIssue: (_repo, _number) => mockVerifyResult,
+    listLabels: () => [],
+    createLabel: () => {},
+    addLabelsToIssue: () => {},
+    listRepos: () => [],
+    listIssues: () => [],
+    fetchIssuesApi: () => [],
+    fetchLabelsApi: () => [],
+    uploadImageToRepo: () => ({ url: 'https://raw.githubusercontent.com/test/repo/HEAD/.tissues/images/test.png', path: '.tissues/images/test.png' }),
+  },
+})
+
+mock.module('../lib/safety.js', {
+  namedExports: {
+    checkSafety: () => ({
+      allowed: mockSafetyAllowed,
+      reason: mockSafetyReason || 'rate limited',
+      circuitState: 'closed',
+      rateInfo: {},
+    }),
+    recordSuccess: () => {},
+    recordFailure: () => {},
+  },
+})
+
+mock.module('../lib/dedup.js', {
+  namedExports: {
+    checkDuplicate: async () => mockDedupResult,
+    recordCreation: async () => {},
+    computeFingerprint: (title, body) => {
+      // simple stub fingerprint
+      return Buffer.from(title + body).toString('hex').slice(0, 64)
+    },
+  },
+})
+
+// Skip AI enhancement entirely
+let mockCheckAvailable = () => false
+mock.module('../lib/ai/index.js', {
+  namedExports: {
+    checkAvailable: (...args) => mockCheckAvailable(...args),
+    enhance: async (_cfg, _t, _d, body) => body,
+    checkBudgets: () => {},
+    recordUsage: () => {},
+  },
+})
+
+let mockPipelineResult = null
+let mockPipelineThrows = null
+mock.module('../lib/ai/enhance.js', {
+  namedExports: {
+    runEnhancePipeline: async () => {
+      if (mockPipelineThrows) throw mockPipelineThrows
+      return mockPipelineResult
+    },
+  },
+})
+
+// ---------------------------------------------------------------------------
+// Import the module under test AFTER mocks are set up
+// ---------------------------------------------------------------------------
+
+const { runCreate } = await import('./create.js')
+const { readDrafts, markComplete } = await import('../lib/drafts.js')
+
+// ---------------------------------------------------------------------------
+// Temp dir setup
+// ---------------------------------------------------------------------------
+
+let tmpDir
+let originalCwd
+
+before(() => {
+  originalCwd = process.cwd()
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-create-test-'))
+  fs.mkdirSync(path.join(tmpDir, '.git'))
+  process.chdir(tmpDir)
+})
+
+after(() => {
+  try { process.chdir(originalCwd) } catch { /* ignore */ }
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch { /* ignore */ }
+})
+
+// ---------------------------------------------------------------------------
+// Helper: base opts that avoid interactive prompts
+// ---------------------------------------------------------------------------
+
+function baseOpts(overrides = {}) {
+  return {
+    repo: 'test/repo',
+    title: 'Test issue title',
+    body: 'Test body',
+    instructions: undefined,
+    template: 'default',
+    agent: 'human',
+    session: null,
+    labels: undefined,
+    force: true,
+    dryRun: false,
+    enhance: false,
+    ...overrides,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helper: intercept process.exit so it doesn't kill the test runner
+// ---------------------------------------------------------------------------
+
+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)
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('create.js outbox integration', () => {
+  // Reset stubs before each test
+  before(() => {
+    mockSafetyAllowed = true
+    mockSafetyReason = ''
+    mockCreateIssueResult = { number: 42, url: 'https://github.com/test/repo/issues/42' }
+    mockCreateIssueThrows = null
+    mockVerifyResult = true
+    mockDedupResult = { action: 'allow', results: [] }
+  })
+
+  test('full success path — outbox file deleted after verify', async () => {
+    mockSafetyAllowed = true
+    mockVerifyResult = true
+
+    const result = await runCreate(baseOpts())
+
+    assert.ok(result, 'should return result')
+    assert.equal(result.number, 42)
+    assert.equal(result.url, 'https://github.com/test/repo/issues/42')
+
+    // Outbox file should be gone
+    const pending = readDrafts(tmpDir)
+    const mine = pending.filter((i) => i.title === 'Test issue title' && i.status !== 'failed')
+    assert.equal(mine.length, 0, 'outbox file should be deleted after success')
+  })
+
+  test('safety blocked — outbox file stays pending, exits 0', async () => {
+    mockSafetyAllowed = false
+    mockSafetyReason = 'Burst rate limit reached'
+
+    const exitTrap = trapExit()
+
+    let exitCode = null
+    try {
+      await runCreate(baseOpts({ title: 'Safety blocked issue' }))
+    } catch (err) {
+      if (err instanceof ExitError) {
+        exitCode = err.exitCode
+      } else {
+        throw err
+      }
+    } finally {
+      exitTrap.mock.restore()
+      mockSafetyAllowed = true
+    }
+
+    assert.equal(exitCode, 0, 'should exit 0 on safety block (not a failure)')
+
+    // Outbox file must still be there
+    const pending = readDrafts(tmpDir)
+    const mine = pending.filter((i) => i.title === 'Safety blocked issue')
+    assert.equal(mine.length, 1, 'outbox file should be kept when safety blocks')
+    assert.equal(mine[0].status, 'pending')
+
+    // Clean up
+    markComplete(mine[0].id, {}, tmpDir)
+  })
+
+  test('createIssue() throws — outbox file gets status=failed', async () => {
+    mockSafetyAllowed = true
+    mockCreateIssueThrows = new Error('API rate limit exceeded')
+
+    const exitTrap = trapExit()
+
+    try {
+      await runCreate(baseOpts({ title: 'Failed create issue' }))
+    } catch (err) {
+      if (!(err instanceof ExitError) && !err.message.includes('Failed to create issue')) {
+        throw err
+      }
+    } finally {
+      exitTrap.mock.restore()
+      mockCreateIssueThrows = null
+    }
+
+    // File should still exist with status=failed
+    const allItems = readDrafts(tmpDir)
+    const mine = allItems.filter((i) => i.title === 'Failed create issue')
+    assert.equal(mine.length, 1, 'outbox file should be kept when createIssue throws')
+    assert.equal(mine[0].status, 'failed')
+    assert.ok(mine[0].error, 'error field should be set')
+    assert.ok(mine[0].failedAt, 'failedAt should be set')
+
+    // Clean up
+    markComplete(mine[0].id, {}, tmpDir)
+  })
+
+  test('verifyIssue() returns false — outbox file kept as pending', async () => {
+    mockSafetyAllowed = true
+    mockCreateIssueResult = { number: 99, url: 'https://github.com/test/repo/issues/99' }
+    mockVerifyResult = false
+
+    await runCreate(baseOpts({ title: 'Unverified issue' }))
+
+    const allItems = readDrafts(tmpDir)
+    const mine = allItems.filter((i) => i.title === 'Unverified issue')
+    assert.equal(mine.length, 1, 'outbox file should remain when verify fails')
+    // Status should still be pending (not completed, not failed)
+    assert.equal(mine[0].status, 'pending')
+
+    // Clean up
+    markComplete(mine[0].id, {}, tmpDir)
+    mockVerifyResult = true
+  })
+
+  test('duplicate detected — no draft file created, throws', async () => {
+    const before = readDrafts(tmpDir).length
+
+    mockDedupResult = {
+      action: 'block',
+      results: [{ action: 'block', reason: 'Exact duplicate', existingIssue: null }],
+    }
+
+    await assert.rejects(
+      () => runCreate(baseOpts({ title: 'Duplicate issue' })),
+      /Duplicate detected/,
+    )
+
+    // No draft file should be created for dedup blocks
+    const after = readDrafts(tmpDir).length
+    assert.equal(after, before, 'no draft file should be created for duplicates')
+
+    mockDedupResult = { action: 'allow', results: [] }
+  })
+
+  test('dry run — no outbox file written', async () => {
+    const before = readDrafts(tmpDir).length
+
+    const result = await runCreate(baseOpts({ title: 'Dry run issue', dryRun: true }))
+
+    assert.equal(result, null, 'dry run should return null')
+    const after = readDrafts(tmpDir).length
+    assert.equal(after, before, 'no outbox file should be written for dry run')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Pipeline integration tests
+// ---------------------------------------------------------------------------
+
+describe('create.js pipeline integration', () => {
+  before(() => {
+    mockSafetyAllowed = true
+    mockSafetyReason = ''
+    mockCreateIssueResult = { number: 42, url: 'https://github.com/test/repo/issues/42' }
+    mockCreateIssueThrows = null
+    mockVerifyResult = true
+    mockDedupResult = { action: 'allow', results: [] }
+    mockCheckAvailable = () => false
+    mockPipelineResult = null
+    mockPipelineThrows = null
+  })
+
+  test('pipeline disabled (AI unavailable) — falls back to template', async () => {
+    mockCheckAvailable = () => false
+    mockPipelineResult = null
+
+    const result = await runCreate(baseOpts({ title: 'No AI issue' }))
+    assert.ok(result)
+    assert.equal(result.number, 42)
+    // Clean up
+    const items = readDrafts(tmpDir).filter((i) => i.title === 'No AI issue')
+    for (const i of items) markComplete(i.id, {}, tmpDir)
+  })
+
+  test('--no-pipeline flag forces single-shot even if pipeline enabled', async () => {
+    // With AI unavailable, pipeline flag doesn't matter — body stays as template
+    mockCheckAvailable = () => false
+
+    const result = await runCreate(baseOpts({ title: 'No pipeline flag', pipeline: false }))
+    assert.ok(result)
+    assert.equal(result.number, 42)
+  })
+
+  test('pipeline failure degrades gracefully to template', async () => {
+    mockCheckAvailable = () => true
+    mockPipelineThrows = new Error('Pipeline exploded')
+
+    const result = await runCreate(baseOpts({ title: 'Pipeline fail issue' }))
+    assert.ok(result)
+    assert.equal(result.number, 42)
+
+    // Clean up
+    mockPipelineThrows = null
+    mockCheckAvailable = () => false
+  })
+
+  test('pipeline result title is used for GitHub issue', async () => {
+    mockCheckAvailable = () => true
+    mockPipelineResult = {
+      title: 'AI-refined title',
+      body: '## Summary\nAI body',
+      aiLabels: [],
+      dedupScore: null,
+    }
+
+    const result = await runCreate(baseOpts({
+      title: 'Original title from splitInput',
+      pipeline: true,
+      enhance: true,
+    }))
+    assert.ok(result)
+    assert.equal(result.number, 42)
+
+    // Clean up
+    mockPipelineResult = null
+    mockCheckAvailable = () => false
+  })
+})

package/src/commands/enhancements.js

@@ -0,0 +1,282 @@
+import { Command } from 'commander'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { dim, red, green } from '../lib/color.js'
+import { select, input, editor } from '@inquirer/prompts'
+import {
+  listEnhancements,
+  loadEnhancement,
+  builtInEnhancementKeys,
+  BUILT_IN_ENHANCEMENTS,
+  parseEnhancementFile,
+} from '../lib/enhancements.js'
+import { findRepoRoot, loadConfig } from '../lib/defaults.js'
+import { listProviders, listAllProviders } from '../lib/ai/index.js'
+import { theme } from '../lib/theme.js'
+
+const PROVIDER_LABELS = {
+  anthropic: 'Anthropic',
+  openai: 'OpenAI',
+  gemini: 'Gemini',
+  ollama: 'Ollama',
+  'openai-compat': 'OpenAI Custom',
+  command: 'Command',
+}
+
+const builtInProviders = new Set(listProviders())
+
+function formatProviderName(name) {
+  if (!name) return null
+  if (builtInProviders.has(name)) return PROVIDER_LABELS[name] || name
+  return `${name} ${dim('(custom)')}`
+}
+
+function isCancelled(err) {
+  return err?.name === 'ExitPromptError' || err?.message?.includes('User force closed')
+}
+
+async function promptOrBack(fn) {
+  try { return await fn() } catch (err) { if (isCancelled(err)) return Symbol.for('back'); throw err }
+}
+
+function userEnhancementDir() {
+  return path.join(os.homedir(), '.config', 'tissues', 'enhancements')
+}
+
+export const enhancementsCommand = new Command('enhancements')
+  .description('Manage AI pipeline enhancements (view, edit, create)')
+  .action(async () => {
+    while (true) {
+      const repoRoot = findRepoRoot()
+      const enhancements = listEnhancements(repoRoot)
+      const builtInKeys = builtInEnhancementKeys()
+
+      // Deduplicate by key (higher-priority sources shadow lower ones)
+      const seen = new Set()
+      const choices = []
+      for (const enh of enhancements) {
+        if (!seen.has(enh.key)) {
+          seen.add(enh.key)
+          const provLabel = enh.provider ? formatProviderName(enh.provider) : 'default'
+          choices.push({
+            name: `${enh.key.padEnd(18)} ${dim(provLabel)}`,
+            value: enh.key,
+          })
+        }
+      }
+      choices.push({ name: green('Create New Enhancement'), value: '_create' })
+      choices.push({ name: dim('Done'), value: 'done' })
+
+      const chosen = await promptOrBack(() => select({ message: 'Enhancements', choices, theme }))
+      if (chosen === Symbol.for('back') || chosen === 'done') break
+
+      if (chosen === '_create') {
+        await createNewEnhancement(builtInKeys, seen)
+        continue
+      }
+
+      // View / edit existing enhancement
+      await viewEnhancement(chosen, repoRoot, builtInKeys)
+      console.log()
+    }
+  })
+
+async function createNewEnhancement(builtInKeys, existingKeys) {
+  const name = await promptOrBack(() => input({ message: 'Enhancement key (lowercase, no spaces)', theme }))
+  if (name === Symbol.for('back') || !name) return
+
+  const key = name.trim().toLowerCase().replace(/\s+/g, '-')
+  if (!key) return
+
+  // Block reusing exact built-in names
+  if (builtInKeys.includes(key)) {
+    console.log(red(`  "${key}" is a built-in enhancement. Use edit to customize it instead.`))
+    return
+  }
+
+  // Block duplicates
+  if (existingKeys.has(key)) {
+    console.log(red(`  Enhancement "${key}" already exists.`))
+    return
+  }
+
+  const displayName = await promptOrBack(() =>
+    input({ message: 'Display name', default: key.charAt(0).toUpperCase() + key.slice(1), theme }),
+  )
+  if (displayName === Symbol.for('back')) return
+
+  const contextKey = await promptOrBack(() =>
+    input({ message: 'Context key (where result is stored)', default: key, theme }),
+  )
+  if (contextKey === Symbol.for('back')) return
+
+  const skeleton = [
+    '---',
+    `name: ${displayName}`,
+    'maxTokens: 1024',
+    'mode: auto',
+    'format: json',
+    `contextKey: ${contextKey}`,
+    'order: 50',
+    'requires: []',
+    '---',
+    `You are an expert at analyzing GitHub issues.`,
+    `Assess the ${key} aspects of the proposed change.`,
+    'Return a JSON object with your analysis.',
+    'Return ONLY valid JSON.',
+  ].join('\n')
+
+  const body = await promptOrBack(() =>
+    editor({
+      message: 'Enhancement file (opens editor)',
+      default: skeleton,
+      theme,
+    }),
+  )
+  if (body === Symbol.for('back') || !body) return
+
+  const dir = userEnhancementDir()
+  fs.mkdirSync(dir, { recursive: true })
+  const filePath = path.join(dir, `${key}.md`)
+  fs.writeFileSync(filePath, body, 'utf8')
+  console.log(green(`  ✔ Enhancement "${key}" created: ${filePath}`))
+}
+
+async function viewEnhancement(key, repoRoot, builtInKeys) {
+  let enh
+  try {
+    enh = loadEnhancement(key, repoRoot)
+  } catch (err) {
+    console.log(red(`  ${err.message}`))
+    return
+  }
+
+  console.log(`\n  ${enh.name} ${dim(`(${enh.source})`)}`)
+  console.log(dim('  ─'.repeat(20)))
+  console.log(dim(`  Mode: ${enh.mode}  Format: ${enh.format}  Tokens: ${enh.maxTokens}  Order: ${enh.order}`))
+  if (enh.provider) console.log(dim(`  Provider: ${enh.provider}`))
+  if (enh.contextKey) console.log(dim(`  Context key: ${enh.contextKey}`))
+  if (enh.requires?.length) console.log(dim(`  Requires: ${enh.requires.join(', ')}`))
+  console.log()
+
+  // Show prompt preview (truncated)
+  const preview = enh.prompt.split('\n').slice(0, 8).join('\n')
+  console.log(dim(preview))
+  if (enh.prompt.split('\n').length > 8) console.log(dim('  ...'))
+  console.log()
+
+  const actionChoices = [
+    { name: 'Edit', value: 'edit' },
+    { name: `Provider        ${formatProviderName(enh.provider) || dim('default')}`, value: 'provider' },
+  ]
+  if (builtInKeys.includes(key) && enh.source === 'built-in') {
+    actionChoices[0] = { name: 'Customize (creates user copy)', value: 'edit' }
+  }
+  // Only allow deleting user enhancements
+  const userFile = path.join(userEnhancementDir(), `${key}.md`)
+  if (fs.existsSync(userFile)) {
+    actionChoices.push({ name: red('Delete user copy'), value: 'delete' })
+  }
+  actionChoices.push({ name: dim('Back'), value: 'back' })
+
+  const action = await promptOrBack(() => select({ message: enh.name, choices: actionChoices, theme }))
+  if (action === Symbol.for('back') || action === 'back') return
+
+  if (action === 'provider') {
+    const cfg = loadConfig()
+    const allProviders = listAllProviders(cfg)
+    const providerChoices = [
+      { name: 'Default (use pipeline provider)', value: '_default' },
+      ...allProviders.map((p) => ({
+        name: formatProviderName(p),
+        value: p,
+      })),
+      { name: dim('Back'), value: 'back' },
+    ]
+
+    const chosen = await promptOrBack(() =>
+      select({
+        message: `Provider for ${enh.name}`,
+        choices: providerChoices,
+        default: enh.provider || '_default',
+        theme,
+      }),
+    )
+    if (chosen === Symbol.for('back') || chosen === 'back') return
+
+    const newProvider = chosen === '_default' ? null : chosen
+
+    // Update the .md file frontmatter (creates user copy if built-in)
+    const updatedEnh = { ...enh, provider: newProvider }
+    const content = buildFileContent(updatedEnh)
+    const dir = userEnhancementDir()
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(path.join(dir, `${key}.md`), content, 'utf8')
+
+    if (newProvider) {
+      console.log(green(`  ✔ ${enh.name}: → ${newProvider}`))
+    } else {
+      console.log(green(`  ✔ ${enh.name}: using default provider`))
+    }
+    if (enh.source === 'built-in') {
+      console.log(dim(`  User copy created (overrides built-in)`))
+    }
+    return
+  }
+
+  if (action === 'delete') {
+    fs.unlinkSync(userFile)
+    console.log(green(`  ✔ User copy of "${key}" deleted`))
+    if (builtInKeys.includes(key)) {
+      console.log(dim(`  Built-in "${key}" will be used again.`))
+    }
+    return
+  }
+
+  // Edit — build the file content from the current enhancement
+  const currentContent = buildFileContent(enh)
+
+  const newBody = await promptOrBack(() =>
+    editor({
+      message: `Edit ${key}`,
+      default: currentContent,
+      theme,
+    }),
+  )
+  if (newBody === Symbol.for('back') || !newBody) return
+
+  // Save as user enhancement
+  const dir = userEnhancementDir()
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(path.join(dir, `${key}.md`), newBody, 'utf8')
+
+  if (enh.source === 'built-in') {
+    console.log(green(`  ✔ User copy of "${key}" created (overrides built-in)`))
+  } else {
+    console.log(green(`  ✔ Enhancement "${key}" updated`))
+  }
+}
+
+function buildFileContent(enh) {
+  const lines = [
+    '---',
+    `name: ${enh.name}`,
+    `maxTokens: ${enh.maxTokens}`,
+    `mode: ${enh.mode}`,
+    `format: ${enh.format}`,
+    `contextKey: ${enh.contextKey}`,
+    `order: ${enh.order}`,
+  ]
+  if (enh.provider) {
+    lines.push(`provider: ${enh.provider}`)
+  }
+  if (enh.requires?.length) {
+    lines.push(`requires: [${enh.requires.map((r) => `"${r}"`).join(', ')}]`)
+  } else {
+    lines.push('requires: []')
+  }
+  lines.push('---')
+  lines.push(enh.prompt)
+  return lines.join('\n')
+}