tissues 0.6.1 → 0.6.2

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

@@ -0,0 +1,335 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import { ALL_STEPS, getStep } from './steps.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function baseCtx(overrides = {}) {
+  return {
+    rawInput: '',
+    title: 'Fix auth bug in login flow',
+    description: 'The login page throws a 401 error when using OAuth',
+    instructions: '',
+    templateBody: '## Summary\n\n{{description}}',
+    labels: ['bug'],
+    existingIssues: [],
+    repoLabels: ['bug', 'feature', 'P0-critical', 'P1-high', 'P2-medium'],
+    dedupScore: null,
+    structuredContext: null,
+    scopeAnalysis: null,
+    complexity: null,
+    complexityRationale: null,
+    risk: null,
+    riskRationale: null,
+    aiLabels: null,
+    body: '',
+    ...overrides,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// ALL_STEPS structure
+// ---------------------------------------------------------------------------
+
+describe('ALL_STEPS', () => {
+  test('has 8 steps in correct order', () => {
+    assert.equal(ALL_STEPS.length, 8)
+    assert.deepEqual(
+      ALL_STEPS.map((s) => s.name),
+      ['triage', 'dedup', 'context', 'scope', 'complexity', 'risk', 'labels', 'format'],
+    )
+  })
+
+  test('every step has required fields', () => {
+    for (const step of ALL_STEPS) {
+      assert.ok(step.name, `${step.name} has name`)
+      assert.ok(step.displayName, `${step.name} has displayName`)
+      assert.ok(typeof step.maxTokens === 'number', `${step.name} has maxTokens`)
+      assert.ok(typeof step.shouldRun === 'function', `${step.name} has shouldRun`)
+      assert.ok(typeof step.buildMessages === 'function', `${step.name} has buildMessages`)
+      assert.ok(typeof step.parseResponse === 'function', `${step.name} has parseResponse`)
+    }
+  })
+
+  test('getStep returns correct step', () => {
+    assert.equal(getStep('dedup').name, 'dedup')
+    assert.equal(getStep('format').name, 'format')
+    assert.equal(getStep('nonexistent'), undefined)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildMessages tests
+// ---------------------------------------------------------------------------
+
+describe('buildMessages', () => {
+  test('each step returns well-formed messages', () => {
+    const ctx = baseCtx({ rawInput: 'the login page throws a 401 error when using OAuth' })
+    for (const step of ALL_STEPS) {
+      const msgs = step.buildMessages(ctx)
+      assert.ok(Array.isArray(msgs), `${step.name} returns array`)
+      assert.ok(msgs.length >= 2, `${step.name} has system + user messages`)
+      assert.equal(msgs[0].role, 'system')
+      assert.equal(msgs[1].role, 'user')
+      assert.ok(msgs[0].content.length > 0, `${step.name} system message not empty`)
+      assert.ok(msgs[1].content.length > 0, `${step.name} user message not empty`)
+    }
+  })
+
+  test('format step includes prior analysis when available', () => {
+    const ctx = baseCtx({
+      complexity: 7,
+      complexityRationale: 'Multi-service change',
+      risk: 4,
+      riskRationale: 'Low data loss risk',
+      scopeAnalysis: { files: [{ path: 'auth.js' }], affectedAreas: ['auth'] },
+    })
+    const msgs = getStep('format').buildMessages(ctx)
+    const userContent = msgs[1].content
+    assert.ok(userContent.includes('Complexity: 7/10'))
+    assert.ok(userContent.includes('Risk: 4/10'))
+  })
+
+  test('dedup step includes existing issues', () => {
+    const ctx = baseCtx({
+      existingIssues: [
+        { number: 1, title: 'Fix login bug' },
+        { number: 2, title: 'Add OAuth support' },
+      ],
+    })
+    const msgs = getStep('dedup').buildMessages(ctx)
+    const userContent = msgs[1].content
+    assert.ok(userContent.includes('#1: Fix login bug'))
+    assert.ok(userContent.includes('#2: Add OAuth support'))
+  })
+
+  test('labels step includes available repo labels', () => {
+    const ctx = baseCtx()
+    const msgs = getStep('labels').buildMessages(ctx)
+    const systemContent = msgs[0].content
+    assert.ok(systemContent.includes('bug'))
+    assert.ok(systemContent.includes('P0-critical'))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// parseResponse tests
+// ---------------------------------------------------------------------------
+
+describe('parseResponse', () => {
+  test('dedup parses valid JSON', () => {
+    const ctx = baseCtx()
+    getStep('dedup').parseResponse(
+      JSON.stringify({ confidence: 85, level: 'high', matches: [{ number: 1, reason: 'similar title' }] }),
+      ctx,
+    )
+    assert.equal(ctx.dedupScore.confidence, 85)
+    assert.equal(ctx.dedupScore.level, 'high')
+    assert.equal(ctx.dedupScore.matches.length, 1)
+  })
+
+  test('dedup handles malformed JSON gracefully', () => {
+    const ctx = baseCtx()
+    getStep('dedup').parseResponse('not json at all', ctx)
+    assert.equal(ctx.dedupScore, null)
+  })
+
+  test('context parses valid JSON', () => {
+    const ctx = baseCtx()
+    getStep('context').parseResponse(
+      JSON.stringify({ problem: 'Auth fails', files: ['auth.js'], errors: ['401'], sessionContext: '' }),
+      ctx,
+    )
+    assert.equal(ctx.structuredContext.problem, 'Auth fails')
+    assert.deepEqual(ctx.structuredContext.files, ['auth.js'])
+  })
+
+  test('context handles malformed JSON gracefully', () => {
+    const ctx = baseCtx()
+    getStep('context').parseResponse('invalid', ctx)
+    assert.equal(ctx.structuredContext, null)
+  })
+
+  test('scope parses valid JSON', () => {
+    const ctx = baseCtx()
+    getStep('scope').parseResponse(
+      JSON.stringify({ files: [{ path: 'a.js', purpose: 'auth', deps: [] }], affectedAreas: ['auth'] }),
+      ctx,
+    )
+    assert.equal(ctx.scopeAnalysis.files.length, 1)
+    assert.deepEqual(ctx.scopeAnalysis.affectedAreas, ['auth'])
+  })
+
+  test('complexity parses valid JSON and clamps score', () => {
+    const ctx = baseCtx()
+    getStep('complexity').parseResponse(
+      JSON.stringify({ score: 15, rationale: 'very complex' }),
+      ctx,
+    )
+    assert.equal(ctx.complexity, 10) // clamped to max
+    assert.equal(ctx.complexityRationale, 'very complex')
+  })
+
+  test('complexity handles malformed JSON gracefully', () => {
+    const ctx = baseCtx()
+    getStep('complexity').parseResponse('nope', ctx)
+    assert.equal(ctx.complexity, null)
+  })
+
+  test('risk parses valid JSON', () => {
+    const ctx = baseCtx()
+    getStep('risk').parseResponse(
+      JSON.stringify({ score: 3, rationale: 'low risk' }),
+      ctx,
+    )
+    assert.equal(ctx.risk, 3)
+  })
+
+  test('labels parses valid JSON and filters to repo labels', () => {
+    const ctx = baseCtx()
+    getStep('labels').parseResponse(
+      JSON.stringify({ labels: ['bug', 'nonexistent', 'P2-medium'], reasoning: 'fits' }),
+      ctx,
+    )
+    assert.deepEqual(ctx.aiLabels, ['bug', 'P2-medium'])
+  })
+
+  test('labels handles malformed JSON gracefully', () => {
+    const ctx = baseCtx()
+    getStep('labels').parseResponse('bad', ctx)
+    assert.equal(ctx.aiLabels, null)
+  })
+
+  test('format sets body from raw markdown', () => {
+    const ctx = baseCtx()
+    getStep('format').parseResponse('## Summary\n\nFixed the auth bug.', ctx)
+    assert.equal(ctx.body, '## Summary\n\nFixed the auth bug.')
+  })
+
+  test('format ignores empty response', () => {
+    const ctx = baseCtx({ body: 'original template' })
+    getStep('format').parseResponse('   ', ctx)
+    assert.equal(ctx.body, 'original template')
+  })
+
+  test('dedup parses response with markdown fences', () => {
+    const ctx = baseCtx()
+    getStep('dedup').parseResponse(
+      '```json\n{"confidence": 50, "level": "medium", "matches": []}\n```',
+      ctx,
+    )
+    assert.equal(ctx.dedupScore.confidence, 50)
+    assert.equal(ctx.dedupScore.level, 'medium')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// shouldRun tests
+// ---------------------------------------------------------------------------
+
+describe('shouldRun heuristics', () => {
+  test('dedup AI step is always disabled', () => {
+    assert.equal(getStep('dedup').shouldRun(baseCtx({ existingIssues: [] })), false)
+    assert.equal(getStep('dedup').shouldRun(baseCtx({ existingIssues: [{ number: 1, title: 'x' }] })), false)
+  })
+
+  test('context always runs', () => {
+    assert.equal(getStep('context').shouldRun(baseCtx()), true)
+  })
+
+  test('scope runs when description mentions files', () => {
+    assert.equal(getStep('scope').shouldRun(baseCtx({ description: 'fix auth.js module' })), true)
+    assert.equal(getStep('scope').shouldRun(baseCtx({ description: 'button color wrong' })), false)
+  })
+
+  test('scope runs when context step found files', () => {
+    assert.equal(
+      getStep('scope').shouldRun(baseCtx({ structuredContext: { files: ['a.js'] } })),
+      true,
+    )
+  })
+
+  test('complexity runs when scope exists', () => {
+    assert.equal(
+      getStep('complexity').shouldRun(baseCtx({ scopeAnalysis: { files: [], affectedAreas: [] } })),
+      true,
+    )
+  })
+
+  test('complexity runs when description is long enough', () => {
+    assert.equal(getStep('complexity').shouldRun(baseCtx({ description: 'x'.repeat(51) })), true)
+    assert.equal(getStep('complexity').shouldRun(baseCtx({ description: 'short', scopeAnalysis: null })), false)
+  })
+
+  test('labels only runs when repoLabels present', () => {
+    assert.equal(getStep('labels').shouldRun(baseCtx({ repoLabels: [] })), false)
+    assert.equal(getStep('labels').shouldRun(baseCtx({ repoLabels: ['bug'] })), true)
+  })
+
+  test('format always runs', () => {
+    assert.equal(getStep('format').shouldRun(baseCtx()), true)
+  })
+
+  test('triage runs when rawInput is present', () => {
+    assert.equal(getStep('triage').shouldRun(baseCtx({ rawInput: 'the login page is broken on safari' })), true)
+  })
+
+  test('triage does not run when rawInput is empty', () => {
+    assert.equal(getStep('triage').shouldRun(baseCtx({ rawInput: '' })), false)
+    assert.equal(getStep('triage').shouldRun(baseCtx()), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Triage step tests
+// ---------------------------------------------------------------------------
+
+describe('triage step', () => {
+  test('buildMessages sends rawInput as user content', () => {
+    const ctx = baseCtx({ rawInput: 'the login page throws a 401 on safari when using oauth' })
+    const msgs = getStep('triage').buildMessages(ctx)
+    assert.equal(msgs.length, 2)
+    assert.equal(msgs[0].role, 'system')
+    assert.equal(msgs[1].role, 'user')
+    assert.equal(msgs[1].content, 'the login page throws a 401 on safari when using oauth')
+  })
+
+  test('parseResponse sets title and description from valid JSON', () => {
+    const ctx = baseCtx({ rawInput: 'long freeform text here' })
+    getStep('triage').parseResponse(
+      JSON.stringify({ title: 'Fix OAuth 401 on Safari', description: 'The login page throws a 401 error.' }),
+      ctx,
+    )
+    assert.equal(ctx.title, 'Fix OAuth 401 on Safari')
+    assert.equal(ctx.description, 'The login page throws a 401 error.')
+  })
+
+  test('parseResponse truncates title to 80 chars', () => {
+    const ctx = baseCtx()
+    const longTitle = 'A'.repeat(120)
+    getStep('triage').parseResponse(
+      JSON.stringify({ title: longTitle, description: 'desc' }),
+      ctx,
+    )
+    assert.equal(ctx.title.length, 80)
+  })
+
+  test('parseResponse handles malformed JSON gracefully', () => {
+    const ctx = baseCtx({ title: 'original title', description: 'original desc' })
+    getStep('triage').parseResponse('not valid json', ctx)
+    assert.equal(ctx.title, 'original title')
+    assert.equal(ctx.description, 'original desc')
+  })
+
+  test('parseResponse handles markdown-fenced JSON', () => {
+    const ctx = baseCtx()
+    getStep('triage').parseResponse(
+      '```json\n{"title": "Fix the bug", "description": "It breaks"}\n```',
+      ctx,
+    )
+    assert.equal(ctx.title, 'Fix the bug')
+    assert.equal(ctx.description, 'It breaks')
+  })
+})

package/src/lib/attribution.test.js

@@ -0,0 +1,64 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import { buildAttribution, renderAttribution } from './attribution.js'
+
+describe('buildAttribution', () => {
+  test('returns empty object with no options', () => {
+    const meta = buildAttribution()
+    assert.deepEqual(meta, {})
+  })
+
+  test('omits undefined optional fields', () => {
+    const meta = buildAttribution()
+    assert.equal('session' in meta, false)
+    assert.equal('model' in meta, false)
+  })
+
+  test('sets session and model when provided', () => {
+    const meta = buildAttribution({ session: 'abc123', model: 'claude-opus-4-6' })
+    assert.equal(meta.session, 'abc123')
+    assert.equal(meta.model, 'claude-opus-4-6')
+  })
+
+  test('only includes session when model is missing', () => {
+    const meta = buildAttribution({ session: 'sess-1' })
+    assert.equal(meta.session, 'sess-1')
+    assert.equal('model' in meta, false)
+  })
+
+  test('only includes model when session is missing', () => {
+    const meta = buildAttribution({ model: 'gpt-4' })
+    assert.equal(meta.model, 'gpt-4')
+    assert.equal('session' in meta, false)
+  })
+})
+
+describe('renderAttribution', () => {
+  test('returns null when no fields provided', () => {
+    const output = renderAttribution()
+    assert.equal(output, null)
+  })
+
+  test('wraps output in frontmatter delimiters', () => {
+    const output = renderAttribution({ session: 'abc' })
+    assert.ok(output.startsWith('---\ntissues-meta:'))
+    assert.ok(output.endsWith('---'))
+  })
+
+  test('includes session line', () => {
+    const output = renderAttribution({ session: 'sess-123' })
+    assert.ok(output.includes('session: sess-123'))
+  })
+
+  test('includes model line', () => {
+    const output = renderAttribution({ model: 'claude-opus-4-6' })
+    assert.ok(output.includes('model: claude-opus-4-6'))
+  })
+
+  test('each key appears on its own line', () => {
+    const output = renderAttribution({ session: 'abc', model: 'gpt-4' })
+    const lines = output.split('\n')
+    assert.ok(lines.find((l) => l.startsWith('session:')))
+    assert.ok(lines.find((l) => l.startsWith('model:')))
+  })
+})