@coreframe/scripts 0.0.0 → 0.1.0

package/upgrade/ensure-template-remote.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process"
+
+const defaultRemote = "template"
+const defaultUrl = "https://github.com/airlock-labs/coreframe.git"
+
+export type EnsureTemplateRemoteOptions = {
+  fetch: boolean
+  remote: string
+}
+
+function git(args: string[]) {
+  return spawnSync("git", args, { encoding: "utf8" })
+}
+
+function runGit(args: string[]) {
+  const result = git(args)
+
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim()
+    throw new Error(`Git command failed: git ${args.join(" ")}${detail ? `\n${detail}` : ""}`)
+  }
+
+  return result.stdout
+}
+
+function getRemoteUrl(remote: string) {
+  const result = git(["remote", "get-url", remote])
+
+  if (result.status === 2) {
+    return null
+  }
+
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim()
+    throw new Error(`Could not inspect remote ${remote}.${detail ? `\n${detail}` : ""}`)
+  }
+
+  return result.stdout.trim()
+}
+
+export function ensureTemplateRemote({
+  fetch = true,
+  remote = defaultRemote,
+}: Partial<EnsureTemplateRemoteOptions> = {}) {
+  if (remote.length === 0) {
+    throw new Error("Remote name must not be empty.")
+  }
+
+  runGit(["rev-parse", "--show-toplevel"])
+
+  const existingUrl = getRemoteUrl(remote)
+
+  if (existingUrl === null) {
+    runGit(["remote", "add", remote, defaultUrl])
+    console.log(`Added ${remote} remote: ${defaultUrl}`)
+  } else if (existingUrl === defaultUrl) {
+    console.log(`${remote} remote already points at ${defaultUrl}`)
+  } else {
+    throw new Error(
+      `${remote} remote points at ${existingUrl}, not ${defaultUrl}.\n` +
+        "Choose the intended template source before continuing, then update or rename the remote manually.",
+    )
+  }
+
+  if (fetch) {
+    runGit(["fetch", remote, "--tags", "--prune"])
+    console.log(`Fetched ${remote}.`)
+  }
+}
+
+if (import.meta.main) {
+  try {
+    ensureTemplateRemote({ fetch: !process.argv.includes("--no-fetch") })
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error))
+    process.exit(65)
+  }
+}

package/upgrade/fast-forward-template-files.ts

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process"
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs"
+import type { Stats } from "node:fs"
+import { dirname, join, resolve, sep } from "node:path"
+
+const projectOwnedPathPrefixes = ["drizzle/", "drizzle-hold/"]
+const supportedModes = new Set(["100644", "100755", "120000"])
+
+type GitEntry = {
+  mode: string
+  object: string
+  path: string
+  type: string
+}
+
+type ChangedPath = {
+  path: string
+  status: string
+}
+
+type PendingEntry = {
+  action: string
+  path: string
+  reason?: string
+  targetEntry?: GitEntry | null
+}
+
+export type FastForwardTemplateFilesOptions = {
+  apply: boolean
+  base?: string
+  target: string
+}
+
+function git(args: string[], options = {}) {
+  return spawnSync("git", args, options)
+}
+
+function gitText(args: string[]) {
+  const result = git(args, { encoding: "utf8" })
+
+  if (result.status !== 0) {
+    const detail = result.stderr.toString().trim() || result.stdout.toString().trim()
+    throw new Error(`Git command failed: git ${args.join(" ")}${detail ? `\n${detail}` : ""}`)
+  }
+
+  return result.stdout.toString()
+}
+
+function gitBuffer(args: string[]) {
+  const result = git(args)
+
+  if (result.status !== 0) {
+    const detail = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim()
+    throw new Error(`Git command failed: git ${args.join(" ")}${detail ? `\n${detail}` : ""}`)
+  }
+
+  return result.stdout
+}
+
+function getRepoRoot() {
+  return gitText(["rev-parse", "--show-toplevel"]).trim()
+}
+
+function readPackageCoreframeVersion(repoRoot: string) {
+  const packagePath = join(repoRoot, "package.json")
+
+  if (!existsSync(packagePath)) {
+    throw new Error("Missing --base <git-ref>, and package.json does not exist.")
+  }
+
+  const packageJson = JSON.parse(readFileSync(packagePath, "utf8")) as {
+    engines?: { coreframe?: unknown }
+  }
+  const version = packageJson.engines?.coreframe
+
+  if (typeof version !== "string" || version.length === 0) {
+    throw new Error("Missing --base <git-ref>, and package.json engines.coreframe is not set.")
+  }
+
+  return version
+}
+
+function splitNullTerminated(buffer: Buffer) {
+  const fields = []
+  let start = 0
+
+  for (let index = 0; index < buffer.length; index += 1) {
+    if (buffer[index] !== 0) {
+      continue
+    }
+
+    fields.push(buffer.subarray(start, index).toString("utf8"))
+    start = index + 1
+  }
+
+  return fields.filter((field) => field.length > 0)
+}
+
+function listChangedPaths(base: string, target: string) {
+  const output = gitBuffer(["diff", "--name-status", "-z", "--no-renames", base, target, "--"])
+  const fields = splitNullTerminated(output)
+  const changes: ChangedPath[] = []
+
+  for (let index = 0; index < fields.length; index += 2) {
+    const status = fields[index]
+    const path = fields[index + 1]
+
+    if (!status || !path) {
+      throw new Error("Could not parse git diff --name-status output.")
+    }
+
+    changes.push({ path, status })
+  }
+
+  return changes
+}
+
+function getGitEntry(ref: string, path: string): GitEntry | null {
+  const output = gitBuffer(["ls-tree", "-z", ref, "--", path])
+
+  if (output.length === 0) {
+    return null
+  }
+
+  const record = splitNullTerminated(output)[0]
+  const tabIndex = record.indexOf("\t")
+
+  if (tabIndex === -1) {
+    throw new Error(`Could not parse git ls-tree output for ${ref}:${path}.`)
+  }
+
+  const [mode, type, object] = record.slice(0, tabIndex).split(" ")
+
+  if (!mode || !type || !object) {
+    throw new Error(`Could not parse git ls-tree metadata for ${ref}:${path}.`)
+  }
+
+  return { mode, object, path, type }
+}
+
+function readGitBlob(entry: GitEntry) {
+  return gitBuffer(["cat-file", "blob", entry.object])
+}
+
+function safeWorktreePath(repoRoot: string, path: string) {
+  const absolutePath = resolve(repoRoot, path)
+  const rootPrefix = repoRoot.endsWith(sep) ? repoRoot : `${repoRoot}${sep}`
+
+  if (absolutePath !== repoRoot && !absolutePath.startsWith(rootPrefix)) {
+    throw new Error(`Refusing to access path outside repository: ${path}`)
+  }
+
+  return absolutePath
+}
+
+function pathExists(path: string) {
+  try {
+    lstatSync(path)
+    return true
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false
+    }
+
+    throw error
+  }
+}
+
+function isExecutable(stat: Stats) {
+  return (stat.mode & 0o111) !== 0
+}
+
+function entryIsSupported(entry: GitEntry | null) {
+  return entry === null || (entry.type === "blob" && supportedModes.has(entry.mode))
+}
+
+function isProjectOwnedPath(path: string) {
+  return projectOwnedPathPrefixes.some(
+    (prefix) => path === prefix.slice(0, -1) || path.startsWith(prefix),
+  )
+}
+
+function currentMatchesEntry(repoRoot: string, path: string, entry: GitEntry | null) {
+  const worktreePath = safeWorktreePath(repoRoot, path)
+
+  if (entry === null) {
+    return { matches: !pathExists(worktreePath) }
+  }
+
+  if (!entryIsSupported(entry)) {
+    return { matches: false, reason: `unsupported template entry mode ${entry.mode} ${entry.type}` }
+  }
+
+  let stat: Stats
+
+  try {
+    stat = lstatSync(worktreePath)
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { matches: false, reason: "path is missing from worktree" }
+    }
+
+    throw error
+  }
+
+  const expected = readGitBlob(entry)
+
+  if (entry.mode === "120000") {
+    if (!stat.isSymbolicLink()) {
+      return { matches: false, reason: "worktree path is not a symlink" }
+    }
+
+    const linkTarget = Buffer.from(readlinkSync(worktreePath), "utf8")
+    return { matches: linkTarget.equals(expected) }
+  }
+
+  if (!stat.isFile()) {
+    return { matches: false, reason: "worktree path is not a regular file" }
+  }
+
+  const executableMatches = entry.mode === "100755" ? isExecutable(stat) : !isExecutable(stat)
+
+  if (!executableMatches) {
+    return { matches: false, reason: "worktree executable bit differs from template" }
+  }
+
+  return { matches: readFileSync(worktreePath).equals(expected) }
+}
+
+function removeExistingPath(worktreePath: string) {
+  if (!pathExists(worktreePath)) {
+    return
+  }
+
+  rmSync(worktreePath, { force: true, recursive: false })
+}
+
+function applyEntry(repoRoot: string, path: string, entry: GitEntry | null) {
+  const worktreePath = safeWorktreePath(repoRoot, path)
+
+  if (entry === null) {
+    removeExistingPath(worktreePath)
+    return
+  }
+
+  mkdirSync(dirname(worktreePath), { recursive: true })
+
+  if (entry.mode === "120000") {
+    removeExistingPath(worktreePath)
+    symlinkSync(readGitBlob(entry).toString("utf8"), worktreePath)
+    return
+  }
+
+  const stat = pathExists(worktreePath) ? lstatSync(worktreePath) : null
+
+  if (stat && !stat.isFile()) {
+    removeExistingPath(worktreePath)
+  }
+
+  writeFileSync(worktreePath, readGitBlob(entry))
+  chmodSync(worktreePath, entry.mode === "100755" ? 0o755 : 0o644)
+}
+
+function actionFor(baseEntry: GitEntry | null, targetEntry: GitEntry | null) {
+  if (baseEntry === null && targetEntry !== null) {
+    return "add"
+  }
+
+  if (baseEntry !== null && targetEntry === null) {
+    return "delete"
+  }
+
+  return "update"
+}
+
+function printEntries(title: string, entries: PendingEntry[]) {
+  if (entries.length === 0) {
+    return
+  }
+
+  console.log(`${title}:`)
+
+  for (const entry of entries) {
+    const detail = entry.reason ? ` (${entry.reason})` : ""
+    console.log(`  ${entry.action}: ${entry.path}${detail}`)
+  }
+
+  console.log("")
+}
+
+export function fastForwardTemplateFiles(args: FastForwardTemplateFilesOptions) {
+  const repoRoot = getRepoRoot()
+  const base = args.base ?? readPackageCoreframeVersion(repoRoot)
+  const target = args.target
+  const changes = listChangedPaths(base, target)
+  const clean: PendingEntry[] = []
+  const ignored: PendingEntry[] = []
+  const skipped: PendingEntry[] = []
+  const unchanged: PendingEntry[] = []
+
+  for (const change of changes) {
+    if (isProjectOwnedPath(change.path)) {
+      ignored.push({
+        action: "ignored",
+        path: change.path,
+        reason: "project-owned migration history",
+      })
+      continue
+    }
+
+    const baseEntry = getGitEntry(base, change.path)
+    const targetEntry = getGitEntry(target, change.path)
+    const action = actionFor(baseEntry, targetEntry)
+
+    if (!entryIsSupported(baseEntry) || !entryIsSupported(targetEntry)) {
+      skipped.push({
+        action,
+        path: change.path,
+        reason: "unsupported template entry type",
+      })
+      continue
+    }
+
+    const targetMatch = currentMatchesEntry(repoRoot, change.path, targetEntry)
+
+    if (targetMatch.matches) {
+      unchanged.push({ action: "unchanged", path: change.path })
+      continue
+    }
+
+    const baseMatch = currentMatchesEntry(repoRoot, change.path, baseEntry)
+
+    if (!baseMatch.matches) {
+      skipped.push({
+        action,
+        path: change.path,
+        reason: baseMatch.reason ?? "downstream differs from base template",
+      })
+      continue
+    }
+
+    clean.push({ action, path: change.path, targetEntry })
+  }
+
+  if (args.apply) {
+    for (const entry of clean) {
+      applyEntry(repoRoot, entry.path, entry.targetEntry ?? null)
+    }
+  }
+
+  console.log(`Coreframe template fast-forward: ${base} -> ${target}`)
+  console.log("")
+
+  printEntries(
+    args.apply ? "Applied clean template updates" : "Would apply clean template updates",
+    clean,
+  )
+  printEntries("Ignored project-owned paths", ignored)
+  printEntries("Skipped for agent review", skipped)
+
+  if (unchanged.length > 0) {
+    console.log(`${unchanged.length} changed template path(s) already matched the target state.`)
+  }
+
+  if (changes.length === 0) {
+    console.log("No template file changes found in the requested range.")
+  }
+
+  if (!args.apply && clean.length > 0) {
+    console.log("")
+    console.log(`Run with --apply to write the ${clean.length} clean update(s).`)
+  }
+}
+
+if (import.meta.main) {
+  const targetIndex = process.argv.indexOf("--target")
+  const target = targetIndex === -1 ? null : process.argv[targetIndex + 1]
+
+  if (!target) {
+    console.error(
+      "Usage: coreframe upgrade fast-forward-template-files --target <git-ref> [--base <git-ref>] [--apply]",
+    )
+    process.exit(64)
+  }
+
+  try {
+    const baseIndex = process.argv.indexOf("--base")
+    fastForwardTemplateFiles({
+      apply: process.argv.includes("--apply"),
+      base: baseIndex === -1 ? undefined : process.argv[baseIndex + 1],
+      target,
+    })
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error))
+    process.exit(65)
+  }
+}

package/readme.md

@@ -1 +0,0 @@
-Coming soon...