tissues 0.6.1 → 0.6.2

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)
+  })
+})