tissues 0.5.2 → 0.6.1

package/src/lib/attribution.js

@@ -1,216 +1,55 @@
-import { createRequire } from 'node:module'
-import { fileURLToPath } from 'node:url'
-import path from 'node:path'
-import fs from 'node:fs'
-
-// ---------------------------------------------------------------------------
-// Package version (read once at module load)
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the package version from the nearest package.json.
- * Falls back to '0.0.0' if unavailable.
- *
- * @returns {string}
- */
-function resolvePackageVersion() {
-  try {
-    const require = createRequire(import.meta.url)
-    // Walk up from this file to find package.json
-    let dir = path.dirname(fileURLToPath(import.meta.url))
-    const { root } = path.parse(dir)
-    while (dir !== root) {
-      const pkgPath = path.join(dir, 'package.json')
-      if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
-        if (pkg.name === 'tissues' && pkg.version) return pkg.version
-      }
-      dir = path.dirname(dir)
-    }
-  } catch {
-    // ignore
-  }
-  return '0.0.0'
-}
-
-const PKG_VERSION = resolvePackageVersion()
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Return the current UTC timestamp in ISO 8601 format.
- *
- * @returns {string}
- */
-function nowISO() {
-  return new Date().toISOString()
-}
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
 /**
  * @typedef {object} AttributionOpts
- * @property {string}  [agent]          - agent identifier (e.g. 'claude-opus-4-6')
- * @property {string}  [session]        - session or conversation ID
- * @property {number}  [pid]            - process ID (opt-in; omitted by default)
- * @property {string}  [model]          - AI model used (if any)
- * @property {string}  [trigger]        - how the issue was created (e.g. 'cli-create')
- * @property {string}  [fingerprint]    - content fingerprint (sha256:...)
- * @property {string}  [idempotencyKey] - deterministic idempotency key
- * @property {number}  [risk]           - risk score [0,1]
- * @property {number}  [complexity]     - complexity estimate [0,1]
- * @property {number}  [confidence]     - AI confidence score [0,1]
- * @property {string[]} [contextTags]   - free-form tags for filtering/search
- * @property {string}  [createdAt]      - override timestamp (defaults to now)
+ * @property {string}  [session] - session or conversation ID
+ * @property {string}  [model]   - AI model used (if any)
  */
 
 /**
  * Build a normalized attribution metadata object from raw options.
  *
- * The returned object includes all provided fields plus automatic defaults
- * (`created_at`, `created_via`). Undefined/null fields are omitted.
- * `pid` is opt-in — it is only included if explicitly passed.
+ * Only includes session and model — fields the user actually cares about.
+ * Undefined/null fields are omitted.
  *
  * @param {AttributionOpts} opts
  * @returns {object} metadata record
  */
 export function buildAttribution(opts = {}) {
-  const {
-    agent,
-    session,
-    pid,
-    model,
-    trigger,
-    fingerprint,
-    idempotencyKey,
-    risk,
-    complexity,
-    confidence,
-    contextTags,
-    createdAt,
-  } = opts
-
+  const { session, model } = opts
   const meta = {}
 
-  // Identity
-  if (agent != null) meta.agent = String(agent)
   if (session != null) meta.session = String(session)
   if (model != null) meta.model = String(model)
 
-  // Process info (pid is opt-in — pass it explicitly to include)
-  if (pid != null) meta.pid = Number(pid)
-  meta.trigger = trigger != null ? String(trigger) : 'cli-create'
-
-  // Deduplication handles
-  if (fingerprint != null) meta.fingerprint = String(fingerprint)
-  if (idempotencyKey != null) meta.idempotency_key = String(idempotencyKey)
-
-  // Scoring (numeric, clamped to [0,1])
-  if (risk != null) meta.risk = Math.max(0, Math.min(1, Number(risk)))
-  if (complexity != null) meta.complexity = Math.max(0, Math.min(1, Number(complexity)))
-  if (confidence != null) meta.confidence = Math.max(0, Math.min(1, Number(confidence)))
-
-  // Tags
-  if (Array.isArray(contextTags) && contextTags.length > 0) {
-    meta.context_tags = contextTags.map(String)
-  }
-
-  // Timestamps / versioning
-  meta.created_at = createdAt ?? nowISO()
-  meta.created_via = `tissues-cli/${PKG_VERSION.split('.').slice(0, 2).join('.')}`
-
   return meta
 }
 
 /**
- * Render attribution metadata as an HTML comment block for inclusion at the
- * bottom of a GitHub issue body.
- *
- * The format is a YAML-like key: value listing inside an HTML comment, which
- * GitHub renders as invisible text. Other tools (including tissues itself)
- * can parse it back via `parseAttribution`.
+ * Render attribution metadata as a YAML frontmatter block for inclusion at
+ * the bottom of a GitHub issue body.
  *
  * @example
- * <!-- tissues-meta
- * agent: claude-opus-4-6
+ * ---
+ * tissues-meta:
  * session: abc123
- * trigger: cli-create
- * fingerprint: sha256:deadbeef
- * created_at: 2026-02-19T15:30:00Z
- * created_via: tissues-cli/0.1
- * -->
+ * model: claude-opus-4-6
+ * ---
  *
  * @param {AttributionOpts} opts
- * @returns {string}
+ * @returns {string | null} frontmatter block, or null if no fields to render
  */
 export function renderAttribution(opts = {}) {
   const meta = buildAttribution(opts)
-  const lines = ['<!-- tissues-meta']
+  const entries = Object.entries(meta)
+  if (entries.length === 0) return null
 
-  for (const [key, value] of Object.entries(meta)) {
-    if (Array.isArray(value)) {
-      // Render arrays as comma-separated values on a single line
-      lines.push(`${key}: ${value.join(', ')}`)
-    } else {
-      lines.push(`${key}: ${value}`)
-    }
+  const lines = ['---', 'tissues-meta:']
+  for (const [key, value] of entries) {
+    lines.push(`${key}: ${value}`)
   }
-
-  lines.push('-->')
+  lines.push('---')
   return lines.join('\n')
 }
-
-/**
- * Parse a `<!-- tissues-meta ... -->` attribution block from an issue body.
- *
- * Returns the parsed key/value pairs as a plain object, or `null` if no
- * attribution block is present in `issueBody`.
- *
- * Numeric fields (`risk`, `complexity`, `confidence`) are coerced to
- * numbers. The `context_tags` field is split back into an array.
- *
- * @param {string} issueBody - raw GitHub issue body markdown
- * @returns {object|null} parsed metadata, or null if not found
- */
-export function parseAttribution(issueBody) {
-  if (!issueBody) return null
-
-  // Match the comment block (non-greedy, handle CRLF)
-  const match = issueBody.match(/<!--\s*tissues-meta\s*([\s\S]*?)-->/m)
-  if (!match) return null
-
-  const block = match[1]
-  const meta = {}
-
-  for (const line of block.split(/\r?\n/)) {
-    const trimmed = line.trim()
-    if (!trimmed) continue
-
-    const colonIdx = trimmed.indexOf(':')
-    if (colonIdx === -1) continue
-
-    const key = trimmed.slice(0, colonIdx).trim()
-    const rawValue = trimmed.slice(colonIdx + 1).trim()
-
-    if (!key) continue
-
-    // Type coercions
-    if (['pid'].includes(key)) {
-      const n = Number(rawValue)
-      meta[key] = Number.isNaN(n) ? rawValue : n
-    } else if (['risk', 'complexity', 'confidence'].includes(key)) {
-      const n = parseFloat(rawValue)
-      meta[key] = Number.isNaN(n) ? rawValue : n
-    } else if (key === 'context_tags') {
-      meta[key] = rawValue.split(',').map((t) => t.trim()).filter(Boolean)
-    } else {
-      meta[key] = rawValue
-    }
-  }
-
-  return Object.keys(meta).length > 0 ? meta : null
-}

package/src/lib/clipboard.js

@@ -0,0 +1,147 @@
+/**
+ * Clipboard image detection and extraction.
+ *
+ * macOS: uses osascript to read «class PNGf» from NSPasteboard.
+ * Linux: uses xclip (X11) or wl-paste (Wayland).
+ * Windows: not supported yet.
+ */
+
+import { execFileSync, spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+/**
+ * Check if the system clipboard currently holds image data.
+ *
+ * @returns {boolean}
+ */
+export function clipboardHasImage() {
+  const platform = os.platform()
+  if (platform === 'darwin') return clipboardHasImageMac()
+  if (platform === 'linux') return clipboardHasImageLinux()
+  return false
+}
+
+/**
+ * Save clipboard image to a PNG file on disk.
+ *
+ * @param {string} destPath - where to write the PNG
+ * @returns {boolean} true if saved successfully
+ */
+export function saveClipboardImage(destPath) {
+  const platform = os.platform()
+  if (platform === 'darwin') return saveClipboardImageMac(destPath)
+  if (platform === 'linux') return saveClipboardImageLinux(destPath)
+  return false
+}
+
+// ---------------------------------------------------------------------------
+// macOS
+// ---------------------------------------------------------------------------
+
+function clipboardHasImageMac() {
+  try {
+    const info = execFileSync('osascript', ['-e', 'clipboard info'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    return info.includes('PNGf') || info.includes('TIFF picture')
+  } catch {
+    return false
+  }
+}
+
+function saveClipboardImageMac(destPath) {
+  // Prefer pngpaste if installed (more reliable)
+  const hasPngpaste = spawnSync('which', ['pngpaste'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  }).status === 0
+
+  if (hasPngpaste) {
+    const result = spawnSync('pngpaste', [destPath], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    return result.status === 0
+  }
+
+  // Fallback: osascript with temp script file to avoid quoting issues
+  const scriptFile = path.join(os.tmpdir(), `tissues-clip-${Date.now()}.scpt`)
+  const script = [
+    'try',
+    '  set theImage to (the clipboard as «class PNGf»)',
+    `  set fd to open for access POSIX file "${destPath}" with write permission`,
+    '  set eof of fd to 0',
+    '  write theImage to fd',
+    '  close access fd',
+    '  return "ok"',
+    'on error errMsg',
+    '  try',
+    `    close access POSIX file "${destPath}"`,
+    '  end try',
+    '  return "fail"',
+    'end try',
+  ].join('\n')
+
+  try {
+    fs.writeFileSync(scriptFile, script, 'utf8')
+    const result = execFileSync('osascript', [scriptFile], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+    return result === 'ok'
+  } catch {
+    return false
+  } finally {
+    try { fs.unlinkSync(scriptFile) } catch { /* ignore */ }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Linux
+// ---------------------------------------------------------------------------
+
+function clipboardHasImageLinux() {
+  // Try wl-paste first (Wayland), then xclip (X11)
+  const wl = spawnSync('wl-paste', ['--list-types'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  })
+  if (wl.status === 0) {
+    return wl.stdout.includes('image/png') || wl.stdout.includes('image/jpeg')
+  }
+
+  const xc = spawnSync('xclip', ['-selection', 'clipboard', '-t', 'TARGETS', '-o'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  })
+  if (xc.status === 0) {
+    return xc.stdout.includes('image/png') || xc.stdout.includes('image/jpeg')
+  }
+
+  return false
+}
+
+function saveClipboardImageLinux(destPath) {
+  // Wayland
+  const wlResult = spawnSync('wl-paste', ['--type', 'image/png'], {
+    stdio: ['ignore', 'pipe', 'ignore'],
+  })
+  if (wlResult.status === 0 && wlResult.stdout.length > 0) {
+    fs.writeFileSync(destPath, wlResult.stdout)
+    return true
+  }
+
+  // X11
+  const xcResult = spawnSync('xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o'], {
+    stdio: ['ignore', 'pipe', 'ignore'],
+  })
+  if (xcResult.status === 0 && xcResult.stdout.length > 0) {
+    fs.writeFileSync(destPath, xcResult.stdout)
+    return true
+  }
+
+  return false
+}

package/src/lib/color.js

@@ -0,0 +1,9 @@
+import { styleText } from 'node:util'
+
+export const bold   = (s) => styleText('bold', s)
+export const dim    = (s) => styleText('dim', s)
+export const red    = (s) => styleText('red', s)
+export const green  = (s) => styleText('green', s)
+export const yellow = (s) => styleText('yellow', s)
+export const cyan   = (s) => styleText('cyan', s)
+export const blue   = (s) => styleText('blue', s)

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
 }
 
 /**
@@ -104,6 +106,27 @@ async function getCachedIssues(repo) {
  * @typedef {{ action: 'block' | 'warn' | 'allow', reason: string, existingIssue?: { number: number, title: string, url: string } }} LayerResult
  */
 
+/**
+ * Score dedup confidence from cumulative overlap signals.
+ *
+ * Used by the AI dedup pipeline step to convert raw LLM overlap scores
+ * into deterministic confidence levels.
+ *
+ * @param {{ titleOverlap?: number, fileMentions?: number, labelMatches?: number }} scores
+ *   - titleOverlap:  0-50 points (how similar the titles are)
+ *   - fileMentions:  0-30 points (shared file references)
+ *   - labelMatches:  0-20 points (shared labels)
+ * @returns {{ confidence: number, level: 'high' | 'medium' | 'low' | 'none' }}
+ */
+export function scoreDedupConfidence({ titleOverlap = 0, fileMentions = 0, labelMatches = 0 } = {}) {
+  const confidence = Math.min(100, Math.max(0, titleOverlap + fileMentions + labelMatches))
+  let level = 'none'
+  if (confidence >= 70) level = 'high'
+  else if (confidence >= 40) level = 'medium'
+  else if (confidence > 20) level = 'low'
+  return { confidence, level }
+}
+
 /**
  * Run the full deduplication pipeline for a prospective issue.
  *
@@ -146,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.95) {
+    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`,
@@ -162,7 +189,7 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
         },
       })
       break
-    } else if (similarity > 0.80) {
+    } else if (similarity >= warnThreshold) {
       results.push({
         action: 'warn',
         reason: `Fuzzy title is similar (similarity ${(similarity * 100).toFixed(1)}%) to existing issue`,
@@ -190,16 +217,24 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
 /**
  * Persist deduplication records after a successful issue creation.
  * Stores both the content fingerprint and, if provided, the idempotency key.
+ * Also appends the new issue to the in-memory cache so subsequent dedup
+ * checks within the same process (or cache TTL window) see it immediately.
  *
  * @param {string} repo
- * @param {{ title: string, body: string, issueNumber: number, idempotencyKey?: string, agent?: string }} options
+ * @param {{ title: string, body: string, issueNumber: number, url?: string, idempotencyKey?: string, agent?: string }} options
  * @returns {Promise<void>}
  */
-export async function recordCreation(repo, { title, body, issueNumber, idempotencyKey, agent }) {
+export async function recordCreation(repo, { title, body, issueNumber, url, idempotencyKey, agent }) {
   const fingerprint = computeFingerprint(title, body ?? '')
   await storeFingerprint(repo, fingerprint, issueNumber, title, agent ?? 'unknown')
 
   if (idempotencyKey) {
     await storeIdempotencyKey(idempotencyKey, repo, issueNumber)
   }
+
+  // Atomically append to the issues cache so back-to-back runs catch duplicates
+  const cached = issuesCache.get(repo)
+  if (cached) {
+    cached.issues.unshift({ number: issueNumber, title, url: url ?? null })
+  }
 }

package/src/lib/defaults.js

@@ -36,11 +36,63 @@ 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,
-    provider: 'anthropic', // or 'openai'
-    model: 'claude-haiku-4-5-20251001',
+    provider: 'anthropic',
+    model: null,                        // global model override
+    models: {                           // per-provider defaults
+      anthropic: 'claude-haiku-4-5-20251001',
+      openai: 'gpt-4o-mini',
+      gemini: 'gemini-2.0-flash',
+      ollama: 'llama3.2',
+      'openai-compat': null,            // user must set
+      command: null,                     // not applicable
+    },
+    keys: {
+      anthropic: null,
+      openai: null,
+      gemini: null,
+      'openai-compat': null,
+    },
+    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
+      maxTokensPerHour: 50000,          // rolling hourly token budget
+      maxTokensPerDay: 200000,          // rolling daily token budget
+    },
+    pipeline: {
+      enabled: true,                    // multi-step enhancement pipeline
+      steps: {                          // legacy key (alias for enhancements)
+        triage:     'always',           // 'always' | 'auto' | 'never'
+        dedup:      'auto',             // 'always' | 'auto' | 'never'
+        context:    'always',
+        scope:      'auto',
+        complexity: 'auto',
+        risk:       'auto',
+        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',
+      },
+    },
   },
 
   // Hooks (shell commands to run)