tissues 0.6.0 → 0.6.2

package/src/lib/dedup.test.js

@@ -0,0 +1,227 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import { normalizeText, computeFingerprint, computeIdempotencyKey, jaccardSimilarity, scoreDedupConfidence } from './dedup.js'
+
+describe('normalizeText', () => {
+  test('lowercases input', () => {
+    assert.equal(normalizeText('Hello World'), 'hello world')
+  })
+
+  test('replaces non-alphanumeric characters with spaces', () => {
+    assert.equal(normalizeText('foo-bar_baz!qux'), 'foo bar baz qux')
+  })
+
+  test('collapses multiple spaces into one', () => {
+    assert.equal(normalizeText('foo   bar   baz'), 'foo bar baz')
+  })
+
+  test('trims leading and trailing whitespace', () => {
+    assert.equal(normalizeText('  hello world  '), 'hello world')
+  })
+
+  test('handles empty string', () => {
+    assert.equal(normalizeText(''), '')
+  })
+
+  test('handles only special characters', () => {
+    assert.equal(normalizeText('!!!---...'), '')
+  })
+
+  test('preserves digits', () => {
+    assert.equal(normalizeText('fix bug 42 in v2'), 'fix bug 42 in v2')
+  })
+
+  test('normalizes punctuation-heavy title', () => {
+    assert.equal(normalizeText('[BUG]: Fix null-pointer exception!'), 'bug fix null pointer exception')
+  })
+})
+
+describe('computeFingerprint', () => {
+  test('returns a 64-character hex string', () => {
+    const fp = computeFingerprint('Title', 'Body text')
+    assert.equal(typeof fp, 'string')
+    assert.equal(fp.length, 64)
+    assert.match(fp, /^[0-9a-f]{64}$/)
+  })
+
+  test('same inputs produce same fingerprint', () => {
+    const fp1 = computeFingerprint('Fix login bug', 'The login page crashes when...')
+    const fp2 = computeFingerprint('Fix login bug', 'The login page crashes when...')
+    assert.equal(fp1, fp2)
+  })
+
+  test('different titles produce different fingerprints', () => {
+    const fp1 = computeFingerprint('Fix login bug', 'Same body')
+    const fp2 = computeFingerprint('Fix signup bug', 'Same body')
+    assert.notEqual(fp1, fp2)
+  })
+
+  test('different bodies produce different fingerprints', () => {
+    const fp1 = computeFingerprint('Same title', 'Body A')
+    const fp2 = computeFingerprint('Same title', 'Body B')
+    assert.notEqual(fp1, fp2)
+  })
+
+  test('only uses first 500 chars of body', () => {
+    const body500 = 'a'.repeat(500)
+    const body501 = 'a'.repeat(500) + 'z'
+    const fp3 = computeFingerprint('T', body500)
+    const fp4 = computeFingerprint('T', body501)
+    assert.equal(fp3, fp4)
+  })
+
+  test('handles null/undefined body gracefully', () => {
+    const fp1 = computeFingerprint('Title', null)
+    const fp2 = computeFingerprint('Title', undefined)
+    const fp3 = computeFingerprint('Title', '')
+    assert.equal(fp1, fp3)
+    assert.equal(fp2, fp3)
+  })
+})
+
+describe('computeIdempotencyKey', () => {
+  test('returns a 64-character hex string', () => {
+    const key = computeIdempotencyKey({ agent: 'bot', trigger: 'cli', issueType: 'bug', repo: 'owner/repo' })
+    assert.equal(typeof key, 'string')
+    assert.equal(key.length, 64)
+    assert.match(key, /^[0-9a-f]{64}$/)
+  })
+
+  test('same context produces same key', () => {
+    const ctx = { agent: 'bot', trigger: 'api', issueType: 'feature', repo: 'org/proj' }
+    assert.equal(computeIdempotencyKey(ctx), computeIdempotencyKey(ctx))
+  })
+
+  test('different agent produces different key', () => {
+    const ctx = { agent: 'bot-a', trigger: 'api', issueType: 'bug', repo: 'org/repo' }
+    const ctx2 = { ...ctx, agent: 'bot-b' }
+    assert.notEqual(computeIdempotencyKey(ctx), computeIdempotencyKey(ctx2))
+  })
+
+  test('different repo produces different key', () => {
+    const ctx = { agent: 'bot', trigger: 'api', issueType: 'bug', repo: 'org/repo-a' }
+    const ctx2 = { ...ctx, repo: 'org/repo-b' }
+    assert.notEqual(computeIdempotencyKey(ctx), computeIdempotencyKey(ctx2))
+  })
+})
+
+describe('jaccardSimilarity', () => {
+  test('identical strings return 1.0', () => {
+    assert.equal(jaccardSimilarity('fix login crash', 'fix login crash'), 1)
+  })
+
+  test('both empty strings return 1.0', () => {
+    assert.equal(jaccardSimilarity('', ''), 1)
+  })
+
+  test('both only stop words return 1.0', () => {
+    // After stop-word removal, both are empty token sets
+    assert.equal(jaccardSimilarity('the and or', 'is are was'), 1)
+  })
+
+  test('one empty string returns 0', () => {
+    assert.equal(jaccardSimilarity('', 'fix login'), 0)
+    assert.equal(jaccardSimilarity('fix login', ''), 0)
+  })
+
+  test('one all-stop-words vs meaningful tokens returns 0', () => {
+    assert.equal(jaccardSimilarity('the and or', 'fix login crash'), 0)
+  })
+
+  test('zero word overlap returns 0', () => {
+    assert.equal(jaccardSimilarity('stop agents hallucinating', 'sadfdasfa'), 0)
+  })
+
+  test('partial overlap computes correct ratio', () => {
+    // tokens: {fix,login,crash} vs {fix,login,error} → intersection=2, union=4
+    const sim = jaccardSimilarity('fix login crash', 'fix login error')
+    assert.equal(sim, 2 / 4)
+  })
+
+  test('stop words are stripped from comparison', () => {
+    // "fix the login crash" → {fix,login,crash}; "fix a login error" → {fix,login,error}
+    const sim = jaccardSimilarity('fix the login crash', 'fix a login error')
+    assert.equal(sim, 2 / 4)
+  })
+
+  test('high overlap for near-duplicate titles', () => {
+    // {fix,login,crash} vs {fix,login,crash,safari} → 3/4 = 0.75
+    const sim = jaccardSimilarity('fix login crash', 'fix login crash on safari')
+    assert.equal(sim, 3 / 4)
+  })
+
+  test('symmetric: sim(a,b) === sim(b,a)', () => {
+    const a = 'authentication error in production'
+    const b = 'authorization failure in staging'
+    assert.equal(jaccardSimilarity(a, b), jaccardSimilarity(b, a))
+  })
+
+  test('returns value in [0, 1] range', () => {
+    const pairs = [
+      ['', 'abc'],
+      ['abc', ''],
+      ['abc', 'abc'],
+      ['totally', 'different'],
+      ['Fix null pointer', 'fix null-pointer exception in login'],
+    ]
+    for (const [a, b] of pairs) {
+      const sim = jaccardSimilarity(a, b)
+      assert.ok(sim >= 0 && sim <= 1, `similarity out of range for "${a}", "${b}": ${sim}`)
+    }
+  })
+
+  test('short titles with different words have low similarity', () => {
+    // "fix bug" → {fix,bug}, "fix auth" → {fix,auth} → 1/3 = 0.33
+    const sim = jaccardSimilarity('fix bug', 'fix auth')
+    assert.ok(sim < 0.5, `expected < 0.5 for short distinct titles, got ${sim}`)
+  })
+
+  test('case insensitive', () => {
+    assert.equal(jaccardSimilarity('Fix Login Crash', 'fix login crash'), 1)
+  })
+
+  test('punctuation ignored', () => {
+    // Punctuation stripped: "fix login crash!" → {fix,login,crash}, same as "fix login crash"
+    assert.equal(jaccardSimilarity('fix login crash!', 'fix login crash'), 1)
+  })
+})
+
+describe('scoreDedupConfidence', () => {
+  test('high confidence at 70+', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 50, fileMentions: 20, labelMatches: 5 })
+    assert.equal(result.level, 'high')
+    assert.equal(result.confidence, 75)
+  })
+
+  test('medium confidence at 40-69', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 30, fileMentions: 15, labelMatches: 0 })
+    assert.equal(result.level, 'medium')
+    assert.equal(result.confidence, 45)
+  })
+
+  test('low confidence at 21-39', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 20, fileMentions: 5, labelMatches: 0 })
+    assert.equal(result.level, 'low')
+    assert.equal(result.confidence, 25)
+  })
+
+  test('none confidence at 20 or below', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 10, fileMentions: 5, labelMatches: 5 })
+    assert.equal(result.level, 'none')
+    assert.equal(result.confidence, 20)
+  })
+
+  test('clamps to 0-100 range', () => {
+    const high = scoreDedupConfidence({ titleOverlap: 60, fileMentions: 40, labelMatches: 20 })
+    assert.equal(high.confidence, 100)
+
+    const low = scoreDedupConfidence({ titleOverlap: -10, fileMentions: 0, labelMatches: 0 })
+    assert.equal(low.confidence, 0)
+  })
+
+  test('defaults to zero for missing fields', () => {
+    const result = scoreDedupConfidence({})
+    assert.equal(result.confidence, 0)
+    assert.equal(result.level, 'none')
+  })
+})

package/src/lib/defaults.js

@@ -36,6 +36,11 @@ export const BUILT_IN_DEFAULTS = {
     default: 'default',          // default template name
   },
 
+  // Enhancements
+  enhancements: {
+    dir: '.tissues/enhancements', // relative to repo root, or absolute
+  },
+
   // AI
   ai: {
     enabled: true,
@@ -48,6 +53,10 @@ export const BUILT_IN_DEFAULTS = {
       ollama: 'llama3.2',
       'openai-compat': null,            // user must set
       command: null,                     // not applicable
+      'gemini-cli': null,               // uses CLI default
+      'claude-cli': null,               // uses CLI default
+      'codex-cli': null,                // uses CLI default
+      openclaw: null,                   // set by gateway
     },
     keys: {
       anthropic: null,
@@ -57,7 +66,13 @@ export const BUILT_IN_DEFAULTS = {
     },
     ollama: { url: 'http://localhost:11434' },
     custom: { url: null },              // openai-compat base URL
+    openclaw: {                         // OpenClaw gateway config
+      gatewayUrl: null,                 // default: http://localhost:18790
+      token: null,                      // or OPENCLAW_GATEWAY_TOKEN env var
+      agentId: null,                    // optional agent ID
+    },
     command: null,                       // e.g. 'co inference'
+    providers: {},                       // named custom providers: { "my-gemini": { command: "co gemini", timeout: 120000 } }
     routes: [],                         // routing rules
     budgets: {
       maxTokensPerRequest: 4096,        // hard cap per single AI call
@@ -66,7 +81,7 @@ export const BUILT_IN_DEFAULTS = {
     },
     pipeline: {
       enabled: true,                    // multi-step enhancement pipeline
-      steps: {
+      steps: {                          // legacy key (alias for enhancements)
         triage:     'always',           // 'always' | 'auto' | 'never'
         dedup:      'auto',             // 'always' | 'auto' | 'never'
         context:    'always',
@@ -76,9 +91,30 @@ export const BUILT_IN_DEFAULTS = {
         labels:     'auto',
         format:     'always',
       },
+      enhancements: {                   // preferred key (same shape as steps)
+        triage:     'always',
+        dedup:      'auto',
+        context:    'always',
+        scope:      'auto',
+        complexity: 'auto',
+        risk:       'auto',
+        labels:     'auto',
+        format:     'always',
+      },
     },
   },
 
+  // Background sync
+  sync: {
+    enabled: false,           // opt-in
+    repos: [],                // empty = activeRepo only
+    interval: 300,            // seconds (5 min default)
+    adaptiveInterval: true,   // adjust based on user activity
+    issueLimit: 500,          // max issues per repo per sync
+    includeClosedDays: 30,    // sync issues closed within N days
+    autoStart: false,         // auto-fork daemon on first CLI use
+  },
+
   // Hooks (shell commands to run)
   hooks: {
     postCreate: null, // e.g., 'slack-notify.sh'

package/src/lib/defaults.test.js

@@ -0,0 +1,217 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { BUILT_IN_DEFAULTS, findRepoRoot, loadConfig, getConfigValue, userConfigPath } from './defaults.js'
+
+describe('BUILT_IN_DEFAULTS', () => {
+  test('has safety section with expected keys', () => {
+    assert.ok(BUILT_IN_DEFAULTS.safety)
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.maxPerHour, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.burstLimit, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.burstWindowMinutes, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.tripThreshold, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.cooldownMinutes, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.globalMaxPerHour, 'number')
+  })
+
+  test('has dedup section with thresholds', () => {
+    assert.ok(BUILT_IN_DEFAULTS.dedup)
+    assert.equal(BUILT_IN_DEFAULTS.dedup.blockAbove, 0.95)
+    assert.equal(BUILT_IN_DEFAULTS.dedup.warnAbove, 0.80)
+    assert.ok(typeof BUILT_IN_DEFAULTS.dedup.fingerprintTTLDays === 'number')
+  })
+
+  test('has attribution section', () => {
+    assert.ok(BUILT_IN_DEFAULTS.attribution)
+    assert.equal(BUILT_IN_DEFAULTS.attribution.required, false)
+    assert.equal(BUILT_IN_DEFAULTS.attribution.defaultAgent, 'human')
+  })
+
+  test('has templates section', () => {
+    assert.ok(BUILT_IN_DEFAULTS.templates)
+    assert.ok(typeof BUILT_IN_DEFAULTS.templates.dir === 'string')
+    assert.equal(BUILT_IN_DEFAULTS.templates.default, 'default')
+  })
+
+  test('has ai section', () => {
+    assert.ok(BUILT_IN_DEFAULTS.ai)
+    assert.equal(typeof BUILT_IN_DEFAULTS.ai.enabled, 'boolean')
+    assert.ok(typeof BUILT_IN_DEFAULTS.ai.provider === 'string')
+    assert.equal(BUILT_IN_DEFAULTS.ai.model, null)
+    assert.ok(BUILT_IN_DEFAULTS.ai.models)
+    assert.ok(typeof BUILT_IN_DEFAULTS.ai.models.anthropic === 'string')
+    assert.ok(BUILT_IN_DEFAULTS.ai.keys)
+    assert.ok(Array.isArray(BUILT_IN_DEFAULTS.ai.routes))
+  })
+
+  test('has hooks section with null defaults', () => {
+    assert.ok(BUILT_IN_DEFAULTS.hooks)
+    assert.equal(BUILT_IN_DEFAULTS.hooks.postCreate, null)
+    assert.equal(BUILT_IN_DEFAULTS.hooks.postClose, null)
+  })
+})
+
+describe('findRepoRoot', () => {
+  test('finds a git repo root from a subdirectory', () => {
+    // The project itself is a git repo
+    const root = findRepoRoot(path.join(process.cwd(), 'src', 'lib'))
+    assert.ok(root, 'should find a repo root')
+    assert.ok(fs.existsSync(path.join(root, '.git')))
+  })
+
+  test('returns null when no git repo found', () => {
+    // Use os.tmpdir() which (almost certainly) has no .git above it
+    const root = findRepoRoot(os.tmpdir())
+    // On some systems tmpdir might be inside a git repo; just check type
+    assert.ok(root === null || typeof root === 'string')
+  })
+
+  test('returns the directory that contains .git, not a subdirectory', () => {
+    const root = findRepoRoot(process.cwd())
+    assert.ok(root)
+    assert.ok(fs.existsSync(path.join(root, '.git')))
+    // The .git directory should be a direct child, not deeper
+    const gitPath = path.join(root, '.git')
+    const stat = fs.statSync(gitPath)
+    assert.ok(stat.isDirectory() || stat.isFile()) // worktrees use a file
+  })
+})
+
+describe('userConfigPath', () => {
+  test('returns a string path ending in config.json', () => {
+    const p = userConfigPath()
+    assert.ok(typeof p === 'string')
+    assert.ok(p.endsWith('config.json'))
+  })
+
+  test('includes tissues in the path', () => {
+    const p = userConfigPath()
+    assert.ok(p.includes('tissues'))
+  })
+
+  test('is under the home directory', () => {
+    const p = userConfigPath()
+    const home = os.homedir()
+    assert.ok(p.startsWith(home))
+  })
+})
+
+describe('loadConfig', () => {
+  test('returns an object with all built-in sections when no files exist', () => {
+    // Use a temp dir with .git so loadConfig does not pick up project-level config
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-defaults-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    try {
+      const cfg = loadConfig(tmpDir)
+      assert.ok(cfg.safety)
+      assert.ok(cfg.dedup)
+      assert.ok(cfg.attribution)
+      assert.ok(cfg.templates)
+      assert.ok(cfg.ai)
+      assert.ok(cfg.hooks)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('CLI overrides take highest priority', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-cli-override-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    try {
+      const cfg = loadConfig(tmpDir, { safety: { maxPerHour: 999 } })
+      assert.equal(cfg.safety.maxPerHour, 999)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('repo-level config overrides built-in defaults', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-repo-cfg-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues'))
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'config.json'),
+      JSON.stringify({ safety: { maxPerHour: 50 } })
+    )
+    try {
+      const cfg = loadConfig(tmpDir)
+      assert.equal(cfg.safety.maxPerHour, 50)
+      // Other fields still come from defaults
+      assert.equal(cfg.safety.burstLimit, BUILT_IN_DEFAULTS.safety.burstLimit)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('CLI overrides take priority over repo config', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-priority-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues'))
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'config.json'),
+      JSON.stringify({ safety: { maxPerHour: 50 } })
+    )
+    try {
+      const cfg = loadConfig(tmpDir, { safety: { maxPerHour: 100 } })
+      assert.equal(cfg.safety.maxPerHour, 100)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('deep merge does not clobber sibling keys', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-deep-merge-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    try {
+      // Override only one key in safety; others should remain
+      const cfg = loadConfig(tmpDir, { safety: { maxPerHour: 20 } })
+      assert.equal(cfg.safety.maxPerHour, 20)
+      assert.equal(cfg.safety.burstLimit, BUILT_IN_DEFAULTS.safety.burstLimit)
+      assert.equal(cfg.safety.tripThreshold, BUILT_IN_DEFAULTS.safety.tripThreshold)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('invalid JSON in repo config is silently ignored', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-bad-json-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues'))
+    fs.writeFileSync(path.join(tmpDir, '.tissues', 'config.json'), 'not json {{{')
+    try {
+      const cfg = loadConfig(tmpDir)
+      // Should fall back gracefully to defaults
+      assert.equal(cfg.safety.maxPerHour, BUILT_IN_DEFAULTS.safety.maxPerHour)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe('getConfigValue', () => {
+  test('retrieves a nested value using dot notation', () => {
+    // Use the actual tissues repo root — the project itself is a git repo
+    const val = getConfigValue('safety.maxPerHour')
+    assert.ok(typeof val === 'number')
+    assert.ok(val > 0)
+  })
+
+  test('returns undefined for unknown key path', () => {
+    const val = getConfigValue('nonexistent.key.path')
+    assert.equal(val, undefined)
+  })
+
+  test('retrieves top-level section', () => {
+    const safety = getConfigValue('safety')
+    assert.ok(safety && typeof safety === 'object')
+    assert.ok('maxPerHour' in safety)
+  })
+
+  test('retrieves deeply nested ai.models.anthropic', () => {
+    const model = getConfigValue('ai.models.anthropic')
+    assert.ok(typeof model === 'string')
+    assert.ok(model.length > 0)
+  })
+})