tissues 0.5.2 → 0.6.0

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

@@ -104,6 +104,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.
  *
@@ -151,7 +172,7 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
   const openIssues = await getCachedIssues(repo)
   for (const issue of openIssues) {
     const similarity = levenshteinSimilarity(normalizedTitle, normalizeText(issue.title))
-    if (similarity > 0.95) {
+    if (similarity >= 0.90) {
       results.push({
         action: 'block',
         reason: `Fuzzy title match (similarity ${(similarity * 100).toFixed(1)}%) with existing issue`,
@@ -162,7 +183,7 @@ export async function checkDuplicate(repo, { title, body, idempotencyKey, agent
         },
       })
       break
-    } else if (similarity > 0.80) {
+    } else if (similarity >= 0.75) {
       results.push({
         action: 'warn',
         reason: `Fuzzy title is similar (similarity ${(similarity * 100).toFixed(1)}%) to existing issue`,
@@ -190,16 +211,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

@@ -39,8 +39,44 @@ export const BUILT_IN_DEFAULTS = {
   // 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'
+    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: {
+        triage:     'always',           // 'always' | 'auto' | 'never'
+        dedup:      'auto',             // 'always' | 'auto' | 'never'
+        context:    'always',
+        scope:      'auto',
+        complexity: 'auto',
+        risk:       'auto',
+        labels:     'auto',
+        format:     'always',
+      },
+    },
   },
 
   // Hooks (shell commands to run)