tissues 0.6.0 → 0.6.1

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/lib/ai/adapters/command.js

@@ -16,27 +16,35 @@ export class CommandAdapter extends BaseAdapter {
     const command = this.config.command
     if (!command) throw new Error('Command not configured (ai.command)')
 
-    const timeoutMs = opts.maxTokens
-      ? Math.max(DEFAULT_TIMEOUT_MS, opts.maxTokens * 15) // rough heuristic
-      : DEFAULT_TIMEOUT_MS
+    const timeoutMs = this.config.timeout
+      || (opts.maxTokens
+        ? Math.max(DEFAULT_TIMEOUT_MS, opts.maxTokens * 15) // rough heuristic
+        : DEFAULT_TIMEOUT_MS)
 
-    const payload = JSON.stringify({
+    // Extract the last user message as the prompt text
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user')
+    const promptText = lastUserMsg?.content || ''
+
+    // Check if command uses {prompt} placeholder (arg mode) or JSON stdin
+    const usesPlaceholder = command.includes('{prompt}')
+
+    const resolvedCommand = usesPlaceholder
+      ? command.replace(/\{prompt\}/g, promptText)
+      : command
+
+    const payload = usesPlaceholder ? null : JSON.stringify({
       messages: messages.map((m) => ({ role: m.role, content: m.content })),
       model: opts.model || null,
       maxTokens: opts.maxTokens || 4096,
     })
 
     return new Promise((resolve, reject) => {
-      // Split command string into executable + args
-      const parts = command.split(/\s+/)
-      const exe = parts[0]
-      const args = parts.slice(1)
-
-      const isWindows = process.platform === 'win32'
-      const child = execFile(exe, args, {
+      // Always use shell to support quoted args, pipes, builtins, etc.
+      const shell = process.platform === 'win32' ? true : '/bin/sh'
+      const child = execFile('sh', ['-c', resolvedCommand], {
         timeout: timeoutMs,
         maxBuffer: 10 * 1024 * 1024, // 10 MB
-        shell: isWindows,
+        shell: false, // we're already wrapping in sh -c
       }, (err, stdout, stderr) => {
         if (err) {
           const msg = stderr?.trim() || err.message
@@ -51,7 +59,9 @@ export class CommandAdapter extends BaseAdapter {
         resolve(text)
       })
 
-      child.stdin.write(payload)
+      if (payload) {
+        child.stdin.write(payload)
+      }
       child.stdin.end()
     })
   }

package/src/lib/ai/body-template.js

@@ -38,6 +38,21 @@ export function buildBodyGuidance(ctx) {
     }
   }
 
+  // Include sections for custom enhancement results not covered above
+  const knownKeys = new Set([
+    'structuredContext', 'scopeAnalysis', 'complexity', 'complexityRationale',
+    'risk', 'riskRationale', 'aiLabels', 'dedupScore', 'body',
+    'rawInput', 'title', 'description', 'instructions', 'templateBody',
+    'labels', 'existingIssues', 'repoLabels', '_stepConfigs', 'triage',
+  ])
+  for (const [key, value] of Object.entries(ctx)) {
+    if (!knownKeys.has(key) && value != null && !key.startsWith('_')) {
+      // Custom enhancement produced a result — add a section hint
+      const heading = key.charAt(0).toUpperCase() + key.slice(1).replace(/([A-Z])/g, ' $1')
+      lines.push(`## ${heading}`)
+    }
+  }
+
   lines.push(
     '',
     'Rules:',

package/src/lib/ai/enhance.js

@@ -9,14 +9,16 @@ import { resolveRoute } from './router.js'
 import { runPipeline } from './pipeline.js'
 import { ALL_STEPS } from './steps.js'
 import { checkBudgets, recordUsage } from './index.js'
+import { loadAllEnhancements } from '../enhancements.js'
+import { enhancementToStep } from './enhancement-adapter.js'
 
 /**
  * Run the full enhancement pipeline.
  *
  * @param {object} config - merged config
- * @param {object} input - { title, description, instructions, templateBody, labels, existingIssues, repoLabels }
+ * @param {object} input - { title, description, instructions, templateBody, labels, existingIssues, repoLabels, rawInput }
  * @param {object} [callbacks] - pipeline callbacks for progress display
- * @param {{ provider?: string, model?: string, template?: string }} [routeContext] - routing context
+ * @param {{ provider?: string, model?: string, template?: string, enhancements?: string[] }} [routeContext] - routing context
  * @returns {Promise<object>} PipelineContext with all accumulated results
  */
 export async function runEnhancePipeline(config, input, callbacks, routeContext = {}) {
@@ -27,11 +29,49 @@ export async function runEnhancePipeline(config, input, callbacks, routeContext
   // Resolve adapter + model
   const route = resolveRoute(config, routeContext)
 
-  // Build step configs from pipeline.steps config
-  const stepConfigs = {}
-  const cfgSteps = pipelineConfig.steps || {}
-  for (const step of ALL_STEPS) {
-    stepConfigs[step.name] = cfgSteps[step.name] || 'auto'
+  // Load all enhancements (three-tier: repo > user > built-in)
+  let enhancements
+  try {
+    enhancements = loadAllEnhancements(input._repoRoot)
+  } catch {
+    enhancements = null
+  }
+
+  let activeSteps
+  let stepConfigs = {}
+
+  if (enhancements && enhancements.length > 0) {
+    // Enhancement-based resolution
+    const enhancementNames = routeContext.enhancements || route.enhancements || null
+
+    // Build step configs from config (supports both old `steps` and new `enhancements` key)
+    const cfgEnhancements = pipelineConfig.enhancements || pipelineConfig.steps || {}
+
+    // Filter enhancements if specific names requested
+    let filtered = enhancements
+    if (enhancementNames && enhancementNames.length > 0) {
+      const requested = new Set(enhancementNames)
+      // Always include structural enhancements (triage, format)
+      filtered = enhancements.filter(
+        (enh) => enh.isStructural || requested.has(enh.key),
+      )
+    }
+
+    // Build step configs and convert to step objects
+    for (const enh of filtered) {
+      stepConfigs[enh.key] = cfgEnhancements[enh.key] || enh.mode || 'auto'
+    }
+
+    activeSteps = filtered
+      .filter((enh) => stepConfigs[enh.key] !== 'never')
+      .map((enh) => enhancementToStep(enh))
+  } else {
+    // Fallback: use hardcoded ALL_STEPS (backward compat)
+    const cfgSteps = pipelineConfig.steps || {}
+    for (const step of ALL_STEPS) {
+      stepConfigs[step.name] = cfgSteps[step.name] || 'auto'
+    }
+    activeSteps = ALL_STEPS.filter((s) => stepConfigs[s.name] !== 'never')
   }
 
   // Build the initial PipelineContext
@@ -61,10 +101,7 @@ export async function runEnhancePipeline(config, input, callbacks, routeContext
     body: input.templateBody || '', // fallback to template
   }
 
-  // Filter steps to only those not set to 'never'
-  const activeSteps = ALL_STEPS.filter((s) => stepConfigs[s.name] !== 'never')
-
-  await runPipeline(activeSteps, ctx, route, budgets, callbacks, { checkBudgets, recordUsage })
+  await runPipeline(activeSteps, ctx, route, config, budgets, callbacks, { checkBudgets, recordUsage })
 
   return ctx
 }

package/src/lib/ai/enhancement-adapter.js

@@ -0,0 +1,109 @@
+/**
+ * Bridge between enhancement descriptors and pipeline step objects.
+ *
+ * Converts enhancement descriptors (from enhancements.js) into step objects
+ * that pipeline.js can execute. Built-in steps retain their specialized
+ * shouldRun/parseResponse logic; custom steps get generic implementations.
+ */
+
+import { BUILT_IN_STEPS_MAP, tryParseJSON, contextSummary, priorStepsSummary } from './steps.js'
+import { buildBodyGuidance } from './body-template.js'
+
+/**
+ * Convert an enhancement descriptor into a pipeline step object.
+ *
+ * @param {object} enhancement - descriptor from enhancements.js
+ * @returns {object} step object compatible with pipeline.js
+ */
+export function enhancementToStep(enhancement) {
+  const builtInStep = BUILT_IN_STEPS_MAP[enhancement.key]
+
+  // If this is a built-in enhancement, use the built-in step's specialized
+  // shouldRun and parseResponse, but allow the prompt to be overridden
+  if (builtInStep) {
+    const promptOverridden = enhancement.source && enhancement.source !== 'built-in'
+
+    return {
+      name: enhancement.key,
+      displayName: enhancement.name,
+      maxTokens: enhancement.maxTokens,
+      provider: enhancement.provider || null,
+
+      shouldRun: builtInStep.shouldRun,
+      parseResponse: builtInStep.parseResponse,
+
+      buildMessages(ctx) {
+        if (promptOverridden && enhancement.prompt) {
+          // Use the user/repo-overridden prompt with the standard user message
+          return buildCustomMessages(enhancement, ctx)
+        }
+        return builtInStep.buildMessages(ctx)
+      },
+    }
+  }
+
+  // Custom enhancement — generic implementation
+  return {
+    name: enhancement.key,
+    displayName: enhancement.name,
+    maxTokens: enhancement.maxTokens,
+    provider: enhancement.provider || null,
+
+    shouldRun(ctx) {
+      // Check requires — all required context keys must be present
+      if (enhancement.requires?.length > 0) {
+        return enhancement.requires.every((key) => ctx[key] != null)
+      }
+      return true
+    },
+
+    buildMessages(ctx) {
+      return buildCustomMessages(enhancement, ctx)
+    },
+
+    parseResponse(raw, ctx) {
+      if (enhancement.format === 'json') {
+        try {
+          const parsed = tryParseJSON(raw)
+          ctx[enhancement.contextKey] = parsed
+        } catch {
+          ctx[enhancement.contextKey] = null
+        }
+      } else {
+        // markdown — store raw text
+        let cleaned = raw.trim()
+        const fenceMatch = cleaned.match(/^```(?:markdown|md)?\n([\s\S]*)\n```$/)
+        if (fenceMatch) cleaned = fenceMatch[1].trim()
+        if (cleaned.length > 0) {
+          ctx[enhancement.contextKey] = cleaned
+        }
+      }
+    },
+  }
+}
+
+/**
+ * Build messages for a custom or prompt-overridden enhancement.
+ */
+function buildCustomMessages(enhancement, ctx) {
+  let systemContent = enhancement.prompt
+
+  // For the format step, append body guidance
+  if (enhancement.key === 'format') {
+    const guidance = buildBodyGuidance(ctx)
+    systemContent = systemContent + '\n\n' + guidance
+  }
+
+  // For the labels step, inject available labels
+  if (enhancement.key === 'labels' && ctx.repoLabels?.length) {
+    systemContent = systemContent.replace(
+      /Return ONLY valid JSON\.$/m,
+      `Available labels in this repo: ${ctx.repoLabels.join(', ')}\nReturn ONLY valid JSON.`,
+    )
+  }
+
+  return [
+    { role: 'system', content: systemContent },
+    { role: 'user', content: contextSummary(ctx) + priorStepsSummary(ctx) },
+  ]
+}

package/src/lib/ai/index.js

@@ -1,7 +1,7 @@
-import { resolveRoute, listProviders } from './router.js'
+import { resolveRoute, resolveProviderAdapter, listProviders, listAllProviders } from './router.js'
 import { buildMessages } from './prompt.js'
 
-export { listProviders }
+export { listProviders, listAllProviders, resolveProviderAdapter }
 
 // ---------------------------------------------------------------------------
 // Token usage tracking (in-memory, resets on process exit)

package/src/lib/ai/pipeline.js

@@ -5,19 +5,22 @@
  * Failed steps log a warning and continue (graceful degradation).
  */
 
+import { resolveProviderAdapter } from './router.js'
+
 /**
  * Run a sequence of pipeline steps.
  *
  * @param {object[]} steps - array of step objects (from steps.js)
  * @param {object} ctx - mutable PipelineContext, accumulates results
  * @param {{ adapter: object, model: string }} route - resolved adapter + model
+ * @param {object} [config] - merged config object (enables per-step provider overrides)
  * @param {object} [budgets] - token budget config
  * @param {object} [callbacks] - { onStepStart, onStepDone, onStepSkip, onStepFail }
  * @param {{ checkBudgets: Function, recordUsage: Function }} [budgetHelpers]
  * @returns {Promise<object>} the final ctx
  */
-export async function runPipeline(steps, ctx, route, budgets, callbacks, budgetHelpers) {
-  const { adapter, model } = route
+export async function runPipeline(steps, ctx, route, config, budgets, callbacks, budgetHelpers) {
+  const { adapter: defaultAdapter, model: defaultModel } = route
   const cb = callbacks || {}
   const { checkBudgets, recordUsage } = budgetHelpers || {}
 
@@ -43,6 +46,21 @@ export async function runPipeline(steps, ctx, route, budgets, callbacks, budgetH
 
     cb.onStepStart?.(step)
 
+    // Resolve per-step adapter override
+    let adapter = defaultAdapter
+    let model = defaultModel
+    if (step.provider && config) {
+      try {
+        const override = resolveProviderAdapter(config, step.provider)
+        adapter = override.adapter
+        model = override.model
+      } catch (err) {
+        // Unknown/unconfigured provider — warn and fall back to default
+        cb.onStepFail?.(step, new Error(`Provider override "${step.provider}" failed: ${err.message}, using default`))
+        // Continue with default adapter (don't skip — aligns with "never lose data" principle)
+      }
+    }
+
     try {
       // Check budget before the call (skip for format when budget already exhausted — it degrades gracefully)
       if (checkBudgets && budgets && !budgetExhausted) {