tissues 0.6.0 → 0.6.2

package/src/lib/ai/router.js

@@ -4,6 +4,10 @@ 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'
+import { GeminiCliAdapter } from './adapters/gemini-cli.js'
+import { ClaudeCliAdapter } from './adapters/claude-cli.js'
+import { CodexCliAdapter } from './adapters/codex-cli.js'
+import { OpenClawAdapter } from './adapters/openclaw.js'
 
 const ADAPTER_MAP = {
   anthropic: AnthropicAdapter,
@@ -12,6 +16,38 @@ const ADAPTER_MAP = {
   ollama: OllamaAdapter,
   'openai-compat': OpenAICompatAdapter,
   command: CommandAdapter,
+  'gemini-cli': GeminiCliAdapter,
+  'claude-cli': ClaudeCliAdapter,
+  'codex-cli': CodexCliAdapter,
+  openclaw: OpenClawAdapter,
+}
+
+/**
+ * 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
 }
 
 /**
@@ -23,14 +59,15 @@ const ADAPTER_MAP = {
  *   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 }}
+ * @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)) {
@@ -38,6 +75,7 @@ export function resolveRoute(config, context = {}) {
       if (matchesRule(rule.match, context)) {
         provider = rule.provider || provider
         model = rule.model || model
+        if (rule.enhancements) enhancements = rule.enhancements
         break
       }
     }
@@ -47,12 +85,57 @@ export function resolveRoute(config, context = {}) {
   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}`)
+  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)
+  }
 
-  // Build adapter config based on provider type
-  const adapterConfig = buildAdapterConfig(ai, provider)
   const adapter = new AdapterClass(adapterConfig)
+  const model = modelOverride || ai.model || ai.models?.[providerName] || null
 
   return { adapter, model }
 }
@@ -89,6 +172,21 @@ function buildAdapterConfig(ai, provider) {
       return { baseUrl: ai.custom?.url, apiKey: resolveApiKey(ai, 'openai-compat') }
     case 'command':
       return { command: ai.command || null }
+    case 'gemini-cli':
+      return { binary: 'gemini', model: ai.models?.['gemini-cli'] || null }
+    case 'claude-cli':
+      return { binary: 'claude', model: ai.models?.['claude-cli'] || null }
+    case 'codex-cli':
+      return { binary: 'codex', model: ai.models?.['codex-cli'] || null }
+    case 'openclaw': {
+      const port = process.env.OPENCLAW_GATEWAY_PORT || '18790'
+      return {
+        gatewayUrl: ai.openclaw?.gatewayUrl || `http://localhost:${port}`,
+        token: ai.openclaw?.token || process.env.OPENCLAW_GATEWAY_TOKEN || null,
+        agentId: ai.openclaw?.agentId || null,
+        model: ai.models?.openclaw || null,
+      }
+    }
     default:
       return { apiKey: resolveApiKey(ai, provider) }
   }
@@ -120,9 +218,22 @@ function matchesRule(match, context) {
 }
 
 /**
- * List available provider names.
+ * 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/router.test.js

@@ -0,0 +1,481 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { resolveRoute, resolveProviderAdapter, listProviders, listAllProviders, migrateProviderConfig } from './router.js'
+
+const baseConfig = {
+  ai: {
+    enabled: true,
+    provider: 'anthropic',
+    model: null,
+    models: {
+      anthropic: 'claude-haiku-4-5-20251001',
+      openai: 'gpt-4o-mini',
+      gemini: 'gemini-2.0-flash',
+    },
+    keys: {
+      anthropic: 'sk-ant-test',
+      openai: 'sk-openai-test',
+      gemini: 'gm-test',
+    },
+    routes: [
+      { match: { template: 'bug' }, provider: 'gemini', model: 'gemini-2.0-flash' },
+      { match: { template: 'security' }, provider: 'anthropic', model: 'claude-sonnet-4-5-20241022' },
+      { match: { labels: ['P0-critical'] }, provider: 'anthropic', model: 'claude-opus-4-6' },
+    ],
+  },
+}
+
+describe('resolveRoute', () => {
+  it('uses default provider when no context', () => {
+    const { adapter, model } = resolveRoute(baseConfig, {})
+    assert.equal(adapter.name, 'anthropic')
+    assert.equal(model, 'claude-haiku-4-5-20251001')
+  })
+
+  it('matches template routing rule', () => {
+    const { adapter, model } = resolveRoute(baseConfig, { template: 'bug' })
+    assert.equal(adapter.name, 'gemini')
+    assert.equal(model, 'gemini-2.0-flash')
+  })
+
+  it('matches security template routing rule', () => {
+    const { adapter, model } = resolveRoute(baseConfig, { template: 'security' })
+    assert.equal(adapter.name, 'anthropic')
+    assert.equal(model, 'claude-sonnet-4-5-20241022')
+  })
+
+  it('matches label routing rule', () => {
+    const { adapter, model } = resolveRoute(baseConfig, { labels: ['P0-critical', 'urgent'] })
+    assert.equal(adapter.name, 'anthropic')
+    assert.equal(model, 'claude-opus-4-6')
+  })
+
+  it('explicit provider overrides routes', () => {
+    const { adapter, model } = resolveRoute(baseConfig, {
+      template: 'bug',
+      provider: 'openai',
+      model: 'gpt-4o',
+    })
+    assert.equal(adapter.name, 'openai')
+    assert.equal(model, 'gpt-4o')
+  })
+
+  it('falls through to default when no rule matches', () => {
+    const { adapter, model } = resolveRoute(baseConfig, { template: 'feature' })
+    assert.equal(adapter.name, 'anthropic')
+    assert.equal(model, 'claude-haiku-4-5-20251001')
+  })
+
+  it('throws on unknown provider', () => {
+    assert.throws(
+      () => resolveRoute(baseConfig, { provider: 'unknown' }),
+      /Unknown AI provider: unknown/,
+    )
+  })
+
+  it('first matching rule wins', () => {
+    const config = {
+      ai: {
+        ...baseConfig.ai,
+        routes: [
+          { match: { template: 'bug' }, provider: 'openai' },
+          { match: { template: 'bug' }, provider: 'gemini' },
+        ],
+      },
+    }
+    const { adapter } = resolveRoute(config, { template: 'bug' })
+    assert.equal(adapter.name, 'openai')
+  })
+})
+
+describe('resolveRoute — ollama', () => {
+  it('creates OllamaAdapter with baseUrl from config', () => {
+    const config = {
+      ai: {
+        provider: 'ollama',
+        models: { ollama: 'mistral' },
+        ollama: { url: 'http://myhost:11434' },
+      },
+    }
+    const { adapter, model } = resolveRoute(config, {})
+    assert.equal(adapter.name, 'ollama')
+    assert.equal(model, 'mistral')
+    assert.equal(adapter.config.baseUrl, 'http://myhost:11434')
+    assert.equal(adapter.isConfigured(), true)
+  })
+})
+
+describe('resolveRoute — openai-compat', () => {
+  it('creates OpenAICompatAdapter with baseUrl and optional key', () => {
+    const config = {
+      ai: {
+        provider: 'openai-compat',
+        models: { 'openai-compat': 'my-model' },
+        custom: { url: 'http://localhost:8080' },
+        keys: { 'openai-compat': 'sk-test' },
+      },
+    }
+    const { adapter, model } = resolveRoute(config, {})
+    assert.equal(adapter.name, 'openai-compat')
+    assert.equal(model, 'my-model')
+    assert.equal(adapter.config.baseUrl, 'http://localhost:8080')
+    assert.equal(adapter.config.apiKey, 'sk-test')
+    assert.equal(adapter.isConfigured(), true)
+  })
+
+  it('isConfigured returns false without baseUrl', () => {
+    const config = {
+      ai: {
+        provider: 'openai-compat',
+        custom: { url: null },
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.isConfigured(), false)
+  })
+})
+
+describe('resolveRoute — command', () => {
+  it('creates CommandAdapter with command from config', () => {
+    const config = {
+      ai: {
+        provider: 'command',
+        command: 'my-ai-tool enhance',
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'my-ai-tool enhance')
+    assert.equal(adapter.isConfigured(), true)
+  })
+
+  it('isConfigured returns false without command', () => {
+    const config = {
+      ai: {
+        provider: 'command',
+        command: null,
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.isConfigured(), false)
+  })
+})
+
+describe('listProviders', () => {
+  it('returns known providers', () => {
+    const providers = listProviders()
+    assert.ok(providers.includes('anthropic'))
+    assert.ok(providers.includes('openai'))
+    assert.ok(providers.includes('gemini'))
+    assert.ok(providers.includes('ollama'))
+    assert.ok(providers.includes('openai-compat'))
+    assert.ok(providers.includes('command'))
+    assert.ok(providers.includes('gemini-cli'))
+    assert.ok(providers.includes('claude-cli'))
+    assert.ok(providers.includes('codex-cli'))
+    assert.ok(providers.includes('openclaw'))
+  })
+})
+
+describe('resolveRoute — named CLI commands (legacy ai.commands)', () => {
+  it('resolves a named command from ai.commands to CommandAdapter', () => {
+    const config = {
+      ai: {
+        provider: 'my-cli',
+        commands: {
+          'my-cli': { command: 'co gemini', timeout: 120000 },
+        },
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'co gemini')
+    assert.equal(adapter.config.timeout, 120000)
+    assert.equal(adapter.isConfigured(), true)
+  })
+
+  it('named command works via explicit --provider flag', () => {
+    const config = {
+      ai: {
+        provider: 'anthropic',
+        keys: { anthropic: 'sk-test' },
+        commands: {
+          'my-claude': { command: 'claude --print' },
+        },
+      },
+    }
+    const { adapter } = resolveRoute(config, { provider: 'my-claude' })
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'claude --print')
+    assert.equal(adapter.config.timeout, undefined)
+  })
+
+  it('named command works in routing rules', () => {
+    const config = {
+      ai: {
+        provider: 'anthropic',
+        keys: { anthropic: 'sk-test' },
+        commands: {
+          'my-gemini': { command: 'co gemini' },
+        },
+        routes: [
+          { match: { template: 'bug' }, provider: 'my-gemini' },
+        ],
+      },
+    }
+    const { adapter } = resolveRoute(config, { template: 'bug' })
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'co gemini')
+  })
+
+  it('legacy provider: "command" still works', () => {
+    const config = {
+      ai: {
+        provider: 'command',
+        command: 'old-tool',
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'old-tool')
+  })
+
+  it('throws on unknown provider not in commands', () => {
+    const config = {
+      ai: {
+        provider: 'nonexistent',
+        commands: {},
+      },
+    }
+    assert.throws(
+      () => resolveRoute(config, {}),
+      /Unknown AI provider: nonexistent/,
+    )
+  })
+
+  it('named command without command string is not configured', () => {
+    const config = {
+      ai: {
+        provider: 'bad-cmd',
+        commands: {
+          'bad-cmd': {},
+        },
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.isConfigured(), false)
+  })
+})
+
+describe('resolveRoute — ai.providers (new canonical key)', () => {
+  it('resolves a provider from ai.providers', () => {
+    const config = {
+      ai: {
+        provider: 'my-tool',
+        providers: {
+          'my-tool': { command: 'my-tool enhance', timeout: 30000 },
+        },
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'my-tool enhance')
+    assert.equal(adapter.config.timeout, 30000)
+  })
+
+  it('ai.providers wins over ai.commands on conflict', () => {
+    const config = {
+      ai: {
+        provider: 'my-tool',
+        commands: {
+          'my-tool': { command: 'old-command' },
+        },
+        providers: {
+          'my-tool': { command: 'new-command' },
+        },
+      },
+    }
+    const { adapter } = resolveRoute(config, {})
+    assert.equal(adapter.config.command, 'new-command')
+  })
+
+  it('ai.commands entries still work alongside ai.providers', () => {
+    const config = {
+      ai: {
+        provider: 'anthropic',
+        keys: { anthropic: 'sk-test' },
+        commands: {
+          'old-tool': { command: 'old cmd' },
+        },
+        providers: {
+          'new-tool': { command: 'new cmd' },
+        },
+      },
+    }
+    // old-tool from commands still works
+    const { adapter: old } = resolveRoute(config, { provider: 'old-tool' })
+    assert.equal(old.config.command, 'old cmd')
+    // new-tool from providers works
+    const { adapter: nw } = resolveRoute(config, { provider: 'new-tool' })
+    assert.equal(nw.config.command, 'new cmd')
+  })
+})
+
+describe('migrateProviderConfig', () => {
+  it('merges ai.commands and ai.providers', () => {
+    const ai = {
+      commands: { a: { command: 'cmd-a' } },
+      providers: { b: { command: 'cmd-b' } },
+    }
+    const merged = migrateProviderConfig(ai)
+    assert.equal(merged.a.command, 'cmd-a')
+    assert.equal(merged.b.command, 'cmd-b')
+  })
+
+  it('ai.providers wins on conflict', () => {
+    const ai = {
+      commands: { x: { command: 'old' } },
+      providers: { x: { command: 'new' } },
+    }
+    const merged = migrateProviderConfig(ai)
+    assert.equal(merged.x.command, 'new')
+  })
+
+  it('does not include ai.command (handled by built-in command provider)', () => {
+    const ai = { command: 'legacy-tool' }
+    const merged = migrateProviderConfig(ai)
+    assert.deepEqual(merged, {})
+  })
+
+  it('works with empty ai object', () => {
+    const merged = migrateProviderConfig({})
+    assert.deepEqual(merged, {})
+  })
+})
+
+describe('resolveProviderAdapter', () => {
+  it('resolves a built-in provider', () => {
+    const config = {
+      ai: {
+        keys: { anthropic: 'sk-test' },
+        models: { anthropic: 'claude-haiku-4-5-20251001' },
+      },
+    }
+    const { adapter, model } = resolveProviderAdapter(config, 'anthropic')
+    assert.equal(adapter.name, 'anthropic')
+    assert.equal(model, 'claude-haiku-4-5-20251001')
+  })
+
+  it('resolves a custom provider from ai.providers', () => {
+    const config = {
+      ai: {
+        providers: {
+          'my-cli': { command: 'my-tool run', timeout: 5000 },
+        },
+      },
+    }
+    const { adapter } = resolveProviderAdapter(config, 'my-cli')
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'my-tool run')
+    assert.equal(adapter.config.timeout, 5000)
+  })
+
+  it('resolves a custom provider from legacy ai.commands', () => {
+    const config = {
+      ai: {
+        commands: {
+          'old-cli': { command: 'old-tool' },
+        },
+      },
+    }
+    const { adapter } = resolveProviderAdapter(config, 'old-cli')
+    assert.equal(adapter.name, 'command')
+    assert.equal(adapter.config.command, 'old-tool')
+  })
+
+  it('applies model override', () => {
+    const config = {
+      ai: {
+        keys: { openai: 'sk-test' },
+        models: { openai: 'gpt-4o-mini' },
+      },
+    }
+    const { model } = resolveProviderAdapter(config, 'openai', 'gpt-4o')
+    assert.equal(model, 'gpt-4o')
+  })
+
+  it('throws on unknown provider', () => {
+    assert.throws(
+      () => resolveProviderAdapter({ ai: {} }, 'nonexistent'),
+      /Unknown AI provider: nonexistent/,
+    )
+  })
+})
+
+describe('listAllProviders', () => {
+  it('includes built-in providers and named commands', () => {
+    const config = {
+      ai: {
+        commands: {
+          'my-gemini': { command: 'co gemini' },
+          'my-claude': { command: 'claude --print' },
+        },
+      },
+    }
+    const all = listAllProviders(config)
+    assert.ok(all.includes('anthropic'))
+    assert.ok(all.includes('openai'))
+    assert.ok(all.includes('command'))
+    assert.ok(all.includes('my-gemini'))
+    assert.ok(all.includes('my-claude'))
+    // New built-in CLI adapters
+    assert.ok(all.includes('gemini-cli'))
+    assert.ok(all.includes('claude-cli'))
+    assert.ok(all.includes('codex-cli'))
+    assert.ok(all.includes('openclaw'))
+  })
+
+  it('includes providers from ai.providers', () => {
+    const config = {
+      ai: {
+        providers: {
+          'new-tool': { command: 'new cmd' },
+        },
+      },
+    }
+    const all = listAllProviders(config)
+    assert.ok(all.includes('new-tool'))
+  })
+
+  it('merges ai.commands and ai.providers in listing', () => {
+    const config = {
+      ai: {
+        commands: { 'old-tool': { command: 'old' } },
+        providers: { 'new-tool': { command: 'new' } },
+      },
+    }
+    const all = listAllProviders(config)
+    assert.ok(all.includes('old-tool'))
+    assert.ok(all.includes('new-tool'))
+  })
+
+  it('does not duplicate built-in names', () => {
+    const config = {
+      ai: {
+        commands: {
+          anthropic: { command: 'echo test' },
+        },
+      },
+    }
+    const all = listAllProviders(config)
+    const count = all.filter((p) => p === 'anthropic').length
+    assert.equal(count, 1)
+  })
+
+  it('works with no commands configured', () => {
+    const all = listAllProviders({ ai: {} })
+    assert.ok(all.includes('anthropic'))
+    assert.ok(all.length >= 10)
+  })
+})

package/src/lib/ai/steps.js

@@ -114,9 +114,11 @@ const dedupStep = {
   displayName: 'Duplicate check',
   maxTokens: 1024,
 
-  shouldRun(ctx) {
-    // Only useful when there are existing issues to compare against
-    return ctx.existingIssues?.length > 0
+  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) {
@@ -462,6 +464,21 @@ export const ALL_STEPS = [
   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
@@ -470,3 +487,6 @@ export const ALL_STEPS = [
 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 }