@codefast/cli 0.3.7-canary.0 → 0.3.13-canary.0

package/dist/lib/mirror/infra/workspace-packages.test.mjs

@@ -0,0 +1,167 @@
+import { t as createNodeCliFs } from "../../../node-io-DFRbHO6m.mjs";
+import { i as workspacePatternToPackageJsonGlob, n as parsePnpmWorkspaceDocument, r as splitWorkspacePackageEntries, t as findWorkspacePackageRelPaths } from "../../../workspace-packages-K2NYTHJq.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/lib/mirror/infra/workspace-packages.test.ts
+function createTestLogger() {
+	const lines = [];
+	return {
+		lines,
+		out: (line) => {
+			lines.push(line);
+		},
+		err: (line) => {
+			lines.push(`[err] ${line}`);
+		}
+	};
+}
+describe("splitWorkspacePackageEntries", () => {
+	it("splits include and exclude entries", () => {
+		expect(splitWorkspacePackageEntries([
+			"packages/*",
+			"!packages/playground",
+			"apps/*"
+		])).toEqual({
+			include: ["packages/*", "apps/*"],
+			exclude: ["packages/playground"]
+		});
+	});
+	it("ignores non-strings", () => {
+		expect(splitWorkspacePackageEntries([
+			"a",
+			1,
+			null,
+			"b"
+		])).toEqual({
+			include: ["a", "b"],
+			exclude: []
+		});
+	});
+});
+describe("parsePnpmWorkspaceDocument", () => {
+	it("throws on non-object root", () => {
+		expect(() => parsePnpmWorkspaceDocument([])).toThrow(/root must be a mapping/);
+		expect(() => parsePnpmWorkspaceDocument("x")).toThrow(/root must be a mapping/);
+	});
+	it("throws when packages is not an array", () => {
+		expect(() => parsePnpmWorkspaceDocument({ packages: "nope" })).toThrow(/must be an array/);
+	});
+	it("marks missing packages key", () => {
+		expect(parsePnpmWorkspaceDocument({ catalog: {} })).toEqual({
+			include: [],
+			exclude: [],
+			hasPackagesKey: false,
+			isEmptyPackagesArray: false
+		});
+	});
+	it("marks explicit empty array", () => {
+		expect(parsePnpmWorkspaceDocument({ packages: [] })).toEqual({
+			include: [],
+			exclude: [],
+			hasPackagesKey: true,
+			isEmptyPackagesArray: true
+		});
+	});
+});
+describe("workspacePatternToPackageJsonGlob", () => {
+	it("appends /package.json with POSIX slashes", () => {
+		expect(workspacePatternToPackageJsonGlob("packages/*")).toBe("packages/*/package.json");
+		expect(workspacePatternToPackageJsonGlob("packages/**")).toBe("packages/**/package.json");
+		expect(workspacePatternToPackageJsonGlob("apps/*")).toBe("apps/*/package.json");
+	});
+});
+describe("findWorkspacePackageRelPaths", () => {
+	const cliFs = createNodeCliFs();
+	it("falls back to packages/* when pnpm-workspace.yaml is missing", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "ws-missing-"));
+		const logger = createTestLogger();
+		try {
+			fs.mkdirSync(path.join(root, "packages", "a"), { recursive: true });
+			fs.writeFileSync(path.join(root, "packages", "a", "package.json"), "{}", "utf8");
+			const { relPaths, multiSource } = await findWorkspacePackageRelPaths(root, cliFs, logger);
+			expect(relPaths).toEqual(["packages/a"]);
+			expect(multiSource).toBe("default-patterns");
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("reads globs from pnpm-workspace.yaml", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "ws-yaml-"));
+		const logger = createTestLogger();
+		try {
+			fs.writeFileSync(path.join(root, "pnpm-workspace.yaml"), `packages:
+  - 'tooling/*'
+  - 'packages/*'
+`, "utf8");
+			fs.mkdirSync(path.join(root, "tooling", "eslint"), { recursive: true });
+			fs.writeFileSync(path.join(root, "tooling", "eslint", "package.json"), "{}", "utf8");
+			fs.mkdirSync(path.join(root, "packages", "ui"), { recursive: true });
+			fs.writeFileSync(path.join(root, "packages", "ui", "package.json"), "{}", "utf8");
+			const { relPaths, multiSource } = await findWorkspacePackageRelPaths(root, cliFs, logger);
+			expect(relPaths).toEqual(["packages/ui", "tooling/eslint"]);
+			expect(multiSource).toBe("pnpm-workspace-yaml");
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("applies negated workspace patterns", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "ws-neg-"));
+		const logger = createTestLogger();
+		try {
+			fs.writeFileSync(path.join(root, "pnpm-workspace.yaml"), `packages:
+  - 'packages/*'
+  - '!packages/skip'
+`, "utf8");
+			for (const name of ["keep", "skip"]) {
+				fs.mkdirSync(path.join(root, "packages", name), { recursive: true });
+				fs.writeFileSync(path.join(root, "packages", name, "package.json"), "{}", "utf8");
+			}
+			const { relPaths, multiSource } = await findWorkspacePackageRelPaths(root, cliFs, logger);
+			expect(relPaths).toEqual(["packages/keep"]);
+			expect(multiSource).toBe("pnpm-workspace-yaml");
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("returns empty paths when packages is an explicit empty array", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "ws-empty-arr-"));
+		const logger = createTestLogger();
+		try {
+			fs.writeFileSync(path.join(root, "pnpm-workspace.yaml"), `packages: []
+`, "utf8");
+			const { relPaths, multiSource } = await findWorkspacePackageRelPaths(root, cliFs, logger);
+			expect(relPaths).toEqual([]);
+			expect(multiSource).toBe("declared-empty");
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("rejects invalid YAML document when file exists", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "ws-bad-yaml-"));
+		const logger = createTestLogger();
+		try {
+			fs.writeFileSync(path.join(root, "pnpm-workspace.yaml"), "{ not yaml", "utf8");
+			await expect(findWorkspacePackageRelPaths(root, cliFs, logger)).rejects.toThrow(/Failed to parse pnpm-workspace.yaml/);
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+});
+//#endregion
+export {};

package/dist/lib/mirror/presentation/reporter.mjs

@@ -0,0 +1,2 @@
+import { a as mirrorBanner, c as mirrorNoPackages, d as mirrorSummarySeparator, f as printMirrorConfigWarnings, i as logSkippedWorkspacePackage, l as mirrorProcessingMode, n as logPackageError, o as mirrorFatalError, r as logPackageSuccess, s as mirrorGlobWarning, t as configureMirrorColors, u as mirrorSummary } from "../../../reporter-CwIe_tAM.mjs";
+export { configureMirrorColors, logPackageError, logPackageSuccess, logSkippedWorkspacePackage, mirrorBanner, mirrorFatalError, mirrorGlobWarning, mirrorNoPackages, mirrorProcessingMode, mirrorSummary, mirrorSummarySeparator, printMirrorConfigWarnings };

package/dist/lib/tag/application/engine.mjs

@@ -0,0 +1,2 @@
+import { n as runTagOnTarget, r as runTagSync, t as resolveNearestPackageVersion } from "../../../engine-CcWEHSCq.mjs";
+export { resolveNearestPackageVersion, runTagOnTarget, runTagSync };

package/dist/lib/tag/application/engine.test.mjs

@@ -0,0 +1,159 @@
+import { t as createNodeCliFs } from "../../../node-io-DFRbHO6m.mjs";
+import { n as runTagOnTarget, r as runTagSync, t as resolveNearestPackageVersion } from "../../../engine-CcWEHSCq.mjs";
+import "../../../tag-Cd9JujU5.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/lib/tag/application/engine.test.ts
+const tagFs = createNodeCliFs();
+function withTempPackage(fileName, source, fn) {
+	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "tag-engine-"));
+	const srcDir = path.join(rootDir, "src");
+	const sourceFile = path.join(srcDir, fileName);
+	try {
+		fs.mkdirSync(srcDir, { recursive: true });
+		fs.writeFileSync(path.join(rootDir, "package.json"), "{\"name\":\"demo\",\"version\":\"1.2.3\"}", "utf8");
+		fs.writeFileSync(sourceFile, source, "utf8");
+		fn({
+			rootDir,
+			sourceFile
+		});
+	} finally {
+		fs.rmSync(rootDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+describe("resolveNearestPackageVersion", () => {
+	it("loads version from nearest package.json", () => {
+		withTempPackage("index.ts", "export const foo = 1;\n", ({ sourceFile }) => {
+			expect(resolveNearestPackageVersion(sourceFile, tagFs)).toBe("1.2.3");
+		});
+	});
+});
+describe("runTagOnTarget", () => {
+	it("adds @since for exported declarations and preserves existing @since tags", () => {
+		withTempPackage("index.ts", `/** Existing docs */
+export function a() {
+  return 1;
+}
+
+/** @since 0.0.1 */
+export const b = 2;
+
+const c = 3;
+export { c };
+`, ({ sourceFile, rootDir }) => {
+			const result = runTagOnTarget(path.join(rootDir, "src"), { write: true }, tagFs);
+			const after = fs.readFileSync(sourceFile, "utf8");
+			expect(result.version).toBe("1.2.3");
+			expect(result.filesChanged).toBe(1);
+			expect(result.taggedDeclarations).toBe(2);
+			expect(after).toContain("* @since 1.2.3");
+			expect(after).toContain("/** @since 0.0.1 */");
+			expect(after).toContain("/**\n * @since 1.2.3\n */\nconst c = 3;");
+		});
+	});
+	it("normalizes single-line JSDoc to multiline before appending @since", () => {
+		withTempPackage("types.ts", `/** String or no-substitution template literal used as a Tailwind class blob. */
+export type TailwindClassBlob = string;
+`, ({ sourceFile, rootDir }) => {
+			runTagOnTarget(path.join(rootDir, "src"), { write: true }, tagFs);
+			const after = fs.readFileSync(sourceFile, "utf8");
+			expect(after).toContain(`/**
+ * String or no-substitution template literal used as a Tailwind class blob.
+ *
+ * @since 1.2.3
+ */`);
+		});
+	});
+	it("supports dry-run mode without changing files", () => {
+		const before = "export interface User { id: string }\n";
+		withTempPackage("types.ts", before, ({ sourceFile, rootDir }) => {
+			const result = runTagOnTarget(path.join(rootDir, "src"), { write: false }, tagFs);
+			const after = fs.readFileSync(sourceFile, "utf8");
+			expect(result.filesChanged).toBe(1);
+			expect(result.taggedDeclarations).toBe(1);
+			expect(after).toBe(before);
+		});
+	});
+});
+describe("runTagSync", () => {
+	it("auto-discovers workspace package src directories when no target is provided", async () => {
+		const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "tag-workspace-"));
+		const packageOneDir = path.join(rootDir, "packages", "one");
+		const packageTwoDir = path.join(rootDir, "packages", "two");
+		const packageOneSrcDir = path.join(packageOneDir, "src");
+		const packageTwoSrcDir = path.join(packageTwoDir, "src");
+		try {
+			fs.mkdirSync(packageOneSrcDir, { recursive: true });
+			fs.mkdirSync(packageTwoSrcDir, { recursive: true });
+			fs.writeFileSync(path.join(rootDir, "pnpm-workspace.yaml"), "packages:\n  - 'packages/*'\n", "utf8");
+			fs.writeFileSync(path.join(packageOneDir, "package.json"), "{\"name\":\"one\",\"version\":\"1.0.0\"}", "utf8");
+			fs.writeFileSync(path.join(packageTwoDir, "package.json"), "{\"name\":\"two\",\"version\":\"2.0.0\"}", "utf8");
+			fs.writeFileSync(path.join(packageOneSrcDir, "index.ts"), "export const one = 1;\n", "utf8");
+			fs.writeFileSync(path.join(packageTwoSrcDir, "index.ts"), "export const two = 2;\n", "utf8");
+			const startedTargets = [];
+			const completedTargets = [];
+			const runResult = await runTagSync({
+				rootDir,
+				write: true,
+				fs: tagFs,
+				listener: {
+					onTargetStarted: (target) => startedTargets.push(target.rootRelativeTargetPath),
+					onTargetCompleted: (target) => completedTargets.push(target.rootRelativeTargetPath)
+				}
+			});
+			expect(runResult.selectedTargets.length).toBe(2);
+			expect(runResult.targetResults.every((entry) => entry.runError === null)).toBe(true);
+			expect(fs.readFileSync(path.join(packageOneSrcDir, "index.ts"), "utf8")).toContain("* @since 1.0.0");
+			expect(fs.readFileSync(path.join(packageTwoSrcDir, "index.ts"), "utf8")).toContain("* @since 2.0.0");
+			expect(runResult.versionSummary).toBe("mixed");
+			expect(runResult.distinctVersions).toEqual(["1.0.0", "2.0.0"]);
+			expect(runResult.skippedPackages).toEqual([]);
+			expect(runResult.filesChanged).toBe(2);
+			expect(startedTargets.sort((left, right) => left.localeCompare(right))).toEqual(["packages/one/src", "packages/two/src"]);
+			expect(completedTargets.sort((left, right) => left.localeCompare(right))).toEqual(["packages/one/src", "packages/two/src"]);
+		} finally {
+			fs.rmSync(rootDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("skips workspace packages listed in skipPackages", async () => {
+		const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "tag-workspace-skip-"));
+		const packageOneDir = path.join(rootDir, "packages", "one");
+		const packageTwoDir = path.join(rootDir, "packages", "two");
+		const packageOneSrcDir = path.join(packageOneDir, "src");
+		const packageTwoSrcDir = path.join(packageTwoDir, "src");
+		try {
+			fs.mkdirSync(packageOneSrcDir, { recursive: true });
+			fs.mkdirSync(packageTwoSrcDir, { recursive: true });
+			fs.writeFileSync(path.join(rootDir, "pnpm-workspace.yaml"), "packages:\n  - 'packages/*'\n", "utf8");
+			fs.writeFileSync(path.join(packageOneDir, "package.json"), "{\"name\":\"@scope/one\",\"version\":\"1.0.0\"}", "utf8");
+			fs.writeFileSync(path.join(packageTwoDir, "package.json"), "{\"name\":\"@scope/two\",\"version\":\"2.0.0\"}", "utf8");
+			fs.writeFileSync(path.join(packageOneSrcDir, "index.ts"), "export const one = 1;\n", "utf8");
+			fs.writeFileSync(path.join(packageTwoSrcDir, "index.ts"), "export const two = 2;\n", "utf8");
+			const runResult = await runTagSync({
+				rootDir,
+				write: true,
+				fs: tagFs,
+				skipPackages: ["@scope/two"]
+			});
+			expect(runResult.skippedPackages).toEqual(["@scope/two"]);
+			expect(runResult.selectedTargets).toHaveLength(1);
+			expect(runResult.selectedTargets[0]?.packageName).toBe("@scope/one");
+			expect(fs.readFileSync(path.join(packageOneSrcDir, "index.ts"), "utf8")).toContain("* @since 1.0.0");
+			expect(fs.readFileSync(path.join(packageTwoSrcDir, "index.ts"), "utf8")).not.toContain("* @since 2.0.0");
+		} finally {
+			fs.rmSync(rootDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+});
+//#endregion
+export {};

package/dist/lib/tag/domain/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/index.mjs

@@ -0,0 +1,5 @@
+import { n as createNodeCliLogger, t as createNodeCliFs } from "../../node-io-DFRbHO6m.mjs";
+import { n as runTagOnTarget, r as runTagSync, t as resolveNearestPackageVersion } from "../../engine-CcWEHSCq.mjs";
+import { a as formatWarningsAndErrors, i as formatTargetTable, n as formatProgress, r as formatSummary, t as createTagProgressListener } from "../../tag-presenter-Cs66UBsH.mjs";
+import "../../tag-Cd9JujU5.mjs";
+export { createNodeCliFs, createNodeCliLogger, createTagProgressListener, formatProgress, formatSummary, formatTargetTable, formatWarningsAndErrors, resolveNearestPackageVersion, runTagOnTarget, runTagSync };

package/dist/lib/tag/infra/target-resolver.mjs

@@ -0,0 +1,2 @@
+import { t as resolveTagTargetCandidates } from "../../../target-resolver-CR3FXMTy.mjs";
+export { resolveTagTargetCandidates };

package/dist/lib/tag/presentation/colors.mjs

@@ -0,0 +1,2 @@
+import { n as withTagColor, t as TAG_COLORS } from "../../../colors-BjdkCfGK.mjs";
+export { TAG_COLORS, withTagColor };

package/dist/lib/tag/presentation/tag-presenter.mjs

@@ -0,0 +1,2 @@
+import { a as formatWarningsAndErrors, i as formatTargetTable, n as formatProgress, r as formatSummary, t as createTagProgressListener } from "../../../tag-presenter-Cs66UBsH.mjs";
+export { createTagProgressListener, formatProgress, formatSummary, formatTargetTable, formatWarningsAndErrors };

package/dist/lib/tag/presentation/tag-presenter.test.mjs

@@ -0,0 +1,29 @@
+import { i as formatTargetTable } from "../../../tag-presenter-Cs66UBsH.mjs";
+//#region src/lib/tag/presentation/tag-presenter.test.ts
+describe("formatTargetTable", () => {
+	it("aligns columns using longest package and path values", () => {
+		const lines = formatTargetTable([{
+			packageName: "@codefast/core",
+			packageDir: "/repo/packages/core",
+			rootRelativeTargetPath: "packages/core/src",
+			targetPath: "/repo/packages/core/src",
+			source: "workspace-package-selected-src"
+		}, {
+			packageName: "@codefast/benchmark-tailwind-variants",
+			packageDir: "/repo/benchmarks/tailwind-variants",
+			rootRelativeTargetPath: "benchmarks/tailwind-variants/src",
+			targetPath: "/repo/benchmarks/tailwind-variants/src",
+			source: "workspace-package-selected-src"
+		}], "/repo").split("\n");
+		const headerLine = lines[3];
+		const firstDataLine = lines[5];
+		const secondDataLine = lines[6];
+		const pathHeaderIndex = headerLine.indexOf("path");
+		const firstPathIndex = firstDataLine.indexOf("packages/core/src");
+		const secondPathIndex = secondDataLine.indexOf("benchmarks/tailwind-variants/src");
+		expect(firstPathIndex).toBe(pathHeaderIndex);
+		expect(secondPathIndex).toBe(pathHeaderIndex);
+	});
+});
+//#endregion
+export {};

package/dist/loader-DpN-zl5g.mjs

@@ -0,0 +1,78 @@
+import { n as codefastConfigSchema } from "./schema-Or8RAARd.mjs";
+import process from "node:process";
+import path from "node:path";
+import jiti from "jiti";
+import { ZodError } from "zod";
+//#region src/lib/config/infra/loader.ts
+const CONFIG_JS_PRIORITY = [
+	"codefast.config.mjs",
+	"codefast.config.js",
+	"codefast.config.cjs"
+];
+const CONFIG_JSON = "codefast.config.json";
+const cachedLoads = /* @__PURE__ */ new Map();
+function formatZodError(error, filePath) {
+	const formatted = error.issues.map((issue) => {
+		return `  - ${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`;
+	}).join("\n");
+	return `Invalid config schema in ${path.basename(filePath)}:\n${formatted}`;
+}
+function parseLoadedConfig(raw, filePath) {
+	try {
+		return codefastConfigSchema.parse(raw);
+	} catch (caughtError) {
+		if (caughtError instanceof ZodError) throw new Error(formatZodError(caughtError, filePath));
+		throw caughtError;
+	}
+}
+function listConfigCandidates(startDir, fs) {
+	const candidates = [];
+	let current = path.resolve(startDir);
+	while (true) {
+		for (const name of CONFIG_JS_PRIORITY) {
+			const candidate = path.join(current, name);
+			if (fs.existsSync(candidate)) candidates.push(candidate);
+		}
+		const jsonCandidate = path.join(current, CONFIG_JSON);
+		if (fs.existsSync(jsonCandidate)) candidates.push(jsonCandidate);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return candidates;
+}
+async function readConfigFromPath(filePath, fs) {
+	if (path.extname(filePath) === ".json") {
+		const content = await fs.readFile(filePath, "utf8");
+		return parseLoadedConfig(JSON.parse(content), filePath);
+	}
+	const moduleConfig = jiti(process.cwd(), {
+		interopDefault: true,
+		moduleCache: false
+	})(filePath);
+	return parseLoadedConfig(typeof moduleConfig === "object" && moduleConfig !== null && "default" in moduleConfig ? moduleConfig.default : moduleConfig, filePath);
+}
+async function loadOnce(fs, startDir) {
+	const warnings = [];
+	const configPaths = listConfigCandidates(startDir, fs);
+	if (configPaths.length === 0) return {
+		config: {},
+		warnings
+	};
+	const configPath = configPaths[0];
+	return {
+		config: await readConfigFromPath(configPath, fs),
+		warnings,
+		configPath
+	};
+}
+async function loadConfig(fs, startDir = process.cwd()) {
+	const cacheKey = path.resolve(startDir);
+	if (!cachedLoads.has(cacheKey)) cachedLoads.set(cacheKey, loadOnce(fs, cacheKey));
+	return cachedLoads.get(cacheKey);
+}
+function resetConfigLoaderCacheForTests() {
+	cachedLoads.clear();
+}
+//#endregion
+export { resetConfigLoaderCacheForTests as n, loadConfig as t };

package/dist/mirror-CbGiLXKT.mjs

@@ -0,0 +1,2 @@
+import "./sync-e1Sp-shi.mjs";
+export {};

package/dist/mirror-DqJE3ejL.mjs

@@ -0,0 +1,66 @@
+import { t as messageFromCaughtUnknown } from "./caught-unknown-message-CRhkDWO7.mjs";
+import { t as loadConfig } from "./loader-DpN-zl5g.mjs";
+import "./config-DVia_f9a.mjs";
+import { t as printConfigSchemaWarnings } from "./config-reporter-SCcWDZc1.mjs";
+import { n as createNodeCliLogger, t as createNodeCliFs } from "./node-io-DFRbHO6m.mjs";
+import { t as findRepoRoot } from "./repo-root-HmtIEm6J.mjs";
+import { t as runMirrorSync } from "./sync-e1Sp-shi.mjs";
+import "./mirror-CbGiLXKT.mjs";
+import process from "node:process";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+//#region src/commands/mirror.ts
+function tryRealpath(entryPath) {
+	try {
+		return realpathSync.native(entryPath);
+	} catch {
+		return path.resolve(entryPath);
+	}
+}
+function normalizePath(relPath) {
+	return relPath.split(path.sep).join("/").replace(/\\/g, "/");
+}
+function packageArgToRelative(rootDir, arg) {
+	if (!arg) return void 0;
+	const rootReal = tryRealpath(path.resolve(rootDir));
+	const cwdReal = tryRealpath(process.cwd());
+	const targetReal = tryRealpath(path.isAbsolute(arg) ? path.resolve(arg) : path.resolve(cwdReal, arg));
+	const normalized = normalizePath(path.relative(rootReal, targetReal));
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") throw new Error(`Package path must be a subdirectory under monorepo root: ${rootDir}`);
+	return normalized;
+}
+function registerMirrorCommand(program) {
+	program.command("mirror").description("Keep package manifests aligned with what you ship").command("sync").description("Write package.json exports from dist/ for workspace packages").argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)").option("-v, --verbose", "Print extra diagnostics", false).action(async function(pkg, options) {
+		const globals = this.optsWithGlobals();
+		const fs = createNodeCliFs();
+		const logger = createNodeCliLogger();
+		const rootDir = findRepoRoot(fs);
+		let packageFilter;
+		try {
+			packageFilter = packageArgToRelative(rootDir, pkg);
+		} catch (caughtPathError) {
+			this.error(messageFromCaughtUnknown(caughtPathError));
+			return;
+		}
+		let mirrorConfig = {};
+		try {
+			const { config, warnings } = await loadConfig(fs, rootDir);
+			printConfigSchemaWarnings(logger, warnings);
+			mirrorConfig = config.mirror ?? {};
+		} catch (caughtConfigError) {
+			this.error(messageFromCaughtUnknown(caughtConfigError));
+			return;
+		}
+		process.exitCode = await runMirrorSync({
+			rootDir,
+			config: mirrorConfig,
+			verbose: options.verbose,
+			noColor: globals.color === false,
+			packageFilter,
+			fs,
+			logger
+		});
+	});
+}
+//#endregion
+export { registerMirrorCommand as n, packageArgToRelative as t };

package/dist/node-io-DFRbHO6m.mjs

@@ -0,0 +1,30 @@
+import process from "node:process";
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+//#region src/lib/infra/node-io.ts
+function createNodeCliFs() {
+	return {
+		existsSync: fs.existsSync,
+		statSync: fs.statSync,
+		readFileSync: fs.readFileSync,
+		writeFileSync: fs.writeFileSync,
+		readdirSync: fs.readdirSync,
+		readFile: (p, enc) => fsPromises.readFile(p, enc),
+		writeFile: (p, data, enc) => fsPromises.writeFile(p, data, enc),
+		readdir: (p, opts) => fsPromises.readdir(p, opts),
+		rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+		unlink: (p) => fsPromises.unlink(p)
+	};
+}
+function createNodeCliLogger() {
+	return {
+		out: (line) => {
+			process.stdout.write(`${line}\n`);
+		},
+		err: (line) => {
+			process.stderr.write(`${line}\n`);
+		}
+	};
+}
+//#endregion
+export { createNodeCliLogger as n, createNodeCliFs as t };

package/dist/package-filter-C_8ryqvz.mjs

@@ -0,0 +1,26 @@
+import { t as normalizePath } from "./path-normalizer-D4ceBO3l.mjs";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+//#region src/lib/mirror/infra/package-filter.ts
+function tryRealpath(entryPath) {
+	try {
+		return realpathSync.native(entryPath);
+	} catch {
+		return path.resolve(entryPath);
+	}
+}
+/**
+* Resolve `packageFilter` to a POSIX-ish path relative to `rootDir`, without using
+* `process.cwd()`. Use for programmatic `runMirrorSync` calls.
+*
+* @throws If the resolved path is not a strict subdirectory of `rootDir`.
+*/
+function resolvePackageFilterUnderRoot(rootDir, packageFilter) {
+	const rootReal = tryRealpath(path.resolve(rootDir));
+	const resolved = path.isAbsolute(packageFilter) ? tryRealpath(path.resolve(packageFilter)) : tryRealpath(path.join(rootReal, packageFilter));
+	const normalized = normalizePath(path.relative(rootReal, resolved));
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") throw new Error(`Package path must be a subdirectory under monorepo root: ${rootDir}`);
+	return normalized;
+}
+//#endregion
+export { resolvePackageFilterUnderRoot as t };

package/dist/path-normalizer-D4ceBO3l.mjs

@@ -0,0 +1,7 @@
+import path from "node:path";
+//#region src/lib/mirror/infra/path-normalizer.ts
+function normalizePath(pathString) {
+	return pathString.split(path.sep).join("/").replace(/\\/g, "/");
+}
+//#endregion
+export { normalizePath as t };

package/dist/program-DR-H4tH3.mjs

@@ -0,0 +1,34 @@
+import { t as registerArrangeCommand } from "./arrange-Bbh62DrU.mjs";
+import { n as registerMirrorCommand } from "./mirror-DqJE3ejL.mjs";
+import { t as registerTagCommand } from "./tag-hEKVZ_-7.mjs";
+import process from "node:process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+//#region src/program.ts
+function readVersion() {
+	try {
+		const dir = path.dirname(fileURLToPath(import.meta.url));
+		const raw = readFileSync(path.join(dir, "..", "package.json"), "utf-8");
+		const pkgVersion = JSON.parse(raw).version;
+		return typeof pkgVersion === "string" && pkgVersion.length > 0 ? pkgVersion : "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+function createProgram() {
+	const program = new Command();
+	program.name("codefast").description("Codefast monorepo developer CLI").version(readVersion()).option("--no-color", "Disable ANSI color output").configureHelp({ sortSubcommands: true }).showHelpAfterError("(use --help for usage)");
+	registerMirrorCommand(program);
+	registerArrangeCommand(program);
+	registerTagCommand(program);
+	return program;
+}
+async function runCli(argv) {
+	await createProgram().parseAsync(argv, { from: "node" });
+	const code = process.exitCode ?? 0;
+	return typeof code === "number" ? code : Number(code) || 0;
+}
+//#endregion
+export { runCli as n, createProgram as t };

package/dist/program.mjs

@@ -0,0 +1,2 @@
+import { n as runCli, t as createProgram } from "./program-DR-H4tH3.mjs";
+export { createProgram, runCli };

package/dist/repo-root-HmtIEm6J.mjs

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/lib/infra/workspace/repo-root.ts
+/**
+* Resolve the monorepo root (directory containing `pnpm-workspace.yaml`).
+* Tries the compiled package location first, then `process.cwd()`.
+*/
+function findRepoRoot(fs) {
+	const candidates = [path.dirname(fileURLToPath(import.meta.url)), process.cwd()];
+	for (const start of candidates) {
+		let dir = path.resolve(start);
+		for (;;) {
+			if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	}
+	throw new Error(`Could not locate monorepo root (missing pnpm-workspace.yaml). Searched from: ${candidates.join(", ")}`);
+}
+//#endregion
+export { findRepoRoot as t };