tissues 0.3.0

package/src/lib/dedup.js

@@ -0,0 +1,205 @@
+import crypto from 'node:crypto'
+import { checkFingerprint, storeFingerprint, checkIdempotencyKey, storeIdempotencyKey } from './db.js'
+import { listIssues } from './gh.js'
+
+/** @type {Map<string, { issues: Array, fetchedAt: number }>} */
+const issuesCache = new Map()
+const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
+/**
+ * Normalize text for comparison: lowercase, replace non-alphanumeric with
+ * space, collapse multiple spaces, trim.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function normalizeText(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/**
+ * Compute a SHA-256 content fingerprint from a title and the first 500
+ * characters of a body.
+ *
+ * @param {string} title
+ * @param {string} body
+ * @returns {string} hex digest
+ */
+export function computeFingerprint(title, body) {
+  const normalized = normalizeText(title) + '|||' + normalizeText((body ?? '').slice(0, 500))
+  return crypto.createHash('sha256').update(normalized).digest('hex')
+}
+
+/**
+ * Compute a deterministic idempotency key from trigger context.
+ *
+ * @param {{ agent: string, trigger: string, issueType: string, repo: string }} context
+ * @returns {string} hex digest
+ */
+export function computeIdempotencyKey({ agent, trigger, issueType, repo }) {
+  const raw = [agent, trigger, issueType, repo].join('|')
+  return crypto.createHash('sha256').update(raw).digest('hex')
+}
+
+/**
+ * Compute Levenshtein distance between two strings.
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+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]
+}
+
+/**
+ * Compute similarity between two strings as a value in [0, 1].
+ * 1.0 means identical, 0.0 means completely different.
+ *
+ * @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
+}
+
+/**
+ * Fetch open issues for a repo, using a session-level cache that expires after
+ * 5 minutes.
+ *
+ * @param {string} repo
+ * @returns {Promise<Array>}
+ */
+async function getCachedIssues(repo) {
+  const cached = issuesCache.get(repo)
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.issues
+  }
+  const issues = listIssues(repo)
+  issuesCache.set(repo, { issues, fetchedAt: Date.now() })
+  return issues
+}
+
+/**
+ * @typedef {{ action: 'block' | 'warn' | 'allow', reason: string, existingIssue?: { number: number, title: string, url: string } }} LayerResult
+ */
+
+/**
+ * Run the full deduplication pipeline for a prospective issue.
+ *
+ * Layers run cheapest-first:
+ *   1. Idempotency key (O(1) DB lookup)
+ *   2. Content fingerprint (O(1) DB lookup)
+ *   3. Fuzzy title match against open GitHub issues (O(n))
+ *
+ * @param {string} repo  e.g. "owner/name"
+ * @param {{ title: string, body: string, idempotencyKey?: string, agent?: string }} options
+ * @returns {Promise<{ action: 'block' | 'warn' | 'allow', results: LayerResult[] }>}
+ */
+export async function checkDuplicate(repo, { title, body, idempotencyKey, agent }) {
+  const results = []
+
+  // Layer 1: idempotency key
+  if (idempotencyKey) {
+    const existingNumber = await checkIdempotencyKey(idempotencyKey)
+    if (existingNumber != null) {
+      results.push({
+        action: 'block',
+        reason: 'Idempotency key matches existing issue',
+        existingIssue: { number: existingNumber, title: null, url: null },
+      })
+    }
+  }
+
+  // Layer 2: content fingerprint
+  const fingerprint = computeFingerprint(title, body ?? '')
+  const fpResult = await checkFingerprint(repo, fingerprint)
+  if (fpResult && fpResult.exists) {
+    results.push({
+      action: 'block',
+      reason: 'Content fingerprint matches existing issue',
+      existingIssue: {
+        number: fpResult.issueNumber,
+        title: fpResult.title,
+        url: null,
+      },
+    })
+  }
+
+  // Layer 3: fuzzy title match
+  const normalizedTitle = normalizeText(title)
+  const openIssues = await getCachedIssues(repo)
+  for (const issue of openIssues) {
+    const similarity = levenshteinSimilarity(normalizedTitle, normalizeText(issue.title))
+    if (similarity > 0.95) {
+      results.push({
+        action: 'block',
+        reason: `Fuzzy title match (similarity ${(similarity * 100).toFixed(1)}%) with existing issue`,
+        existingIssue: {
+          number: issue.number,
+          title: issue.title,
+          url: issue.url,
+        },
+      })
+      break
+    } else if (similarity > 0.80) {
+      results.push({
+        action: 'warn',
+        reason: `Fuzzy title is similar (similarity ${(similarity * 100).toFixed(1)}%) to existing issue`,
+        existingIssue: {
+          number: issue.number,
+          title: issue.title,
+          url: issue.url,
+        },
+      })
+      break
+    }
+  }
+
+  // Determine overall action
+  let action = 'allow'
+  if (results.some((r) => r.action === 'block')) {
+    action = 'block'
+  } else if (results.some((r) => r.action === 'warn')) {
+    action = 'warn'
+  }
+
+  return { action, results }
+}
+
+/**
+ * Persist deduplication records after a successful issue creation.
+ * Stores both the content fingerprint and, if provided, the idempotency key.
+ *
+ * @param {string} repo
+ * @param {{ title: string, body: string, issueNumber: number, idempotencyKey?: string, agent?: string }} options
+ * @returns {Promise<void>}
+ */
+export async function recordCreation(repo, { title, body, issueNumber, idempotencyKey, agent }) {
+  const fingerprint = computeFingerprint(title, body ?? '')
+  await storeFingerprint(repo, fingerprint, issueNumber, title, agent ?? 'unknown')
+
+  if (idempotencyKey) {
+    await storeIdempotencyKey(idempotencyKey, repo, issueNumber)
+  }
+}

package/src/lib/defaults.js

@@ -0,0 +1,252 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+// ---------------------------------------------------------------------------
+// Built-in defaults
+// ---------------------------------------------------------------------------
+
+const BUILT_IN_DEFAULTS = {
+  // Safety
+  safety: {
+    maxPerHour: 10,
+    burstLimit: 5,
+    burstWindowMinutes: 5,
+    tripThreshold: 3,
+    cooldownMinutes: 30,
+    globalMaxPerHour: 30,
+  },
+
+  // Deduplication
+  dedup: {
+    blockAbove: 0.95,       // fuzzy similarity threshold to block
+    warnAbove: 0.80,        // fuzzy similarity threshold to warn
+    fingerprintTTLDays: 90, // expire fingerprints after this many days
+  },
+
+  // Attribution (can be set globally or per-repo)
+  attribution: {
+    required: false,        // if true, --agent is mandatory
+    defaultAgent: 'human',
+  },
+
+  // Templates
+  templates: {
+    dir: '.gitissues/templates', // relative to repo root, or absolute
+    default: 'default',          // default template name
+  },
+
+  // AI
+  ai: {
+    enabled: true,
+    provider: 'anthropic', // or 'openai'
+    model: 'claude-haiku-4-5-20251001',
+  },
+
+  // Hooks (shell commands to run)
+  hooks: {
+    postCreate: null, // e.g., 'slack-notify.sh'
+    postClose: null,
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Env var prefix
+// ---------------------------------------------------------------------------
+
+const ENV_PREFIX = 'GITISSUES_'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Deep-merge two plain objects. `override` values take priority over `base`.
+ * Arrays in `override` replace (not append to) arrays in `base`.
+ *
+ * @param {object} base
+ * @param {object} override
+ * @returns {object}
+ */
+function deepMerge(base, override) {
+  if (override === null || typeof override !== 'object' || Array.isArray(override)) {
+    return override !== undefined ? override : base
+  }
+  const result = { ...base }
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key]
+    const overrideVal = override[key]
+    if (
+      overrideVal !== null &&
+      typeof overrideVal === 'object' &&
+      !Array.isArray(overrideVal) &&
+      baseVal !== null &&
+      typeof baseVal === 'object' &&
+      !Array.isArray(baseVal)
+    ) {
+      result[key] = deepMerge(baseVal, overrideVal)
+    } else if (overrideVal !== undefined) {
+      result[key] = overrideVal
+    }
+  }
+  return result
+}
+
+/**
+ * Attempt to read and parse a JSON file. Returns `null` if the file does not
+ * exist or cannot be parsed.
+ *
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+function readJsonFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    return JSON.parse(raw)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Get the path to the user-level config file.
+ *
+ * @returns {string}
+ */
+function userConfigPath() {
+  return path.join(os.homedir(), '.config', 'gitissues', 'config.json')
+}
+
+/**
+ * Convert a flat `GITISSUES_SECTION_KEY=value` environment variable map into
+ * a nested object matching the config shape.
+ *
+ * Variable names are lowercased and split on `_` to build the path:
+ *   GITISSUES_SAFETY_MAX_PER_HOUR=20  →  { safety: { maxPerHour: 20 } }
+ *
+ * Simple camelCase reconstruction: after stripping the prefix and splitting on
+ * `_`, the first segment is the section; the remaining segments are joined in
+ * camelCase.
+ *
+ * Only variables whose section exists in BUILT_IN_DEFAULTS are included so we
+ * do not accidentally pollute the config with unrelated env vars.
+ *
+ * @returns {object}
+ */
+function configFromEnv() {
+  const result = {}
+  const knownSections = new Set(Object.keys(BUILT_IN_DEFAULTS))
+
+  for (const [rawKey, rawValue] of Object.entries(process.env)) {
+    if (!rawKey.startsWith(ENV_PREFIX)) continue
+    const stripped = rawKey.slice(ENV_PREFIX.length).toLowerCase()
+    const parts = stripped.split('_')
+    if (parts.length < 2) continue
+
+    const section = parts[0]
+    if (!knownSections.has(section)) continue
+
+    // Join remaining parts as camelCase
+    const remainingParts = parts.slice(1)
+    const fieldName = remainingParts
+      .map((p, i) => (i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1)))
+      .join('')
+
+    // Coerce value type based on built-in defaults
+    let value = rawValue
+    const builtInSection = BUILT_IN_DEFAULTS[section]
+    if (builtInSection && fieldName in builtInSection) {
+      const defaultVal = builtInSection[fieldName]
+      if (typeof defaultVal === 'number') {
+        value = Number(rawValue)
+      } else if (typeof defaultVal === 'boolean') {
+        value = rawValue === 'true' || rawValue === '1'
+      }
+    }
+
+    if (!result[section]) result[section] = {}
+    result[section][fieldName] = value
+  }
+
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Walk up from `startDir` (defaults to `process.cwd()`) looking for a `.git`
+ * directory. Returns the first directory that contains `.git`, or `null` if no
+ * git repo is found.
+ *
+ * @param {string} [startDir]
+ * @returns {string|null}
+ */
+export function findRepoRoot(startDir) {
+  let dir = path.resolve(startDir ?? process.cwd())
+  const { root } = path.parse(dir)
+
+  while (true) {
+    const gitDir = path.join(dir, '.git')
+    if (fs.existsSync(gitDir)) return dir
+    if (dir === root) return null
+    dir = path.dirname(dir)
+  }
+}
+
+/**
+ * Load merged configuration from all sources in ascending priority order:
+ *   1. Built-in defaults  (lowest)
+ *   2. User-level config  (~/.config/gitissues/config.json)
+ *   3. Repo-level config  (<repoRoot>/.gitissues/config.json)
+ *   4. Environment vars   (GITISSUES_*)
+ *   5. CLI flags          (passed as `cliOverrides`, highest)
+ *
+ * @param {string} [repoRoot] - path to the repo root; auto-detected if omitted
+ * @param {object} [cliOverrides] - values from parsed CLI flags (already nested)
+ * @returns {object} merged config
+ */
+export function loadConfig(repoRoot, cliOverrides) {
+  const root = repoRoot ?? findRepoRoot()
+
+  // 1. Built-in defaults
+  let merged = deepMerge({}, BUILT_IN_DEFAULTS)
+
+  // 2. User-level config
+  const userCfg = readJsonFile(userConfigPath())
+  if (userCfg) merged = deepMerge(merged, userCfg)
+
+  // 3. Repo-level config
+  if (root) {
+    const repoCfg = readJsonFile(path.join(root, '.gitissues', 'config.json'))
+    if (repoCfg) merged = deepMerge(merged, repoCfg)
+  }
+
+  // 4. Environment variables
+  const envCfg = configFromEnv()
+  if (Object.keys(envCfg).length > 0) merged = deepMerge(merged, envCfg)
+
+  // 5. CLI overrides
+  if (cliOverrides && typeof cliOverrides === 'object') {
+    merged = deepMerge(merged, cliOverrides)
+  }
+
+  return merged
+}
+
+/**
+ * Get a specific config value using dot notation.
+ *
+ * @example
+ *   getConfigValue('safety.maxPerHour')        // 10
+ *   getConfigValue('ai.model', '/path/to/repo') // 'claude-haiku-4-5-20251001'
+ *
+ * @param {string} key - dot-separated path (e.g. 'safety.maxPerHour')
+ * @param {string} [repoRoot] - optional repo root for repo-level config lookup
+ * @returns {*} the resolved value, or `undefined` if not found
+ */
+export function getConfigValue(key, repoRoot) {
+  const cfg = loadConfig(repoRoot)
+  return key.split('.').reduce((obj, part) => (obj != null ? obj[part] : undefined), cfg)
+}