tissues 0.6.1 → 0.6.2

package/src/lib/drafts.test.js

@@ -0,0 +1,300 @@
+/**
+ * Tests for drafts.js
+ *
+ * Uses real temp directories — no mocks. Each describe block gets its own
+ * isolated tmpDir so tests remain independent and clean up after themselves.
+ */
+
+import { test, describe, before, after, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+import {
+  getDraftsDir,
+  writeToDrafts,
+  readDrafts,
+  markComplete,
+  markFailed,
+  hasPending,
+  countPending,
+} from './drafts.js'
+
+// ---------------------------------------------------------------------------
+// Helper: create a temp dir that looks like a repo root
+// ---------------------------------------------------------------------------
+
+function makeTempRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-drafts-test-'))
+  fs.mkdirSync(path.join(dir, '.git'))
+  return dir
+}
+
+// ---------------------------------------------------------------------------
+// writeToDrafts
+// ---------------------------------------------------------------------------
+
+describe('writeToDrafts()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('creates a JSON file with correct structure', () => {
+    const item = writeToDrafts(
+      { repo: 'owner/repo', title: 'My issue', body: 'Some body', labels: ['bug'] },
+      tmpDir,
+    )
+
+    assert.equal(item.repo, 'owner/repo')
+    assert.equal(item.title, 'My issue')
+    assert.equal(item.body, 'Some body')
+    assert.deepEqual(item.labels, ['bug'])
+    assert.equal(item.status, 'pending')
+    assert.equal(item.attemptCount, 0)
+    assert.ok(item.id, 'id should be set')
+    assert.ok(item.createdAt, 'createdAt should be set')
+
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+    assert.ok(fs.existsSync(filePath), 'file should exist on disk')
+
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    assert.deepEqual(parsed, item)
+  })
+
+  test('uses empty array for labels when omitted', () => {
+    const item = writeToDrafts({ repo: 'owner/repo', title: 'No labels', body: 'body' }, tmpDir)
+    assert.deepEqual(item.labels, [])
+  })
+
+  test('two concurrent writeToDrafts() calls produce unique IDs', () => {
+    const a = writeToDrafts({ repo: 'a/b', title: 'A', body: '' }, tmpDir)
+    const b = writeToDrafts({ repo: 'a/b', title: 'B', body: '' }, tmpDir)
+    assert.notEqual(a.id, b.id)
+
+    const dir = getDraftsDir(tmpDir)
+    assert.ok(fs.existsSync(path.join(dir, `${a.id}.json`)))
+    assert.ok(fs.existsSync(path.join(dir, `${b.id}.json`)))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// readDrafts
+// ---------------------------------------------------------------------------
+
+describe('readDrafts()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('returns empty array when drafts is empty', () => {
+    const items = readDrafts(tmpDir)
+    assert.deepEqual(items, [])
+  })
+
+  test('returns items sorted by createdAt ascending', async () => {
+    // Write three items with intentional ordering
+    const a = writeToDrafts({ repo: 'r/r', title: 'First', body: '' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 5)) // tiny gap so timestamps differ
+    const b = writeToDrafts({ repo: 'r/r', title: 'Second', body: '' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 5))
+    const c = writeToDrafts({ repo: 'r/r', title: 'Third', body: '' }, tmpDir)
+
+    const items = readDrafts(tmpDir)
+    const titles = items.map((i) => i.title)
+    assert.ok(titles.indexOf('First') < titles.indexOf('Second'), 'First should be before Second')
+    assert.ok(titles.indexOf('Second') < titles.indexOf('Third'), 'Second should be before Third')
+  })
+
+  test('ignores non-JSON files gracefully', () => {
+    const dir = getDraftsDir(tmpDir)
+    fs.writeFileSync(path.join(dir, '.DS_Store'), 'junk')
+    fs.writeFileSync(path.join(dir, 'README.txt'), 'not json')
+
+    // Should not throw and should not include the non-JSON files
+    const items = readDrafts(tmpDir)
+    const nonDraft = items.filter((i) => !i.id)
+    assert.equal(nonDraft.length, 0)
+  })
+
+  test('skips corrupt JSON files', () => {
+    const dir = getDraftsDir(tmpDir)
+    fs.writeFileSync(path.join(dir, 'corrupt.json'), '{ invalid json !!!')
+
+    // Should not throw
+    const items = readDrafts(tmpDir)
+    // The corrupt file should be silently skipped
+    const corrupt = items.find((i) => i === undefined)
+    assert.equal(corrupt, undefined)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// markComplete
+// ---------------------------------------------------------------------------
+
+describe('markComplete()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('deletes the draft file', () => {
+    const item = writeToDrafts({ repo: 'r/r', title: 'To delete', body: '' }, tmpDir)
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+
+    assert.ok(fs.existsSync(filePath))
+    markComplete(item.id, { issueNumber: 42, issueUrl: 'https://github.com/r/r/issues/42' }, tmpDir)
+    assert.ok(!fs.existsSync(filePath), 'file should be deleted')
+  })
+
+  test('is idempotent — does not throw if file already gone', () => {
+    assert.doesNotThrow(() => markComplete('nonexistent-id', {}, tmpDir))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// markFailed
+// ---------------------------------------------------------------------------
+
+describe('markFailed()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('updates file with status=failed and error message', () => {
+    const item = writeToDrafts({ repo: 'r/r', title: 'Fail me', body: '' }, tmpDir)
+    markFailed(item.id, 'Connection refused', tmpDir)
+
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+    assert.ok(fs.existsSync(filePath), 'file should still exist')
+
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    assert.equal(parsed.status, 'failed')
+    assert.equal(parsed.error, 'Connection refused')
+    assert.ok(parsed.failedAt, 'failedAt should be set')
+  })
+
+  test('is idempotent — does not throw if file is gone', () => {
+    assert.doesNotThrow(() => markFailed('nonexistent-id', 'error', tmpDir))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasPending / countPending
+// ---------------------------------------------------------------------------
+
+describe('hasPending() and countPending()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('hasPending() returns false when drafts dir does not exist', () => {
+    const freshDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-fresh-'))
+    fs.mkdirSync(path.join(freshDir, '.git'))
+    try {
+      assert.equal(hasPending(freshDir), false)
+    } finally {
+      fs.rmSync(freshDir, { recursive: true, force: true })
+    }
+  })
+
+  test('countPending() returns 0 when drafts is empty', () => {
+    assert.equal(countPending(tmpDir), 0)
+  })
+
+  test('hasPending() returns true after writing an item', () => {
+    writeToDrafts({ repo: 'r/r', title: 'Pending', body: '' }, tmpDir)
+    assert.equal(hasPending(tmpDir), true)
+  })
+
+  test('countPending() counts correctly', () => {
+    writeToDrafts({ repo: 'r/r', title: 'One more', body: '' }, tmpDir)
+    const count = countPending(tmpDir)
+    assert.ok(count >= 2, `Expected at least 2 pending, got ${count}`)
+  })
+
+  test('hasPending() returns false after all items are removed', () => {
+    const items = readDrafts(tmpDir)
+    for (const item of items) {
+      markComplete(item.id, {}, tmpDir)
+    }
+    assert.equal(hasPending(tmpDir), false)
+    assert.equal(countPending(tmpDir), 0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Full round-trip lifecycle
+// ---------------------------------------------------------------------------
+
+describe('Full round-trip: write → read → markComplete', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('lifecycle ends with empty drafts', async () => {
+    // Write three items
+    const a = writeToDrafts({ repo: 'lifecycle/repo', title: 'Issue A', body: 'body a' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 2))
+    const b = writeToDrafts({ repo: 'lifecycle/repo', title: 'Issue B', body: 'body b' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 2))
+    const c = writeToDrafts({ repo: 'lifecycle/repo', title: 'Issue C', body: 'body c' }, tmpDir)
+
+    // Read and verify order
+    const items = readDrafts(tmpDir)
+    assert.equal(items.length, 3)
+    assert.equal(items[0].title, 'Issue A')
+    assert.equal(items[1].title, 'Issue B')
+    assert.equal(items[2].title, 'Issue C')
+
+    // Complete all
+    for (const item of items) {
+      markComplete(item.id, {}, tmpDir)
+    }
+
+    // Drafts should be empty
+    assert.equal(hasPending(tmpDir), false)
+    assert.deepEqual(readDrafts(tmpDir), [])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Migration: old outbox dir → drafts
+// ---------------------------------------------------------------------------
+
+describe('outbox → drafts migration', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('auto-renames .tissues/outbox/ to .tissues/drafts/ on first access', () => {
+    // Simulate an old outbox directory
+    const oldDir = path.join(tmpDir, '.tissues', 'outbox')
+    fs.mkdirSync(oldDir, { recursive: true })
+    fs.writeFileSync(path.join(oldDir, 'test-issue.json'), JSON.stringify({
+      id: 'test-issue',
+      repo: 'r/r',
+      title: 'Test issue',
+      body: '',
+      labels: [],
+      createdAt: new Date().toISOString(),
+      status: 'pending',
+    }))
+
+    // getDraftsDir should migrate
+    const dir = getDraftsDir(tmpDir)
+    assert.ok(dir.endsWith('.tissues/drafts'), `Expected drafts dir, got ${dir}`)
+    assert.ok(!fs.existsSync(oldDir), 'old outbox dir should be gone')
+    assert.ok(fs.existsSync(path.join(dir, 'test-issue.json')), 'migrated file should exist')
+  })
+})

package/src/lib/enhancements.test.js

@@ -0,0 +1,294 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import {
+  BUILT_IN_ENHANCEMENTS,
+  builtInEnhancementKeys,
+  listEnhancements,
+  loadEnhancement,
+  loadAllEnhancements,
+  parseEnhancementFile,
+} from './enhancements.js'
+
+// ---------------------------------------------------------------------------
+// BUILT_IN_ENHANCEMENTS
+// ---------------------------------------------------------------------------
+
+describe('BUILT_IN_ENHANCEMENTS', () => {
+  test('has 8 built-in enhancements', () => {
+    assert.equal(Object.keys(BUILT_IN_ENHANCEMENTS).length, 8)
+  })
+
+  test('each enhancement has required fields', () => {
+    for (const [key, enh] of Object.entries(BUILT_IN_ENHANCEMENTS)) {
+      assert.ok(enh.key, `${key} has key`)
+      assert.ok(enh.name, `${key} has name`)
+      assert.ok(typeof enh.maxTokens === 'number', `${key} has maxTokens`)
+      assert.ok(['always', 'auto', 'never'].includes(enh.mode), `${key} has valid mode`)
+      assert.ok(['json', 'markdown'].includes(enh.format), `${key} has valid format`)
+      assert.ok(enh.contextKey, `${key} has contextKey`)
+      assert.ok(typeof enh.order === 'number', `${key} has order`)
+      assert.ok(typeof enh.prompt === 'string', `${key} has prompt`)
+      assert.ok(enh.prompt.length > 0, `${key} prompt is non-empty`)
+    }
+  })
+
+  test('triage and format are structural', () => {
+    assert.equal(BUILT_IN_ENHANCEMENTS.triage.isStructural, true)
+    assert.equal(BUILT_IN_ENHANCEMENTS.format.isStructural, true)
+    assert.equal(BUILT_IN_ENHANCEMENTS.context.isStructural, false)
+  })
+
+  test('orders are correct', () => {
+    assert.equal(BUILT_IN_ENHANCEMENTS.triage.order, 10)
+    assert.equal(BUILT_IN_ENHANCEMENTS.dedup.order, 15)
+    assert.equal(BUILT_IN_ENHANCEMENTS.context.order, 20)
+    assert.equal(BUILT_IN_ENHANCEMENTS.scope.order, 30)
+    assert.equal(BUILT_IN_ENHANCEMENTS.complexity.order, 40)
+    assert.equal(BUILT_IN_ENHANCEMENTS.risk.order, 50)
+    assert.equal(BUILT_IN_ENHANCEMENTS.labels.order, 60)
+    assert.equal(BUILT_IN_ENHANCEMENTS.format.order, 90)
+  })
+})
+
+describe('builtInEnhancementKeys', () => {
+  test('returns all 8 keys', () => {
+    const keys = builtInEnhancementKeys()
+    assert.equal(keys.length, 8)
+    assert.ok(keys.includes('triage'))
+    assert.ok(keys.includes('format'))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// parseEnhancementFile
+// ---------------------------------------------------------------------------
+
+describe('parseEnhancementFile', () => {
+  test('parses frontmatter + body', () => {
+    const content = [
+      '---',
+      'name: Security Review',
+      'maxTokens: 2048',
+      'mode: always',
+      'format: json',
+      'contextKey: securityScore',
+      'order: 55',
+      'requires: ["scopeAnalysis"]',
+      '---',
+      'You are a security reviewer.',
+      'Return JSON.',
+    ].join('\n')
+
+    const { meta, prompt } = parseEnhancementFile(content)
+    assert.equal(meta.name, 'Security Review')
+    assert.equal(meta.maxTokens, 2048)
+    assert.equal(meta.mode, 'always')
+    assert.equal(meta.format, 'json')
+    assert.equal(meta.contextKey, 'securityScore')
+    assert.equal(meta.order, 55)
+    assert.deepEqual(meta.requires, ['scopeAnalysis'])
+    assert.ok(prompt.includes('You are a security reviewer.'))
+  })
+
+  test('handles file with no frontmatter', () => {
+    const content = 'Just a plain prompt.'
+    const { meta, prompt } = parseEnhancementFile(content)
+    assert.deepEqual(meta, {})
+    assert.equal(prompt, 'Just a plain prompt.')
+  })
+
+  test('parses boolean values', () => {
+    const content = '---\nname: Test\nsome: true\nother: false\n---\nprompt'
+    const { meta } = parseEnhancementFile(content)
+    assert.equal(meta.some, true)
+    assert.equal(meta.other, false)
+  })
+
+  test('parses numeric values', () => {
+    const content = '---\nmaxTokens: 512\norder: 42\n---\nprompt'
+    const { meta } = parseEnhancementFile(content)
+    assert.equal(meta.maxTokens, 512)
+    assert.equal(meta.order, 42)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listEnhancements
+// ---------------------------------------------------------------------------
+
+describe('listEnhancements', () => {
+  test('returns an array including built-ins', () => {
+    const list = listEnhancements(os.tmpdir())
+    assert.ok(Array.isArray(list))
+    const builtInKeys = list.filter((e) => e.source === 'built-in').map((e) => e.key)
+    assert.ok(builtInKeys.includes('triage'))
+    assert.ok(builtInKeys.includes('format'))
+  })
+
+  test('each item has key, name, source, mode, order', () => {
+    const list = listEnhancements(os.tmpdir())
+    for (const item of list) {
+      assert.ok('key' in item)
+      assert.ok('name' in item)
+      assert.ok('source' in item)
+      assert.ok('mode' in item)
+      assert.ok('order' in item)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// loadEnhancement
+// ---------------------------------------------------------------------------
+
+describe('loadEnhancement', () => {
+  test('loads a built-in enhancement', () => {
+    const enh = loadEnhancement('triage', os.tmpdir())
+    assert.equal(enh.key, 'triage')
+    assert.equal(enh.source, 'built-in')
+    assert.ok(enh.prompt.length > 0)
+  })
+
+  test('throws for unknown enhancement', () => {
+    assert.throws(
+      () => loadEnhancement('does-not-exist', os.tmpdir()),
+      /Enhancement "does-not-exist" not found/,
+    )
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Three-tier priority
+// ---------------------------------------------------------------------------
+
+describe('three-tier priority', () => {
+  test('user enhancement overrides built-in', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-enh-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+
+    // Create a user enhancement that overrides 'context'
+    const userDir = path.join(os.homedir(), '.config', 'tissues', 'enhancements')
+    const testFile = path.join(userDir, '__test-context-override.md')
+
+    try {
+      fs.mkdirSync(userDir, { recursive: true })
+      fs.writeFileSync(testFile, '---\nname: Custom Context\nmaxTokens: 512\n---\nCustom prompt here.')
+
+      const enh = loadEnhancement('__test-context-override', tmpDir)
+      assert.equal(enh.source, 'user')
+      assert.ok(enh.prompt.includes('Custom prompt here.'))
+    } finally {
+      try { fs.unlinkSync(testFile) } catch { /* ignore */ }
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('repo enhancement overrides user and built-in', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-enh-repo-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'enhancements'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'enhancements', 'context.md'),
+      '---\nname: Repo Context\n---\nRepo-level context prompt.',
+    )
+
+    try {
+      const enh = loadEnhancement('context', tmpDir)
+      assert.equal(enh.source, 'repo')
+      assert.ok(enh.prompt.includes('Repo-level context prompt.'))
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('repo enhancements appear before built-ins in list', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-enh-list-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'enhancements'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'enhancements', 'context.md'),
+      '---\nname: Repo Context\n---\nOverride.',
+    )
+
+    try {
+      const list = listEnhancements(tmpDir)
+      const repoIdx = list.findIndex((e) => e.source === 'repo' && e.key === 'context')
+      const builtInIdx = list.findIndex((e) => e.source === 'built-in' && e.key === 'context')
+      assert.ok(repoIdx >= 0)
+      assert.ok(builtInIdx >= 0)
+      assert.ok(repoIdx < builtInIdx)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// loadAllEnhancements
+// ---------------------------------------------------------------------------
+
+describe('loadAllEnhancements', () => {
+  test('returns sorted array of all enhancements', () => {
+    const all = loadAllEnhancements(os.tmpdir())
+    assert.ok(Array.isArray(all))
+    assert.ok(all.length >= 8)
+
+    // Verify sorted by order
+    for (let i = 1; i < all.length; i++) {
+      assert.ok(all[i].order >= all[i - 1].order, `${all[i].key} order >= ${all[i - 1].key}`)
+    }
+  })
+
+  test('custom enhancements are included', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-enh-all-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'enhancements'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'enhancements', 'security.md'),
+      '---\nname: Security Review\norder: 55\ncontextKey: securityScore\n---\nReview security.',
+    )
+
+    try {
+      const all = loadAllEnhancements(tmpDir)
+      const security = all.find((e) => e.key === 'security')
+      assert.ok(security)
+      assert.equal(security.name, 'Security Review')
+      assert.equal(security.order, 55)
+      assert.equal(security.source, 'repo')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('user override preserves isStructural from built-in', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-enh-struct-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+
+    const userDir = path.join(os.homedir(), '.config', 'tissues', 'enhancements')
+    const testFile = path.join(userDir, 'triage.md')
+
+    // Only run this test if we can safely write and clean up
+    let wrote = false
+    try {
+      // Skip if user already has a triage override
+      if (fs.existsSync(testFile)) {
+        return
+      }
+      fs.mkdirSync(userDir, { recursive: true })
+      fs.writeFileSync(testFile, '---\nname: Custom Triage\n---\nCustom triage prompt.')
+      wrote = true
+
+      const all = loadAllEnhancements(tmpDir)
+      const triage = all.find((e) => e.key === 'triage')
+      assert.ok(triage)
+      assert.equal(triage.isStructural, true) // preserved from built-in
+      assert.equal(triage.source, 'user')
+    } finally {
+      if (wrote) try { fs.unlinkSync(testFile) } catch { /* ignore */ }
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/lib/gh.js

@@ -381,6 +381,66 @@ export function uploadImageToRepo(repo, localPath, filename) {
   return { url, path: repoPath }
 }
 
+/**
+ * Fetch issues via `gh api` with incremental sync support.
+ * Returns raw GitHub API issue objects (not pull requests).
+ *
+ * @param {string} repo - owner/name
+ * @param {{ since?: string, state?: string, perPage?: number, page?: number }} [opts]
+ * @returns {Array<object>} raw API issue objects
+ */
+export function fetchIssuesApi(repo, opts = {}) {
+  const { since, state = 'all', perPage = 100, page = 1 } = opts
+  let endpoint = `repos/${repo}/issues?state=${state}&per_page=${perPage}&page=${page}&sort=updated&direction=asc`
+  if (since) endpoint += `&since=${since}`
+
+  let raw
+  try {
+    raw = execFileSync('gh', ['api', endpoint], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim()
+  } catch (err) {
+    const reason = (err.stderr || err.message || '').trim()
+    throw new Error(`gh api issues failed: ${reason}`)
+  }
+
+  if (!raw) return []
+  const items = JSON.parse(raw)
+  // Filter out pull requests (they have a pull_request key)
+  return items.filter(i => !i.pull_request)
+}
+
+/**
+ * Fetch labels via `gh api` with full details.
+ *
+ * @param {string} repo - owner/name
+ * @param {{ perPage?: number, page?: number }} [opts]
+ * @returns {Array<{ name: string, color: string, description: string }>}
+ */
+export function fetchLabelsApi(repo, opts = {}) {
+  const { perPage = 100, page = 1 } = opts
+  let raw
+  try {
+    raw = execFileSync('gh', [
+      'api', `repos/${repo}/labels?per_page=${perPage}&page=${page}`,
+    ], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim()
+  } catch (err) {
+    const reason = (err.stderr || err.message || '').trim()
+    throw new Error(`gh api labels failed: ${reason}`)
+  }
+
+  if (!raw) return []
+  return JSON.parse(raw).map(l => ({
+    name: l.name,
+    color: l.color || '',
+    description: l.description || '',
+  }))
+}
+
 /**
  * List repos the user has access to.
  * @param {{ limit?: number }} [opts]