tissues 0.6.0 → 0.6.1

package/src/lib/enhancements.js

@@ -0,0 +1,436 @@
+/**
+ * Enhancement definitions — first-class pipeline step descriptors.
+ *
+ * Three-tier priority (same as templates): repo > user > built-in.
+ * File format: YAML-ish frontmatter + system prompt body (.md files).
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { findRepoRoot, loadConfig } from './defaults.js'
+
+// ---------------------------------------------------------------------------
+// Built-in enhancements (extracted from steps.js prompts)
+// ---------------------------------------------------------------------------
+
+export const BUILT_IN_ENHANCEMENTS = {
+  triage: {
+    key: 'triage',
+    name: 'Input Analysis',
+    maxTokens: 1024,
+    mode: 'always',
+    format: 'json',
+    contextKey: 'triage',
+    order: 10,
+    requires: [],
+    isStructural: true,
+    provider: null,
+    prompt: [
+      'You extract a structured GitHub issue title and description from freeform user input.',
+      'Return a JSON object with:',
+      '  title: string — concise issue title, ≤80 characters, imperative mood (e.g. "Fix login timeout on Safari")',
+      '  description: string — structured description expanding on the input, in markdown',
+      'The title must capture the core intent. The description should organize and expand the raw input into clear context.',
+      'Return ONLY valid JSON.',
+    ].join('\n'),
+  },
+  dedup: {
+    key: 'dedup',
+    name: 'Duplicate Check',
+    maxTokens: 1024,
+    mode: 'auto',
+    format: 'json',
+    contextKey: 'dedupScore',
+    order: 15,
+    requires: [],
+    isStructural: false,
+    provider: null,
+    prompt: [
+      'You are a duplicate detection system for GitHub issues.',
+      'Compare the new issue against existing open issues.',
+      'Return a JSON object with:',
+      '  confidence: number 0-100 (how likely this is a duplicate)',
+      '  level: "high" | "medium" | "low" | "none"',
+      '  matches: array of { number, reason } for similar issues',
+      'Return ONLY valid JSON.',
+    ].join('\n'),
+  },
+  context: {
+    key: 'context',
+    name: 'Context Extraction',
+    maxTokens: 1024,
+    mode: 'always',
+    format: 'json',
+    contextKey: 'structuredContext',
+    order: 20,
+    requires: [],
+    isStructural: false,
+    provider: null,
+    prompt: [
+      'You are an expert at understanding software issues.',
+      'Extract structured context from the issue description.',
+      'Return a JSON object with:',
+      '  problem: string — the core problem in one sentence',
+      '  files: string[] — file paths mentioned or implied',
+      '  errors: string[] — error messages mentioned',
+      '  sessionContext: string — any relevant session/environment context',
+      'Return ONLY valid JSON.',
+    ].join('\n'),
+  },
+  scope: {
+    key: 'scope',
+    name: 'Scope Analysis',
+    maxTokens: 1024,
+    mode: 'auto',
+    format: 'json',
+    contextKey: 'scopeAnalysis',
+    order: 30,
+    requires: [],
+    isStructural: false,
+    provider: null,
+    prompt: [
+      'You are a software scope analyzer.',
+      'Given an issue description and context, identify the files and areas affected.',
+      'Return a JSON object with:',
+      '  files: array of { path: string, purpose: string, deps: string[] }',
+      '  affectedAreas: string[] — high-level areas (e.g. "auth", "UI", "database")',
+      'Return ONLY valid JSON.',
+    ].join('\n'),
+  },
+  complexity: {
+    key: 'complexity',
+    name: 'Complexity Scoring',
+    maxTokens: 512,
+    mode: 'auto',
+    format: 'json',
+    contextKey: 'complexity',
+    order: 40,
+    requires: [],
+    isStructural: false,
+    provider: null,
+    prompt: [
+      'You assess implementation complexity for GitHub issues.',
+      'Return a JSON object with:',
+      '  score: number 1-10 (1=trivial, 10=massive refactor)',
+      '  rationale: string — one sentence explaining the score',
+      'Return ONLY valid JSON.',
+    ].join('\n'),
+  },
+  risk: {
+    key: 'risk',
+    name: 'Risk Assessment',
+    maxTokens: 512,
+    mode: 'auto',
+    format: 'json',
+    contextKey: 'risk',
+    order: 50,
+    requires: [],
+    isStructural: false,
+    provider: null,
+    prompt: [
+      'You assess implementation risk for GitHub issues.',
+      'Consider: breaking changes, data loss potential, security implications, blast radius.',
+      'Return a JSON object with:',
+      '  score: number 1-10 (1=no risk, 10=extremely risky)',
+      '  rationale: string — one sentence explaining the score',
+      'Return ONLY valid JSON.',
+    ].join('\n'),
+  },
+  labels: {
+    key: 'labels',
+    name: 'Label Suggestion',
+    maxTokens: 512,
+    mode: 'auto',
+    format: 'json',
+    contextKey: 'aiLabels',
+    order: 60,
+    requires: [],
+    isStructural: false,
+    provider: null,
+    prompt: [
+      'You suggest GitHub labels for issues.',
+      'Return a JSON object with:',
+      '  labels: string[] — labels to apply (must be from the available list)',
+      '  reasoning: string — brief explanation',
+      'Only suggest labels that genuinely fit. Return ONLY valid JSON.',
+    ].join('\n'),
+  },
+  format: {
+    key: 'format',
+    name: 'Body Formatting',
+    maxTokens: 4096,
+    mode: 'always',
+    format: 'markdown',
+    contextKey: 'body',
+    order: 90,
+    requires: [],
+    isStructural: true,
+    provider: null,
+    prompt: [
+      'You are an expert at writing clear, well-structured GitHub issues.',
+      'Given an issue title, description, and analysis from prior steps,',
+      'write a complete issue body in markdown.',
+    ].join('\n'),
+  },
+}
+
+/**
+ * Return the list of built-in enhancement keys.
+ * @returns {string[]}
+ */
+export function builtInEnhancementKeys() {
+  return Object.keys(BUILT_IN_ENHANCEMENTS)
+}
+
+// ---------------------------------------------------------------------------
+// Frontmatter parser
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse an enhancement file: YAML-ish frontmatter + system prompt body.
+ *
+ * @param {string} content - raw file content
+ * @returns {{ meta: object, prompt: string }}
+ */
+export function parseEnhancementFile(content) {
+  const meta = {}
+  let prompt = content
+
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/)
+  if (fmMatch) {
+    const frontmatter = fmMatch[1]
+    prompt = fmMatch[2].trim()
+
+    for (const line of frontmatter.split('\n')) {
+      const m = line.match(/^(\w+):\s*(.+)$/)
+      if (!m) continue
+      const [, key, rawVal] = m
+      let val = rawVal.trim()
+
+      // Parse arrays: ["a", "b"] or [a, b]
+      if (val.startsWith('[') && val.endsWith(']')) {
+        val = val.slice(1, -1).split(',').map((s) => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean)
+      } else if (val === 'true') {
+        val = true
+      } else if (val === 'false') {
+        val = false
+      } else if (/^\d+$/.test(val)) {
+        val = Number(val)
+      }
+
+      meta[key] = val
+    }
+  }
+
+  return { meta, prompt }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the enhancement directory for a given source.
+ *
+ * @param {'repo' | 'user'} source
+ * @param {string|null} repoRoot
+ * @param {object} cfg - loaded config object
+ * @returns {string}
+ */
+export function resolveEnhancementDir(source, repoRoot, cfg) {
+  if (source === 'user') {
+    return path.join(os.homedir(), '.config', 'tissues', 'enhancements')
+  }
+  // repo source
+  const enhDir = cfg.enhancements?.dir ?? '.tissues/enhancements'
+  if (path.isAbsolute(enhDir)) return enhDir
+  if (repoRoot) return path.join(repoRoot, enhDir)
+  return path.resolve(enhDir)
+}
+
+/**
+ * Read all `.md` files from a directory and return enhancement descriptors.
+ *
+ * @param {string} dir
+ * @param {'repo' | 'user'} source
+ * @returns {Array<object>}
+ */
+function readEnhancementsFromDir(dir, source) {
+  try {
+    const entries = fs.readdirSync(dir)
+    return entries
+      .filter((f) => f.endsWith('.md'))
+      .map((f) => {
+        const key = path.basename(f, '.md')
+        const raw = fs.readFileSync(path.join(dir, f), 'utf8')
+        const { meta, prompt } = parseEnhancementFile(raw)
+
+        return {
+          key,
+          name: meta.name || key.charAt(0).toUpperCase() + key.slice(1),
+          maxTokens: meta.maxTokens || 1024,
+          mode: meta.mode || 'auto',
+          format: meta.format || 'json',
+          contextKey: meta.contextKey || key,
+          order: meta.order != null ? meta.order : 50,
+          requires: Array.isArray(meta.requires) ? meta.requires : [],
+          isStructural: false,
+          provider: meta.provider || null,
+          prompt,
+          source,
+        }
+      })
+  } catch {
+    return []
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * List all available enhancements from all sources.
+ *
+ * Priority (highest → lowest): repo > user > built-in
+ *
+ * @param {string} [repoRoot] - path to repo root; auto-detected if omitted
+ * @returns {Array<{ key: string, name: string, source: string, mode: string, order: number }>}
+ */
+export function listEnhancements(repoRoot) {
+  const root = repoRoot ?? findRepoRoot()
+  const cfg = loadConfig(root)
+
+  // Built-in (lowest priority)
+  const builtIn = Object.entries(BUILT_IN_ENHANCEMENTS).map(([key, enh]) => ({
+    key,
+    name: enh.name,
+    source: 'built-in',
+    mode: enh.mode,
+    order: enh.order,
+    provider: enh.provider || null,
+  }))
+
+  // User enhancements
+  const userDir = resolveEnhancementDir('user', root, cfg)
+  const userEnhancements = readEnhancementsFromDir(userDir, 'user').map(({ key, name, mode, order, provider }) => ({
+    key, name, source: 'user', mode, order, provider: provider || null,
+  }))
+
+  // Repo enhancements (highest priority)
+  const repoDir = resolveEnhancementDir('repo', root, cfg)
+  const repoEnhancements = readEnhancementsFromDir(repoDir, 'repo').map(({ key, name, mode, order, provider }) => ({
+    key, name, source: 'repo', mode, order, provider: provider || null,
+  }))
+
+  return [...repoEnhancements, ...userEnhancements, ...builtIn]
+}
+
+/**
+ * Load a single enhancement by key, applying source priority:
+ *   repo > user > built-in
+ *
+ * @param {string} name - enhancement key
+ * @param {string} [repoRoot]
+ * @returns {object} full enhancement descriptor with prompt
+ * @throws {Error} if enhancement not found
+ */
+export function loadEnhancement(name, repoRoot) {
+  const root = repoRoot ?? findRepoRoot()
+  const cfg = loadConfig(root)
+
+  // 1. Repo
+  const repoDir = resolveEnhancementDir('repo', root, cfg)
+  const repoFile = path.join(repoDir, `${name}.md`)
+  if (fs.existsSync(repoFile)) {
+    const raw = fs.readFileSync(repoFile, 'utf8')
+    return buildDescriptor(name, raw, 'repo')
+  }
+
+  // 2. User
+  const userDir = resolveEnhancementDir('user', root, cfg)
+  const userFile = path.join(userDir, `${name}.md`)
+  if (fs.existsSync(userFile)) {
+    const raw = fs.readFileSync(userFile, 'utf8')
+    return buildDescriptor(name, raw, 'user')
+  }
+
+  // 3. Built-in
+  const builtIn = BUILT_IN_ENHANCEMENTS[name]
+  if (builtIn) {
+    return { ...builtIn, source: 'built-in' }
+  }
+
+  throw new Error(
+    `Enhancement "${name}" not found. ` +
+    `Available: ${Object.keys(BUILT_IN_ENHANCEMENTS).join(', ')}`,
+  )
+}
+
+/**
+ * Load all enhancements, merged by priority and sorted by order.
+ *
+ * @param {string} [repoRoot]
+ * @returns {object[]} sorted array of enhancement descriptors
+ */
+export function loadAllEnhancements(repoRoot) {
+  const root = repoRoot ?? findRepoRoot()
+  const cfg = loadConfig(root)
+
+  // Start with built-ins
+  const merged = new Map()
+  for (const [key, enh] of Object.entries(BUILT_IN_ENHANCEMENTS)) {
+    merged.set(key, { ...enh, source: 'built-in' })
+  }
+
+  // User overrides
+  const userDir = resolveEnhancementDir('user', root, cfg)
+  for (const enh of readEnhancementsFromDir(userDir, 'user')) {
+    if (merged.has(enh.key)) {
+      // Override built-in but preserve isStructural
+      const builtIn = merged.get(enh.key)
+      merged.set(enh.key, { ...builtIn, ...enh, isStructural: builtIn.isStructural })
+    } else {
+      merged.set(enh.key, enh)
+    }
+  }
+
+  // Repo overrides (highest priority)
+  const repoDir = resolveEnhancementDir('repo', root, cfg)
+  for (const enh of readEnhancementsFromDir(repoDir, 'repo')) {
+    if (merged.has(enh.key)) {
+      const existing = merged.get(enh.key)
+      merged.set(enh.key, { ...existing, ...enh, isStructural: existing.isStructural || false })
+    } else {
+      merged.set(enh.key, enh)
+    }
+  }
+
+  // Sort by order
+  return [...merged.values()].sort((a, b) => a.order - b.order)
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function buildDescriptor(key, rawContent, source) {
+  const { meta, prompt } = parseEnhancementFile(rawContent)
+  const builtIn = BUILT_IN_ENHANCEMENTS[key]
+
+  return {
+    key,
+    name: meta.name || (builtIn ? builtIn.name : key.charAt(0).toUpperCase() + key.slice(1)),
+    maxTokens: meta.maxTokens || (builtIn ? builtIn.maxTokens : 1024),
+    mode: meta.mode || (builtIn ? builtIn.mode : 'auto'),
+    format: meta.format || (builtIn ? builtIn.format : 'json'),
+    contextKey: meta.contextKey || (builtIn ? builtIn.contextKey : key),
+    order: meta.order != null ? meta.order : (builtIn ? builtIn.order : 50),
+    requires: Array.isArray(meta.requires) ? meta.requires : (builtIn ? builtIn.requires : []),
+    isStructural: builtIn ? builtIn.isStructural : false,
+    provider: meta.provider || null,
+    prompt,
+    source,
+  }
+}

package/src/lib/gh.js

@@ -321,16 +321,22 @@ export function addLabelsToIssue(repo, issueNumber, labels) {
  */
 export function listIssues(repo, opts = {}) {
   const limit = opts.limit ?? 100
-  const raw = execFileSync('gh', [
-    'issue', 'list',
-    '--repo', repo,
-    '--state', 'open',
-    '--limit', String(limit),
-    '--json', 'number,title,url,labels,createdAt',
-  ], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore'],
-  }).trim()
+  let raw
+  try {
+    raw = execFileSync('gh', [
+      'issue', 'list',
+      '--repo', repo,
+      '--state', 'open',
+      '--limit', String(limit),
+      '--json', 'number,title,url,labels,createdAt',
+    ], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim()
+  } catch (err) {
+    const reason = (err.stderr || err.message || '').trim()
+    throw new Error(`gh issue list failed: ${reason}`)
+  }
 
   if (!raw) return []
   const issues = JSON.parse(raw)