tissues 0.6.1 → 0.6.2

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

@@ -0,0 +1,257 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import { runPipeline } from './pipeline.js'
+
+// ---------------------------------------------------------------------------
+// Mock adapter
+// ---------------------------------------------------------------------------
+
+function mockAdapter(responses = {}) {
+  return {
+    name: 'mock',
+    complete(messages, opts) {
+      const lastUser = messages.find((m) => m.role === 'user')?.content || ''
+      // Return pre-configured response or a default
+      for (const [key, val] of Object.entries(responses)) {
+        if (lastUser.includes(key) || opts._stepName === key) return Promise.resolve(val)
+      }
+      return Promise.resolve('{}')
+    },
+  }
+}
+
+function makeStep(name, { shouldRun = true, response = '{}', parseResult = {}, failOnParse = false, provider = null } = {}) {
+  return {
+    name,
+    displayName: name,
+    maxTokens: 512,
+    provider,
+    shouldRun: () => shouldRun,
+    buildMessages: (ctx) => [
+      { role: 'system', content: 'test' },
+      { role: 'user', content: `step:${name} title:${ctx.title}` },
+    ],
+    parseResponse: (raw, ctx) => {
+      if (failOnParse) throw new Error('parse failed')
+      Object.assign(ctx, parseResult)
+    },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('runPipeline', () => {
+  test('steps execute in order, context accumulates', async () => {
+    const order = []
+    const steps = [
+      makeStep('a', { parseResult: { aResult: 'from-a' } }),
+      makeStep('b', { parseResult: { bResult: 'from-b' } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always', b: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test-model' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepStart(step) { order.push(`start:${step.name}`) },
+      onStepDone(step) { order.push(`done:${step.name}`) },
+    })
+
+    assert.deepEqual(order, ['start:a', 'done:a', 'start:b', 'done:b'])
+    assert.equal(ctx.aResult, 'from-a')
+    assert.equal(ctx.bResult, 'from-b')
+  })
+
+  test('shouldRun: false skips steps correctly', async () => {
+    const skipped = []
+    const steps = [
+      makeStep('a', { shouldRun: false }),
+      makeStep('b', { parseResult: { bDone: true } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'auto', b: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepSkip(step, reason) { skipped.push({ name: step.name, reason }) },
+    })
+
+    assert.equal(skipped.length, 1)
+    assert.equal(skipped[0].name, 'a')
+    assert.equal(ctx.bDone, true)
+    assert.equal(ctx.aResult, undefined)
+  })
+
+  test('step config "never" skips regardless of shouldRun', async () => {
+    const skipped = []
+    const steps = [makeStep('a', { shouldRun: true, parseResult: { aResult: true } })]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'never' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepSkip(step) { skipped.push(step.name) },
+    })
+
+    assert.equal(skipped.length, 1)
+    assert.equal(ctx.aResult, undefined)
+  })
+
+  test('failed step does not block subsequent steps', async () => {
+    const failed = []
+    const done = []
+    const steps = [
+      makeStep('a'),
+      makeStep('b', { parseResult: { bDone: true } }),
+    ]
+
+    // 'a' will fail because the adapter throws, 'b' uses a working adapter
+    // Actually both use the same adapter. Let's make a smarter adapter.
+    let callCount = 0
+    const smartAdapter = {
+      complete() {
+        callCount++
+        if (callCount === 1) return Promise.reject(new Error('API error'))
+        return Promise.resolve('{}')
+      },
+    }
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always', b: 'always' } }
+    const route = { adapter: smartAdapter, model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepFail(step) { failed.push(step.name) },
+      onStepDone(step) { done.push(step.name) },
+    })
+
+    assert.deepEqual(failed, ['a'])
+    assert.deepEqual(done, ['b'])
+  })
+
+  test('budget exceeded mid-pipeline skips remaining non-format steps', async () => {
+    const failed = []
+    const done = []
+    const skipped = []
+
+    const steps = [
+      makeStep('context', { parseResult: { contextDone: true } }),
+      makeStep('scope', { parseResult: { scopeDone: true } }),
+      makeStep('risk', { parseResult: { riskDone: true } }),
+      { ...makeStep('format', { parseResult: { body: 'formatted' } }), name: 'format' },
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { context: 'always', scope: 'always', risk: 'always', format: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    // Budget check fails after first step
+    let budgetCalls = 0
+    const budgetHelpers = {
+      checkBudgets() {
+        budgetCalls++
+        if (budgetCalls > 1) throw new Error('budget exceeded')
+      },
+      recordUsage() {},
+    }
+
+    await runPipeline(steps, ctx, route, null, {}, {
+      onStepDone(step) { done.push(step.name) },
+      onStepSkip(step, reason) { skipped.push(step.name) },
+      onStepFail(step) { failed.push(step.name) },
+    }, budgetHelpers)
+
+    // context runs successfully
+    assert.ok(done.includes('context'))
+    // scope fails on budget check
+    assert.ok(failed.includes('scope'))
+    // risk is skipped because budgetExhausted is true and it's not format
+    assert.ok(skipped.includes('risk'))
+    // format still runs (allowed even when budget exhausted)
+    assert.ok(done.includes('format'))
+  })
+
+  test('callbacks fire with correct arguments', async () => {
+    const events = []
+    const steps = [
+      makeStep('a', { parseResult: { x: 1 } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+
+    await runPipeline(steps, ctx, route, null, null, {
+      onStepStart(step) { events.push({ type: 'start', step: step.name }) },
+      onStepDone(step, resultCtx) { events.push({ type: 'done', step: step.name, hasCtx: !!resultCtx }) },
+    })
+
+    assert.equal(events.length, 2)
+    assert.equal(events[0].type, 'start')
+    assert.equal(events[0].step, 'a')
+    assert.equal(events[1].type, 'done')
+    assert.equal(events[1].hasCtx, true)
+  })
+
+  test('step with provider override uses different adapter', async () => {
+    const adapterNames = []
+
+    // Override adapter that records its name
+    const overrideAdapter = {
+      name: 'override',
+      complete() { return Promise.resolve('{}') },
+      isConfigured() { return true },
+    }
+
+    const steps = [
+      makeStep('a', { parseResult: { aDone: true }, provider: 'my-cli' }),
+      makeStep('b', { parseResult: { bDone: true } }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always', b: 'always' } }
+    const defaultAdapter = mockAdapter()
+    const route = { adapter: defaultAdapter, model: 'test-model' }
+
+    // Config with a custom provider that resolveProviderAdapter will find
+    const config = {
+      ai: {
+        providers: {
+          'my-cli': { command: 'echo test' },
+        },
+      },
+    }
+
+    const done = []
+    await runPipeline(steps, ctx, route, config, null, {
+      onStepDone(step) { done.push(step.name) },
+    })
+
+    // Both steps should complete (step a uses the override provider, step b uses default)
+    assert.deepEqual(done, ['a', 'b'])
+    assert.equal(ctx.aDone, true)
+    assert.equal(ctx.bDone, true)
+  })
+
+  test('step with invalid provider falls back to default route', async () => {
+    const failed = []
+    const done = []
+
+    const steps = [
+      makeStep('a', { parseResult: { aDone: true }, provider: 'nonexistent-provider' }),
+    ]
+
+    const ctx = { title: 'test', _stepConfigs: { a: 'always' } }
+    const route = { adapter: mockAdapter(), model: 'test' }
+    const config = { ai: {} }
+
+    await runPipeline(steps, ctx, route, config, null, {
+      onStepFail(step, err) { failed.push({ name: step.name, msg: err.message }) },
+      onStepDone(step) { done.push(step.name) },
+    })
+
+    // Provider override fails — onStepFail called with warning, but step continues with default
+    assert.equal(failed.length, 1)
+    assert.ok(failed[0].msg.includes('nonexistent-provider'))
+    // Step still runs with default adapter
+    assert.deepEqual(done, ['a'])
+    assert.equal(ctx.aDone, true)
+  })
+})

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

@@ -0,0 +1,30 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { buildMessages } from './prompt.js'
+
+describe('buildMessages', () => {
+  it('builds system and user messages', () => {
+    const msgs = buildMessages('Fix login', 'Login is broken', '## Bug\n\nLogin is broken')
+    assert.equal(msgs.length, 2)
+    assert.equal(msgs[0].role, 'system')
+    assert.equal(msgs[1].role, 'user')
+    assert.ok(msgs[1].content.includes('Fix login'))
+    assert.ok(msgs[1].content.includes('Login is broken'))
+  })
+
+  it('includes instructions in system message', () => {
+    const msgs = buildMessages('Fix it', 'desc', 'body', 'keep it short')
+    assert.ok(msgs[0].content.includes('keep it short'))
+  })
+
+  it('omits instructions when not provided', () => {
+    const msgs = buildMessages('Fix it', 'desc', 'body')
+    assert.ok(!msgs[0].content.includes('Additional instructions'))
+  })
+
+  it('handles empty description', () => {
+    const msgs = buildMessages('Title', '', '## Template')
+    assert.equal(msgs.length, 2)
+    assert.ok(msgs[1].content.includes('Title'))
+  })
+})

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,10 @@ const ADAPTER_MAP = {
   ollama: OllamaAdapter,
   'openai-compat': OpenAICompatAdapter,
   command: CommandAdapter,
+  'gemini-cli': GeminiCliAdapter,
+  'claude-cli': ClaudeCliAdapter,
+  'codex-cli': CodexCliAdapter,
+  openclaw: OpenClawAdapter,
 }
 
 /**
@@ -164,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) }
   }