tissues 0.3.0

package/src/lib/templates.js

@@ -0,0 +1,220 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { findRepoRoot, loadConfig } from './defaults.js'
+
+// ---------------------------------------------------------------------------
+// Built-in templates
+// ---------------------------------------------------------------------------
+
+const BUILT_IN_TEMPLATES = {
+  default: {
+    name: 'Default',
+    body: `## Summary\n\n{{description}}\n\n## Details\n\n## Additional context\n`,
+  },
+  bug: {
+    name: 'Bug Report',
+    body: `## Bug\n\n{{description}}\n\n## Steps to reproduce\n\n1. \n\n## Expected behavior\n\n## Actual behavior\n\n## Environment\n\n`,
+  },
+  feature: {
+    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`,
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Derive the template name from a filename by stripping its `.md` extension.
+ *
+ * @param {string} filename - e.g. 'bug.md'
+ * @returns {string} e.g. 'bug'
+ */
+function templateNameFromFile(filename) {
+  return path.basename(filename, '.md')
+}
+
+/**
+ * Read all `.md` files from a directory and return them as a map of
+ * `{ name -> { name, body } }`. Returns an empty object if the directory does
+ * not exist or cannot be read.
+ *
+ * @param {string} dir
+ * @param {'repo' | 'user'} source
+ * @returns {Array<{ key: string, name: string, body: string, source: string }>}
+ */
+function readTemplatesFromDir(dir, source) {
+  try {
+    const entries = fs.readdirSync(dir)
+    return entries
+      .filter((f) => f.endsWith('.md'))
+      .map((f) => {
+        const key = templateNameFromFile(f)
+        const body = fs.readFileSync(path.join(dir, f), 'utf8')
+        // Use capitalized key as display name unless a front-matter `name:` line
+        // exists. Keep it simple — no full YAML parser dependency.
+        const nameLine = body.match(/^name:\s*(.+)$/m)
+        const name = nameLine ? nameLine[1].trim() : key.charAt(0).toUpperCase() + key.slice(1)
+        return { key, name, body, source }
+      })
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Resolve the template directory for a given source.
+ *
+ * @param {'repo' | 'user'} source
+ * @param {string|null} repoRoot
+ * @param {object} cfg - loaded config object
+ * @returns {string}
+ */
+function resolveTemplateDir(source, repoRoot, cfg) {
+  if (source === 'user') {
+    return path.join(os.homedir(), '.config', 'gitissues', 'templates')
+  }
+  // repo source
+  const templateDir = cfg.templates?.dir ?? '.gitissues/templates'
+  if (path.isAbsolute(templateDir)) return templateDir
+  if (repoRoot) return path.join(repoRoot, templateDir)
+  return path.resolve(templateDir)
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * List all available templates from all sources.
+ *
+ * Returns an array of descriptor objects. When multiple sources define a
+ * template with the same key, all entries are included (higher-priority sources
+ * will shadow lower-priority ones in `loadTemplate`).
+ *
+ * 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: 'built-in' | 'repo' | 'user' }>}
+ */
+export function listTemplates(repoRoot) {
+  const root = repoRoot ?? findRepoRoot()
+  const cfg = loadConfig(root)
+
+  // Built-in (lowest priority, listed last)
+  const builtIn = Object.entries(BUILT_IN_TEMPLATES).map(([key, tpl]) => ({
+    key,
+    name: tpl.name,
+    source: /** @type {'built-in'} */ ('built-in'),
+  }))
+
+  // User templates
+  const userDir = resolveTemplateDir('user', root, cfg)
+  const userTemplates = readTemplatesFromDir(userDir, 'user').map(({ key, name }) => ({
+    key,
+    name,
+    source: /** @type {'user'} */ ('user'),
+  }))
+
+  // Repo templates (highest priority among file-based)
+  const repoDir = resolveTemplateDir('repo', root, cfg)
+  const repoTemplates = readTemplatesFromDir(repoDir, 'repo').map(({ key, name }) => ({
+    key,
+    name,
+    source: /** @type {'repo'} */ ('repo'),
+  }))
+
+  // Return repo first so callers can see which keys override which
+  return [...repoTemplates, ...userTemplates, ...builtIn]
+}
+
+/**
+ * Load a template by name, applying source priority:
+ *   repo templates > user templates > built-in templates
+ *
+ * @param {string} [name] - template key (e.g. 'bug'); defaults to config value
+ * @param {string} [repoRoot] - path to repo root; auto-detected if omitted
+ * @returns {{ key: string, name: string, body: string, source: 'built-in' | 'repo' | 'user' }}
+ * @throws {Error} if the named template cannot be found in any source
+ */
+export function loadTemplate(name, repoRoot) {
+  const root = repoRoot ?? findRepoRoot()
+  const cfg = loadConfig(root)
+  const templateName = name ?? cfg.templates?.default ?? 'default'
+
+  // 1. Repo templates (highest priority)
+  const repoDir = resolveTemplateDir('repo', root, cfg)
+  const repoFile = path.join(repoDir, `${templateName}.md`)
+  if (fs.existsSync(repoFile)) {
+    const body = fs.readFileSync(repoFile, 'utf8')
+    const nameLine = body.match(/^name:\s*(.+)$/m)
+    const displayName = nameLine
+      ? nameLine[1].trim()
+      : templateName.charAt(0).toUpperCase() + templateName.slice(1)
+    return { key: templateName, name: displayName, body, source: 'repo' }
+  }
+
+  // 2. User templates
+  const userDir = resolveTemplateDir('user', root, cfg)
+  const userFile = path.join(userDir, `${templateName}.md`)
+  if (fs.existsSync(userFile)) {
+    const body = fs.readFileSync(userFile, 'utf8')
+    const nameLine = body.match(/^name:\s*(.+)$/m)
+    const displayName = nameLine
+      ? nameLine[1].trim()
+      : templateName.charAt(0).toUpperCase() + templateName.slice(1)
+    return { key: templateName, name: displayName, body, source: 'user' }
+  }
+
+  // 3. Built-in templates (lowest priority)
+  const builtIn = BUILT_IN_TEMPLATES[templateName]
+  if (builtIn) {
+    return { key: templateName, name: builtIn.name, body: builtIn.body, source: 'built-in' }
+  }
+
+  throw new Error(
+    `Template "${templateName}" not found. ` +
+      `Available templates: ${Object.keys(BUILT_IN_TEMPLATES).join(', ')}`
+  )
+}
+
+/**
+ * Render a template body by replacing `{{variable}}` placeholders with values
+ * from the `variables` map.
+ *
+ * Supported variables (any key can be provided):
+ *   - `title`       — issue title
+ *   - `description` — user's description
+ *   - `agent`       — agent name
+ *   - `session`     — session ID
+ *   - `date`        — ISO date string
+ *   - `repo`        — repo name (owner/name)
+ *
+ * Unknown variables in the template that have no matching key in `variables`
+ * are left as-is so callers can run multiple passes if needed.
+ *
+ * @param {string} templateBody - raw template string with `{{...}}` tokens
+ * @param {Record<string, string|number|null|undefined>} variables - substitution map
+ * @returns {string} rendered body
+ */
+export function renderTemplate(templateBody, variables) {
+  return templateBody.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = variables[key]
+    if (value == null) return match // leave unknown/missing vars intact
+    return String(value)
+  })
+}