tissues 0.6.0 → 0.6.2

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/enhancement-adapter.test.js

@@ -0,0 +1,188 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import { enhancementToStep } from './enhancement-adapter.js'
+import { BUILT_IN_ENHANCEMENTS } from '../enhancements.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function baseCtx(overrides = {}) {
+  return {
+    rawInput: '',
+    title: 'Fix auth bug',
+    description: 'The login page throws a 401 error',
+    instructions: '',
+    templateBody: '## Summary\n\n{{description}}',
+    labels: ['bug'],
+    existingIssues: [],
+    repoLabels: ['bug', 'feature', 'P0-critical'],
+    dedupScore: null,
+    structuredContext: null,
+    scopeAnalysis: null,
+    complexity: null,
+    complexityRationale: null,
+    risk: null,
+    riskRationale: null,
+    aiLabels: null,
+    body: '',
+    ...overrides,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Built-in enhancement → step conversion
+// ---------------------------------------------------------------------------
+
+describe('enhancementToStep — built-in enhancements', () => {
+  test('converts built-in triage to step with correct fields', () => {
+    const step = enhancementToStep(BUILT_IN_ENHANCEMENTS.triage)
+    assert.equal(step.name, 'triage')
+    assert.equal(step.displayName, 'Input Analysis')
+    assert.equal(step.maxTokens, 1024)
+    assert.ok(typeof step.shouldRun === 'function')
+    assert.ok(typeof step.buildMessages === 'function')
+    assert.ok(typeof step.parseResponse === 'function')
+  })
+
+  test('built-in step uses original shouldRun', () => {
+    const step = enhancementToStep(BUILT_IN_ENHANCEMENTS.triage)
+    assert.equal(step.shouldRun(baseCtx({ rawInput: 'hello' })), true)
+    assert.equal(step.shouldRun(baseCtx({ rawInput: '' })), false)
+  })
+
+  test('built-in step uses original buildMessages', () => {
+    const step = enhancementToStep(BUILT_IN_ENHANCEMENTS.context)
+    const ctx = baseCtx()
+    const msgs = step.buildMessages(ctx)
+    assert.ok(Array.isArray(msgs))
+    assert.equal(msgs[0].role, 'system')
+    assert.equal(msgs[1].role, 'user')
+  })
+
+  test('built-in step uses original parseResponse', () => {
+    const step = enhancementToStep(BUILT_IN_ENHANCEMENTS.complexity)
+    const ctx = baseCtx()
+    step.parseResponse(JSON.stringify({ score: 7, rationale: 'complex' }), ctx)
+    assert.equal(ctx.complexity, 7)
+    assert.equal(ctx.complexityRationale, 'complex')
+  })
+
+  test('all built-in enhancements convert to valid steps', () => {
+    for (const [key, enh] of Object.entries(BUILT_IN_ENHANCEMENTS)) {
+      const step = enhancementToStep(enh)
+      assert.equal(step.name, key)
+      assert.ok(step.displayName)
+      assert.ok(typeof step.maxTokens === 'number')
+      assert.ok(typeof step.shouldRun === 'function')
+      assert.ok(typeof step.buildMessages === 'function')
+      assert.ok(typeof step.parseResponse === 'function')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Prompt override
+// ---------------------------------------------------------------------------
+
+describe('enhancementToStep — prompt override', () => {
+  test('user-overridden built-in uses custom prompt', () => {
+    const overridden = {
+      ...BUILT_IN_ENHANCEMENTS.context,
+      source: 'user',
+      prompt: 'Custom context prompt here.',
+    }
+    const step = enhancementToStep(overridden)
+    const msgs = step.buildMessages(baseCtx())
+    // Should use the custom prompt, not the built-in
+    assert.ok(msgs[0].content.includes('Custom context prompt here.'))
+  })
+
+  test('built-in source uses original buildMessages', () => {
+    const builtIn = { ...BUILT_IN_ENHANCEMENTS.context, source: 'built-in' }
+    const step = enhancementToStep(builtIn)
+    const msgs = step.buildMessages(baseCtx())
+    // Should use built-in prompt (includes "Extract structured context")
+    assert.ok(msgs[0].content.includes('Extract structured context'))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Custom enhancement → step conversion
+// ---------------------------------------------------------------------------
+
+describe('enhancementToStep — custom enhancements', () => {
+  const customEnh = {
+    key: 'security',
+    name: 'Security Review',
+    maxTokens: 1024,
+    mode: 'auto',
+    format: 'json',
+    contextKey: 'securityScore',
+    order: 55,
+    requires: ['scopeAnalysis'],
+    isStructural: false,
+    prompt: 'You are a security reviewer.\nReturn JSON.',
+    source: 'user',
+  }
+
+  test('converts custom to step with correct fields', () => {
+    const step = enhancementToStep(customEnh)
+    assert.equal(step.name, 'security')
+    assert.equal(step.displayName, 'Security Review')
+    assert.equal(step.maxTokens, 1024)
+  })
+
+  test('custom shouldRun checks requires array', () => {
+    const step = enhancementToStep(customEnh)
+    // Should not run when scopeAnalysis is missing
+    assert.equal(step.shouldRun(baseCtx({ scopeAnalysis: null })), false)
+    // Should run when scopeAnalysis is present
+    assert.equal(step.shouldRun(baseCtx({ scopeAnalysis: { files: [] } })), true)
+  })
+
+  test('custom shouldRun returns true when no requires', () => {
+    const noReqs = { ...customEnh, requires: [] }
+    const step = enhancementToStep(noReqs)
+    assert.equal(step.shouldRun(baseCtx()), true)
+  })
+
+  test('custom buildMessages uses prompt and context', () => {
+    const step = enhancementToStep(customEnh)
+    const msgs = step.buildMessages(baseCtx())
+    assert.equal(msgs[0].role, 'system')
+    assert.ok(msgs[0].content.includes('You are a security reviewer.'))
+    assert.equal(msgs[1].role, 'user')
+    assert.ok(msgs[1].content.includes('Fix auth bug'))
+  })
+
+  test('custom JSON parseResponse stores at contextKey', () => {
+    const step = enhancementToStep(customEnh)
+    const ctx = baseCtx()
+    step.parseResponse(JSON.stringify({ score: 8, rationale: 'risky' }), ctx)
+    assert.deepEqual(ctx.securityScore, { score: 8, rationale: 'risky' })
+  })
+
+  test('custom JSON parseResponse handles malformed JSON', () => {
+    const step = enhancementToStep(customEnh)
+    const ctx = baseCtx()
+    step.parseResponse('not json', ctx)
+    assert.equal(ctx.securityScore, null)
+  })
+
+  test('custom markdown parseResponse stores raw text', () => {
+    const mdEnh = { ...customEnh, format: 'markdown', contextKey: 'review' }
+    const step = enhancementToStep(mdEnh)
+    const ctx = baseCtx()
+    step.parseResponse('## Review\n\nLooks good.', ctx)
+    assert.equal(ctx.review, '## Review\n\nLooks good.')
+  })
+
+  test('custom markdown parseResponse strips code fences', () => {
+    const mdEnh = { ...customEnh, format: 'markdown', contextKey: 'review' }
+    const step = enhancementToStep(mdEnh)
+    const ctx = baseCtx()
+    step.parseResponse('```markdown\n## Review\n\nContent here.\n```', ctx)
+    assert.equal(ctx.review, '## Review\n\nContent here.')
+  })
+})

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) {

package/src/lib/ai/pipeline.test.js

@@ -0,0 +1,257 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import { runPipeline } from './pipeline.js'
+
+// ---------------------------------------------------------------------------
+// Mock adapter
+// ---------------------------------------------------------------------------
+
+function mockAdapter(responses = {}) {
+  return {
+    name: 'mock',
+    complete(messages, opts) {
+      const lastUser = messages.find((m) => m.role === 'user')?.content || ''
+      // Return pre-configured response or a default
+      for (const [key, val] of Object.entries(responses)) {
+        if (lastUser.includes(key) || opts._stepName === key) return Promise.resolve(val)
+      }
+      return Promise.resolve('{}')
+    },
+  }
+}
+
+function makeStep(name, { shouldRun = true, response = '{}', parseResult = {}, failOnParse = false, provider = null } = {}) {
+  return {
+    name,
+    displayName: name,
+    maxTokens: 512,
+    provider,
+    shouldRun: () => shouldRun,
+    buildMessages: (ctx) => [
+      { role: 'system', content: 'test' },
+      { role: 'user', content: `step:${name} title:${ctx.title}` },
+    ],
+    parseResponse: (raw, ctx) => {
+      if (failOnParse) throw new Error('parse failed')
+      Object.assign(ctx, parseResult)
+    },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('runPipeline', () => {
+  test('steps execute in order, context accumulates', async () => {
+    const order = []
+    const steps = [
+      makeStep('a', { parseResult: { aResult: 'from-a' } }),
+      makeStep('b', { parseResult: { bResult: 'from-b' } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always', b: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test-model' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepStart(step) { order.push(`start:${step.name}`) },
+      onStepDone(step) { order.push(`done:${step.name}`) },
+    })
+
+    assert.deepEqual(order, ['start:a', 'done:a', 'start:b', 'done:b'])
+    assert.equal(ctx.aResult, 'from-a')
+    assert.equal(ctx.bResult, 'from-b')
+  })
+
+  test('shouldRun: false skips steps correctly', async () => {
+    const skipped = []
+    const steps = [
+      makeStep('a', { shouldRun: false }),
+      makeStep('b', { parseResult: { bDone: true } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'auto', b: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepSkip(step, reason) { skipped.push({ name: step.name, reason }) },
+    })
+
+    assert.equal(skipped.length, 1)
+    assert.equal(skipped[0].name, 'a')
+    assert.equal(ctx.bDone, true)
+    assert.equal(ctx.aResult, undefined)
+  })
+
+  test('step config "never" skips regardless of shouldRun', async () => {
+    const skipped = []
+    const steps = [makeStep('a', { shouldRun: true, parseResult: { aResult: true } })]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'never' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepSkip(step) { skipped.push(step.name) },
+    })
+
+    assert.equal(skipped.length, 1)
+    assert.equal(ctx.aResult, undefined)
+  })
+
+  test('failed step does not block subsequent steps', async () => {
+    const failed = []
+    const done = []
+    const steps = [
+      makeStep('a'),
+      makeStep('b', { parseResult: { bDone: true } }),
+    ]
+
+    // 'a' will fail because the adapter throws, 'b' uses a working adapter
+    // Actually both use the same adapter. Let's make a smarter adapter.
+    let callCount = 0
+    const smartAdapter = {
+      complete() {
+        callCount++
+        if (callCount === 1) return Promise.reject(new Error('API error'))
+        return Promise.resolve('{}')
+      },
+    }
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always', b: 'always' } }
+    const route = { adapter: smartAdapter, model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepFail(step) { failed.push(step.name) },
+      onStepDone(step) { done.push(step.name) },
+    })
+
+    assert.deepEqual(failed, ['a'])
+    assert.deepEqual(done, ['b'])
+  })
+
+  test('budget exceeded mid-pipeline skips remaining non-format steps', async () => {
+    const failed = []
+    const done = []
+    const skipped = []
+
+    const steps = [
+      makeStep('context', { parseResult: { contextDone: true } }),
+      makeStep('scope', { parseResult: { scopeDone: true } }),
+      makeStep('risk', { parseResult: { riskDone: true } }),
+      { ...makeStep('format', { parseResult: { body: 'formatted' } }), name: 'format' },
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { context: 'always', scope: 'always', risk: 'always', format: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    // Budget check fails after first step
+    let budgetCalls = 0
+    const budgetHelpers = {
+      checkBudgets() {
+        budgetCalls++
+        if (budgetCalls > 1) throw new Error('budget exceeded')
+      },
+      recordUsage() {},
+    }
+
+    await runPipeline(steps, ctx, route, null, {}, {
+      onStepDone(step) { done.push(step.name) },
+      onStepSkip(step, reason) { skipped.push(step.name) },
+      onStepFail(step) { failed.push(step.name) },
+    }, budgetHelpers)
+
+    // context runs successfully
+    assert.ok(done.includes('context'))
+    // scope fails on budget check
+    assert.ok(failed.includes('scope'))
+    // risk is skipped because budgetExhausted is true and it's not format
+    assert.ok(skipped.includes('risk'))
+    // format still runs (allowed even when budget exhausted)
+    assert.ok(done.includes('format'))
+  })
+
+  test('callbacks fire with correct arguments', async () => {
+    const events = []
+    const steps = [
+      makeStep('a', { parseResult: { x: 1 } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepStart(step) { events.push({ type: 'start', step: step.name }) },
+      onStepDone(step, resultCtx) { events.push({ type: 'done', step: step.name, hasCtx: !!resultCtx }) },
+    })
+
+    assert.equal(events.length, 2)
+    assert.equal(events[0].type, 'start')
+    assert.equal(events[0].step, 'a')
+    assert.equal(events[1].type, 'done')
+    assert.equal(events[1].hasCtx, true)
+  })
+
+  test('step with provider override uses different adapter', async () => {
+    const adapterNames = []
+
+    // Override adapter that records its name
+    const overrideAdapter = {
+      name: 'override',
+      complete() { return Promise.resolve('{}') },
+      isConfigured() { return true },
+    }
+
+    const steps = [
+      makeStep('a', { parseResult: { aDone: true }, provider: 'my-cli' }),
+      makeStep('b', { parseResult: { bDone: true } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always', b: 'always' } }
+    const defaultAdapter = mockAdapter()
+    const route = { adapter: defaultAdapter, model: 'test-model' }
+
+    // Config with a custom provider that resolveProviderAdapter will find
+    const config = {
+      ai: {
+        providers: {
+          'my-cli': { command: 'echo test' },
+        },
+      },
+    }
+
+    const done = []
+    await runPipeline(steps, ctx, route, config, null, {
+      onStepDone(step) { done.push(step.name) },
+    })
+
+    // Both steps should complete (step a uses the override provider, step b uses default)
+    assert.deepEqual(done, ['a', 'b'])
+    assert.equal(ctx.aDone, true)
+    assert.equal(ctx.bDone, true)
+  })
+
+  test('step with invalid provider falls back to default route', async () => {
+    const failed = []
+    const done = []
+
+    const steps = [
+      makeStep('a', { parseResult: { aDone: true }, provider: 'nonexistent-provider' }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+    const config = { ai: {} }
+
+    await runPipeline(steps, ctx, route, config, null, {
+      onStepFail(step, err) { failed.push({ name: step.name, msg: err.message }) },
+      onStepDone(step) { done.push(step.name) },
+    })
+
+    // Provider override fails — onStepFail called with warning, but step continues with default
+    assert.equal(failed.length, 1)
+    assert.ok(failed[0].msg.includes('nonexistent-provider'))
+    // Step still runs with default adapter
+    assert.deepEqual(done, ['a'])
+    assert.equal(ctx.aDone, true)
+  })
+})

package/src/lib/ai/prompt.test.js

@@ -0,0 +1,30 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { buildMessages } from './prompt.js'
+
+describe('buildMessages', () => {
+  it('builds system and user messages', () => {
+    const msgs = buildMessages('Fix login', 'Login is broken', '## Bug\n\nLogin is broken')
+    assert.equal(msgs.length, 2)
+    assert.equal(msgs[0].role, 'system')
+    assert.equal(msgs[1].role, 'user')
+    assert.ok(msgs[1].content.includes('Fix login'))
+    assert.ok(msgs[1].content.includes('Login is broken'))
+  })
+
+  it('includes instructions in system message', () => {
+    const msgs = buildMessages('Fix it', 'desc', 'body', 'keep it short')
+    assert.ok(msgs[0].content.includes('keep it short'))
+  })
+
+  it('omits instructions when not provided', () => {
+    const msgs = buildMessages('Fix it', 'desc', 'body')
+    assert.ok(!msgs[0].content.includes('Additional instructions'))
+  })
+
+  it('handles empty description', () => {
+    const msgs = buildMessages('Title', '', '## Template')
+    assert.equal(msgs.length, 2)
+    assert.ok(msgs[1].content.includes('Title'))
+  })
+})