tissues 0.6.1 → 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/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) {