tissues 0.5.2 → 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

@@ -4,7 +4,9 @@
  */
 
 import { execFileSync, execSync } from 'node:child_process'
-import chalk from 'chalk'
+import fs from 'node:fs'
+import nodePath from 'node:path'
+import { red, cyan, dim } from './color.js'
 
 // ---------------------------------------------------------------------------
 // gh availability
@@ -22,14 +24,14 @@ export function requireGh() {
     }).trim()
     return path
   } catch {
-    console.error(chalk.red('\n  gh CLI is required but not installed.\n'))
+    console.error(red('\n  gh CLI is required but not installed.\n'))
     console.error('  Install it with one of:')
-    console.error(chalk.cyan('    brew install gh                  ') + chalk.dim('# macOS'))
-    console.error(chalk.cyan('    sudo apt install gh              ') + chalk.dim('# Debian/Ubuntu'))
-    console.error(chalk.cyan('    winget install GitHub.cli         ') + chalk.dim('# Windows'))
-    console.error(chalk.cyan('    conda install -c conda-forge gh  ') + chalk.dim('# conda'))
+    console.error(cyan('    brew install gh                  ') + dim('# macOS'))
+    console.error(cyan('    sudo apt install gh              ') + dim('# Debian/Ubuntu'))
+    console.error(cyan('    winget install GitHub.cli         ') + dim('# Windows'))
+    console.error(cyan('    conda install -c conda-forge gh  ') + dim('# conda'))
     console.error()
-    console.error(chalk.dim('  More: https://cli.github.com'))
+    console.error(dim('  More: https://cli.github.com'))
     console.error()
     process.exit(1)
   }
@@ -62,9 +64,9 @@ export function requireAuth() {
   const token = getToken()
   if (token) return token
 
-  console.error(chalk.red('\n  Not authenticated with GitHub.\n'))
+  console.error(red('\n  Not authenticated with GitHub.\n'))
   console.error('  Run:')
-  console.error(chalk.cyan('    gh auth login'))
+  console.error(cyan('    gh auth login'))
   console.error()
   process.exit(1)
 }
@@ -75,11 +77,26 @@ export function requireAuth() {
  */
 export function getAuthStatus() {
   try {
-    const raw = execFileSync('gh', ['auth', 'status', '--json'], {
+    const raw = execFileSync('gh', ['auth', 'status', '--json', 'hosts'], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     }).trim()
-    return JSON.parse(raw)
+    const data = JSON.parse(raw)
+    // Normalize: flatten hosts map into an accounts array for callers
+    const accounts = []
+    if (data.hosts) {
+      for (const entries of Object.values(data.hosts)) {
+        for (const entry of entries) {
+          accounts.push({
+            login: entry.login,
+            active: !!entry.active,
+            host: entry.host,
+            state: entry.state,
+          })
+        }
+      }
+    }
+    return { accounts }
   } catch {
     // Older gh versions may not support --json, fall back to text parsing
     try {
@@ -217,6 +234,32 @@ export function createIssue(repo, { title, body, labels }) {
   return { number, url }
 }
 
+/**
+ * Verify that a GitHub issue exists and is open.
+ * Used after `createIssue()` to confirm the issue was actually created
+ * before removing it from the outbox.
+ *
+ * @param {string} repo - owner/name
+ * @param {number} number - issue number
+ * @returns {boolean} true if the issue exists and is open
+ */
+export function verifyIssue(repo, number) {
+  try {
+    const raw = execFileSync('gh', [
+      'issue', 'view', String(number),
+      '--repo', repo,
+      '--json', 'number,state',
+    ], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+    const data = JSON.parse(raw)
+    return data.state === 'OPEN'
+  } catch {
+    return false
+  }
+}
+
 /**
  * List all label names for a repo.
  * @param {string} repo - owner/name
@@ -278,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)
@@ -300,6 +349,38 @@ export function listIssues(repo, opts = {}) {
   }))
 }
 
+/**
+ * Upload an image file to a repo's .tissues/images/ directory and return
+ * the raw URL for embedding in markdown.
+ *
+ * Uses the GitHub Contents API via `gh api` to commit the file.
+ *
+ * @param {string} repo - owner/name
+ * @param {string} localPath - path to the local image file
+ * @param {string} [filename] - optional filename override
+ * @returns {{ url: string, path: string }} raw URL and repo path
+ */
+export function uploadImageToRepo(repo, localPath, filename) {
+  const name = filename || nodePath.basename(localPath)
+  const repoPath = `.tissues/images/${name}`
+  const content = fs.readFileSync(localPath).toString('base64')
+
+  const raw = execFileSync('gh', [
+    'api',
+    `repos/${repo}/contents/${repoPath}`,
+    '--method', 'PUT',
+    '-f', `message=tissues: attach ${name}`,
+    '-f', `content=${content}`,
+  ], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim()
+
+  const data = JSON.parse(raw)
+  const url = data.content?.download_url || `https://raw.githubusercontent.com/${repo}/HEAD/${repoPath}`
+  return { url, path: repoPath }
+}
+
 /**
  * List repos the user has access to.
  * @param {{ limit?: number }} [opts]

package/src/lib/repo-picker.js

@@ -1,5 +1,6 @@
 import { search } from '@inquirer/prompts'
 import { store, setConfig } from './config.js'
+import { theme } from './theme.js'
 import { listRepos } from './gh.js'
 import ora from 'ora'
 
@@ -46,6 +47,7 @@ export async function pickRepo() {
         .filter((r) => r.toLowerCase().includes(term))
         .map((r) => ({ name: r, value: r }))
     },
+    theme,
   })
 
   trackRepoUsage(repo)

package/src/lib/safety.js

@@ -110,7 +110,7 @@ export function checkSafety(repo, agent, config = {}) {
 
   // Step 3: half-open → log and allow the probe through (no rate checks)
   if (circuitState === 'half-open') {
-    console.warn(`[safety] Circuit is half-open for ${repo}/${agent} — allowing probe request through.`)
+    // half-open: silently allow the probe through — no user-facing noise
     return {
       allowed: true,
       circuitState,

package/src/lib/templates.js

@@ -20,18 +20,14 @@ const BUILT_IN_TEMPLATES = {
     name: 'Feature Request',
     body: `## Feature\n\n{{description}}\n\n## Motivation\n\n## Proposed solution\n\n## Alternatives considered\n\n`,
   },
-  security: {
-    name: 'Security Issue',
-    body: `## Security Issue\n\n{{description}}\n\n## Severity\n\n## Affected components\n\n## Suggested fix\n\n`,
-  },
-  performance: {
-    name: 'Performance Issue',
-    body: `## Performance\n\n{{description}}\n\n## Current metric\n\n## Target metric\n\n## Affected area\n\n`,
-  },
-  refactor: {
-    name: 'Refactor',
-    body: `## Refactor\n\n{{description}}\n\n## Motivation\n\n## Scope\n\n## Risk assessment\n\n`,
-  },
+}
+
+/**
+ * Return the list of built-in template keys.
+ * @returns {string[]}
+ */
+export function builtInTemplateKeys() {
+  return Object.keys(BUILT_IN_TEMPLATES)
 }
 
 // ---------------------------------------------------------------------------

package/src/lib/theme.js

@@ -0,0 +1,9 @@
+import { bold, dim } from './color.js'
+
+export const theme = {
+  prefix: { idle: dim('›'), done: dim('›') },
+  style: {
+    message: (text) => bold(text),
+    defaultAnswer: (text) => dim(text),
+  },
+}

package/src/commands/use.js

@@ -1,19 +0,0 @@
-import { Command } from 'commander'
-import { pickRepo } from '../lib/repo-picker.js'
-import { setConfig } from '../lib/config.js'
-import chalk from 'chalk'
-
-export const useCommand = new Command('use')
-  .description('Set the active repository context')
-  .argument('[repo]', 'Repository in owner/name format (e.g. owner/repo)')
-  .option('--repo <repo>', 'Repository in owner/name format (alias for positional argument)')
-  .action(async (repoArg, opts) => {
-    const repo = repoArg || opts.repo
-    if (repo) {
-      setConfig({ activeRepo: repo })
-      console.log(chalk.green(`✓ Active repo set to ${repo}`))
-    } else {
-      const selected = await pickRepo()
-      console.log(chalk.green(`\n✓ Active repo set to ${selected}`))
-    }
-  })