tissues 0.5.2 → 0.6.1

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
+}