tissues 0.5.2 → 0.6.1

package/src/lib/ai/router.js

@@ -0,0 +1,216 @@
+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,
+}
+
+/**
+ * Merge custom providers from both old (`ai.commands`) and new (`ai.providers`) keys,
+ * and migrate the legacy singleton `ai.command` into the registry.
+ *
+ * `ai.providers` wins on conflict with `ai.commands`.
+ *
+ * @param {object} ai - the `config.ai` object
+ * @returns {object} merged custom providers map
+ */
+export function migrateProviderConfig(ai) {
+  const merged = {}
+
+  // Legacy: ai.commands (old key)
+  if (ai.commands && typeof ai.commands === 'object') {
+    Object.assign(merged, ai.commands)
+  }
+
+  // Canonical: ai.providers (new key, wins on conflict)
+  if (ai.providers && typeof ai.providers === 'object') {
+    Object.assign(merged, ai.providers)
+  }
+
+  // Note: ai.command (legacy singleton) is NOT merged here — the built-in
+  // "command" provider already reads it via buildAdapterConfig.
+
+  return merged
+}
+
+/**
+ * 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, enhancements?: string[] }} context
+ * @returns {{ adapter: import('./adapters/base.js').BaseAdapter, model: string, enhancements?: string[] }}
+ */
+export function resolveRoute(config, context = {}) {
+  const ai = config.ai || {}
+
+  let provider = context.provider || null
+  let model = context.model || null
+  let enhancements = 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
+        if (rule.enhancements) enhancements = rule.enhancements
+        break
+      }
+    }
+  }
+
+  // 3. Fall back to defaults
+  if (!provider) provider = ai.provider || 'anthropic'
+  if (!model) model = ai.model || ai.models?.[provider] || null
+
+  let AdapterClass = ADAPTER_MAP[provider]
+  let adapterConfig
+
+  if (!AdapterClass) {
+    // Check custom providers registry (merged from ai.commands + ai.providers)
+    const customProviders = migrateProviderConfig(ai)
+    const cmdEntry = customProviders[provider]
+    if (!cmdEntry) throw new Error(`Unknown AI provider: ${provider}`)
+    AdapterClass = CommandAdapter
+    adapterConfig = { command: cmdEntry.command || null, timeout: cmdEntry.timeout || undefined }
+  } else {
+    // Build adapter config based on provider type
+    adapterConfig = buildAdapterConfig(ai, provider)
+  }
+
+  const adapter = new AdapterClass(adapterConfig)
+
+  const result = { adapter, model }
+  if (enhancements) result.enhancements = enhancements
+  return result
+}
+
+/**
+ * Resolve an adapter + model for a specific provider name.
+ *
+ * Checks ADAPTER_MAP first, then the merged custom providers registry.
+ * Used by the pipeline for per-step provider overrides.
+ *
+ * @param {object} config - merged config object
+ * @param {string} providerName - provider to resolve
+ * @param {string} [modelOverride] - optional model override
+ * @returns {{ adapter: import('./adapters/base.js').BaseAdapter, model: string }}
+ */
+export function resolveProviderAdapter(config, providerName, modelOverride) {
+  const ai = config.ai || {}
+
+  let AdapterClass = ADAPTER_MAP[providerName]
+  let adapterConfig
+
+  if (!AdapterClass) {
+    const customProviders = migrateProviderConfig(ai)
+    const cmdEntry = customProviders[providerName]
+    if (!cmdEntry) throw new Error(`Unknown AI provider: ${providerName}`)
+    AdapterClass = CommandAdapter
+    adapterConfig = { command: cmdEntry.command || null, timeout: cmdEntry.timeout || undefined }
+  } else {
+    adapterConfig = buildAdapterConfig(ai, providerName)
+  }
+
+  const adapter = new AdapterClass(adapterConfig)
+  const model = modelOverride || ai.model || ai.models?.[providerName] || null
+
+  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 built-in provider names.
+ * @returns {string[]}
+ */
+export function listProviders() {
+  return Object.keys(ADAPTER_MAP)
+}
+
+/**
+ * List all available provider names: built-in + custom providers from config.
+ * @param {object} config - merged config object
+ * @returns {string[]}
+ */
+export function listAllProviders(config) {
+  const builtIn = Object.keys(ADAPTER_MAP)
+  const ai = config?.ai || {}
+  const customProviders = migrateProviderConfig(ai)
+  const custom = Object.keys(customProviders)
+  return [...builtIn, ...custom.filter((k) => !builtIn.includes(k))]
+}

package/src/lib/ai/steps.js

@@ -0,0 +1,492 @@
+/**
+ * Pipeline step definitions for multi-step AI issue enhancement.
+ *
+ * Each step is a plain object with:
+ *   - name:          unique identifier
+ *   - displayName:   human-readable label for progress display
+ *   - maxTokens:     token budget for this step's LLM call
+ *   - shouldRun:     (ctx, stepConfig) => boolean — whether to run in 'auto' mode
+ *   - buildMessages: (ctx) => [{ role, content }] — prompt for the LLM
+ *   - parseResponse: (raw, ctx) => void — parse LLM output and mutate ctx
+ */
+
+import { buildBodyGuidance } from './body-template.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function tryParseJSON(raw) {
+  let cleaned = raw.trim()
+  // Strip markdown fences if present
+  if (cleaned.startsWith('```')) {
+    cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '')
+  }
+  return JSON.parse(cleaned)
+}
+
+function contextSummary(ctx) {
+  const parts = [`Title: ${ctx.title}`]
+  if (ctx.description) parts.push(`Description: ${ctx.description}`)
+  if (ctx.instructions) parts.push(`User instructions: ${ctx.instructions}`)
+  if (ctx.templateBody) parts.push(`Template:\n${ctx.templateBody}`)
+  if (ctx.labels?.length) parts.push(`Labels: ${ctx.labels.join(', ')}`)
+  return parts.join('\n\n')
+}
+
+function priorStepsSummary(ctx) {
+  const parts = []
+  if (ctx.dedupScore != null) {
+    parts.push(`Dedup confidence: ${ctx.dedupScore.confidence}/100 (${ctx.dedupScore.level})`)
+  }
+  if (ctx.structuredContext) {
+    parts.push(`Context: ${JSON.stringify(ctx.structuredContext)}`)
+  }
+  if (ctx.scopeAnalysis) {
+    parts.push(`Scope: ${JSON.stringify(ctx.scopeAnalysis)}`)
+  }
+  if (ctx.complexity != null) {
+    parts.push(`Complexity: ${ctx.complexity}/10 — ${ctx.complexityRationale || ''}`)
+  }
+  if (ctx.risk != null) {
+    parts.push(`Risk: ${ctx.risk}/10 — ${ctx.riskRationale || ''}`)
+  }
+  if (ctx.aiLabels?.length) {
+    parts.push(`AI labels: ${ctx.aiLabels.join(', ')}`)
+  }
+  return parts.length > 0 ? '\n\nPrior analysis:\n' + parts.join('\n') : ''
+}
+
+// ---------------------------------------------------------------------------
+// Step: triage — extract title + description from freeform input
+// ---------------------------------------------------------------------------
+
+const triageStep = {
+  name: 'triage',
+  displayName: 'Input analyzed',
+  maxTokens: 1024,
+
+  shouldRun(ctx) {
+    return !!(ctx.rawInput && ctx.rawInput.length > 0)
+  },
+
+  buildMessages(ctx) {
+    return [
+      {
+        role: 'system',
+        content: [
+          'You extract a structured GitHub issue title and description from freeform user input.',
+          'Return a JSON object with:',
+          '  title: string — concise issue title, ≤80 characters, imperative mood (e.g. "Fix login timeout on Safari")',
+          '  description: string — structured description expanding on the input, in markdown',
+          'The title must capture the core intent. The description should organize and expand the raw input into clear context.',
+          'Return ONLY valid JSON.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: ctx.rawInput,
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    try {
+      const parsed = tryParseJSON(raw)
+      if (parsed.title && typeof parsed.title === 'string') {
+        ctx.title = parsed.title.slice(0, 80)
+      }
+      if (parsed.description && typeof parsed.description === 'string') {
+        ctx.description = parsed.description
+      }
+    } catch {
+      // Parse failure — keep splitInput() values as fallback
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Step: dedup
+// ---------------------------------------------------------------------------
+
+const dedupStep = {
+  name: 'dedup',
+  displayName: 'Duplicate check',
+  maxTokens: 1024,
+
+  shouldRun() {
+    // Disabled: deterministic dedup (Jaccard) runs before the pipeline.
+    // The AI step hallucinated connections between unrelated issues (#56).
+    // Keep the code for future opt-in via config.
+    return false
+  },
+
+  buildMessages(ctx) {
+    const existing = (ctx.existingIssues || [])
+      .slice(0, 20)
+      .map((i) => `#${i.number}: ${i.title}`)
+      .join('\n')
+
+    return [
+      {
+        role: 'system',
+        content: [
+          'You are a duplicate detection system for GitHub issues.',
+          'Compare the new issue against existing open issues.',
+          'Return a JSON object with:',
+          '  confidence: number 0-100 (how likely this is a duplicate)',
+          '  level: "high" | "medium" | "low" | "none"',
+          '  matches: array of { number, reason } for similar issues',
+          'Return ONLY valid JSON.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: `New issue:\nTitle: ${ctx.title}\nDescription: ${ctx.description || 'none'}\n\nExisting open issues:\n${existing}`,
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    try {
+      const parsed = tryParseJSON(raw)
+      ctx.dedupScore = {
+        confidence: Math.min(100, Math.max(0, Number(parsed.confidence) || 0)),
+        level: ['high', 'medium', 'low', 'none'].includes(parsed.level) ? parsed.level : 'none',
+        matches: Array.isArray(parsed.matches) ? parsed.matches : [],
+      }
+    } catch {
+      ctx.dedupScore = null
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Step: context
+// ---------------------------------------------------------------------------
+
+const contextStep = {
+  name: 'context',
+  displayName: 'Context gathered',
+  maxTokens: 1024,
+
+  shouldRun() {
+    return true
+  },
+
+  buildMessages(ctx) {
+    return [
+      {
+        role: 'system',
+        content: [
+          'You are an expert at understanding software issues.',
+          'Extract structured context from the issue description.',
+          'Return a JSON object with:',
+          '  problem: string — the core problem in one sentence',
+          '  files: string[] — file paths mentioned or implied',
+          '  errors: string[] — error messages mentioned',
+          '  sessionContext: string — any relevant session/environment context',
+          'Return ONLY valid JSON.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: contextSummary(ctx),
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    try {
+      const parsed = tryParseJSON(raw)
+      ctx.structuredContext = {
+        problem: parsed.problem || '',
+        files: Array.isArray(parsed.files) ? parsed.files : [],
+        errors: Array.isArray(parsed.errors) ? parsed.errors : [],
+        sessionContext: parsed.sessionContext || '',
+      }
+    } catch {
+      ctx.structuredContext = null
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Step: scope
+// ---------------------------------------------------------------------------
+
+const scopeStep = {
+  name: 'scope',
+  displayName: 'Scope analyzed',
+  maxTokens: 1024,
+
+  shouldRun(ctx) {
+    // Only run if description mentions code/files or context step found files
+    const desc = (ctx.description || '').toLowerCase()
+    const hasCodeMentions = /\.(js|ts|py|go|rs|rb|java|css|html|json|yml|yaml|md)\b/.test(desc) ||
+      /\b(file|module|component|function|class|import|require)\b/.test(desc)
+    const hasContextFiles = ctx.structuredContext?.files?.length > 0
+    return hasCodeMentions || hasContextFiles
+  },
+
+  buildMessages(ctx) {
+    return [
+      {
+        role: 'system',
+        content: [
+          'You are a software scope analyzer.',
+          'Given an issue description and context, identify the files and areas affected.',
+          'Return a JSON object with:',
+          '  files: array of { path: string, purpose: string, deps: string[] }',
+          '  affectedAreas: string[] — high-level areas (e.g. "auth", "UI", "database")',
+          'Return ONLY valid JSON.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: contextSummary(ctx) + priorStepsSummary(ctx),
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    try {
+      const parsed = tryParseJSON(raw)
+      ctx.scopeAnalysis = {
+        files: Array.isArray(parsed.files) ? parsed.files : [],
+        affectedAreas: Array.isArray(parsed.affectedAreas) ? parsed.affectedAreas : [],
+      }
+    } catch {
+      ctx.scopeAnalysis = null
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Step: complexity
+// ---------------------------------------------------------------------------
+
+const complexityStep = {
+  name: 'complexity',
+  displayName: 'Complexity scored',
+  maxTokens: 512,
+
+  shouldRun(ctx) {
+    // Run if we have scope analysis or a non-trivial description
+    return ctx.scopeAnalysis != null || (ctx.description || '').length > 50
+  },
+
+  buildMessages(ctx) {
+    return [
+      {
+        role: 'system',
+        content: [
+          'You assess implementation complexity for GitHub issues.',
+          'Return a JSON object with:',
+          '  score: number 1-10 (1=trivial, 10=massive refactor)',
+          '  rationale: string — one sentence explaining the score',
+          'Return ONLY valid JSON.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: contextSummary(ctx) + priorStepsSummary(ctx),
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    try {
+      const parsed = tryParseJSON(raw)
+      ctx.complexity = Math.min(10, Math.max(1, Number(parsed.score) || 5))
+      ctx.complexityRationale = parsed.rationale || ''
+    } catch {
+      ctx.complexity = null
+      ctx.complexityRationale = null
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Step: risk
+// ---------------------------------------------------------------------------
+
+const riskStep = {
+  name: 'risk',
+  displayName: 'Risk assessed',
+  maxTokens: 512,
+
+  shouldRun(ctx) {
+    return ctx.scopeAnalysis != null || (ctx.description || '').length > 50
+  },
+
+  buildMessages(ctx) {
+    return [
+      {
+        role: 'system',
+        content: [
+          'You assess implementation risk for GitHub issues.',
+          'Consider: breaking changes, data loss potential, security implications, blast radius.',
+          'Return a JSON object with:',
+          '  score: number 1-10 (1=no risk, 10=extremely risky)',
+          '  rationale: string — one sentence explaining the score',
+          'Return ONLY valid JSON.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: contextSummary(ctx) + priorStepsSummary(ctx),
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    try {
+      const parsed = tryParseJSON(raw)
+      ctx.risk = Math.min(10, Math.max(1, Number(parsed.score) || 3))
+      ctx.riskRationale = parsed.rationale || ''
+    } catch {
+      ctx.risk = null
+      ctx.riskRationale = null
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Step: labels
+// ---------------------------------------------------------------------------
+
+const labelsStep = {
+  name: 'labels',
+  displayName: 'Labels suggested',
+  maxTokens: 512,
+
+  shouldRun(ctx) {
+    // Run if there are repo labels to choose from
+    return ctx.repoLabels?.length > 0
+  },
+
+  buildMessages(ctx) {
+    const available = (ctx.repoLabels || []).join(', ')
+    return [
+      {
+        role: 'system',
+        content: [
+          'You suggest GitHub labels for issues.',
+          `Available labels in this repo: ${available}`,
+          'Return a JSON object with:',
+          '  labels: string[] — labels to apply (must be from the available list)',
+          '  reasoning: string — brief explanation',
+          'Only suggest labels that genuinely fit. Return ONLY valid JSON.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: contextSummary(ctx) + priorStepsSummary(ctx),
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    try {
+      const parsed = tryParseJSON(raw)
+      const suggested = Array.isArray(parsed.labels) ? parsed.labels : []
+      // Filter to only labels that actually exist in the repo
+      const valid = ctx.repoLabels || []
+      ctx.aiLabels = suggested.filter((l) => valid.includes(l))
+    } catch {
+      ctx.aiLabels = null
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Step: format
+// ---------------------------------------------------------------------------
+
+const formatStep = {
+  name: 'format',
+  displayName: 'Body formatted',
+  maxTokens: 4096,
+
+  shouldRun() {
+    return true
+  },
+
+  buildMessages(ctx) {
+    const guidance = buildBodyGuidance(ctx)
+    return [
+      {
+        role: 'system',
+        content: [
+          'You are an expert at writing clear, well-structured GitHub issues.',
+          'Given an issue title, description, and analysis from prior steps,',
+          'write a complete issue body in markdown.',
+          '',
+          guidance,
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: contextSummary(ctx) + priorStepsSummary(ctx),
+      },
+    ]
+  },
+
+  parseResponse(raw, ctx) {
+    // The format step returns raw markdown, not JSON
+    // Strip wrapping code fences (```markdown ... ```) that LLMs often add
+    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.body = cleaned
+    }
+    // If empty, ctx.body stays as whatever it was (template fallback)
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+/**
+ * All pipeline steps in execution order.
+ */
+export const ALL_STEPS = [
+  triageStep,
+  dedupStep,
+  contextStep,
+  scopeStep,
+  complexityStep,
+  riskStep,
+  labelsStep,
+  formatStep,
+]
+
+/**
+ * Map of built-in step name → step object.
+ * Used by the enhancement adapter to bridge built-in logic with custom prompts.
+ */
+export const BUILT_IN_STEPS_MAP = {
+  triage: triageStep,
+  dedup: dedupStep,
+  context: contextStep,
+  scope: scopeStep,
+  complexity: complexityStep,
+  risk: riskStep,
+  labels: labelsStep,
+  format: formatStep,
+}
+
+/**
+ * Get a step by name.
+ * @param {string} name
+ * @returns {object|undefined}
+ */
+export function getStep(name) {
+  return ALL_STEPS.find((s) => s.name === name)
+}
+
+// Re-export helpers for use by the enhancement adapter
+export { tryParseJSON, contextSummary, priorStepsSummary }