tissues 0.5.2 → 0.6.1

package/src/commands/drafts.js

@@ -0,0 +1,288 @@
+import { Command } from 'commander'
+import { store } from '../lib/config.js'
+import { loadConfig, findRepoRoot } from '../lib/defaults.js'
+import { readDrafts, markComplete, markDuplicate, markFailed, countPending } from '../lib/drafts.js'
+import { checkSafety, recordSuccess, recordFailure } from '../lib/safety.js'
+import { checkDuplicate, recordCreation } from '../lib/dedup.js'
+import { createIssue, verifyIssue } from '../lib/gh.js'
+import { bold, dim, red } from '../lib/color.js'
+import ora from 'ora'
+import { select, confirm } from '@inquirer/prompts'
+import { theme } from '../lib/theme.js'
+
+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 timeAgo(isoString) {
+  const ts = new Date(isoString)
+  const diffMs = Date.now() - ts.getTime()
+  if (diffMs < 0) return 'just now'
+  const seconds = Math.floor(diffMs / 1000)
+  if (seconds < 60) return `${seconds}s ago`
+  const minutes = Math.floor(diffMs / 60_000)
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.floor(diffMs / 3_600_000)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.floor(diffMs / 86_400_000)
+  return `${days}d ago`
+}
+
+// ---------------------------------------------------------------------------
+// Publish logic — creates GitHub issues from pending drafts
+// ---------------------------------------------------------------------------
+
+async function publishItems(repo, repoRoot, config, agent) {
+  const allItems = readDrafts(repoRoot)
+  const flushable = new Set(['pending', 'draft'])
+  const items = allItems.filter((item) => item.repo === repo && flushable.has(item.status))
+
+  if (items.length === 0) {
+    const total = countPending(repoRoot)
+    if (total > 0) {
+      console.log(dim(`No pending items for ${repo}.`))
+      console.log(dim(`(${total} item(s) belong to other repos or have failed)`))
+    } else {
+      console.log(dim('No drafts to publish.'))
+    }
+    return
+  }
+
+  console.log(bold(`Publishing ${items.length} issue${items.length === 1 ? '' : 's'}...\n`))
+
+  const flushed = []
+  const skipped = []
+
+  for (const item of items) {
+    const safetyResult = checkSafety(repo, agent, config.safety)
+    if (!safetyResult.allowed) {
+      const remaining = items.length - flushed.length - skipped.length
+      console.log()
+      console.log(dim(`  ⏸ Sent ${flushed.length}/${items.length}. Rate limit reached — ${remaining} still in drafts.`))
+      return
+    }
+
+    const dedupSpinner = ora(`Checking: "${item.title}"`).start()
+    let dedupResult
+    try {
+      dedupResult = await checkDuplicate(repo, { title: item.title, body: item.body, agent })
+      dedupSpinner.stop()
+    } catch (err) {
+      dedupSpinner.warn(`Dedup failed (skipping): ${err.message}`)
+      dedupResult = { action: 'allow', results: [] }
+    }
+
+    if (dedupResult.action === 'block') {
+      recordFailure(repo, agent, config.safety)
+      console.log(dim(`  ⊘ Skipping "${item.title}" — duplicate`))
+      const reason = dedupResult.results.filter((r) => r.action === 'block').map((r) => r.reason).join('; ')
+      markDuplicate(item.id, reason, repoRoot)
+      skipped.push(item)
+      continue
+    }
+
+    const createSpinner = ora(`Creating: "${item.title}"`).start()
+    let issue
+    try {
+      issue = createIssue(repo, { title: item.title, body: item.body, labels: item.labels ?? [] })
+      createSpinner.succeed(`Created: ${issue.url}`)
+    } catch (err) {
+      createSpinner.fail(`Failed: "${item.title}" — ${err.message}`)
+      markFailed(item.id, err.message, repoRoot)
+      continue
+    }
+
+    const verified = verifyIssue(repo, issue.number)
+    if (!verified) {
+      console.warn(dim(`  #${issue.number} could not be verified — keeping in drafts`))
+      continue
+    }
+
+    markComplete(item.id, { issueNumber: issue.number, issueUrl: issue.url }, repoRoot)
+    try {
+      await recordCreation(repo, { title: item.title, body: item.body, issueNumber: issue.number, url: issue.url, agent })
+    } catch { /* non-fatal */ }
+    recordSuccess(repo, agent)
+    flushed.push({ title: item.title, number: issue.number, url: issue.url })
+  }
+
+  console.log()
+  if (flushed.length > 0) {
+    console.log(dim(`  ✓ Published ${flushed.length} issue${flushed.length === 1 ? '' : 's'}`))
+  }
+  if (skipped.length > 0) {
+    console.log(dim(`  ⊘ Skipped ${skipped.length} duplicate${skipped.length === 1 ? '' : 's'}`))
+  }
+  const stillPending = countPending(repoRoot)
+  if (stillPending === 0 && flushed.length > 0) {
+    console.log(dim('  No drafts remaining.'))
+  } else if (stillPending > 0) {
+    console.log(dim(`  ${stillPending} item(s) still in drafts.`))
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Interactive drafts management
+// ---------------------------------------------------------------------------
+
+async function manageDrafts(repo, repoRoot) {
+  while (true) {
+    const allItems = readDrafts(repoRoot)
+    const repoItems = allItems.filter((item) => item.repo === repo)
+    const flushable = new Set(['pending', 'draft'])
+    const pending = repoItems.filter((item) => flushable.has(item.status))
+    const failed = repoItems.filter((item) => item.status === 'failed')
+    const duplicates = repoItems.filter((item) => item.status === 'duplicate')
+    const aborted = repoItems.filter((item) => item.status === 'aborted')
+    const otherRepoCount = allItems.length - repoItems.length
+
+    console.log()
+    if (repoItems.length === 0 && otherRepoCount === 0) {
+      console.log(dim('  No drafts.'))
+      return
+    } else if (repoItems.length === 0) {
+      console.log(dim(`  No items for ${repo}.`))
+      if (otherRepoCount > 0) console.log(dim(`  ${otherRepoCount} in other repos`))
+    } else {
+      if (pending.length > 0) console.log(dim(`  ${pending.length} pending for ${repo}`))
+      if (failed.length > 0) console.log(dim(`  ${failed.length} failed for ${repo}`))
+      if (duplicates.length > 0) console.log(dim(`  ${duplicates.length} duplicate for ${repo}`))
+      if (aborted.length > 0) console.log(dim(`  ${aborted.length} aborted for ${repo}`))
+      if (otherRepoCount > 0) console.log(dim(`  ${otherRepoCount} in other repos`))
+    }
+
+    const choices = []
+    if (pending.length > 0) choices.push({ name: `Publish ${pending.length} pending`, value: 'publish' })
+    if (repoItems.length > 0) choices.push({ name: 'View items', value: 'view' })
+    if (failed.length > 0) choices.push({ name: `Retry ${failed.length} failed`, value: 'retry' })
+    if (repoItems.length > 0) choices.push({ name: 'Delete all', value: 'delete-all' })
+    choices.push({ name: 'Done', value: 'done' })
+
+    const action = await promptOrBack(() => select({ message: 'Drafts', choices, theme }))
+    if (action === Symbol.for('back') || action === 'done') return
+
+    if (action === 'publish') {
+      const config = loadConfig(repoRoot)
+      const agent = config.attribution?.defaultAgent ?? 'human'
+      await publishItems(repo, repoRoot, config, agent)
+      continue
+    }
+
+    if (action === 'retry') {
+      const config = loadConfig(repoRoot)
+      const agent = config.attribution?.defaultAgent ?? 'human'
+      console.log(bold(`\nRetrying ${failed.length} failed item(s)...\n`))
+      for (const item of failed) {
+        const safetyResult = checkSafety(repo, agent, config.safety)
+        if (!safetyResult.allowed) {
+          console.log(dim('  ⏸ Rate limit — try again later.'))
+          break
+        }
+        const spinner = ora(`Creating: "${item.title}"`).start()
+        try {
+          const issue = createIssue(repo, { title: item.title, body: item.body, labels: item.labels ?? [] })
+          spinner.succeed(`Created: ${issue.url}`)
+          markComplete(item.id, { issueNumber: issue.number, issueUrl: issue.url }, repoRoot)
+          recordSuccess(repo, agent)
+        } catch (err) {
+          spinner.fail(`Failed again: ${err.message}`)
+          markFailed(item.id, err.message, repoRoot)
+        }
+      }
+      continue
+    }
+
+    if (action === 'view') {
+      const viewChoices = repoItems.map((item) => {
+        const statusMap = { failed: 'FAIL', duplicate: 'DUP ', aborted: dim('ABRT'), draft: 'DRFT' }
+        const status = statusMap[item.status] ?? 'PEND'
+        return {
+          name: `${status} ${item.title.slice(0, 40).padEnd(40)} ${dim(timeAgo(item.createdAt))}`,
+          value: item.id,
+        }
+      })
+      viewChoices.push({ name: dim('Back'), value: 'back' })
+
+      const itemId = await promptOrBack(() => select({ message: 'Draft items', choices: viewChoices, theme }))
+      if (itemId === Symbol.for('back') || itemId === 'back') continue
+
+      const item = repoItems.find((i) => i.id === itemId)
+      if (item) {
+        console.log(`\n  ${bold(item.title)}`)
+        console.log(`  Status: ${item.status}  Created: ${item.createdAt}`)
+        if (item.error) console.log(`  Error: ${item.error}`)
+        if (item.labels?.length) console.log(`  Labels: ${item.labels.join(', ')}`)
+        console.log(dim('  ─'.repeat(20)))
+        console.log(dim(item.body?.slice(0, 300)))
+        if (item.body?.length > 300) console.log(dim('...'))
+
+        const itemAction = await promptOrBack(() =>
+          select({
+            message: 'Action',
+            choices: [
+              { name: 'Delete this item', value: 'delete' },
+              { name: dim('Back'), value: 'back' },
+            ],
+            theme,
+          }),
+        )
+        if (itemAction === 'delete') {
+          markComplete(item.id, {}, repoRoot)
+          console.log(dim(`  Removed "${item.title}"`))
+        }
+      }
+      continue
+    }
+
+    if (action === 'delete-all') {
+      const ok = await promptOrBack(() =>
+        confirm({ message: `Delete all ${repoItems.length} drafts for ${repo}?`, default: false, theme }),
+      )
+      if (ok === true) {
+        for (const item of repoItems) markComplete(item.id, {}, repoRoot)
+        console.log(dim(`  Deleted ${repoItems.length} items`))
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export const draftsCommand = new Command('drafts')
+  .description('Manage issue drafts (view, publish, retry, delete)')
+  .option('--repo <repo>', 'Repository override (owner/name)')
+  .action(async (opts) => {
+    let repo = opts.repo || store.get('activeRepo')
+    if (!repo) {
+      console.error(red('No active repo. Set one with: tissues config'))
+      process.exit(1)
+    }
+
+    const repoRoot = findRepoRoot()
+    await manageDrafts(repo, repoRoot)
+  })
+
+// publish subcommand of drafts
+draftsCommand.addCommand(
+  new Command('publish')
+    .description('Publish pending drafts as GitHub issues')
+    .option('--repo <repo>', 'Repository override')
+    .option('--agent <name>', 'Agent identifier (default: human)')
+    .action(async (opts) => {
+      let repo = opts.repo || store.get('activeRepo')
+      if (!repo) {
+        console.error(red('No active repo. Set one with: tissues config'))
+        process.exit(1)
+      }
+      const repoRoot = findRepoRoot()
+      const config = loadConfig(repoRoot)
+      const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
+      await publishItems(repo, repoRoot, config, agent)
+    }),
+)

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

package/src/commands/list.js

@@ -1,9 +1,10 @@
 import { Command } from 'commander'
 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 chalk from 'chalk'
+import { yellow, dim, cyan } from '../lib/color.js'
 import ora from 'ora'
 import { execSync } from 'child_process'
 
@@ -19,7 +20,7 @@ export const listCommand = new Command('list')
     }
 
     if (!repo) {
-      console.log(chalk.yellow('No active repo. Pick one:\n'))
+      console.log(yellow('No active repo. Pick one:\n'))
       repo = await pickRepo()
       console.log()
     }
@@ -29,12 +30,12 @@ export const listCommand = new Command('list')
     spinner.stop()
 
     if (issues.length === 0) {
-      console.log(chalk.dim('No open issues.'))
+      console.log(dim('No open issues.'))
       return
     }
 
     const selected = await search({
-      message: `Open issues in ${chalk.cyan(repo)}`,
+      message: `Open issues in ${cyan(repo)}`,
       source: (input) => {
         const term = (input || '').toLowerCase()
         return issues
@@ -48,12 +49,13 @@ export const listCommand = new Command('list')
             value: i.url,
           }))
       },
+      theme,
     })
 
     // Open in browser
     try {
       execSync(`open "${selected}"`)
     } catch {
-      console.log(`\nOpen: ${chalk.cyan(selected)}`)
+      console.log(`\nOpen: ${cyan(selected)}`)
     }
   })