tissues 0.5.2 → 0.6.0

package/src/lib/drafts.js

@@ -0,0 +1,439 @@
+/**
+ * Write-ahead drafts for pending issues.
+ *
+ * ZERO DATA LOSS GUARANTEE:
+ * Every issue is written to disk the moment we have user input — before
+ * template rendering, AI enhancement, dedup, or safety checks. The draft
+ * file is the source of truth until GitHub confirms the issue exists.
+ *
+ * Files live in `.tissues/drafts/{slug}.json` where slug is derived from
+ * the issue title. If a file with the same slug already exists, new attempt
+ * data is appended (append-only — we never overwrite user content).
+ *
+ * Lifecycle:  draft → pending → complete (deleted)
+ *                              → duplicate (kept)
+ *                              → aborted (kept)
+ *                              → failed (kept)
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import crypto from 'node:crypto'
+import { findRepoRoot } from './defaults.js'
+
+// ---------------------------------------------------------------------------
+// Directory resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Auto-migrate old `.tissues/outbox/` to `.tissues/drafts/` on first access.
+ *
+ * @param {string} draftsDir
+ * @param {string} base
+ */
+function migrateOutboxDir(draftsDir, base) {
+  const oldDir = path.join(base, '.tissues', 'outbox')
+  if (fs.existsSync(oldDir) && !fs.existsSync(draftsDir)) {
+    fs.renameSync(oldDir, draftsDir)
+  }
+}
+
+/**
+ * Resolve the drafts directory. Creates it if it doesn't exist.
+ *
+ * @param {string|null} [repoRoot] - repo root path; auto-detected if omitted
+ * @returns {string} absolute path to the drafts directory
+ */
+export function getDraftsDir(repoRoot) {
+  const base = repoRoot ?? findRepoRoot()
+  const dir = base
+    ? path.join(base, '.tissues', 'drafts')
+    : path.join(os.homedir(), '.config', 'tissues', 'drafts')
+  if (base) migrateOutboxDir(dir, base)
+  else {
+    const oldGlobal = path.join(os.homedir(), '.config', 'tissues', 'outbox')
+    if (fs.existsSync(oldGlobal) && !fs.existsSync(dir)) {
+      fs.renameSync(oldGlobal, dir)
+    }
+  }
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+/**
+ * Compute the drafts dir path without creating it (for existence checks).
+ *
+ * @param {string|null} [repoRoot]
+ * @returns {string}
+ */
+function resolveDraftsDir(repoRoot) {
+  const base = repoRoot ?? findRepoRoot()
+  return base
+    ? path.join(base, '.tissues', 'drafts')
+    : path.join(os.homedir(), '.config', 'tissues', 'drafts')
+}
+
+// ---------------------------------------------------------------------------
+// Slug helper — title → filesystem-safe identifier
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert a title to a filesystem-safe slug.
+ *
+ * @param {string} title
+ * @returns {string} slug (max 60 chars, lowercase, hyphens)
+ */
+function slugify(title) {
+  const slug = title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 60)
+  return slug || crypto.randomUUID().replace(/-/g, '').slice(0, 10)
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Write a draft immediately with raw user input.
+ * Called as soon as we have title + repo — before any processing.
+ *
+ * If a file with the same title slug already exists, appends a new attempt
+ * entry (append-only — never overwrites user content).
+ *
+ * @param {{ repo: string, title: string, description?: string, instructions?: string, labels?: string[] }} item
+ * @param {string|null} [repoRoot]
+ * @returns {{ id: string, filePath: string }}
+ */
+export function writeDraft(item, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const id = slugify(item.title)
+  const filePath = path.join(dir, `${id}.json`)
+  const now = new Date().toISOString()
+
+  if (fs.existsSync(filePath)) {
+    // Append new attempt to existing file — never lose what's already there
+    try {
+      const existing = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+      const attempt = {
+        createdAt: now,
+        description: item.description || '',
+        instructions: item.instructions || '',
+      }
+      if (!existing.attempts) existing.attempts = []
+      existing.attempts.push(attempt)
+      // Reset to draft so it's visible in the drafts list
+      existing.status = 'draft'
+      existing.updatedAt = now
+      fs.writeFileSync(filePath, JSON.stringify(existing, null, 2), 'utf8')
+      return { id: existing.id, filePath }
+    } catch {
+      // Corrupt file — overwrite it
+    }
+  }
+
+  const record = {
+    id,
+    repo: item.repo,
+    title: item.title,
+    description: item.description || '',
+    instructions: item.instructions || '',
+    body: '',
+    labels: item.labels ?? [],
+    createdAt: now,
+    status: 'draft',
+    attemptCount: 0,
+  }
+
+  fs.writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8')
+  return { id, filePath }
+}
+
+/**
+ * Update a draft entry with the processed body and labels.
+ * Called after template rendering + AI enhancement + attribution.
+ * Transitions status from 'draft' to 'pending' (ready to submit).
+ *
+ * @param {string} id - draft item ID (slug)
+ * @param {{ body: string, labels?: string[] }} updates
+ * @param {string|null} [repoRoot]
+ */
+export function updateDraftItem(id, updates, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const filePath = path.join(dir, `${id}.json`)
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const record = JSON.parse(raw)
+    if (updates.body) record.body = updates.body
+    if (updates.labels) record.labels = updates.labels
+    record.status = 'pending'
+    record.updatedAt = new Date().toISOString()
+    fs.writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8')
+  } catch {
+    // File may have been deleted manually — that's ok
+  }
+}
+
+/**
+ * Write a new pending item to drafts (legacy API, still used by batch).
+ * For single creates, prefer writeDraft() + updateDraftItem().
+ *
+ * @param {{ repo: string, title: string, body: string, labels?: string[] }} item
+ * @param {string|null} [repoRoot]
+ * @returns {{ id: string, repo: string, title: string, body: string, labels: string[], createdAt: string, status: string, attemptCount: number }}
+ */
+export function writeToDrafts(item, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const id = slugify(item.title)
+  const filePath = path.join(dir, `${id}.json`)
+
+  // If slug exists, append
+  if (fs.existsSync(filePath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+      existing.body = item.body
+      existing.labels = item.labels ?? existing.labels
+      existing.status = 'pending'
+      existing.updatedAt = new Date().toISOString()
+      fs.writeFileSync(filePath, JSON.stringify(existing, null, 2), 'utf8')
+      return existing
+    } catch { /* corrupt — fall through to overwrite */ }
+  }
+
+  const record = {
+    id,
+    repo: item.repo,
+    title: item.title,
+    body: item.body,
+    labels: item.labels ?? [],
+    createdAt: new Date().toISOString(),
+    status: 'pending',
+    attemptCount: 0,
+  }
+
+  fs.writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8')
+  return record
+}
+
+/**
+ * Read all draft items, sorted by createdAt ascending.
+ * Skips non-JSON files and corrupt entries gracefully.
+ *
+ * @param {string|null} [repoRoot]
+ * @returns {Array<object>}
+ */
+export function readDrafts(repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith('.json'))
+  const items = []
+
+  for (const file of files) {
+    try {
+      const raw = fs.readFileSync(path.join(dir, file), 'utf8')
+      const parsed = JSON.parse(raw)
+      // Skip non-object values (null, arrays, primitives)
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        items.push(parsed)
+      }
+    } catch {
+      // Skip corrupt or unreadable files
+    }
+  }
+
+  return items.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt))
+}
+
+/**
+ * Delete a draft item (issue successfully created and verified).
+ * This is the ONLY function that removes a draft file.
+ *
+ * @param {string} id - draft item ID
+ * @param {object} [_meta] - unused (issueNumber, issueUrl) — reserved for future logging
+ * @param {string|null} [repoRoot]
+ */
+export function markComplete(id, _meta, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const filePath = path.join(dir, `${id}.json`)
+  try {
+    fs.unlinkSync(filePath)
+  } catch {
+    // Already gone — that's fine
+  }
+}
+
+/**
+ * Mark a draft item as a duplicate. File is KEPT — user data is never lost.
+ *
+ * @param {string} id
+ * @param {string} reason - e.g. "Fuzzy title match (100%) with #36"
+ * @param {string|null} [repoRoot]
+ */
+export function markDuplicate(id, reason, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const filePath = path.join(dir, `${id}.json`)
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const record = JSON.parse(raw)
+    record.status = 'duplicate'
+    record.duplicateReason = reason
+    record.duplicateAt = new Date().toISOString()
+    fs.writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8')
+  } catch {
+    // File may have been deleted already
+  }
+}
+
+/**
+ * Mark a draft item as aborted by the user. File is KEPT.
+ *
+ * @param {string} id
+ * @param {string|null} [repoRoot]
+ */
+export function markAborted(id, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const filePath = path.join(dir, `${id}.json`)
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const record = JSON.parse(raw)
+    record.status = 'aborted'
+    record.abortedAt = new Date().toISOString()
+    fs.writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8')
+  } catch {
+    // File may have been deleted already
+  }
+}
+
+/**
+ * Mark a draft item as failed (network error, API rejection, etc.).
+ * Keeps the file so the user can retry with `tissues drafts publish`.
+ *
+ * @param {string} id - draft item ID
+ * @param {string} errorMessage
+ * @param {string|null} [repoRoot]
+ */
+export function markFailed(id, errorMessage, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  const filePath = path.join(dir, `${id}.json`)
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const record = JSON.parse(raw)
+    record.status = 'failed'
+    record.error = errorMessage
+    record.failedAt = new Date().toISOString()
+    fs.writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8')
+  } catch {
+    // File may have been deleted already
+  }
+}
+
+/**
+ * Fast check: are there any pending draft items?
+ * Does NOT create the drafts dir if it doesn't exist.
+ *
+ * @param {string|null} [repoRoot]
+ * @returns {boolean}
+ */
+export function hasPending(repoRoot) {
+  try {
+    const dir = resolveDraftsDir(repoRoot)
+    if (!fs.existsSync(dir)) return false
+    return fs.readdirSync(dir).some((f) => f.endsWith('.json'))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Count pending draft items.
+ *
+ * @param {string|null} [repoRoot]
+ * @returns {number}
+ */
+export function countPending(repoRoot) {
+  try {
+    const dir = resolveDraftsDir(repoRoot)
+    if (!fs.existsSync(dir)) return 0
+    return fs.readdirSync(dir).filter((f) => f.endsWith('.json')).length
+  } catch {
+    return 0
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Attachments
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the attachment directory for a given draft item.
+ *
+ * @param {string} id - draft item ID (slug)
+ * @param {string|null} [repoRoot]
+ * @returns {string} absolute path to the attachment directory
+ */
+export function getAttachmentDir(id, repoRoot) {
+  const dir = getDraftsDir(repoRoot)
+  return path.join(dir, id)
+}
+
+/**
+ * Copy a file into the draft attachment directory and record metadata
+ * in the draft JSON.
+ *
+ * @param {string} id - draft item ID (slug)
+ * @param {string} filePath - absolute or relative path to the file
+ * @param {string|null} [repoRoot]
+ * @returns {{ filename: string, size: number, type: string }}
+ */
+export function attachFile(id, filePath, repoRoot) {
+  const resolved = path.resolve(filePath.replace(/^~/, os.homedir()))
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`File not found: ${filePath}`)
+  }
+
+  const stat = fs.statSync(resolved)
+  if (!stat.isFile()) {
+    throw new Error(`Not a file: ${filePath}`)
+  }
+
+  const filename = path.basename(resolved)
+  const attachDir = getAttachmentDir(id, repoRoot)
+  fs.mkdirSync(attachDir, { recursive: true })
+
+  const destPath = path.join(attachDir, filename)
+  fs.copyFileSync(resolved, destPath)
+
+  const ext = path.extname(filename).toLowerCase()
+  const typeMap = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.log': 'text/plain',
+  }
+  const type = typeMap[ext] || 'application/octet-stream'
+
+  const meta = { filename, size: stat.size, type }
+
+  // Update draft JSON with attachment metadata
+  const draftsDir = getDraftsDir(repoRoot)
+  const jsonPath = path.join(draftsDir, `${id}.json`)
+  try {
+    const raw = fs.readFileSync(jsonPath, 'utf8')
+    const record = JSON.parse(raw)
+    if (!record.attachments) record.attachments = []
+    record.attachments.push(meta)
+    record.updatedAt = new Date().toISOString()
+    fs.writeFileSync(jsonPath, JSON.stringify(record, null, 2), 'utf8')
+  } catch {
+    // JSON may be corrupt — attachment is still saved to disk
+  }
+
+  return meta
+}

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
@@ -300,6 +343,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}`))
-    }
-  })