pm4ai 0.0.73

package/dist/sync-DN1rgN3P.mjs

@@ -0,0 +1,732 @@
+import { C as DEFAULT_FILES, E as EXPECTED, L as TSDOWN_BASE, N as READONLY_UI, P as REQUIRED_ROOT_DEVDEPS, S as DEFAULT_DEP_VERSION, T as DEFAULT_SCRIPTS, V as filterTurboWorkspaceWarning, c as gitCleanRe, d as isSkippedPath, g as resolveManagedFiles, l as isExtended, m as readPkg, n as collectWorkspacePackages, o as getGhRepo, p as readJson, s as getTsconfigTypes, t as buildPkgDepMap, v as writeJson, w as DEFAULT_LICENSE, y as CLAUDE_MD } from "./utils-CpkOMuQN.mjs";
+import { i as DEP_FIELDS, n as isPublishedPkg, r as ALL_DEP_FIELDS } from "./audit-oQQfgtxr.mjs";
+import { $, file, write } from "bun";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/infer.ts
+const parseFrontmatter = (content) => {
+	if (!content.startsWith("---")) return {};
+	const endIdx = content.indexOf("---", 3);
+	if (endIdx === -1) return {};
+	const fm = {};
+	for (const line of content.slice(3, endIdx).trim().split("\n")) {
+		const colon = line.indexOf(":");
+		if (colon > 0) fm[line.slice(0, colon).trim()] = line.slice(colon + 1).trim();
+	}
+	return fm;
+};
+const getRulesDir = () => {
+	return [join(import.meta.dir, "..", "..", "..", "apps", "web", "content", "rules"), join(import.meta.dir, "..", "apps", "web", "content", "rules")].find((c) => existsSync(c));
+};
+const getAllDeps = async (projectPath) => {
+	const deps = /* @__PURE__ */ new Set();
+	const entries = await collectWorkspacePackages(projectPath);
+	for (const { pkg } of entries) for (const field of ALL_DEP_FIELDS) {
+		const d = pkg[field];
+		if (d) for (const name of Object.keys(d)) deps.add(name);
+	}
+	return deps;
+};
+const inferRules = async (projectPath, rulesDir) => {
+	const dir = rulesDir ?? getRulesDir();
+	if (!(dir && existsSync(dir))) return [];
+	const deps = await getAllDeps(projectPath);
+	const rules = [];
+	const mdxFiles = readdirSync(dir).filter((f) => f.endsWith(".mdx"));
+	const indexFile = mdxFiles.find((f) => f === "index.mdx");
+	const sorted = [...indexFile ? [indexFile] : [], ...mdxFiles.filter((f) => f !== "index.mdx").toSorted()];
+	for (const mdxFile of sorted) {
+		const { infer } = parseFrontmatter(readFileSync(join(dir, mdxFile), "utf8"));
+		if (infer && (infer === "always" || deps.has(infer))) rules.push(mdxFile.replace(".mdx", ""));
+	}
+	return rules;
+};
+//#endregion
+//#region src/sync.ts
+/** biome-ignore-all lint/performance/noDelete: must delete pkg keys */
+/** biome-ignore-all lint/nursery/noContinue: loop control flow */
+const sortKeys = (obj) => Object.fromEntries(Object.entries(obj).toSorted(([a], [b]) => a.localeCompare(b)));
+const stripFrontmatter = (content) => {
+	if (!content.startsWith("---")) return content;
+	const endIdx = content.indexOf("---", 3);
+	if (endIdx === -1) return content;
+	return content.slice(endIdx + 3).trim();
+};
+const syncConfigs = async (selfPath, projectPath) => {
+	const managed = await resolveManagedFiles(projectPath);
+	return (await Promise.all(managed.map(async ({ extendable, path: name }) => {
+		const src = file(join(selfPath, name));
+		const dst = file(join(projectPath, name));
+		if (!await src.exists()) return;
+		const srcContent = await src.text();
+		const dstContent = await dst.exists() ? await dst.text() : "";
+		if (extendable && isExtended(srcContent, dstContent)) return;
+		if (srcContent !== dstContent) {
+			await write(dst, srcContent);
+			return {
+				detail: `${name} updated`,
+				type: "synced"
+			};
+		}
+	}))).filter((r) => r !== void 0);
+};
+const canonicaliseViaLintmax = async (rawContent, relName, projectPath) => {
+	const lintmaxBin = join(projectPath, "node_modules", ".bin", "lintmax");
+	if (!existsSync(lintmaxBin)) return rawContent;
+	const cacheDir = join(projectPath, "node_modules", ".cache", "canon");
+	if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true });
+	const tmpRel = join("node_modules", ".cache", "canon", relName.replaceAll("/", "_"));
+	const tmpPath = join(projectPath, tmpRel);
+	await write(file(tmpPath), rawContent);
+	await $`${lintmaxBin} fix ${tmpRel}`.cwd(projectPath).quiet().nothrow();
+	const formatted = await file(tmpPath).text();
+	try {
+		rmSync(tmpPath);
+	} catch {}
+	return formatted;
+};
+const syncClaudeMd = async (selfPath, projectPath) => {
+	const issues = [];
+	const rulesDir = join(selfPath, "apps", "docs", "content", "rules");
+	if (!existsSync(rulesDir)) {
+		issues.push({
+			detail: "rules directory not found in pm4ai repo",
+			type: "error"
+		});
+		return issues;
+	}
+	const inferred = await inferRules(projectPath, rulesDir);
+	const generated = await canonicaliseViaLintmax(`${(await Promise.all(inferred.map(async (rule) => file(join(rulesDir, `${rule}.mdx`)).text()))).map((c) => stripFrontmatter(c)).join("\n\n---\n\n")}\n`, CLAUDE_MD, projectPath);
+	const claudeFile = file(join(projectPath, CLAUDE_MD));
+	if (generated !== (await claudeFile.exists() ? await claudeFile.text() : "")) {
+		await write(claudeFile, generated);
+		issues.push({
+			detail: `${CLAUDE_MD} updated`,
+			type: "synced"
+		});
+	}
+	return issues;
+};
+const isFixScriptCanonical = (script, fallback) => {
+	const value = script ?? "";
+	return value.endsWith(fallback) || value.endsWith("cli.js fix") || value.endsWith("cli.mjs fix");
+};
+const syncRootScripts = (scripts, issues) => {
+	let changed = false;
+	for (const [name, value] of Object.entries(DEFAULT_SCRIPTS)) if (name === "postinstall") {
+		if (!scripts.postinstall?.includes("sherif")) {
+			scripts.postinstall = scripts.postinstall ? `${scripts.postinstall} && sherif` : DEFAULT_SCRIPTS.postinstall;
+			changed = true;
+			issues.push({
+				detail: "added sherif to postinstall",
+				type: "synced"
+			});
+		}
+	} else if (name === "fix" ? !isFixScriptCanonical(scripts.fix, value) : scripts[name] !== value) {
+		const action = scripts[name] ? "updated" : "added";
+		scripts[name] = value;
+		changed = true;
+		issues.push({
+			detail: `${action} ${name} script`,
+			type: "synced"
+		});
+	}
+	for (const [name, cmd] of Object.entries(scripts)) {
+		if (name.startsWith("dev") || !cmd.includes("turbo") || !cmd.includes("--output-logs=errors-only") || cmd.includes("WARNING|Could not resolve workspaces|missing field|Turborepo will still function")) continue;
+		scripts[name] = filterTurboWorkspaceWarning(cmd);
+		changed = true;
+		issues.push({
+			detail: `updated ${name} script to filter turbo workspace warning`,
+			type: "synced"
+		});
+	}
+	return changed;
+};
+const syncRootDevDeps = (pkg, devDeps, issues) => {
+	let changed = false;
+	const allDeps = {
+		...pkg.dependencies,
+		...devDeps
+	};
+	for (const dep of REQUIRED_ROOT_DEVDEPS) if (!allDeps[dep]) {
+		devDeps[dep] = DEFAULT_DEP_VERSION;
+		changed = true;
+		issues.push({
+			detail: `added ${dep} to devDependencies`,
+			type: "synced"
+		});
+	}
+	return changed;
+};
+const syncPackageJson = async (projectPath, selfPath) => {
+	const issues = [];
+	const pkgPath = join(projectPath, "package.json");
+	const pkg = await readPkg(pkgPath);
+	if (!pkg) return issues;
+	const wasPrivate = Boolean(pkg.private);
+	if (!pkg.private) {
+		pkg.private = true;
+		issues.push({
+			detail: "set root package.json to private",
+			type: "synced"
+		});
+	}
+	const scripts = pkg.scripts ?? {};
+	pkg.scripts = scripts;
+	const hadHooks = Boolean(pkg["simple-git-hooks"]);
+	if (!pkg["simple-git-hooks"]) {
+		pkg["simple-git-hooks"] = { "pre-commit": EXPECTED.preCommit };
+		issues.push({
+			detail: "added simple-git-hooks",
+			type: "synced"
+		});
+	}
+	let changed = syncRootScripts(scripts, issues) || !wasPrivate || !hadHooks;
+	const devDeps = pkg.devDependencies ?? {};
+	pkg.devDependencies = devDeps;
+	changed = syncRootDevDeps(pkg, devDeps, issues) || changed;
+	const allRootDeps = {
+		...pkg.dependencies,
+		...devDeps
+	};
+	const allRootDepNames = Object.keys(allRootDeps);
+	const required = new Set(REQUIRED_ROOT_DEVDEPS);
+	const depPkgs = await Promise.all(allRootDepNames.map(async (depName) => {
+		const depPkg = await readPkg(join(projectPath, "node_modules", depName, "package.json"));
+		return depPkg ? {
+			depName,
+			transitive: depPkg.dependencies ?? {}
+		} : void 0;
+	}));
+	for (const dep of depPkgs) {
+		if (!dep) continue;
+		for (const other of allRootDepNames) if (other !== dep.depName && dep.transitive[other] && devDeps[other] && !required.has(other)) {
+			delete devDeps[other];
+			changed = true;
+			issues.push({
+				detail: `removed redundant "${other}" (provided by ${dep.depName})`,
+				type: "synced"
+			});
+		}
+	}
+	if (!pkg.packageManager) {
+		const bunVersion = (await $`bun --version`.quiet().nothrow()).stdout.toString().trim();
+		if (bunVersion) {
+			pkg.packageManager = `bun@${bunVersion}`;
+			changed = true;
+			issues.push({
+				detail: `set packageManager to bun@${bunVersion}`,
+				type: "synced"
+			});
+		}
+	}
+	const trusted = pkg.trustedDependencies ?? [];
+	let requiredTrusted = [];
+	if (selfPath) {
+		const selfPkgPath = join(selfPath, "package.json");
+		requiredTrusted = JSON.parse(await file(selfPkgPath).text()).trustedDependencies ?? [];
+	}
+	const missingTrusted = requiredTrusted.filter((d) => !trusted.includes(d));
+	if (missingTrusted.length > 0) {
+		pkg.trustedDependencies = [...trusted, ...missingTrusted].toSorted();
+		changed = true;
+		issues.push({
+			detail: `added ${missingTrusted.join(", ")} to trustedDependencies`,
+			type: "synced"
+		});
+	}
+	if (!scripts.action?.startsWith("sh up.sh")) {
+		scripts.action = scripts.action ? `sh up.sh && ${scripts.action}` : "sh up.sh";
+		changed = true;
+		issues.push({
+			detail: "action must start with \"sh up.sh\"",
+			type: "synced"
+		});
+	}
+	if (changed) {
+		pkg.devDependencies = sortKeys(pkg.devDependencies ?? {});
+		await writeJson(pkgPath, pkg);
+	}
+	return issues;
+};
+const syncTsconfig = async (projectPath) => {
+	const issues = [];
+	const tsconfigPath = join(projectPath, "tsconfig.json");
+	const tsconfig = await readJson(tsconfigPath);
+	if (!tsconfig) return issues;
+	let changed = false;
+	if ("include" in tsconfig) {
+		delete tsconfig.include;
+		changed = true;
+		issues.push({
+			detail: "removed \"include\" from root tsconfig.json",
+			type: "synced"
+		});
+	}
+	if (tsconfig.extends !== EXPECTED.tsconfigExtends) {
+		tsconfig.extends = EXPECTED.tsconfigExtends;
+		changed = true;
+		issues.push({
+			detail: `set tsconfig extends to "${EXPECTED.tsconfigExtends}"`,
+			type: "synced"
+		});
+	}
+	if (!getTsconfigTypes(tsconfig)?.includes("bun-types")) {
+		const co = tsconfig.compilerOptions ?? {};
+		co.types = ["bun-types"];
+		tsconfig.compilerOptions = co;
+		changed = true;
+		issues.push({
+			detail: "added \"bun-types\" to tsconfig compilerOptions.types",
+			type: "synced"
+		});
+	}
+	if (changed) await writeJson(tsconfigPath, tsconfig);
+	return issues;
+};
+const distPrefixRe = /^\.?\/?dist\//u;
+const dotSlashRe = /^\.\//u;
+const mjsExtRe = /\.mjs$/u;
+const monorepoRootRe = /\/(?:packages|tool|lib)\/[^/]+$/u;
+const resolveExportSource = (key, importPath, pkgDir) => {
+	if (importPath.endsWith(".json")) return;
+	const srcBase = key === "." ? "src/index" : `src/${key.replace(dotSlashRe, "")}`;
+	for (const ext of [".ts", ".tsx"]) if (existsSync(join(pkgDir, `${srcBase}${ext}`))) return `${srcBase}${ext}`;
+};
+const inferTsdownConfig = (pkg, pkgDir) => {
+	const entry = [];
+	const copy = [];
+	const { exports } = pkg;
+	if (exports) for (const [key, val] of Object.entries(exports)) {
+		const importPath = typeof val === "string" ? val : val.import;
+		if (!importPath) continue;
+		if (importPath.endsWith(".css")) {
+			const srcCss = importPath.replace(distPrefixRe, "src/");
+			if (existsSync(join(pkgDir, srcCss))) copy.push(srcCss);
+		} else {
+			const src = resolveExportSource(key, importPath, pkgDir);
+			if (src) entry.push(src);
+		}
+	}
+	if (pkg.bin) {
+		const bins = typeof pkg.bin === "string" ? { default: pkg.bin } : pkg.bin;
+		for (const binPath of Object.values(bins)) {
+			const srcPath = binPath.replace(distPrefixRe, "src/").replace(mjsExtRe, ".ts");
+			if (existsSync(join(pkgDir, srcPath)) && !entry.includes(srcPath)) entry.push(srcPath);
+		}
+	}
+	if (entry.length === 0 && !pkg.bin) {
+		if (existsSync(join(pkgDir, "src/index.ts"))) entry.push("src/index.ts");
+		else if (existsSync(join(pkgDir, "src/index.tsx"))) entry.push("src/index.tsx");
+	}
+	if (entry.length === 0) return;
+	const config = { entry };
+	if (copy.length > 0) config.copy = copy;
+	return config;
+};
+const serializeTsdownConfig = (config) => {
+	const fields = [
+		`  clean: ${TSDOWN_BASE.clean},`,
+		`  deps: { neverBundle: [${TSDOWN_BASE.deps.neverBundle.map((d) => `'${d}'`).join(", ")}] },`,
+		`  dts: ${TSDOWN_BASE.dts},`
+	];
+	if (config.copy) fields.push(`  copy: [${config.copy.map((c) => `'${c}'`).join(", ")}],`);
+	fields.push(`  entry: [${config.entry.map((e) => `'${e}'`).join(", ")}],`);
+	fields.push(`  format: '${TSDOWN_BASE.format}',`);
+	fields.push(`  outDir: '${TSDOWN_BASE.outDir}'`);
+	return `import { defineConfig } from 'tsdown'\n\nexport default defineConfig({\n${fields.join("\n")}\n})\n`;
+};
+const syncReadmeSymlink = ({ issues, monorepoRoot, pkgDir, rel }) => {
+	const readmeSrc = join(monorepoRoot, "README.md");
+	const readmeDst = join(pkgDir, "README.md");
+	if (!existsSync(readmeSrc)) return false;
+	const srcContent = readFileSync(readmeSrc, "utf8");
+	if (existsSync(readmeDst)) {
+		let isSymlink;
+		try {
+			readlinkSync(readmeDst);
+			isSymlink = true;
+		} catch {
+			isSymlink = false;
+		}
+		if (!isSymlink && readFileSync(readmeDst, "utf8") === srcContent) return false;
+		if (isSymlink) rmSync(readmeDst);
+	}
+	writeFileSync(readmeDst, srcContent);
+	issues.push({
+		detail: `${rel} synced README.md`,
+		type: "synced"
+	});
+	return true;
+};
+const fixPublishedPkg = ({ issues, pkg, pkgPath, rel, repo }) => {
+	let changed = false;
+	if (pkg.type !== "module") {
+		pkg.type = "module";
+		changed = true;
+		issues.push({
+			detail: `${rel} set "type": "module"`,
+			type: "synced"
+		});
+	}
+	if (!pkg.files) {
+		pkg.files = DEFAULT_FILES;
+		changed = true;
+		issues.push({
+			detail: `${rel} set "files": ${JSON.stringify(DEFAULT_FILES)}`,
+			type: "synced"
+		});
+	}
+	if (!pkg.license) {
+		pkg.license = DEFAULT_LICENSE;
+		changed = true;
+		issues.push({
+			detail: `${rel} set "license": "${DEFAULT_LICENSE}"`,
+			type: "synced"
+		});
+	}
+	if (!pkg.repository && repo) {
+		pkg.repository = {
+			directory: dirname(rel),
+			type: "git",
+			url: `https://github.com/${repo}`
+		};
+		changed = true;
+		issues.push({
+			detail: `${rel} added repository`,
+			type: "synced"
+		});
+	}
+	const pubScripts = pkg.scripts ?? {};
+	if (pubScripts.build && pubScripts.build !== "tsdown") {
+		pubScripts.build = "tsdown";
+		pkg.scripts = pubScripts;
+		changed = true;
+		issues.push({
+			detail: `${rel} set build to "tsdown"`,
+			type: "synced"
+		});
+	}
+	const pkgDir = dirname(pkgPath);
+	const tsdownConfigPath = join(pkgDir, "tsdown.config.ts");
+	const tsdownConfig = inferTsdownConfig(pkg, pkgDir);
+	if (tsdownConfig) {
+		const existingContent = existsSync(tsdownConfigPath) ? readFileSync(tsdownConfigPath, "utf8") : "";
+		if (existingContent.includes("dts: false") || existingContent.includes("onSuccess")) {} else {
+			const generatedContent = serializeTsdownConfig(tsdownConfig);
+			if (existingContent !== generatedContent) {
+				writeFileSync(tsdownConfigPath, generatedContent);
+				issues.push({
+					detail: `${rel} generated tsdown.config.ts`,
+					type: "synced"
+				});
+			}
+		}
+	}
+	syncReadmeSymlink({
+		issues,
+		monorepoRoot: pkgDir.replace(monorepoRootRe, ""),
+		pkgDir,
+		rel
+	});
+	const expectedPostpublish = "bun ../../tools/prune-versions.ts";
+	if (pubScripts.postpublish !== expectedPostpublish) {
+		pubScripts.postpublish = expectedPostpublish;
+		delete pubScripts["cleanup-old-versions"];
+		pkg.scripts = pubScripts;
+		changed = true;
+		issues.push({
+			detail: `${rel} set postpublish to prune-versions script`,
+			type: "synced"
+		});
+	}
+	if (pubScripts.build && pubScripts.prepublishOnly !== "bun run build") {
+		pubScripts.prepublishOnly = "bun run build";
+		pkg.scripts = pubScripts;
+		changed = true;
+		issues.push({
+			detail: `${rel} set prepublishOnly to always build before publish`,
+			type: "synced"
+		});
+	}
+	return changed;
+};
+const fixGitClean = (pkg, rel, issues) => {
+	let changed = false;
+	const scripts = pkg.scripts ?? {};
+	for (const [name, cmd] of Object.entries(scripts)) {
+		gitCleanRe.lastIndex = 0;
+		if (gitCleanRe.test(cmd)) {
+			gitCleanRe.lastIndex = 0;
+			scripts[name] = cmd.replace(gitCleanRe, "rm -rf ");
+			changed = true;
+			issues.push({
+				detail: `${rel} "${name}" replaced git clean with rm -rf`,
+				type: "synced"
+			});
+		}
+	}
+	return changed;
+};
+const hoistDevDeps = ({ issues, rel, rootDevDeps, subDevDeps }) => {
+	const external = Object.entries(subDevDeps).filter(([, v]) => !v.startsWith("workspace:"));
+	if (external.length === 0) return {
+		hoisted: false,
+		remaining: Object.keys(subDevDeps).length === 0 ? void 0 : subDevDeps
+	};
+	let hoisted = false;
+	for (const [name, version] of external) if (!rootDevDeps[name]) {
+		rootDevDeps[name] = version;
+		hoisted = true;
+		issues.push({
+			detail: `hoisted ${name} from ${rel} to root`,
+			type: "synced"
+		});
+	}
+	const ws = Object.fromEntries(Object.entries(subDevDeps).filter(([, v]) => v.startsWith("workspace:")));
+	return {
+		hoisted,
+		remaining: Object.keys(ws).length === 0 ? void 0 : ws
+	};
+};
+const fixSubEntry = ({ entry, issues, projectPath, repo }) => {
+	const rel = entry.path.replace(`${projectPath}/`, "");
+	if (isSkippedPath(rel)) return false;
+	let changed = false;
+	if (rel.startsWith("apps/") && !entry.pkg.private) {
+		entry.pkg.private = true;
+		changed = true;
+		issues.push({
+			detail: `${rel} set to private`,
+			type: "synced"
+		});
+	}
+	if (isPublishedPkg(entry.pkg)) changed = fixPublishedPkg({
+		issues,
+		pkg: entry.pkg,
+		pkgPath: entry.path,
+		rel,
+		repo
+	}) || changed;
+	if (entry.pkg.scripts?.clean) {
+		delete entry.pkg.scripts.clean;
+		if (Object.keys(entry.pkg.scripts).length === 0) delete entry.pkg.scripts;
+		changed = true;
+		issues.push({
+			detail: `${rel} removed redundant "clean" script`,
+			type: "synced"
+		});
+	}
+	return fixGitClean(entry.pkg, rel, issues) || changed;
+};
+const hoistSubEntry = ({ entry, issues, projectPath, rootDevDeps }) => {
+	const rel = entry.path.replace(`${projectPath}/`, "");
+	const originalDevDeps = entry.pkg.devDependencies;
+	const { hoisted, remaining } = hoistDevDeps({
+		issues,
+		rel,
+		rootDevDeps,
+		subDevDeps: originalDevDeps ?? {}
+	});
+	const changed = remaining !== originalDevDeps && !(remaining === void 0 && !originalDevDeps);
+	if (changed) entry.pkg.devDependencies = remaining;
+	return {
+		changed,
+		hoisted,
+		pkg: entry.pkg,
+		pkgPath: entry.path
+	};
+};
+const syncSubPackages = async (_selfPath, projectPath) => {
+	const issues = [];
+	const entries = await collectWorkspacePackages(projectPath);
+	const rootPkgPath = join(projectPath, "package.json");
+	const repo = await getGhRepo(projectPath);
+	const subEntries = entries.filter((e) => e.path !== rootPkgPath);
+	const writes = [];
+	for (const entry of subEntries) if (fixSubEntry({
+		entry,
+		issues,
+		projectPath,
+		repo
+	})) writes.push(writeJson(entry.path, entry.pkg));
+	const pkgDepsByName = buildPkgDepMap(entries);
+	for (const entry of subEntries) {
+		const rel = entry.path.replace(`${projectPath}/`, "");
+		if (!(isSkippedPath(rel) || rel.startsWith("apps/"))) {
+			const wsDeps = [...Object.entries(entry.pkg.dependencies ?? {}), ...Object.entries(entry.pkg.devDependencies ?? {})].filter(([, v]) => v.startsWith("workspace:")).map(([n]) => n);
+			const providedByWs = /* @__PURE__ */ new Set();
+			for (const ws of wsDeps) for (const d of pkgDepsByName.get(ws) ?? []) providedByWs.add(d);
+			let dedupChanged = false;
+			for (const field of DEP_FIELDS) {
+				const deps = entry.pkg[field];
+				if (!deps) continue;
+				for (const [name, version] of Object.entries(deps)) if (!version.startsWith("workspace:") && providedByWs.has(name)) {
+					delete deps[name];
+					dedupChanged = true;
+					issues.push({
+						detail: `${rel} removed duplicate "${name}" (provided by workspace dep)`,
+						type: "synced"
+					});
+				}
+				if (Object.keys(deps).length === 0) delete entry.pkg[field];
+			}
+			if (dedupChanged) writes.push(writeJson(entry.path, entry.pkg));
+		}
+	}
+	await Promise.all(writes);
+	const rootPkg = await readPkg(rootPkgPath);
+	if (!rootPkg) return issues;
+	let rootChanged = false;
+	const rootDevDeps = rootPkg.devDependencies ?? {};
+	const subWrites = [];
+	const nonSkipped = subEntries.filter((e) => !isSkippedPath(e.path.replace(`${projectPath}/`, "")));
+	for (const entry of nonSkipped) {
+		const result = hoistSubEntry({
+			entry,
+			issues,
+			projectPath,
+			rootDevDeps
+		});
+		if (result.hoisted) rootChanged = true;
+		if (result.changed) subWrites.push(writeJson(result.pkgPath, result.pkg));
+	}
+	await Promise.all(subWrites);
+	if (rootChanged) {
+		rootPkg.devDependencies = sortKeys(rootDevDeps);
+		await writeJson(rootPkgPath, rootPkg);
+	}
+	return issues;
+};
+const syncUi = (cnsyncPath, projectPath) => {
+	const issues = [];
+	const src = join(cnsyncPath, READONLY_UI);
+	const dst = join(projectPath, READONLY_UI);
+	if (!existsSync(src)) {
+		issues.push({
+			detail: `${READONLY_UI} not found in cnsync repo`,
+			type: "error"
+		});
+		return issues;
+	}
+	if (projectPath === cnsyncPath) return issues;
+	cpSync(src, dst, { recursive: true });
+	for (const ext of [
+		"mjs",
+		"ts",
+		"js"
+	]) {
+		const p = join(dst, `postcss.config.${ext}`);
+		if (existsSync(p)) rmSync(p);
+	}
+	issues.push({
+		detail: `${READONLY_UI} updated`,
+		type: "synced"
+	});
+	return issues;
+};
+const NEXT_BUILD_RE = /(?<!bunx --bun )\bnext build\b/gu;
+const FUMADOCS_MDX_RE = /(?<!bunx --bun )\bfumadocs-mdx\b/gu;
+const patchFumadocsScript = (script) => script.replace(NEXT_BUILD_RE, "bunx --bun next build").replace(FUMADOCS_MDX_RE, "bunx --bun fumadocs-mdx");
+const syncFumadocsBuild = async (projectPath) => {
+	const fumadocsApps = (await collectWorkspacePackages(projectPath)).filter((e) => {
+		const allDeps = {
+			...e.pkg.dependencies,
+			...e.pkg.devDependencies
+		};
+		return Boolean(allDeps["fumadocs-ui"]);
+	});
+	const issues = [];
+	for (const app of fumadocsApps) {
+		const scripts = app.pkg.scripts ?? {};
+		let changed = false;
+		const next = { ...scripts };
+		for (const [k, v] of Object.entries(scripts)) {
+			const patched = patchFumadocsScript(v);
+			if (patched !== v) {
+				next[k] = patched;
+				changed = true;
+			}
+		}
+		if (changed) {
+			writeFileSync(app.path, `${JSON.stringify({
+				...app.pkg,
+				scripts: next
+			}, null, 2)}\n`);
+			const rel = app.path.replace(`${projectPath}/`, "");
+			issues.push({
+				detail: `${rel} prefixed fumadocs/next build with bunx --bun`,
+				type: "synced"
+			});
+		}
+	}
+	return issues;
+};
+const getProjectGithubUrl = async (projectPath) => {
+	const r = await $`gh repo view --json url -q .url`.cwd(projectPath).quiet().nothrow();
+	if (r.exitCode !== 0) return;
+	return r.stdout.toString().trim() || void 0;
+};
+const ALIAS_TRIM_RE = /\/\*$/u;
+const ALIAS_DOT_SLASH_RE = /^\.\//u;
+const resolveLibBase = async (appDir) => {
+	const aliasTarget = (((await readJson(join(appDir, "tsconfig.json")))?.compilerOptions)?.paths)?.["@/*"]?.[0];
+	if (!aliasTarget) return "src";
+	return aliasTarget.replace(ALIAS_TRIM_RE, "").replace(ALIAS_DOT_SLASH_RE, "") || ".";
+};
+const layoutSharedRel = (libBase) => libBase === "." ? "lib/layout.shared.tsx" : `${libBase}/lib/layout.shared.tsx`;
+const layoutSharedTemplate = (title, githubUrl) => `import type { BaseLayoutProps } from 'fumadocs-ui/layouts/shared'
+export const baseOptions = (): BaseLayoutProps => ({
+  githubUrl: '${githubUrl}',
+  nav: {
+    title: '${title}'
+  }
+})
+`;
+const SCOPED_PREFIX_RE = /^@[^/]+\//u;
+const GITHUB_URL_KEY_RE = /\bgithubUrl\s*:/u;
+const BASEOPTIONS_OPEN_RE = /(?<open>\(\)[^=]*=>\s*\(\{\s*\n)/u;
+const stripScopedPrefix = (name) => name.replace(SCOPED_PREFIX_RE, "");
+const patchSharedFile = ({ githubUrl, projectPath, sharedPath, title }) => {
+	const relShared = sharedPath.replace(`${projectPath}/`, "");
+	if (!existsSync(sharedPath)) {
+		mkdirSync(dirname(sharedPath), { recursive: true });
+		writeFileSync(sharedPath, layoutSharedTemplate(title, githubUrl));
+		return {
+			detail: `${relShared} created with baseOptions + githubUrl`,
+			type: "synced"
+		};
+	}
+	const content = readFileSync(sharedPath, "utf8");
+	if (GITHUB_URL_KEY_RE.test(content)) return;
+	const next = content.replace(BASEOPTIONS_OPEN_RE, `$<open>  githubUrl: '${githubUrl}',\n`);
+	if (next === content) return;
+	writeFileSync(sharedPath, next);
+	return {
+		detail: `${relShared} added githubUrl`,
+		type: "synced"
+	};
+};
+const syncFumadocsGithubUrl = async (projectPath) => {
+	const fumadocsApps = (await collectWorkspacePackages(projectPath)).filter((e) => {
+		const allDeps = {
+			...e.pkg.dependencies,
+			...e.pkg.devDependencies
+		};
+		return Boolean(allDeps["fumadocs-ui"]);
+	});
+	if (fumadocsApps.length === 0) return [];
+	const githubUrl = await getProjectGithubUrl(projectPath);
+	if (!githubUrl) return [];
+	return (await Promise.all(fumadocsApps.map(async (app) => {
+		const appDir = dirname(app.path);
+		return patchSharedFile({
+			githubUrl,
+			projectPath,
+			sharedPath: join(appDir, layoutSharedRel(await resolveLibBase(appDir))),
+			title: stripScopedPrefix(app.pkg.name ?? "docs")
+		});
+	}))).filter((r) => r !== void 0);
+};
+//#endregion
+export { syncPackageJson as a, syncUi as c, syncFumadocsGithubUrl as i, inferRules as l, syncConfigs as n, syncSubPackages as o, syncFumadocsBuild as r, syncTsconfig as s, syncClaudeMd as t };