@coreframe/scripts 0.0.0 → 0.1.0

package/dist/upgrade/fast-forward-template-files.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+const projectOwnedPathPrefixes = ["drizzle/", "drizzle-hold/"];
+const supportedModes = new Set(["100644", "100755", "120000"]);
+function git(args, options = {}) {
+    return spawnSync("git", args, options);
+}
+function gitText(args) {
+    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) {
+    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) {
+    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"));
+    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) {
+    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, target) {
+    const output = gitBuffer(["diff", "--name-status", "-z", "--no-renames", base, target, "--"]);
+    const fields = splitNullTerminated(output);
+    const changes = [];
+    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, path) {
+    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) {
+    return gitBuffer(["cat-file", "blob", entry.object]);
+}
+function safeWorktreePath(repoRoot, path) {
+    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) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function isExecutable(stat) {
+    return (stat.mode & 0o111) !== 0;
+}
+function entryIsSupported(entry) {
+    return entry === null || (entry.type === "blob" && supportedModes.has(entry.mode));
+}
+function isProjectOwnedPath(path) {
+    return projectOwnedPathPrefixes.some((prefix) => path === prefix.slice(0, -1) || path.startsWith(prefix));
+}
+function currentMatchesEntry(repoRoot, path, entry) {
+    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;
+    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) {
+    if (!pathExists(worktreePath)) {
+        return;
+    }
+    rmSync(worktreePath, { force: true, recursive: false });
+}
+function applyEntry(repoRoot, path, entry) {
+    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, targetEntry) {
+    if (baseEntry === null && targetEntry !== null) {
+        return "add";
+    }
+    if (baseEntry !== null && targetEntry === null) {
+        return "delete";
+    }
+    return "update";
+}
+function printEntries(title, entries) {
+    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) {
+    const repoRoot = getRepoRoot();
+    const base = args.base ?? readPackageCoreframeVersion(repoRoot);
+    const target = args.target;
+    const changes = listChangedPaths(base, target);
+    const clean = [];
+    const ignored = [];
+    const skipped = [];
+    const unchanged = [];
+    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/image-generator.ts

@@ -0,0 +1,84 @@
+import fs from "node:fs"
+import path from "node:path"
+
+import type sharp from "sharp"
+import { glob } from "tinyglobby"
+import type { Plugin } from "vite"
+
+type SharpFactory = typeof sharp
+
+export function imageGenerator(): Plugin {
+  return {
+    name: "image-generator",
+    async buildStart() {
+      const files = await glob(["src/**/*@3x.{png,webp}", "public/**/*@3x.{png,webp}"])
+
+      console.log(`[image-generator] Found ${files.length} @3x images.`)
+
+      await Promise.all(files.map((file) => generateDensityImages(file)))
+    },
+  }
+}
+
+async function generateDensityImages(file: string) {
+  const dir = path.dirname(file)
+  const ext = path.extname(file)
+  const base = path.basename(file, `@3x${ext}`)
+  const outputImages = [
+    {
+      outputPath: path.join(dir, `${base}@2x${ext}`),
+      scale: 2 / 3,
+    },
+    {
+      outputPath: path.join(dir, `${base}@1x${ext}`),
+      scale: 1 / 3,
+    },
+  ].filter((image) => !fs.existsSync(image.outputPath))
+
+  if (outputImages.length === 0) {
+    return
+  }
+
+  const { default: sharp } = await import("sharp")
+  let width: number | undefined
+
+  try {
+    width = (await sharp(file).metadata()).width
+  } catch (error) {
+    console.error(`[image-generator] Failed to read metadata for ${file}`, error)
+    return
+  }
+
+  if (!width) {
+    console.error(`[image-generator] Skipping ${file}; image width could not be read.`)
+    return
+  }
+
+  await Promise.all(
+    outputImages.map((image) =>
+      generateDensityImage({
+        file,
+        outputPath: image.outputPath,
+        sharp,
+        width: Math.round(width * image.scale),
+      }),
+    ),
+  )
+}
+
+async function generateDensityImage(options: {
+  file: string
+  outputPath: string
+  sharp: SharpFactory
+  width: number
+}) {
+  try {
+    console.log(`[image-generator] Generating ${options.outputPath} (${options.width}w)`)
+    await options.sharp(options.file).resize({ width: options.width }).toFile(options.outputPath)
+  } catch (error) {
+    console.error(
+      `[image-generator] Failed to process ${options.file} for ${options.outputPath}`,
+      error,
+    )
+  }
+}

package/package.json

@@ -1,13 +1,53 @@
 {
   "name": "@coreframe/scripts",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "0.1.0",
+  "bin": {
+    "coreframe": "./bin/coreframe.js"
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/airlock-labs/coreframe.git",
+    "directory": "scripts"
+  },
+  "exports": {
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "format": "oxfmt",
+    "lint": "oxlint"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.6.0",
+    "cmd-ts": "0.15.0",
+    "drizzle-orm": "1.0.0-rc.4",
+    "nano-spawn": "^2.1.0",
+    "procband": "^0.3.5",
+    "tinyglobby": "^0.2.17"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "sharp": "^0.34.5",
+    "typescript": "6.0.3",
+    "vite": "^8.1.0",
+    "vitest": "^4.1.9"
+  },
+  "peerDependencies": {
+    "sharp": "^0.34.5",
+    "vite": "^8.0.0"
   },
-  "keywords": [],
-  "author": "",
-  "license": "All rights reserved",
-  "type": "commonjs"
+  "peerDependenciesMeta": {
+    "sharp": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  }
 }

package/project.ts

@@ -0,0 +1,6 @@
+import { resolve } from "node:path"
+import { pathToFileURL } from "node:url"
+
+export async function importProjectModule<T>(path: string): Promise<T> {
+  return (await import(pathToFileURL(resolve(process.cwd(), path)).href)) as T
+}

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "allowImportingTsExtensions": false,
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "noEmit": false,
+    "outDir": "dist",
+    "rewriteRelativeImportExtensions": true
+  },
+  "exclude": ["**/*.test.ts", "**/*.test.tsx", "dist"]
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "rootDir": ".",
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022",
+    "types": ["node"]
+  },
+  "include": ["**/*.ts"]
+}

package/typecheck.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { access } from "node:fs/promises"
+import path from "node:path"
+import process from "node:process"
+
+import { supervise } from "procband"
+
+const nodeModulesBinPath = path.resolve("node_modules", ".bin")
+process.env.PATH = nodeModulesBinPath + path.delimiter + process.env.PATH
+
+const tscCommand = process.platform === "win32" ? "tsc.cmd" : "tsc"
+const projects = [
+  { name: "scripts", path: "scripts/tsconfig.json" },
+  { name: "shared", path: "src/shared/tsconfig.json" },
+  { name: "api", path: "src/api/tsconfig.json" },
+  { name: "worker", path: "src/api/worker/tsconfig.json" },
+  { name: "web", path: "src/web/tsconfig.json" },
+] as const
+
+export async function typecheckProject() {
+  const existingProjects = []
+
+  for (const project of projects) {
+    try {
+      await access(project.path)
+      existingProjects.push(project)
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+        throw error
+      }
+    }
+  }
+
+  const checks = existingProjects.map((project) =>
+    supervise({
+      name: project.name,
+      command: tscCommand,
+      args: ["-p", project.path],
+    }),
+  )
+
+  const results = await Promise.all(checks.map((check) => check.wait()))
+  const failed = results.filter((result) => result.exitCode !== 0)
+
+  if (failed.length > 0) {
+    process.exitCode = failed[0].exitCode
+  }
+}
+
+if (import.meta.main) {
+  typecheckProject().catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })
+}

package/upgrade/check-skill-current.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+const skillPath = ".agents/skills/coreframe-upgrade/SKILL.md"
+
+export type CheckUpgradeSkillOptions = {
+  apply: boolean
+  target: string
+}
+
+function git(args: string[], options: { encoding?: BufferEncoding } = {}) {
+  return spawnSync("git", args, options)
+}
+
+function errorDetail(result: ReturnType<typeof spawnSync>) {
+  return result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim()
+}
+
+function readGitFile(ref: string, path: string) {
+  const result = git(["show", `${ref}:${path}`], { encoding: "utf8" })
+
+  if (result.status !== 0) {
+    const detail = errorDetail(result)
+    throw new Error(`Could not read ${path} at ${ref}.${detail ? ` ${detail}` : ""}`)
+  }
+
+  return result.stdout.toString()
+}
+
+function getRepoRoot() {
+  const result = git(["rev-parse", "--show-toplevel"], { encoding: "utf8" })
+
+  if (result.status !== 0) {
+    const detail = errorDetail(result)
+    throw new Error(`Could not find git repository root.${detail ? ` ${detail}` : ""}`)
+  }
+
+  return result.stdout.toString().trim()
+}
+
+function printDiff(localPath: string, targetText: string) {
+  const dir = mkdtempSync(join(tmpdir(), "coreframe-upgrade-skill-"))
+  const targetPath = join(dir, "SKILL.md")
+
+  try {
+    writeFileSync(targetPath, targetText)
+    const diff = git([
+      "--no-pager",
+      "diff",
+      "--no-index",
+      "--color=never",
+      "--",
+      localPath,
+      targetPath,
+    ])
+    const output = errorDetail(diff)
+
+    if (output) {
+      console.log(output)
+    }
+  } finally {
+    rmSync(dir, { force: true, recursive: true })
+  }
+}
+
+export function checkUpgradeSkillCurrent({ apply, target }: CheckUpgradeSkillOptions) {
+  const repoRoot = getRepoRoot()
+  const localPath = join(repoRoot, skillPath)
+
+  if (!existsSync(localPath)) {
+    throw new Error(`Local ${skillPath} does not exist.`)
+  }
+
+  const localText = readFileSync(localPath, "utf8")
+  const targetText = readGitFile(target, skillPath)
+
+  if (localText === targetText) {
+    console.log(`Coreframe upgrade skill matches ${target}:${skillPath}.`)
+    return 0
+  }
+
+  if (apply) {
+    writeFileSync(localPath, targetText)
+    console.error(`Updated ${skillPath} from ${target}. Reread it before continuing the upgrade.`)
+    return 20
+  }
+
+  console.error(`Coreframe upgrade skill differs from ${target}:${skillPath}.`)
+  console.error(`Run again with --apply to update it, then reread ${skillPath} before continuing.`)
+  printDiff(localPath, targetText)
+  return 20
+}
+
+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 check-skill-current --target <git-ref> [--apply]")
+    process.exit(64)
+  }
+
+  try {
+    process.exit(checkUpgradeSkillCurrent({ apply: process.argv.includes("--apply"), target }))
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error))
+    process.exit(65)
+  }
+}