tissues 0.6.0 → 0.6.2

package/src/lib/ai/agent.js

@@ -0,0 +1,323 @@
+/**
+ * General-purpose AI agent for tissues CLI.
+ *
+ * Builds a token-efficient system prompt from local cache + filesystem,
+ * dispatches JSON-based actions, and supports multi-turn conversation.
+ */
+
+import { store } from '../config.js'
+import { loadConfig, findRepoRoot } from '../defaults.js'
+import { ensureFresh, getCachedIssues } from '../cache.js'
+import { getAuthenticatedUser } from '../gh.js'
+import { listTemplates } from '../templates.js'
+import { listEnhancements } from '../enhancements.js'
+import { countPending } from '../drafts.js'
+import { resolveRoute } from './router.js'
+import { checkAvailable } from './index.js'
+import { ACTION_SCHEMAS, executeAction } from './agent-actions.js'
+import { bold, dim, cyan, green, yellow, red } from '../color.js'
+
+// ---------------------------------------------------------------------------
+// System prompt builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the system prompt with dynamic state from cache + filesystem.
+ * Designed to be token-efficient (~1000-1400 tokens, max ~2000).
+ *
+ * @param {{ activeRepo: string, config: object, repoRoot: string, user?: string }} context
+ * @returns {string}
+ */
+export function buildAgentSystemPrompt(context) {
+  const sections = []
+
+  // Section 1: Identity + constraints + guardrails
+  sections.push([
+    'You are the tissues CLI agent. You manage GitHub issues via JSON actions.',
+    'Return ONLY a single JSON object: { "action": "<name>", "params": { ... } }',
+    '',
+    'Rules:',
+    '- Output MUST be valid JSON. No markdown, no explanation, no text outside JSON.',
+    '- For read-only queries (list, show), execute immediately.',
+    '- For mutations (create, set, switch), include all required params.',
+    '- Use "answer" action for conversational replies or to ask clarifying questions.',
+    '',
+    'Guardrails:',
+    '- You ONLY handle tissues/GitHub issue operations. Nothing else.',
+    '- NEVER generate code, open URLs, write files, or answer off-topic questions.',
+    '- If asked something outside your scope (weather, coding help, general knowledge),',
+    '  respond with: {"action":"answer","params":{"text":"I can only help with GitHub issues via tissues. Try `tissues --help` for available commands."}}',
+  ].join('\n'))
+
+  // Section 2: Action schemas (compact)
+  const schemaLines = ['Available actions:']
+  for (const schema of ACTION_SCHEMAS) {
+    const paramStr = Object.entries(schema.params)
+      .map(([k, v]) => `${k}: ${v}`)
+      .join(', ')
+    const confirm = schema.requiresConfirmation ? ' [confirms]' : ''
+    schemaLines.push(`  ${schema.name}(${paramStr})${confirm} — ${schema.description}`)
+  }
+  sections.push(schemaLines.join('\n'))
+
+  // Section 3: CLI command reference (so agent can point users to commands)
+  sections.push([
+    'CLI commands (you cannot run these, but can tell users about them):',
+    '  tissues auth — configure GitHub authentication',
+    '  tissues config — view/set configuration',
+    '  tissues create — create an issue interactively',
+    '  tissues draft — manage pending issue drafts',
+    '  tissues list — list issues from cache',
+    '  tissues status — show safety status (circuit breaker, rate limits)',
+    '  tissues templates — list/manage issue templates',
+    '  tissues enhancements — list AI enhancement plugins',
+    '  tissues drafts — review and submit pending drafts',
+    '  tissues ai — run AI agent (this is you)',
+    '  tissues sync — force-sync cache with GitHub',
+    '  tissues storage — manage local database',
+  ].join('\n'))
+
+  // Section 4: Dynamic state snapshot (from cache, zero network calls)
+  const stateLines = ['Current state:']
+
+  if (context.activeRepo) stateLines.push(`  Active repo: ${context.activeRepo}`)
+  if (context.user) stateLines.push(`  User: ${context.user}`)
+
+  // Repos from cache
+  try {
+    const repos = ensureFresh('_global', 'repos', { acceptStale: true })
+    if (repos.length > 0) stateLines.push(`  Available repos: ${repos.slice(0, 15).join(', ')}${repos.length > 15 ? ` (+${repos.length - 15} more)` : ''}`)
+  } catch { /* no cached repos */ }
+
+  // Templates from filesystem
+  try {
+    const templates = listTemplates(context.repoRoot)
+    const keys = [...new Set(templates.map(t => t.key))]
+    if (keys.length > 0) stateLines.push(`  Templates: ${keys.join(', ')}`)
+  } catch { /* ok */ }
+
+  // Enhancements from filesystem
+  try {
+    const enhancements = listEnhancements(context.repoRoot)
+    const keys = [...new Set(enhancements.map(e => e.key))]
+    if (keys.length > 0) stateLines.push(`  Enhancements: ${keys.join(', ')}`)
+  } catch { /* ok */ }
+
+  // Labels from cache
+  if (context.activeRepo) {
+    try {
+      const labels = ensureFresh(context.activeRepo, 'labels', { acceptStale: true })
+      if (labels.length > 0) stateLines.push(`  Labels: ${labels.join(', ')}`)
+    } catch { /* ok */ }
+  }
+
+  // Pending drafts
+  try {
+    const pending = countPending(context.repoRoot)
+    if (pending > 0) stateLines.push(`  Pending drafts: ${pending}`)
+  } catch { /* ok */ }
+
+  // AI provider info
+  const ai = context.config?.ai || {}
+  stateLines.push(`  AI provider: ${ai.provider || 'none'}`)
+
+  // Recent issues — prefer last-24h with labels+author, fallback to top 10 titles
+  if (context.activeRepo) {
+    try {
+      let issueLimit = 30
+      const allIssues = getCachedIssues(context.activeRepo, { state: 'open', limit: issueLimit })
+      const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
+      let recentIssues = allIssues.filter(i => i.updatedAt && i.updatedAt >= oneDayAgo)
+
+      if (recentIssues.length > 0) {
+        stateLines.push(`  Issues updated in last 24h:`)
+        for (const i of recentIssues.slice(0, issueLimit)) {
+          const labelStr = i.labels?.length ? ` [${i.labels.join(',')}]` : ''
+          const authorStr = i.author ? ` @${i.author}` : ''
+          stateLines.push(`    #${i.number}: ${i.title}${labelStr}${authorStr}`)
+        }
+      } else if (allIssues.length > 0) {
+        // Fallback: show top 10 titles
+        stateLines.push(`  Recent open issues:`)
+        for (const i of allIssues.slice(0, 10)) {
+          stateLines.push(`    #${i.number}: ${i.title}`)
+        }
+      }
+    } catch { /* ok */ }
+  }
+
+  sections.push(stateLines.join('\n'))
+
+  // Token safety valve: if prompt is too long, trim issues and rebuild
+  let prompt = sections.join('\n\n')
+  if (prompt.length > 6000) {
+    // Rebuild the state section with halved issue count
+    const trimmedStateLines = stateLines.filter(l => !l.startsWith('    #'))
+    try {
+      const allIssues = getCachedIssues(context.activeRepo, { state: 'open', limit: 5 })
+      if (allIssues.length > 0) {
+        trimmedStateLines.push(`  Recent open issues:`)
+        for (const i of allIssues.slice(0, 5)) {
+          trimmedStateLines.push(`    #${i.number}: ${i.title}`)
+        }
+      }
+    } catch { /* ok */ }
+    sections[sections.length - 1] = trimmedStateLines.join('\n')
+    prompt = sections.join('\n\n')
+  }
+
+  return prompt
+}
+
+// ---------------------------------------------------------------------------
+// Response parser
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse an AI response into an action object.
+ *
+ * @param {string} raw - raw AI response text
+ * @returns {{ action: string, params: object }}
+ */
+export function parseAgentResponse(raw) {
+  let cleaned = raw.trim()
+
+  // Strip markdown code fences if present
+  if (cleaned.startsWith('```')) {
+    cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '')
+  }
+
+  // Try to extract JSON from mixed content
+  const jsonMatch = cleaned.match(/\{[\s\S]*\}/)
+  if (jsonMatch) {
+    cleaned = jsonMatch[0]
+  }
+
+  const parsed = JSON.parse(cleaned)
+
+  if (!parsed.action) {
+    // If the response has create-style fields (title, body), treat as create_issue
+    if (parsed.title) {
+      return { action: 'create_issue', params: parsed }
+    }
+    throw new Error('Response missing "action" field')
+  }
+
+  return { action: parsed.action, params: parsed.params || parsed }
+}
+
+// ---------------------------------------------------------------------------
+// Single-shot dispatch
+// ---------------------------------------------------------------------------
+
+/**
+ * Run a single-shot AI agent: one LLM call, parse action, execute.
+ *
+ * @param {string} prompt - user's natural language prompt
+ * @param {object} config - merged config
+ * @param {{ activeRepo: string, repoRoot: string, user?: string }} context
+ * @param {{ provider?: string, model?: string, dryRun?: boolean }} [opts]
+ * @returns {Promise<{ action: string, result: any } | null>}
+ */
+export async function runAgentSingleShot(prompt, config, context, opts = {}) {
+  const systemPrompt = buildAgentSystemPrompt({ ...context, config })
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: prompt },
+  ]
+
+  const aiContext = { provider: opts.provider, model: opts.model }
+  const { adapter, model } = resolveRoute(config, aiContext)
+  const raw = await adapter.complete(messages, { model, maxTokens: 2048 })
+
+  let action, params
+  try {
+    ({ action, params } = parseAgentResponse(raw))
+  } catch {
+    // AI responded conversationally instead of JSON — treat as answer
+    action = 'answer'
+    params = { text: raw.trim() }
+  }
+  return { action, params, raw }
+}
+
+// ---------------------------------------------------------------------------
+// Multi-turn conversation loop
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the agent in multi-turn chat mode.
+ *
+ * @param {object} config
+ * @param {{ activeRepo: string, repoRoot: string, user?: string }} context
+ * @param {{ provider?: string, model?: string, onInput: () => Promise<string>, onOutput: (text: string) => void }} opts
+ */
+export async function runAgentLoop(config, context, opts) {
+  const { onInput, onOutput } = opts
+  const aiContext = { provider: opts.provider, model: opts.model }
+
+  const systemPrompt = buildAgentSystemPrompt({ ...context, config })
+  const messages = [{ role: 'system', content: systemPrompt }]
+
+  // Token management: keep last N turns to stay within context limits
+  const MAX_TURNS = 20
+  const SYSTEM_MSGS = 1 // system prompt is always first
+
+  while (true) {
+    const userInput = await onInput()
+    if (!userInput || /^(exit|quit|done|bye)$/i.test(userInput.trim())) {
+      onOutput(dim('Goodbye.'))
+      break
+    }
+
+    messages.push({ role: 'user', content: userInput })
+
+    // Trim old turns if conversation is getting long
+    while (messages.length > SYSTEM_MSGS + MAX_TURNS * 2) {
+      // Remove oldest user/assistant pair (keep system prompt)
+      messages.splice(SYSTEM_MSGS, 2)
+    }
+
+    let raw
+    try {
+      const { adapter, model } = resolveRoute(config, aiContext)
+      raw = await adapter.complete(messages, { model, maxTokens: 2048 })
+    } catch (err) {
+      onOutput(red(`AI error: ${err.message}`))
+      continue
+    }
+
+    messages.push({ role: 'assistant', content: raw })
+
+    let action, params
+    try {
+      ({ action, params } = parseAgentResponse(raw))
+    } catch {
+      // If we can't parse, show the raw response
+      onOutput(raw)
+      continue
+    }
+
+    // Execute action
+    const result = await executeAction(action, params || {}, { ...context, config })
+
+    if (result.display) {
+      onOutput(result.display)
+    } else if (result.result) {
+      onOutput(typeof result.result === 'string' ? result.result : JSON.stringify(result.result, null, 2))
+    }
+
+    // Feed result back as a system message for context
+    if (action !== 'answer') {
+      messages.push({
+        role: 'user',
+        content: `[System: ${action} result: ${JSON.stringify(result.result).slice(0, 500)}]`,
+      })
+    }
+
+    // If it was just an answer with no follow-up question, check if we should continue
+    if (action === 'answer' && !result.result?.includes('?')) {
+      // Still continue — user drives the loop
+    }
+  }
+}

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/discovery.js

@@ -0,0 +1,89 @@
+import { execFile } from 'node:child_process'
+
+/**
+ * Check if a binary is available on PATH.
+ * @param {string} name - binary name
+ * @returns {Promise<boolean>}
+ */
+function hasBinary(name) {
+  const cmd = process.platform === 'win32' ? 'where' : 'command'
+  const args = process.platform === 'win32' ? [name] : ['-v', name]
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: 5000 }, (err) => resolve(!err))
+  })
+}
+
+/**
+ * Auto-discover available AI providers on this system.
+ *
+ * Checks for:
+ *   - CLI binaries: gemini, claude, codex
+ *   - OpenClaw gateway (env vars)
+ *   - API keys in env
+ *
+ * @returns {Promise<Array<{ name: string, type: 'cli'|'api'|'openclaw', status: 'available'|'configured', config: object }>>}
+ */
+export async function discoverProviders() {
+  const results = []
+
+  // CLI binaries — check in parallel
+  const cliChecks = [
+    { name: 'gemini-cli', binary: 'gemini' },
+    { name: 'claude-cli', binary: 'claude' },
+    { name: 'codex-cli', binary: 'codex' },
+  ]
+
+  const binaryResults = await Promise.all(
+    cliChecks.map(async ({ name, binary }) => ({
+      name,
+      binary,
+      found: await hasBinary(binary),
+    })),
+  )
+
+  for (const { name, binary, found } of binaryResults) {
+    if (found) {
+      results.push({
+        name,
+        type: 'cli',
+        status: 'available',
+        config: { binary },
+      })
+    }
+  }
+
+  // OpenClaw gateway
+  const openclawToken = process.env.OPENCLAW_GATEWAY_TOKEN
+  const openclawPort = process.env.OPENCLAW_GATEWAY_PORT || '18790'
+  if (openclawToken) {
+    results.push({
+      name: 'openclaw',
+      type: 'openclaw',
+      status: 'configured',
+      config: {
+        gatewayUrl: `http://localhost:${openclawPort}`,
+        token: openclawToken,
+      },
+    })
+  }
+
+  // API keys in environment
+  const apiKeyChecks = [
+    { name: 'anthropic', env: 'ANTHROPIC_API_KEY' },
+    { name: 'openai', env: 'OPENAI_API_KEY' },
+    { name: 'gemini', env: 'GEMINI_API_KEY' },
+  ]
+
+  for (const { name, env } of apiKeyChecks) {
+    if (process.env[env]) {
+      results.push({
+        name,
+        type: 'api',
+        status: 'configured',
+        config: { envVar: env },
+      })
+    }
+  }
+
+  return results
+}

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

@@ -0,0 +1,74 @@
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { discoverProviders } from './discovery.js'
+
+describe('discoverProviders', () => {
+  const savedEnv = {}
+
+  beforeEach(() => {
+    // Save and clear relevant env vars
+    for (const key of ['OPENCLAW_GATEWAY_TOKEN', 'OPENCLAW_GATEWAY_PORT', 'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY']) {
+      savedEnv[key] = process.env[key]
+      delete process.env[key]
+    }
+  })
+
+  afterEach(() => {
+    // Restore env vars
+    for (const [key, val] of Object.entries(savedEnv)) {
+      if (val === undefined) delete process.env[key]
+      else process.env[key] = val
+    }
+  })
+
+  it('returns an array', async () => {
+    const result = await discoverProviders()
+    assert.ok(Array.isArray(result))
+  })
+
+  it('discovers API keys from environment', async () => {
+    process.env.ANTHROPIC_API_KEY = 'sk-ant-test'
+    process.env.OPENAI_API_KEY = 'sk-openai-test'
+    const result = await discoverProviders()
+    const apiProviders = result.filter((r) => r.type === 'api')
+    const names = apiProviders.map((p) => p.name)
+    assert.ok(names.includes('anthropic'))
+    assert.ok(names.includes('openai'))
+    assert.ok(!names.includes('gemini'))
+  })
+
+  it('discovers OpenClaw from environment', async () => {
+    process.env.OPENCLAW_GATEWAY_TOKEN = 'test-token'
+    process.env.OPENCLAW_GATEWAY_PORT = '9999'
+    const result = await discoverProviders()
+    const openclaw = result.find((r) => r.name === 'openclaw')
+    assert.ok(openclaw)
+    assert.equal(openclaw.type, 'openclaw')
+    assert.equal(openclaw.status, 'configured')
+    assert.equal(openclaw.config.gatewayUrl, 'http://localhost:9999')
+  })
+
+  it('uses default port for OpenClaw when not set', async () => {
+    process.env.OPENCLAW_GATEWAY_TOKEN = 'test-token'
+    const result = await discoverProviders()
+    const openclaw = result.find((r) => r.name === 'openclaw')
+    assert.equal(openclaw.config.gatewayUrl, 'http://localhost:18790')
+  })
+
+  it('does not include OpenClaw without token', async () => {
+    const result = await discoverProviders()
+    const openclaw = result.find((r) => r.name === 'openclaw')
+    assert.equal(openclaw, undefined)
+  })
+
+  it('each result has required shape', async () => {
+    process.env.ANTHROPIC_API_KEY = 'sk-test'
+    const result = await discoverProviders()
+    for (const item of result) {
+      assert.ok(item.name, 'has name')
+      assert.ok(['cli', 'api', 'openclaw'].includes(item.type), `valid type: ${item.type}`)
+      assert.ok(['available', 'configured'].includes(item.status), `valid status: ${item.status}`)
+      assert.ok(item.config && typeof item.config === 'object', 'has config object')
+    }
+  })
+})

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
 }