feat(regime)

src/promote.ts

@@ -0,0 +1,163 @@
+import { dirname, join } from "node:path"
+import { existsSync } from "node:fs"
+import { writeFile } from "node:fs/promises"
+import { $ } from "bun"
+import {
+  type RegimeConfig,
+  findRegimeConfigs,
+  resolveTemplateChain,
+  getStrategy,
+  interpolate,
+  deinterpolate,
+  readFileSync,
+  templatesDir,
+} from "./shared"
+
+const green = Bun.color("green", "ansi")
+const orange = Bun.color("orange", "ansi")
+const purple = Bun.color("purple", "ansi")
+const reset = "\x1b[0m"
+
+async function gumStdin(command: string, input: string): Promise<string> {
+  const proc = Bun.spawn(["gum", command], {
+    stdin: Buffer.from(input),
+    stdout: "pipe",
+    stderr: "inherit",
+  })
+  const output = await new Response(proc.stdout).text()
+  await proc.exited
+  return output
+}
+
+interface PromotableFile {
+  relPath: string       // relative path within template/repo (e.g. "tsconfig.json")
+  repoPath: string      // absolute path in the repo
+  configDir: string     // directory containing regime.config.json
+  vars: Record<string, string>
+  templateNames: string[] // all templates in the inheritance tree
+}
+
+export async function promote(targetDir: string, yes = false): Promise<void> {
+  // Step 1: Find regime configs
+  const rcFiles = await findRegimeConfigs(targetDir)
+  if (rcFiles.length === 0) {
+    console.error("No regime.config.json files found.")
+    process.exit(1)
+  }
+
+  // Step 2: Collect promotable files (overwrite-strategy files that differ)
+  const promotable: PromotableFile[] = []
+
+  for (const rcFile of rcFiles) {
+    const rcDir = dirname(rcFile)
+    const rc: RegimeConfig = JSON.parse(readFileSync(rcFile))
+    const templateNames = Array.isArray(rc.templates) ? rc.templates : [rc.templates]
+    const vars = rc.vars ?? {}
+
+    const { files, patterns, templateNames: chainNames } = resolveTemplateChain(templateNames)
+
+    for (const [relPath, templatePaths] of files) {
+      const strategy = getStrategy(relPath, patterns)
+      if (strategy !== "overwrite") continue
+
+      const repoPath = join(rcDir, relPath)
+      if (!existsSync(repoPath)) continue
+
+      const repoContent = readFileSync(repoPath)
+      const templateContent = interpolate(
+        readFileSync(templatePaths[templatePaths.length - 1]),
+        vars,
+        relPath,
+      )
+
+      if (repoContent !== templateContent) {
+        promotable.push({
+          relPath,
+          repoPath,
+          configDir: rcDir,
+          vars,
+          templateNames: chainNames,
+        })
+      }
+    }
+  }
+
+  if (promotable.length === 0) {
+    console.log("Nothing to promote.")
+    return
+  }
+
+  // Step 3: Interactive file selection via gum filter
+  const fileList = promotable.map(p => p.relPath).join("\n")
+  const selectedFile = (await gumStdin("filter", fileList)).trim()
+
+  if (!selectedFile) {
+    console.log("No file selected.")
+    return
+  }
+
+  const entry = promotable.find(p => p.relPath === selectedFile)
+  if (!entry) {
+    console.error(`File "${selectedFile}" not found in promotable list.`)
+    process.exit(1)
+  }
+
+  // Step 4: Interactive template selection via gum choose
+  let selectedTemplate: string
+  if (entry.templateNames.length === 1) {
+    selectedTemplate = entry.templateNames[0]
+  } else {
+    const templateList = entry.templateNames.join("\n")
+    selectedTemplate = (await gumStdin("choose", templateList)).trim()
+  }
+
+  if (!selectedTemplate) {
+    console.log("No template selected.")
+    return
+  }
+
+  // Step 5: De-interpolate
+  const repoContent = readFileSync(entry.repoPath)
+  const promoted = deinterpolate(repoContent, entry.vars)
+
+  // Step 6: Show diff
+  const templateFilePath = join(templatesDir, selectedTemplate, entry.relPath)
+
+  console.log(`\n${purple}Promoting${reset} ${entry.relPath} -> ${green}${selectedTemplate}${reset}`)
+
+  if (existsSync(templateFilePath)) {
+    const tmpFile = `/tmp/regime-promote-${Date.now()}`
+    await writeFile(tmpFile, promoted)
+    try {
+      const diff = await $`diff -u ${templateFilePath} ${tmpFile} || true`.text()
+      if (diff.trim()) {
+        console.log(diff)
+      } else {
+        console.log("No changes detected after de-interpolation.")
+        return
+      }
+    } finally {
+      await $`rm -f ${tmpFile}`.quiet()
+    }
+  } else {
+    console.log(`${orange}New file${reset} — will be created in template "${selectedTemplate}"`)
+    console.log(promoted)
+  }
+
+  // Step 7: Confirm
+  if (!yes) {
+    const confirmed = await $`gum confirm "Write to template?"`.nothrow()
+    if (confirmed.exitCode !== 0) {
+      console.log("Cancelled.")
+      return
+    }
+  }
+
+  // Step 8: Write
+  const targetFileDir = dirname(templateFilePath)
+  if (!existsSync(targetFileDir)) {
+    await $`mkdir -p ${targetFileDir}`.quiet()
+  }
+  await writeFile(templateFilePath, promoted)
+  console.log(`${green}Written${reset} ${templateFilePath}`)
+}