tissues 0.5.2 → 0.6.0

package/src/lib/ai/adapters/anthropic.js

@@ -0,0 +1,52 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MODEL = 'claude-haiku-4-5-20251001'
+const DEFAULT_MAX_TOKENS = 4096
+const API_URL = 'https://api.anthropic.com/v1/messages'
+
+export class AnthropicAdapter extends BaseAdapter {
+  get name() {
+    return 'anthropic'
+  }
+
+  async complete(messages, opts = {}) {
+    const apiKey = this.config.apiKey
+    if (!apiKey) throw new Error('Anthropic API key not configured (ai.keys.anthropic)')
+
+    const model = opts.model || DEFAULT_MODEL
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    // Anthropic Messages API uses a separate `system` param
+    const systemMsg = messages.find((m) => m.role === 'system')
+    const userMessages = messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => ({ role: m.role, content: m.content }))
+
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      messages: userMessages,
+    }
+    if (systemMsg) body.system = systemMsg.content
+
+    const res = await fetch(API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`Anthropic API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const textBlock = data.content?.find((b) => b.type === 'text')
+    if (!textBlock) throw new Error('Anthropic returned no text content')
+    return textBlock.text
+  }
+}

package/src/lib/ai/adapters/base.js

@@ -0,0 +1,45 @@
+/**
+ * Base adapter interface for AI providers.
+ * Each adapter owns its own HTTP calls — callers never touch fetch.
+ */
+export class BaseAdapter {
+  constructor(config) {
+    this.config = config
+  }
+
+  /** @returns {string} provider name (e.g. 'anthropic', 'openai', 'gemini') */
+  get name() {
+    throw new Error('not implemented')
+  }
+
+  /**
+   * Check if this adapter has enough configuration to make requests.
+   * Override in adapters that don't need an API key.
+   * @returns {boolean}
+   */
+  isConfigured() {
+    return !!this.config.apiKey
+  }
+
+  /**
+   * Sanitize API error response body — strip anything that looks like an API key
+   * to prevent accidental leakage in error messages or logs.
+   */
+  sanitizeErrorBody(text, maxLen = 200) {
+    if (!text) return ''
+    // Strip anything that looks like an API key (sk-*, gm-*, key-*, etc.)
+    const cleaned = text.replace(/\b(sk-|gm-|key-|Bearer\s+)[A-Za-z0-9_-]{8,}\b/gi, '[REDACTED]')
+    return cleaned.length > maxLen ? cleaned.slice(0, maxLen) + '...' : cleaned
+  }
+
+  /**
+   * Send a completion request.
+   *
+   * @param {Array<{ role: 'user'|'system', content: string }>} messages
+   * @param {{ model?: string, maxTokens?: number }} opts
+   * @returns {Promise<string>} extracted text response
+   */
+  async complete(messages, opts = {}) {
+    throw new Error('not implemented')
+  }
+}

package/src/lib/ai/adapters/command.js

@@ -0,0 +1,58 @@
+import { execFile } from 'node:child_process'
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_TIMEOUT_MS = 60_000
+
+export class CommandAdapter extends BaseAdapter {
+  get name() {
+    return 'command'
+  }
+
+  isConfigured() {
+    return !!this.config.command
+  }
+
+  async complete(messages, opts = {}) {
+    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 payload = 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, {
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024, // 10 MB
+        shell: isWindows,
+      }, (err, stdout, stderr) => {
+        if (err) {
+          const msg = stderr?.trim() || err.message
+          reject(new Error(`Command adapter error: ${msg}`))
+          return
+        }
+        const text = stdout.trim()
+        if (!text) {
+          reject(new Error('Command adapter returned no output'))
+          return
+        }
+        resolve(text)
+      })
+
+      child.stdin.write(payload)
+      child.stdin.end()
+    })
+  }
+}

package/src/lib/ai/adapters/gemini.js

@@ -0,0 +1,56 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MODEL = 'gemini-2.0-flash'
+const DEFAULT_MAX_TOKENS = 4096
+const API_BASE = 'https://generativelanguage.googleapis.com/v1beta/models'
+
+export class GeminiAdapter extends BaseAdapter {
+  get name() {
+    return 'gemini'
+  }
+
+  async complete(messages, opts = {}) {
+    const apiKey = this.config.apiKey
+    if (!apiKey) throw new Error('Gemini API key not configured (ai.keys.gemini)')
+
+    const model = opts.model || DEFAULT_MODEL
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    // Gemini uses systemInstruction + contents
+    const systemMsg = messages.find((m) => m.role === 'system')
+    const userMessages = messages.filter((m) => m.role !== 'system')
+
+    const body = {
+      contents: userMessages.map((m) => ({
+        role: m.role === 'user' ? 'user' : 'model',
+        parts: [{ text: m.content }],
+      })),
+      generationConfig: {
+        maxOutputTokens: maxTokens,
+      },
+    }
+    if (systemMsg) {
+      body.systemInstruction = { parts: [{ text: systemMsg.content }] }
+    }
+
+    const url = `${API_BASE}/${model}:generateContent`
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': apiKey,
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`Gemini API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const text = data.candidates?.[0]?.content?.parts?.[0]?.text
+    if (!text) throw new Error('Gemini returned no text content')
+    return text
+  }
+}

package/src/lib/ai/adapters/ollama.js

@@ -0,0 +1,60 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MODEL = 'llama3.2'
+const DEFAULT_MAX_TOKENS = 4096
+const DEFAULT_BASE_URL = 'http://localhost:11434'
+
+export class OllamaAdapter extends BaseAdapter {
+  get name() {
+    return 'ollama'
+  }
+
+  isConfigured() {
+    return true // no API key needed — server just needs to be running
+  }
+
+  async complete(messages, opts = {}) {
+    const baseUrl = (this.config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')
+    const model = opts.model || DEFAULT_MODEL
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    }
+
+    const url = `${baseUrl}/v1/chat/completions`
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`Ollama API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const content = data.choices?.[0]?.message?.content
+    if (!content) throw new Error('Ollama returned no content')
+    return content
+  }
+}
+
+/**
+ * List models installed on an Ollama server.
+ *
+ * @param {string} [baseUrl] - Ollama server URL (default: http://localhost:11434)
+ * @returns {Promise<string[]>} array of model names
+ */
+export async function listModels(baseUrl) {
+  const url = `${(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')}/api/tags`
+  const res = await fetch(url)
+  if (!res.ok) {
+    throw new Error(`Ollama /api/tags error ${res.status}`)
+  }
+  const data = await res.json()
+  return (data.models || []).map((m) => m.name)
+}

package/src/lib/ai/adapters/openai-compat.js

@@ -0,0 +1,51 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MAX_TOKENS = 4096
+
+export class OpenAICompatAdapter extends BaseAdapter {
+  get name() {
+    return 'openai-compat'
+  }
+
+  isConfigured() {
+    return !!this.config.baseUrl
+  }
+
+  async complete(messages, opts = {}) {
+    const baseUrl = this.config.baseUrl
+    if (!baseUrl) throw new Error('OpenAI-compatible base URL not configured (ai.custom.url)')
+
+    const model = opts.model
+    if (!model) throw new Error('Model must be configured for openai-compat provider (ai.models.openai-compat)')
+
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    }
+
+    const url = `${baseUrl.replace(/\/+$/, '')}/v1/chat/completions`
+    const headers = { 'Content-Type': 'application/json' }
+    if (this.config.apiKey) {
+      headers.Authorization = `Bearer ${this.config.apiKey}`
+    }
+
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`OpenAI-compatible API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const content = data.choices?.[0]?.message?.content
+    if (!content) throw new Error('OpenAI-compatible endpoint returned no content')
+    return content
+  }
+}

package/src/lib/ai/adapters/openai.js

@@ -0,0 +1,44 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MODEL = 'gpt-4o-mini'
+const DEFAULT_MAX_TOKENS = 4096
+const API_URL = 'https://api.openai.com/v1/chat/completions'
+
+export class OpenAIAdapter extends BaseAdapter {
+  get name() {
+    return 'openai'
+  }
+
+  async complete(messages, opts = {}) {
+    const apiKey = this.config.apiKey
+    if (!apiKey) throw new Error('OpenAI API key not configured (ai.keys.openai)')
+
+    const model = opts.model || DEFAULT_MODEL
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    }
+
+    const res = await fetch(API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`OpenAI API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const content = data.choices?.[0]?.message?.content
+    if (!content) throw new Error('OpenAI returned no content')
+    return content
+  }
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Rich body section guidance for the pipeline `format` step.
+ *
+ * Provides the target structure that the LLM should produce when formatting
+ * an issue body. Sections are conditionally included based on what upstream
+ * pipeline steps produced.
+ */
+
+export const RICH_BODY_SECTIONS = [
+  { key: 'summary', heading: 'Summary', always: true },
+  { key: 'context', heading: 'Context', requires: 'structuredContext' },
+  { key: 'problem', heading: 'Problem', always: true },
+  { key: 'files', heading: 'Files Involved', requires: 'scopeAnalysis' },
+  { key: 'solution', heading: 'Proposed Solution', always: true },
+  { key: 'acceptance', heading: 'Acceptance Criteria', always: true },
+  { key: 'complexity', heading: 'Scope & Complexity', requires: 'complexity' },
+]
+
+/**
+ * Build a guidance string for the `format` step's system prompt.
+ *
+ * Only includes section headings for which upstream data exists (or that are
+ * always-on). This prevents the LLM from hallucinating sections it has no
+ * data for.
+ *
+ * @param {object} ctx - PipelineContext accumulated so far
+ * @returns {string} markdown-formatted guidance
+ */
+export function buildBodyGuidance(ctx) {
+  const lines = [
+    'Structure the issue body with these markdown sections:',
+    '',
+  ]
+
+  for (const section of RICH_BODY_SECTIONS) {
+    if (section.always || ctx[section.requires] != null) {
+      lines.push(`## ${section.heading}`)
+    }
+  }
+
+  lines.push(
+    '',
+    'Rules:',
+    '- Use bullet points for lists, not paragraphs.',
+    '- Keep each section concise (2-5 bullet points).',
+    '- If a section has no relevant information, omit it entirely.',
+    '- Return ONLY the markdown body — no preamble, no explanation, no code fences.',
+  )
+
+  if (ctx.complexity != null && ctx.risk != null) {
+    lines.push(
+      '',
+      'In the "Scope & Complexity" section, include:',
+      `- Complexity: ${ctx.complexity}/10 — ${ctx.complexityRationale || ''}`,
+      `- Risk: ${ctx.risk}/10 — ${ctx.riskRationale || ''}`,
+    )
+  }
+
+  return lines.join('\n')
+}

package/src/lib/ai/enhance.js

@@ -0,0 +1,70 @@
+/**
+ * Bridge between the create command and the pipeline runner.
+ *
+ * Sets up the PipelineContext, resolves routing, filters steps by config,
+ * and calls runPipeline.
+ */
+
+import { resolveRoute } from './router.js'
+import { runPipeline } from './pipeline.js'
+import { ALL_STEPS } from './steps.js'
+import { checkBudgets, recordUsage } from './index.js'
+
+/**
+ * Run the full enhancement pipeline.
+ *
+ * @param {object} config - merged config
+ * @param {object} input - { title, description, instructions, templateBody, labels, existingIssues, repoLabels }
+ * @param {object} [callbacks] - pipeline callbacks for progress display
+ * @param {{ provider?: string, model?: string, template?: string }} [routeContext] - routing context
+ * @returns {Promise<object>} PipelineContext with all accumulated results
+ */
+export async function runEnhancePipeline(config, input, callbacks, routeContext = {}) {
+  const ai = config.ai || {}
+  const budgets = ai.budgets || {}
+  const pipelineConfig = ai.pipeline || {}
+
+  // 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'
+  }
+
+  // Build the initial PipelineContext
+  const ctx = {
+    // Input data
+    rawInput: input.rawInput || '',
+    title: input.title,
+    description: input.description || '',
+    instructions: input.instructions || '',
+    templateBody: input.templateBody || '',
+    labels: input.labels || [],
+    existingIssues: input.existingIssues || [],
+    repoLabels: input.repoLabels || [],
+
+    // Step config (internal)
+    _stepConfigs: stepConfigs,
+
+    // Accumulated results — steps populate these
+    dedupScore: null,
+    structuredContext: null,
+    scopeAnalysis: null,
+    complexity: null,
+    complexityRationale: null,
+    risk: null,
+    riskRationale: null,
+    aiLabels: null,
+    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 })
+
+  return ctx
+}

package/src/lib/ai/index.js

@@ -0,0 +1,122 @@
+import { resolveRoute, listProviders } from './router.js'
+import { buildMessages } from './prompt.js'
+
+export { listProviders }
+
+// ---------------------------------------------------------------------------
+// Token usage tracking (in-memory, resets on process exit)
+// ---------------------------------------------------------------------------
+
+const tokenLog = []
+
+export function recordUsage(tokens) {
+  tokenLog.push({ tokens, timestamp: Date.now() })
+}
+
+function getUsage(windowMs) {
+  const cutoff = Date.now() - windowMs
+  return tokenLog
+    .filter((e) => e.timestamp >= cutoff)
+    .reduce((sum, e) => sum + e.tokens, 0)
+}
+
+/**
+ * Check token budgets before making a request.
+ * Throws if a budget would be exceeded.
+ */
+export function checkBudgets(budgets, requestTokens) {
+  if (!budgets) return
+
+  if (budgets.maxTokensPerRequest && requestTokens > budgets.maxTokensPerRequest) {
+    throw new Error(
+      `Token budget: request (${requestTokens}) exceeds per-request limit (${budgets.maxTokensPerRequest})`,
+    )
+  }
+
+  if (budgets.maxTokensPerHour) {
+    const hourlyUsed = getUsage(60 * 60 * 1000)
+    if (hourlyUsed + requestTokens > budgets.maxTokensPerHour) {
+      throw new Error(
+        `Token budget: hourly usage (${hourlyUsed} + ${requestTokens}) would exceed limit (${budgets.maxTokensPerHour})`,
+      )
+    }
+  }
+
+  if (budgets.maxTokensPerDay) {
+    const dailyUsed = getUsage(24 * 60 * 60 * 1000)
+    if (dailyUsed + requestTokens > budgets.maxTokensPerDay) {
+      throw new Error(
+        `Token budget: daily usage (${dailyUsed} + ${requestTokens}) would exceed limit (${budgets.maxTokensPerDay})`,
+      )
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if AI enhancement is available (enabled + key configured).
+ *
+ * @param {object} config - merged config
+ * @param {{ provider?: string }} [context]
+ * @returns {boolean}
+ */
+export function checkAvailable(config, context = {}) {
+  const ai = config.ai || {}
+  if (!ai.enabled) return false
+  try {
+    const { adapter } = resolveRoute(config, context)
+    return adapter.isConfigured()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Enhance an issue body using AI.
+ *
+ * @param {object} config - merged config
+ * @param {string} title - issue title
+ * @param {string} description - actual issue content
+ * @param {string} templateBody - already-rendered template
+ * @param {string} [instructions] - optional AI guidance
+ * @param {{ template?: string, labels?: string[], provider?: string, model?: string }} [context] - routing context
+ * @returns {Promise<string>} enhanced body
+ */
+export async function enhance(config, title, description, templateBody, instructions, context = {}) {
+  const ai = config.ai || {}
+  const budgets = ai.budgets || {}
+  const { adapter, model } = resolveRoute(config, context)
+  const messages = buildMessages(title, description, templateBody, instructions)
+
+  // Enforce per-request cap: clamp maxTokens to budget
+  const requestMax = budgets.maxTokensPerRequest || 4096
+
+  // Check rolling budgets before the call
+  checkBudgets(budgets, requestMax)
+
+  let result = await adapter.complete(messages, { model, maxTokens: requestMax })
+
+  // Strip wrapping code fences (```markdown ... ```) that LLMs often add
+  const fenceMatch = result.match(/^```(?:markdown|md)?\n([\s\S]*)\n```$/)
+  if (fenceMatch) result = fenceMatch[1].trim()
+
+  // Record approximate usage (response length in chars / 4 is a rough token estimate)
+  const approxTokens = Math.ceil(result.length / 4)
+  recordUsage(approxTokens)
+
+  return result
+}
+
+/**
+ * Get current token usage stats.
+ * @returns {{ hourly: number, daily: number }}
+ */
+export function getTokenUsage() {
+  return {
+    hourly: getUsage(60 * 60 * 1000),
+    daily: getUsage(24 * 60 * 60 * 1000),
+  }
+}