411 lines
13 KiB
TypeScript
411 lines
13 KiB
TypeScript
#!/usr/bin/env bun
|
|
/**
|
|
* Folder reorganisation migration script.
|
|
*
|
|
* Reads scripts/folder-reorg/assignment.yml and moves every package currently
|
|
* under universal/<domain>/<pkg>/ to packages/<plugin>/<pkg>/ via `git mv`.
|
|
*
|
|
* Run modes:
|
|
* bun scripts/folder-reorg/migrate-folders.ts --dry-run # plan only
|
|
* bun scripts/folder-reorg/migrate-folders.ts # execute
|
|
* bun scripts/folder-reorg/migrate-folders.ts --check # validate manifest only
|
|
*
|
|
* Exits non-zero on:
|
|
* - duplicate package across plugins
|
|
* - on-disk package not present in any plugin's list
|
|
* - destination path already exists
|
|
* - git working tree dirty (execute mode only)
|
|
*/
|
|
|
|
import { execFileSync } from "node:child_process";
|
|
import {
|
|
cpSync,
|
|
existsSync,
|
|
mkdirSync,
|
|
readdirSync,
|
|
readFileSync,
|
|
rmdirSync,
|
|
rmSync,
|
|
statSync,
|
|
} from "node:fs";
|
|
import { dirname, join, relative, resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { parse as parseYaml } from "yaml";
|
|
|
|
const here = dirname(fileURLToPath(import.meta.url));
|
|
const repoRoot = resolve(here, "..", "..");
|
|
const assignmentPath = join(here, "assignment.yml");
|
|
|
|
const LEGACY_ROOTS = [
|
|
"universal",
|
|
"browser",
|
|
"react",
|
|
"r3f",
|
|
"server",
|
|
"finance",
|
|
"mcp",
|
|
"python",
|
|
"gaming",
|
|
"api",
|
|
] as const;
|
|
|
|
type Mode = "dry-run" | "execute" | "check";
|
|
|
|
interface Assignment {
|
|
[plugin: string]: string[];
|
|
}
|
|
|
|
interface PlannedMove {
|
|
pkg: string;
|
|
plugin: string;
|
|
from: string; // absolute
|
|
to: string; // absolute
|
|
}
|
|
|
|
const log = (...args: unknown[]) => console.log(...args);
|
|
const warn = (...args: unknown[]) => console.warn("⚠ ", ...args);
|
|
const fail = (msg: string): never => {
|
|
console.error(`✗ ${msg}`);
|
|
process.exit(1);
|
|
};
|
|
|
|
function git(args: string[], cwd: string = repoRoot): string {
|
|
return execFileSync("git", args, { cwd, encoding: "utf8" });
|
|
}
|
|
|
|
function parseMode(argv: string[]): Mode {
|
|
if (argv.includes("--dry-run")) return "dry-run";
|
|
if (argv.includes("--check")) return "check";
|
|
return "execute";
|
|
}
|
|
|
|
function loadAssignment(): Assignment {
|
|
if (!existsSync(assignmentPath)) {
|
|
fail(`Assignment manifest not found: ${assignmentPath}`);
|
|
}
|
|
const raw = readFileSync(assignmentPath, "utf8");
|
|
const parsed = parseYaml(raw) as unknown;
|
|
if (typeof parsed !== "object" || parsed === null) {
|
|
fail("assignment.yml did not parse to an object");
|
|
}
|
|
const a = parsed as Record<string, unknown>;
|
|
for (const [plugin, pkgs] of Object.entries(a)) {
|
|
if (!Array.isArray(pkgs)) fail(`Plugin "${plugin}" is not a list`);
|
|
for (const p of pkgs) {
|
|
if (typeof p !== "string")
|
|
fail(`Plugin "${plugin}" has non-string entry`);
|
|
}
|
|
}
|
|
return a as Assignment;
|
|
}
|
|
|
|
interface ParsedAssignment {
|
|
pkgToPlugin: Map<string, string>;
|
|
retired: Set<string>;
|
|
}
|
|
|
|
function validateUniqueness(assignment: Assignment): ParsedAssignment {
|
|
const pkgToPlugin = new Map<string, string>();
|
|
const retired = new Set<string>(assignment.__retired__ ?? []);
|
|
const duplicates: string[] = [];
|
|
for (const [plugin, pkgs] of Object.entries(assignment)) {
|
|
if (plugin === "__retired__") continue;
|
|
for (const pkg of pkgs) {
|
|
if (retired.has(pkg)) {
|
|
duplicates.push(
|
|
` ${pkg}: listed in plugin "${plugin}" AND in __retired__`
|
|
);
|
|
continue;
|
|
}
|
|
const prior = pkgToPlugin.get(pkg);
|
|
if (prior !== undefined) {
|
|
duplicates.push(` ${pkg}: in "${prior}" AND "${plugin}"`);
|
|
} else {
|
|
pkgToPlugin.set(pkg, plugin);
|
|
}
|
|
}
|
|
}
|
|
if (duplicates.length > 0) {
|
|
fail(`Duplicate package assignments found:\n${duplicates.join("\n")}`);
|
|
}
|
|
return { pkgToPlugin, retired };
|
|
}
|
|
|
|
function discoverOnDiskPackages(): Map<string, string> {
|
|
const result = new Map<string, string>();
|
|
for (const root of LEGACY_ROOTS) {
|
|
const rootPath = join(repoRoot, root);
|
|
if (!existsSync(rootPath) || !statSync(rootPath).isDirectory())
|
|
continue;
|
|
for (const domain of readdirSync(rootPath)) {
|
|
const domainPath = join(rootPath, domain);
|
|
if (!statSync(domainPath).isDirectory()) continue;
|
|
for (const pkg of readdirSync(domainPath)) {
|
|
const pkgPath = join(domainPath, pkg);
|
|
if (!statSync(pkgPath).isDirectory()) continue;
|
|
if (!existsSync(join(pkgPath, "package.json"))) continue;
|
|
if (result.has(pkg)) {
|
|
fail(
|
|
`On-disk duplicate package directory: "${pkg}" exists in both ${result.get(pkg)} and ${pkgPath}`
|
|
);
|
|
}
|
|
result.set(pkg, pkgPath);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function planMoves(
|
|
parsed: ParsedAssignment,
|
|
onDisk: Map<string, string>
|
|
): { moves: PlannedMove[]; orphans: string[]; retiredOnDisk: string[] } {
|
|
const moves: PlannedMove[] = [];
|
|
const orphans: string[] = [];
|
|
const retiredOnDisk: string[] = [];
|
|
for (const [pkg, fromAbs] of onDisk) {
|
|
if (parsed.retired.has(pkg)) {
|
|
retiredOnDisk.push(pkg);
|
|
continue;
|
|
}
|
|
const plugin = parsed.pkgToPlugin.get(pkg);
|
|
if (plugin === undefined) {
|
|
orphans.push(pkg);
|
|
continue;
|
|
}
|
|
const toAbs = join(repoRoot, "packages", plugin, pkg);
|
|
moves.push({ pkg, plugin, from: fromAbs, to: toAbs });
|
|
}
|
|
moves.sort((a, b) =>
|
|
a.plugin === b.plugin
|
|
? a.pkg.localeCompare(b.pkg)
|
|
: a.plugin.localeCompare(b.plugin)
|
|
);
|
|
return { moves, orphans, retiredOnDisk };
|
|
}
|
|
|
|
function checkGitClean(): void {
|
|
const out = git(["status", "--porcelain"]);
|
|
if (out.trim().length > 0) {
|
|
fail(
|
|
`Working tree is dirty — commit or stash before migrating.\n\n${out}\n` +
|
|
"If you really want to proceed with uncommitted changes, run with --dry-run first to verify the plan."
|
|
);
|
|
}
|
|
}
|
|
|
|
function ensureDestinationsClear(moves: PlannedMove[]): void {
|
|
const collisions: string[] = [];
|
|
for (const m of moves) {
|
|
if (existsSync(m.to)) collisions.push(` ${relative(repoRoot, m.to)}`);
|
|
}
|
|
if (collisions.length > 0) {
|
|
fail(`Destination paths already exist:\n${collisions.join("\n")}`);
|
|
}
|
|
}
|
|
|
|
// Skip these from `cp -R` — build/test artifacts + dependency trees, regenerated
|
|
// by `bun install` post-migration. Skipping keeps moves under 1s per package
|
|
// instead of minutes (a single testing-integration package node_modules is ~500MB).
|
|
const COPY_SKIP = new Set([
|
|
"node_modules",
|
|
"dist",
|
|
".turbo",
|
|
"coverage",
|
|
".bd_modules",
|
|
".tsbuildinfo",
|
|
]);
|
|
|
|
function copyTrackedOnly(fromAbs: string, toAbs: string): void {
|
|
cpSync(fromAbs, toAbs, {
|
|
recursive: true,
|
|
filter: (src) => {
|
|
const base = src.split("/").pop() ?? "";
|
|
if (COPY_SKIP.has(base)) return false;
|
|
if (base.endsWith(".tsbuildinfo")) return false;
|
|
return true;
|
|
},
|
|
});
|
|
}
|
|
|
|
function moveOne(fromRel: string, toRel: string): "git-mv" | "cp-rm" {
|
|
// Try `git mv` first — preserves rename in the index cleanly.
|
|
try {
|
|
git(["mv", fromRel, toRel]);
|
|
return "git-mv";
|
|
} catch (err) {
|
|
const msg = (err as Error).message;
|
|
if (!msg.includes("Permission denied")) throw err;
|
|
}
|
|
// WSL2/DrvFs fallback: rename syscall blocked by Windows-side handle.
|
|
// Copy tracked files only (skip node_modules etc), remove source, restage.
|
|
// Git's rename detection still works for `log --follow` on similar files.
|
|
const fromAbs = join(repoRoot, fromRel);
|
|
const toAbs = join(repoRoot, toRel);
|
|
copyTrackedOnly(fromAbs, toAbs);
|
|
rmSync(fromAbs, { recursive: true, force: true });
|
|
git(["add", toRel]);
|
|
git(["rm", "-r", "--quiet", fromRel]);
|
|
return "cp-rm";
|
|
}
|
|
|
|
function executeMoves(moves: PlannedMove[]): void {
|
|
const seenPluginDirs = new Set<string>();
|
|
let cpRmCount = 0;
|
|
for (const m of moves) {
|
|
const pluginDir = join(repoRoot, "packages", m.plugin);
|
|
if (!seenPluginDirs.has(pluginDir)) {
|
|
mkdirSync(pluginDir, { recursive: true });
|
|
seenPluginDirs.add(pluginDir);
|
|
}
|
|
const fromRel = relative(repoRoot, m.from);
|
|
const toRel = relative(repoRoot, m.to);
|
|
const method = moveOne(fromRel, toRel);
|
|
const tag = method === "cp-rm" ? " cp+rm " : " git mv ";
|
|
log(`${tag}${fromRel} → ${toRel}`);
|
|
if (method === "cp-rm") cpRmCount += 1;
|
|
}
|
|
if (cpRmCount > 0) {
|
|
log("");
|
|
log(
|
|
`(${cpRmCount}/${moves.length} moves used cp+rm fallback due to WSL2 rename block.)`
|
|
);
|
|
}
|
|
}
|
|
|
|
function pruneEmptyDir(absPath: string): boolean {
|
|
// Returns true if the directory was removed.
|
|
if (!existsSync(absPath) || !statSync(absPath).isDirectory()) return false;
|
|
const entries = readdirSync(absPath);
|
|
let allRemoved = true;
|
|
for (const entry of entries) {
|
|
const child = join(absPath, entry);
|
|
if (statSync(child).isDirectory()) {
|
|
if (!pruneEmptyDir(child)) allRemoved = false;
|
|
} else {
|
|
allRemoved = false;
|
|
}
|
|
}
|
|
if (allRemoved && readdirSync(absPath).length === 0) {
|
|
rmdirSync(absPath);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function pruneEmptyLegacyDirs(): void {
|
|
for (const root of LEGACY_ROOTS) {
|
|
const rootPath = join(repoRoot, root);
|
|
if (pruneEmptyDir(rootPath)) {
|
|
log(` rmdir ${root}/`);
|
|
}
|
|
}
|
|
}
|
|
|
|
function summarise(
|
|
moves: PlannedMove[],
|
|
orphans: string[],
|
|
retiredOnDisk: string[],
|
|
assignment: Assignment,
|
|
onDisk: Map<string, string>,
|
|
mode: Mode
|
|
): void {
|
|
const pluginCounts = new Map<string, number>();
|
|
for (const m of moves)
|
|
pluginCounts.set(m.plugin, (pluginCounts.get(m.plugin) ?? 0) + 1);
|
|
const pluginKeys = Object.keys(assignment).filter(
|
|
(k) => k !== "__retired__"
|
|
);
|
|
const totalAssigned = pluginKeys.reduce(
|
|
(n, k) => n + (assignment[k]?.length ?? 0),
|
|
0
|
|
);
|
|
|
|
log("");
|
|
log(`Mode: ${mode}`);
|
|
log(`Plugins defined: ${pluginKeys.length}`);
|
|
log(`Packages assigned: ${totalAssigned}`);
|
|
log(`Packages retired: ${assignment.__retired__?.length ?? 0}`);
|
|
log(`Packages on disk: ${onDisk.size}`);
|
|
log(`Packages to migrate: ${moves.length}`);
|
|
log(`Packages on disk (retired, skipped): ${retiredOnDisk.length}`);
|
|
log(`Packages future-only: ${totalAssigned - moves.length}`);
|
|
log("");
|
|
log("Per-plugin migration counts:");
|
|
for (const [plugin, count] of [...pluginCounts.entries()].sort()) {
|
|
log(` ${plugin.padEnd(24)} ${count}`);
|
|
}
|
|
if (retiredOnDisk.length > 0) {
|
|
log("");
|
|
log("Retired packages on disk (NOT migrated; remove via tasks.md §8):");
|
|
for (const p of retiredOnDisk)
|
|
log(` ${p} (${relative(repoRoot, onDisk.get(p) ?? "")})`);
|
|
}
|
|
if (orphans.length > 0) {
|
|
log("");
|
|
warn("On-disk packages not assigned to any plugin:");
|
|
for (const p of orphans) warn(` ${p}`);
|
|
fail(
|
|
"Refusing to proceed — every on-disk package must appear in assignment.yml (or in __retired__)."
|
|
);
|
|
}
|
|
}
|
|
|
|
function main(): void {
|
|
const mode = parseMode(process.argv.slice(2));
|
|
log(`folder-reorg/migrate-folders.ts — mode: ${mode}`);
|
|
|
|
const assignment = loadAssignment();
|
|
const parsed = validateUniqueness(assignment);
|
|
|
|
if (mode === "check") {
|
|
const pluginCount = Object.keys(assignment).filter(
|
|
(k) => k !== "__retired__"
|
|
).length;
|
|
log(
|
|
`✓ Manifest valid: ${parsed.pkgToPlugin.size} unique packages across ${pluginCount} plugins, ${parsed.retired.size} retired.`
|
|
);
|
|
return;
|
|
}
|
|
|
|
const onDisk = discoverOnDiskPackages();
|
|
const { moves, orphans, retiredOnDisk } = planMoves(parsed, onDisk);
|
|
|
|
summarise(moves, orphans, retiredOnDisk, assignment, onDisk, mode);
|
|
|
|
if (mode === "dry-run") {
|
|
log("");
|
|
log("Planned moves (first 10):");
|
|
for (const m of moves.slice(0, 10)) {
|
|
log(
|
|
` ${relative(repoRoot, m.from)} → ${relative(repoRoot, m.to)}`
|
|
);
|
|
}
|
|
if (moves.length > 10) log(` ...and ${moves.length - 10} more`);
|
|
log("");
|
|
log("✓ Dry run complete. Re-run without --dry-run to execute.");
|
|
return;
|
|
}
|
|
|
|
checkGitClean();
|
|
ensureDestinationsClear(moves);
|
|
|
|
log("");
|
|
log("Executing moves:");
|
|
executeMoves(moves);
|
|
pruneEmptyLegacyDirs();
|
|
|
|
log("");
|
|
log(`✓ Migrated ${moves.length} packages.`);
|
|
log("");
|
|
log("Next steps:");
|
|
log(' 1. Update root package.json workspaces to: "packages/*/*"');
|
|
log(" 2. Run: rm -rf node_modules bun.lockb && bun install --force");
|
|
log(" 3. Run: bunx turbo lint typecheck test");
|
|
log(
|
|
" 4. Commit: chore(structure): move all packages to domain-first layout"
|
|
);
|
|
}
|
|
|
|
main();
|