tissues 0.6.0 → 0.6.2

package/src/commands/config.js

@@ -9,7 +9,7 @@ import { theme } from '../lib/theme.js'
 import { listTemplates } from '../lib/templates.js'
 import { pickRepo } from '../lib/repo-picker.js'
 import { store } from '../lib/config.js'
-import { listProviders } from '../lib/ai/index.js'
+import { listProviders, listAllProviders } from '../lib/ai/index.js'
 import { listModels as listOllamaModels } from '../lib/ai/adapters/ollama.js'
 
 // ---------------------------------------------------------------------------
@@ -68,6 +68,8 @@ function coerceValue(dotKey, raw) {
     throw new Error(`Expected true/false for ${dotKey}, got: ${raw}`)
   }
   if (raw === 'null') return null
+  // Auto-coerce pure numeric strings when no default type is known
+  if (defaultVal === undefined && /^\d+$/.test(raw)) return Number(raw)
   return raw
 }
 
@@ -135,11 +137,16 @@ const PROVIDER_LABELS = {
 async function menuActiveProvider() {
   const cfg = loadConfig()
   const current = readUserConfig()
-  const providers = listProviders()
+  const allProviders = listAllProviders(cfg)
+  const builtIn = listProviders()
 
   const defaultProvider = BUILT_IN_DEFAULTS.ai.provider
   const choices = [
-    ...providers.map((p) => ({ name: PROVIDER_LABELS[p] || p, value: p })),
+    ...allProviders.map((p) => {
+      const isCustom = !builtIn.includes(p)
+      const label = isCustom ? `${p} ${dim('(custom)')}` : (PROVIDER_LABELS[p] || p)
+      return { name: label, value: p }
+    }),
     { name: 'None (disable AI)', value: 'none' },
     { name: dim(`Restore default (${defaultProvider})`), value: 'restore' },
     { name: dim('Back'), value: 'back' },
@@ -166,6 +173,13 @@ async function menuActiveProvider() {
     updated = await configureOpenAICompat(updated)
   } else if (provider === 'command') {
     updated = await configureCommand(updated)
+  } else if (!builtIn.includes(provider)) {
+    // Named CLI command — just set as default provider
+    updated = setNestedValue(updated, 'ai.enabled', true)
+    updated = setNestedValue(updated, 'ai.provider', provider)
+    writeUserConfig(updated)
+    const cmd = cfg.ai?.providers?.[provider]?.command || cfg.ai?.commands?.[provider]?.command || '(not set)'
+    console.log(green(`  ✔ Default provider: ${provider} ${dim(`→ ${cmd}`)}`))
   } else {
     updated = setNestedValue(updated, 'ai.enabled', true)
     updated = setNestedValue(updated, 'ai.provider', provider)
@@ -518,7 +532,8 @@ function formatRoute(rule) {
   const match = Object.entries(rule.match || {})
     .map(([k, v]) => `${k}=${Array.isArray(v) ? v.join(',') : v}`)
     .join(', ')
-  return `${match} ${dim('->')} ${rule.provider || 'default'}${rule.model ? dim(` (${rule.model})`) : ''}`
+  const enhTag = rule.enhancements?.length ? dim(` [${rule.enhancements.join(',')}]`) : ''
+  return `${match} ${dim('->')} ${rule.provider || 'default'}${rule.model ? dim(` (${rule.model})`) : ''}${enhTag}`
 }
 
 async function editRoute(rule) {
@@ -571,8 +586,10 @@ async function editRoute(rule) {
   }
 
   // Provider
-  const providerChoices = providers.map((p) => ({
-    name: p.charAt(0).toUpperCase() + p.slice(1),
+  const allProviders = listAllProviders(cfg)
+  const builtInSet = new Set(listProviders())
+  const providerChoices = allProviders.map((p) => ({
+    name: builtInSet.has(p) ? (p.charAt(0).toUpperCase() + p.slice(1)) : `${p} ${dim('(custom)')}`,
     value: p,
   }))
   const provider = await promptOrBack(() =>
@@ -591,7 +608,21 @@ async function editRoute(rule) {
   )
   if (model === Symbol.for('back')) return null
 
-  return { match, provider, model: model || undefined }
+  // Enhancements filter (optional)
+  const enhRaw = await promptOrBack(() =>
+    input({
+      message: 'Enhancements (comma-separated, enter to skip)',
+      default: rule?.enhancements?.join(', ') || '',
+      theme,
+    }),
+  )
+  if (enhRaw === Symbol.for('back')) return null
+
+  const enhancements = enhRaw
+    ? enhRaw.split(',').map((s) => s.trim()).filter(Boolean)
+    : undefined
+
+  return { match, provider, model: model || undefined, enhancements: enhancements?.length ? enhancements : undefined }
 }
 
 async function menuRoutingRules() {
@@ -660,87 +691,130 @@ async function menuRoutingRules() {
 }
 
 // ---------------------------------------------------------------------------
-// Submenu: Enhancement pipeline
+// Submenu: Custom Providers (named command providers)
 // ---------------------------------------------------------------------------
 
-const STEP_NAMES = ['triage', 'dedup', 'context', 'scope', 'complexity', 'risk', 'labels', 'format']
-const STEP_LABELS = {
-  triage: 'Input analysis',
-  dedup: 'Duplicate check',
-  context: 'Context extraction',
-  scope: 'Scope analysis',
-  complexity: 'Complexity scoring',
-  risk: 'Risk assessment',
-  labels: 'Label suggestion',
-  format: 'Body formatting',
+/** Migrate ai.commands → ai.providers on disk if needed. */
+function migrateProvidersOnDisk(current) {
+  if (!current.ai) return current
+  let updated = current
+  if (current.ai.commands) {
+    const existing = current.ai.providers || {}
+    updated = setNestedValue(updated, 'ai.providers', { ...current.ai.commands, ...existing })
+    const ai = { ...updated.ai }
+    delete ai.commands
+    updated = { ...updated, ai }
+  }
+  return updated
 }
 
-async function menuPipeline() {
-  while (true) {
-    const cfg = loadConfig()
-    const pipeline = cfg.ai?.pipeline || BUILT_IN_DEFAULTS.ai.pipeline
-    const enabled = pipeline.enabled !== false
-
-    const choices = [
-      {
-        name: `${'Pipeline'.padEnd(18)} ${enabled ? green('enabled') : dim('disabled')}`,
-        value: 'toggle',
-      },
-    ]
-
-    if (enabled) {
-      for (const name of STEP_NAMES) {
-        const setting = pipeline.steps?.[name] || 'auto'
-        const color = setting === 'always' ? green : setting === 'never' ? red : dim
-        choices.push({
-          name: `  ${(STEP_LABELS[name] || name).padEnd(22)} ${color(setting)}`,
-          value: name,
-        })
-      }
+async function menuProviders() {
+  // One-time disk migration when user opens the menu
+  {
+    const current = readUserConfig()
+    if (current.ai?.commands) {
+      const migrated = migrateProvidersOnDisk(current)
+      writeUserConfig(migrated)
     }
+  }
 
-    choices.push({ name: dim('Restore defaults'), value: 'restore' })
+  while (true) {
+    const cfg = loadConfig()
+    const providers = cfg.ai?.providers || cfg.ai?.commands || {}
+    const names = Object.keys(providers)
+
+    const choices = names.map((name) => {
+      const entry = providers[name]
+      const cmd = entry.command || dim('(no command)')
+      const timeout = entry.timeout ? dim(` ${entry.timeout}ms`) : ''
+      return { name: `${name.padEnd(18)} ${dim(cmd)}${timeout}`, value: name }
+    })
+    choices.push({ name: green('+ Add provider'), value: 'add' })
     choices.push({ name: dim('Back'), value: 'back' })
 
-    const chosen = await promptOrBack(() => select({ message: 'Enhancement Pipeline', choices, theme }))
+    const chosen = await promptOrBack(() => select({ message: 'Custom Providers', choices, theme }))
     if (chosen === Symbol.for('back') || chosen === 'back') return
 
-    if (chosen === 'toggle') {
-      const current = readUserConfig()
-      const updated = setNestedValue(current, 'ai.pipeline.enabled', !enabled)
-      writeUserConfig(updated)
-      console.log(green(`  ✔ Pipeline ${!enabled ? 'enabled' : 'disabled'}`))
-      continue
-    }
+    if (chosen === 'add') {
+      const name = await promptOrBack(() =>
+        input({ message: 'Provider name (e.g. my-gemini)', theme }),
+      )
+      if (name === Symbol.for('back') || !name) continue
+      const key = name.trim().toLowerCase().replace(/\s+/g, '-')
+      if (!key) continue
+      if (providers[key]) {
+        console.log(yellow(`  "${key}" already exists — select it to edit`))
+        continue
+      }
+      const cmd = await promptOrBack(() =>
+        input({ message: 'Shell command to run', theme }),
+      )
+      if (cmd === Symbol.for('back') || !cmd) continue
+      const timeoutRaw = await promptOrBack(() =>
+        input({ message: 'Timeout ms (enter for default 60s)', default: '', theme }),
+      )
+      if (timeoutRaw === Symbol.for('back')) continue
 
-    if (chosen === 'restore') {
       const current = readUserConfig()
-      const updated = setNestedValue(current, 'ai.pipeline', BUILT_IN_DEFAULTS.ai.pipeline)
+      let updated = setNestedValue(current, `ai.providers.${key}.command`, cmd)
+      if (timeoutRaw) {
+        const ms = Number(timeoutRaw)
+        if (!isNaN(ms) && ms > 0) {
+          updated = setNestedValue(updated, `ai.providers.${key}.timeout`, ms)
+        }
+      }
       writeUserConfig(updated)
-      console.log(green('  ✔ Pipeline settings restored to defaults'))
+      console.log(green(`  ✔ Added: ${key} → ${cmd}`))
       continue
     }
 
-    // Toggle a step setting: always → auto → never → always
-    const stepSetting = await promptOrBack(() =>
+    // Edit/delete existing provider
+    const entry = providers[chosen]
+    const action = await promptOrBack(() =>
       select({
-        message: `${STEP_LABELS[chosen] || chosen}`,
+        message: `${chosen}: ${entry.command || '(no command)'}`,
         choices: [
-          { name: 'always — run every time', value: 'always' },
-          { name: 'auto — run when heuristics suggest it', value: 'auto' },
-          { name: 'never — skip this step', value: 'never' },
+          { name: 'Edit', value: 'edit' },
+          { name: red('Delete'), value: 'delete' },
           { name: dim('Back'), value: 'back' },
         ],
-        default: pipeline.steps?.[chosen] || 'auto',
         theme,
       }),
     )
-    if (stepSetting === Symbol.for('back') || stepSetting === 'back') continue
+    if (action === Symbol.for('back') || action === 'back') continue
 
     const current = readUserConfig()
-    const updated = setNestedValue(current, `ai.pipeline.steps.${chosen}`, stepSetting)
-    writeUserConfig(updated)
-    console.log(green(`  ✔ ${STEP_LABELS[chosen]}: ${stepSetting}`))
+    if (action === 'delete') {
+      const provs = { ...(current.ai?.providers || {}) }
+      delete provs[chosen]
+      const updated = setNestedValue(current, 'ai.providers', provs)
+      writeUserConfig(updated)
+      console.log(green(`  ✔ Deleted: ${chosen}`))
+    } else {
+      const cmd = await promptOrBack(() =>
+        input({ message: 'Shell command', default: entry.command || '', theme }),
+      )
+      if (cmd === Symbol.for('back')) continue
+      const timeoutRaw = await promptOrBack(() =>
+        input({ message: 'Timeout ms (enter for default)', default: entry.timeout ? String(entry.timeout) : '', theme }),
+      )
+      if (timeoutRaw === Symbol.for('back')) continue
+
+      let updated = current
+      if (cmd) updated = setNestedValue(updated, `ai.providers.${chosen}.command`, cmd)
+      if (timeoutRaw) {
+        const ms = Number(timeoutRaw)
+        if (!isNaN(ms) && ms > 0) {
+          updated = setNestedValue(updated, `ai.providers.${chosen}.timeout`, ms)
+        }
+      } else {
+        // Clear timeout if empty
+        const provs = { ...(updated.ai?.providers || {}) }
+        if (provs[chosen]) { delete provs[chosen].timeout; updated = setNestedValue(updated, 'ai.providers', provs) }
+      }
+      writeUserConfig(updated)
+      console.log(green(`  ✔ Updated: ${chosen}`))
+    }
   }
 }
 
@@ -910,7 +984,7 @@ async function runWizard() {
       template: cfg.templates?.default || 'default',
       safety: `${cfg.safety?.maxPerHour || '?'}/hr, burst ${cfg.safety?.burstLimit || '?'}`,
       routes: `${(cfg.ai?.routes || []).length} rule${(cfg.ai?.routes || []).length === 1 ? '' : 's'}`,
-      pipeline: cfg.ai?.pipeline?.enabled !== false ? green('enabled') : dim('disabled'),
+      providers: `${Object.keys(cfg.ai?.providers || cfg.ai?.commands || {}).length} registered`,
       backups: `${getBackupFiles().length} saved`,
     }
 
@@ -921,8 +995,8 @@ async function runWizard() {
       { name: `${'API Keys'.padEnd(18)} ${dim(summaries.keys)}`,            value: 'keys' },
       { name: `${'Token Budgets'.padEnd(18)} ${dim(summaries.budgets)}`,    value: 'budgets' },
       { name: `${'Safety Limits'.padEnd(18)} ${dim(summaries.safety)}`,     value: 'safety' },
-      { name: `${'Routing Rules'.padEnd(18)} ${dim(summaries.routes)}`,     value: 'routes' },
-      { name: `${'AI Pipeline'.padEnd(18)} ${summaries.pipeline}`,          value: 'pipeline' },
+      { name: `${'Routing Rules'.padEnd(18)} ${dim(summaries.routes)}`,       value: 'routes' },
+      { name: `${'Custom Providers'.padEnd(18)} ${dim(summaries.providers)}`,  value: 'providers' },
       { name: `${'Backup & Restore'.padEnd(18)} ${dim(summaries.backups)}`, value: 'backup' },
       { name: dim('Done'),                                                   value: 'done' },
     ]
@@ -944,9 +1018,9 @@ async function runWizard() {
         case 'budgets':  await menuTokenBudgets(); break
         case 'template': await menuDefaultTemplate(); break
         case 'safety':   await menuSafety(); break
-        case 'routes':   await menuRoutingRules(); break
-        case 'pipeline': await menuPipeline(); break
-        case 'backup':   await menuBackupRestore(); break
+        case 'routes':        await menuRoutingRules(); break
+        case 'providers':    await menuProviders(); break
+        case 'backup':       await menuBackupRestore(); break
       }
     } catch (err) {
       if (isCancelled(err)) continue

package/src/commands/create.js

@@ -15,11 +15,11 @@ import {
   createIssue,
   verifyIssue,
   listLabels,
-  listIssues,
   createLabel,
   addLabelsToIssue,
   uploadImageToRepo,
 } from '../lib/gh.js'
+import { ensureFresh } from '../lib/cache.js'
 import { enhance, checkAvailable } from '../lib/ai/index.js'
 import { runEnhancePipeline } from '../lib/ai/enhance.js'
 import { clipboardHasImage, saveClipboardImage } from '../lib/clipboard.js'
@@ -401,11 +401,15 @@ export async function runCreate(opts) {
   let body = renderedTemplate
   let pipelineResult = null
   if (opts.enhance !== false && !opts.dryRun) {
+    const enhancementNames = opts.enhancements
+      ? opts.enhancements.split(',').map((s) => s.trim()).filter(Boolean)
+      : undefined
     const aiContext = {
       template: templateName,
       labels: opts.labels ? opts.labels.split(',').map((l) => l.trim()).filter(Boolean) : [],
       provider: opts.provider,
       model: opts.model,
+      enhancements: enhancementNames,
     }
     if (checkAvailable(config, aiContext)) {
       const pipelineConfig = config.ai?.pipeline || {}
@@ -416,11 +420,11 @@ export async function runCreate(opts) {
         // Multi-step pipeline enhancement
         let aiSpinner = ora('Enhancing with AI pipeline...').start()
         try {
-          // Gather existing issues and repo labels for pipeline context
+          // Gather existing issues and repo labels for pipeline context (from cache)
           let existingIssues = []
           let repoLabels = []
-          try { existingIssues = listIssues(repo) } catch { /* non-fatal */ }
-          try { repoLabels = listLabels(repo) } catch { /* non-fatal */ }
+          try { existingIssues = ensureFresh(repo, 'issues', { state: 'open', acceptStale: true }) } catch { /* non-fatal */ }
+          try { repoLabels = ensureFresh(repo, 'labels', { acceptStale: true }) } catch { /* non-fatal */ }
 
           // When --title is explicit, skip triage (no rawInput to analyze)
           const rawInput = opts.title ? '' : (opts._rawInput || '')
@@ -435,7 +439,10 @@ export async function runCreate(opts) {
             existingIssues,
             repoLabels,
           }, {
-            onStepStart(step) { aiSpinner.text = `${step.displayName}...` },
+            onStepStart(step) {
+              if (!aiSpinner.isSpinning) aiSpinner = ora().start()
+              aiSpinner.text = `${step.displayName}...`
+            },
             onStepDone(step, ctx) {
               let detail = ''
               if (step.name === 'triage') detail = ctx.title ? `: ${ctx.title}` : ''
@@ -445,13 +452,12 @@ export async function runCreate(opts) {
               if (step.name === 'risk') detail = ctx.risk != null ? `: ${ctx.risk}/10` : ''
               if (step.name === 'labels') detail = ctx.aiLabels?.length ? `: ${ctx.aiLabels.join(', ')}` : ''
               aiSpinner.succeed(`${step.displayName}${detail}`)
-              aiSpinner = ora('').start()
             },
             onStepSkip(step) { /* silent */ },
             onStepFail(step, err) {
+              if (!aiSpinner.isSpinning) aiSpinner = ora().start()
               aiSpinner.warn(`${step.displayName} failed`)
               console.warn(dim(`  ${err.message}`))
-              aiSpinner = ora('').start()
             },
           }, aiContext)
 
@@ -624,11 +630,11 @@ export async function runCreate(opts) {
 
   if (labels.length > 0) {
     try {
-      const repoLabelNames = listLabels(repo)
+      const repoLabelNames = ensureFresh(repo, 'labels', { acceptStale: true })
       existingLabels = labels.filter((l) => repoLabelNames.includes(l))
       missingLabels = labels.filter((l) => !repoLabelNames.includes(l))
     } catch {
-      // If listLabels fails, proceed with all labels (original behavior)
+      // If label check fails, proceed with all labels (original behavior)
     }
   }
 
@@ -760,6 +766,7 @@ export const createCommand = new Command('create')
   .option('--no-enhance', 'Skip AI enhancement, use rendered template as-is')
   .option('--pipeline', 'Force multi-step AI pipeline even if config disabled')
   .option('--no-pipeline', 'Force single-shot AI enhancement even if pipeline enabled')
+  .option('--enhancements <names>', 'Comma-separated enhancement names to run (e.g. "context,risk")')
   .option('--provider <name>', 'AI provider override (anthropic, openai, gemini)')
   .option('--model <name>', 'AI model override')
   .option(