tissues 0.6.0 → 0.6.1

package/src/lib/ai/router.js

@@ -14,6 +14,34 @@ const ADAPTER_MAP = {
   command: CommandAdapter,
 }
 
+/**
+ * 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
+}
+
 /**
  * Resolve which adapter + model to use for a given issue context.
  *
@@ -23,14 +51,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 +67,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 +77,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 }
 }
@@ -120,9 +195,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/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 }

package/src/lib/dedup.js

@@ -45,42 +45,44 @@ export function computeIdempotencyKey({ agent, trigger, issueType, repo }) {
   return crypto.createHash('sha256').update(raw).digest('hex')
 }
 
+const STOP_WORDS = new Set([
+  'a','an','the','in','on','at','to','for','of','with','by','from',
+  'is','are','was','were','be','been','being','has','have','had',
+  'do','does','did','will','would','could','should','can','may',
+  'not','no','but','or','and','if','then','so','as','it','its',
+  'this','that','we','our','i','my','you','your','they','their',
+])
+
 /**
- * Compute Levenshtein distance between two strings.
+ * Tokenize text: normalize, split on spaces, remove stop words.
  *
- * @param {string} a
- * @param {string} b
- * @returns {number}
+ * @param {string} text
+ * @returns {string[]}
  */
-function levenshteinDistance(a, b) {
-  const m = a.length
-  const n = b.length
-  const dp = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)])
-  for (let j = 0; j <= n; j++) dp[0][j] = j
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i][j] =
-        a[i - 1] === b[j - 1]
-          ? dp[i - 1][j - 1]
-          : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
-    }
-  }
-  return dp[m][n]
+function tokenize(text) {
+  return normalizeText(text)
+    .split(' ')
+    .filter(w => w.length > 0 && !STOP_WORDS.has(w))
 }
 
 /**
- * Compute similarity between two strings as a value in [0, 1].
- * 1.0 means identical, 0.0 means completely different.
+ * Compute Jaccard similarity between two strings based on token sets.
+ * Tokens are words with stop words removed.
+ * Returns a value in [0, 1]: 1.0 = identical token sets, 0.0 = no overlap.
  *
  * @param {string} a
  * @param {string} b
  * @returns {number}
  */
-export function levenshteinSimilarity(a, b) {
-  if (a === b) return 1
-  const maxLen = Math.max(a.length, b.length)
-  if (maxLen === 0) return 1
-  return 1 - levenshteinDistance(a, b) / maxLen
+export function jaccardSimilarity(a, b) {
+  const setA = new Set(tokenize(a))
+  const setB = new Set(tokenize(b))
+  if (setA.size === 0 && setB.size === 0) return 1
+  if (setA.size === 0 || setB.size === 0) return 0
+  let intersection = 0
+  for (const w of setA) if (setB.has(w)) intersection++
+  const union = new Set([...setA, ...setB]).size
+  return intersection / union
 }
 
 /**
@@ -167,12 +169,16 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
     })
   }
 
-  // Layer 3: fuzzy title match
-  const normalizedTitle = normalizeText(title)
+  // Layer 3: fuzzy title match (token-set Jaccard)
+  const newTokens = tokenize(title)
+  const isShortTitle = newTokens.length <= 2
   const openIssues = await getCachedIssues(repo)
   for (const issue of openIssues) {
-    const similarity = levenshteinSimilarity(normalizedTitle, normalizeText(issue.title))
-    if (similarity >= 0.90) {
+    const similarity = jaccardSimilarity(title, issue.title)
+    // Short-title guard: ≤2 meaningful tokens require exact match to block, ≥0.80 to warn
+    const blockThreshold = isShortTitle ? 1.0 : 0.80
+    const warnThreshold = isShortTitle ? 0.80 : 0.50
+    if (similarity >= blockThreshold) {
       results.push({
         action: 'block',
         reason: `Fuzzy title match (similarity ${(similarity * 100).toFixed(1)}%) with existing issue`,
@@ -183,7 +189,7 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
         },
       })
       break
-    } else if (similarity >= 0.75) {
+    } else if (similarity >= warnThreshold) {
       results.push({
         action: 'warn',
         reason: `Fuzzy title is similar (similarity ${(similarity * 100).toFixed(1)}%) to existing issue`,

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,
@@ -58,6 +63,7 @@ export const BUILT_IN_DEFAULTS = {
     ollama: { url: 'http://localhost:11434' },
     custom: { url: null },              // openai-compat base URL
     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 +72,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,6 +82,16 @@ 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',
+      },
     },
   },