tissues 0.5.1 → 0.6.0

package/src/lib/ai/pipeline.js

@@ -0,0 +1,79 @@
+/**
+ * Pipeline runner for multi-step AI issue enhancement.
+ *
+ * Executes steps sequentially, accumulating state in a shared PipelineContext.
+ * Failed steps log a warning and continue (graceful degradation).
+ */
+
+/**
+ * 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} [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
+  const cb = callbacks || {}
+  const { checkBudgets, recordUsage } = budgetHelpers || {}
+
+  let budgetExhausted = false
+
+  for (const step of steps) {
+    // If budget was exhausted, skip all remaining steps except format (which degrades gracefully)
+    if (budgetExhausted && step.name !== 'format') {
+      cb.onStepSkip?.(step, 'budget exhausted')
+      continue
+    }
+
+    // Check shouldRun
+    const stepConfig = ctx._stepConfigs?.[step.name] || 'auto'
+    if (stepConfig === 'never') {
+      cb.onStepSkip?.(step, 'disabled')
+      continue
+    }
+    if (stepConfig === 'auto' && !step.shouldRun(ctx)) {
+      cb.onStepSkip?.(step, 'auto-skipped')
+      continue
+    }
+
+    cb.onStepStart?.(step)
+
+    try {
+      // Check budget before the call (skip for format when budget already exhausted — it degrades gracefully)
+      if (checkBudgets && budgets && !budgetExhausted) {
+        try {
+          checkBudgets(budgets, step.maxTokens)
+        } catch {
+          budgetExhausted = true
+          cb.onStepFail?.(step, new Error('Token budget exceeded'))
+          continue
+        }
+      }
+
+      // Build messages and call the adapter
+      const messages = step.buildMessages(ctx)
+      const raw = await adapter.complete(messages, { model, maxTokens: step.maxTokens })
+
+      // Record approximate usage
+      if (recordUsage) {
+        const approxTokens = Math.ceil(raw.length / 4)
+        recordUsage(approxTokens)
+      }
+
+      // Parse response and update context
+      step.parseResponse(raw, ctx)
+
+      cb.onStepDone?.(step, ctx)
+    } catch (err) {
+      cb.onStepFail?.(step, err)
+      // Non-fatal — continue to next step
+    }
+  }
+
+  return ctx
+}

package/src/lib/ai/prompt.js

@@ -0,0 +1,39 @@
+/**
+ * Build messages array for AI enhancement of an issue body.
+ *
+ * @param {string} title - issue title
+ * @param {string} description - actual issue content (what the issue is about)
+ * @param {string} templateBody - already-rendered template body
+ * @param {string} [instructions] - optional AI prompt guidance (not issue content)
+ * @returns {Array<{ role: 'system'|'user', content: string }>}
+ */
+export function buildMessages(title, description, templateBody, instructions) {
+  const systemContent = [
+    'You are an expert at writing clear, well-structured GitHub issues.',
+    'Given an issue title, description, and a rendered template, improve the issue body.',
+    'Fill in template sections with relevant detail inferred from the title and description.',
+    'Keep the markdown structure intact. Be concise and actionable.',
+    'Return ONLY the improved issue body markdown — no preamble, no explanation, no code fences.',
+  ]
+  if (instructions) {
+    systemContent.push('', 'Additional instructions from the user:', instructions)
+  }
+
+  const userContent = [
+    `Title: ${title}`,
+    '',
+    description ? `Description: ${description}` : '',
+    '',
+    'Template body to improve:',
+    '```',
+    templateBody,
+    '```',
+  ]
+    .filter((line) => line !== undefined)
+    .join('\n')
+
+  return [
+    { role: 'system', content: systemContent.join('\n') },
+    { role: 'user', content: userContent },
+  ]
+}

package/src/lib/ai/router.js

@@ -0,0 +1,128 @@
+import { AnthropicAdapter } from './adapters/anthropic.js'
+import { OpenAIAdapter } from './adapters/openai.js'
+import { GeminiAdapter } from './adapters/gemini.js'
+import { OllamaAdapter } from './adapters/ollama.js'
+import { OpenAICompatAdapter } from './adapters/openai-compat.js'
+import { CommandAdapter } from './adapters/command.js'
+
+const ADAPTER_MAP = {
+  anthropic: AnthropicAdapter,
+  openai: OpenAIAdapter,
+  gemini: GeminiAdapter,
+  ollama: OllamaAdapter,
+  'openai-compat': OpenAICompatAdapter,
+  command: CommandAdapter,
+}
+
+/**
+ * Resolve which adapter + model to use for a given issue context.
+ *
+ * Resolution order:
+ *   1. Explicit provider/model from context (CLI flags)
+ *   2. Routing rules from config (first match wins)
+ *   3. Default provider + model from config
+ *
+ * @param {object} config - merged config object
+ * @param {{ template?: string, labels?: string[], provider?: string, model?: string }} context
+ * @returns {{ adapter: import('./adapters/base.js').BaseAdapter, model: string }}
+ */
+export function resolveRoute(config, context = {}) {
+  const ai = config.ai || {}
+
+  let provider = context.provider || null
+  let model = context.model || null
+
+  // 2. Check routing rules (only if no explicit override)
+  if (!provider && Array.isArray(ai.routes)) {
+    for (const rule of ai.routes) {
+      if (matchesRule(rule.match, context)) {
+        provider = rule.provider || provider
+        model = rule.model || model
+        break
+      }
+    }
+  }
+
+  // 3. Fall back to defaults
+  if (!provider) provider = ai.provider || 'anthropic'
+  if (!model) model = ai.model || ai.models?.[provider] || null
+
+  const AdapterClass = ADAPTER_MAP[provider]
+  if (!AdapterClass) throw new Error(`Unknown AI provider: ${provider}`)
+
+  // Build adapter config based on provider type
+  const adapterConfig = buildAdapterConfig(ai, provider)
+  const adapter = new AdapterClass(adapterConfig)
+
+  return { adapter, model }
+}
+
+// Env var names for API key fallback (checked when config key is not set)
+const KEY_ENV_VARS = {
+  anthropic: 'TISSUES_ANTHROPIC_KEY',
+  openai: 'TISSUES_OPENAI_KEY',
+  gemini: 'TISSUES_GEMINI_KEY',
+  'openai-compat': 'TISSUES_OPENAI_COMPAT_KEY',
+}
+
+/**
+ * Resolve API key: config value first, then env var fallback.
+ */
+function resolveApiKey(ai, provider) {
+  const configKey = provider === 'openai-compat'
+    ? ai.keys?.['openai-compat']
+    : ai.keys?.[provider]
+  if (configKey) return configKey
+
+  const envVar = KEY_ENV_VARS[provider]
+  return envVar ? process.env[envVar] || null : null
+}
+
+/**
+ * Build the config object for a specific adapter.
+ */
+function buildAdapterConfig(ai, provider) {
+  switch (provider) {
+    case 'ollama':
+      return { baseUrl: ai.ollama?.url }
+    case 'openai-compat':
+      return { baseUrl: ai.custom?.url, apiKey: resolveApiKey(ai, 'openai-compat') }
+    case 'command':
+      return { command: ai.command || null }
+    default:
+      return { apiKey: resolveApiKey(ai, provider) }
+  }
+}
+
+/**
+ * Check if a rule's match criteria apply to the given context.
+ *
+ * @param {object} match - e.g. { template: 'bug' } or { labels: ['P0-critical'] }
+ * @param {object} context
+ * @returns {boolean}
+ */
+function matchesRule(match, context) {
+  if (!match) return false
+
+  if (match.template && context.template) {
+    if (match.template !== context.template) return false
+  } else if (match.template) {
+    return false
+  }
+
+  if (match.labels && Array.isArray(match.labels)) {
+    const contextLabels = context.labels || []
+    const hasAny = match.labels.some((l) => contextLabels.includes(l))
+    if (!hasAny) return false
+  }
+
+  return true
+}
+
+/**
+ * List available provider names.
+ * @returns {string[]}
+ */
+export function listProviders() {
+  return Object.keys(ADAPTER_MAP)
+}