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

package/dist/lib/arrange/domain/imports.test.mjs

@@ -0,0 +1,48 @@
+import { n as ensureCnImport, t as cnModuleSpecifierForFile } from "../../../imports-DSVq1xhB.mjs";
+import "../../../arrange-BqP2DI3w.mjs";
+//#region src/lib/arrange/domain/imports.test.ts
+describe("cnModuleSpecifierForFile", () => {
+	it("documents that default module specifier is stable across file paths", () => {
+		expect(cnModuleSpecifierForFile("/repo/packages/ui/src/components/a.tsx")).toBe("@codefast/tailwind-variants");
+		expect(cnModuleSpecifierForFile("/repo/packages/cli/src/lib/a.ts")).toBe("@codefast/tailwind-variants");
+	});
+	it("documents that explicit override always takes precedence", () => {
+		expect(cnModuleSpecifierForFile("/repo/packages/ui/src/components/a.tsx", "clsx")).toBe("clsx");
+	});
+});
+describe("ensureCnImport", () => {
+	it("does not change source when cn is imported as default binding", () => {
+		const source = "import cn from \"@codefast/tailwind-variants\";\nconst x = 1;\n";
+		expect(ensureCnImport(source, "/repo/x.ts")).toBe(source);
+	});
+	it("does not change source when cn already imported", () => {
+		const source = "import { cn, tv } from \"@codefast/tailwind-variants\";\nconst x = 1;\n";
+		expect(ensureCnImport(source, "/repo/x.ts")).toBe(source);
+	});
+	it("injects cn into an existing named import from matching module", () => {
+		const out = ensureCnImport("import { tv } from \"clsx\";\nconst x = 1;\n", "/repo/x.ts", "clsx");
+		expect(out).toContain("import { cn, tv } from \"clsx\";");
+	});
+	it("inserts after use client directive", () => {
+		const out = ensureCnImport("\"use client\";\n\nexport const x = 1;\n", "/repo/x.tsx");
+		expect(out.startsWith("\"use client\";\n\nimport { cn }")).toBe(true);
+	});
+	it("inserts before first import when no matching import exists", () => {
+		const out = ensureCnImport("import { tv } from \"clsx\";\nconst x = 1;\n", "/repo/x.ts");
+		expect(out.indexOf("import { cn } from \"@codefast/tailwind-variants\";")).toBe(0);
+	});
+	it("inserts at file start when there are no imports", () => {
+		const out = ensureCnImport("const x = 1;\n", "/repo/x.ts");
+		expect(out.startsWith("import { cn } from \"@codefast/tailwind-variants\";\n")).toBe(true);
+	});
+	it("respects module override when adding new import", () => {
+		const out = ensureCnImport("const x = 1;\n", "/repo/x.ts", "clsx");
+		expect(out.startsWith("import { cn } from \"clsx\";\n")).toBe(true);
+	});
+	it("keeps existing legacy tailwind-variants import unchanged (backward compat)", () => {
+		const source = "import { cn, tv } from \"tailwind-variants\";\nconst x = 1;\n";
+		expect(ensureCnImport(source, "/repo/x.ts")).toBe(source);
+	});
+});
+//#endregion
+export {};

package/dist/lib/arrange/domain/tokenizer.mjs

@@ -0,0 +1,2 @@
+import { a as compositeSecondaryOrder, c as selectorKey, d as tokenizeClassString, i as classifyToken, l as stateKey, n as bucketsMergeCompatible, o as indexOfFirstVariantColon, r as classifyBareUtility, s as isArbitraryParentSelectorStateToken, t as bucketsCompatible, u as stripVariants } from "../../../tokenizer-CeZx73Zu.mjs";
+export { bucketsCompatible, bucketsMergeCompatible, classifyBareUtility, classifyToken, compositeSecondaryOrder, indexOfFirstVariantColon, isArbitraryParentSelectorStateToken, selectorKey, stateKey, stripVariants, tokenizeClassString };

package/dist/lib/arrange/domain/tokenizer.test.mjs

@@ -0,0 +1,165 @@
+import { c as selectorKey, d as tokenizeClassString, i as classifyToken, l as stateKey, n as bucketsMergeCompatible, o as indexOfFirstVariantColon, t as bucketsCompatible, u as stripVariants } from "../../../tokenizer-CeZx73Zu.mjs";
+import "../../../arrange-BqP2DI3w.mjs";
+//#region src/lib/arrange/domain/tokenizer.test.ts
+describe("tokenizeClassString", () => {
+	it("trims and splits on whitespace runs", () => {
+		expect(tokenizeClassString("  flex  gap-2  ")).toEqual(["flex", "gap-2"]);
+	});
+	it("returns empty for whitespace-only input", () => {
+		expect(tokenizeClassString(" \n	 ")).toEqual([]);
+	});
+});
+describe("bucketsMergeCompatible", () => {
+	it.each([
+		[
+			"state",
+			"state",
+			false
+		],
+		[
+			"starting",
+			"starting",
+			false
+		],
+		[
+			"layout",
+			"sizing",
+			true
+		],
+		[
+			"shape",
+			"shadow",
+			true
+		],
+		[
+			"layout",
+			"state",
+			false
+		],
+		[
+			"arbitrary",
+			"arbitrary",
+			false
+		],
+		[
+			"arbitrary",
+			"state",
+			false
+		],
+		[
+			"selector",
+			"selector",
+			false
+		],
+		[
+			"layout",
+			"selector",
+			false
+		],
+		[
+			"selector",
+			"state",
+			false
+		]
+	])("merge compatibility %s + %s -> %s", (a, b, expected) => {
+		expect(bucketsMergeCompatible(a, b)).toBe(expected);
+		expect(bucketsMergeCompatible(b, a)).toBe(expected);
+	});
+});
+describe("bucketsCompatible", () => {
+	it.each([
+		[
+			"layout",
+			"layout",
+			true
+		],
+		[
+			"layout",
+			"sizing",
+			true
+		],
+		[
+			"shape",
+			"shadow",
+			true
+		],
+		[
+			"layout",
+			"state",
+			false
+		],
+		[
+			"arbitrary",
+			"state",
+			false
+		],
+		[
+			"layout",
+			"selector",
+			false
+		]
+	])("compatibility %s + %s -> %s", (a, b, expected) => {
+		expect(bucketsCompatible(a, b)).toBe(expected);
+		expect(bucketsCompatible(b, a)).toBe(expected);
+	});
+});
+describe("stateKey", () => {
+	it("uses the full variant stack for unique keys", () => {
+		expect(stateKey("@md/field-group:[&>*]:w-auto")).not.toBe(stateKey("@md/field-group:[&>[data-slot=field-label]]:flex-auto"));
+	});
+	it("normalizes bracketed data variant stems", () => {
+		expect(stateKey("data-[state=open]:opacity-100")).toBe("data-[state=open]");
+		expect(stateKey("in-data-[slot=tooltip-content]:bg-background/20")).toBe("in-data-[slot=tooltip-content]");
+	});
+	it("keeps distinct keys for in-data-side-* stems", () => {
+		expect(stateKey("in-data-side-right:cursor-e-resize")).toBe("in-data-side-right");
+		expect(stateKey("in-data-side-left:cursor-w-resize")).not.toBe(stateKey("in-data-side-right:cursor-e-resize"));
+	});
+});
+describe("indexOfFirstVariantColon + stripVariants", () => {
+	it("ignores colons inside square brackets", () => {
+		const tok = "[&_a:hover]:text-red-500";
+		expect(indexOfFirstVariantColon(tok)).toBe(11);
+		expect(stripVariants(tok)).toBe("text-red-500");
+	});
+	it("strips stacked variant prefixes", () => {
+		expect(stripVariants("@min-[600px]:@max-[900px]:hidden")).toBe("hidden");
+	});
+});
+describe("classifyToken", () => {
+	it.each([
+		["flex", "layout"],
+		["w-4", "sizing"],
+		["px-3", "spacing"],
+		["rounded-md", "shape"],
+		["text-sm", "typography"],
+		["transition", "motion"],
+		["outline-hidden", "shadow"],
+		["focus-visible:outline-hidden", "state"],
+		["hover:opacity-80", "state"],
+		["[&_svg]:size-4", "selector"],
+		["*:rounded", "selector"],
+		["**:text-sm", "selector"],
+		["has-[img]:bg-muted", "selector"],
+		["in-[.popover]:opacity-100", "selector"],
+		["group-[.is-published]:block", "selector"],
+		["peer-[.is-dirty]:peer-required:block", "selector"],
+		["not-[.prose]:mt-4", "selector"],
+		["starting:opacity-0", "starting"],
+		["cursor-default", "behavior"],
+		["@container/sidebar", "existence"],
+		["@md/sidebar:w-full", "state"]
+	])("classifies %s -> %s", (token, bucket) => {
+		expect(classifyToken(token)).toBe(bucket);
+	});
+});
+describe("selectorKey", () => {
+	it("merges shadcn svg size guard with plain [&_svg] utilities", () => {
+		expect(selectorKey("[&_svg]:pointer-events-none")).toBe(selectorKey("[&_svg:not([class*='size-'])]:size-6"));
+	});
+	it("still splits unrelated arbitrary parent selectors", () => {
+		expect(selectorKey("[&_svg]:size-4")).not.toBe(selectorKey("[&>*]:block"));
+	});
+});
+//#endregion
+export {};

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

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

package/dist/lib/arrange/index.mjs

@@ -0,0 +1,16 @@
+import { i as DEFAULT_ARRANGE_TARGET, o as LONG_STRING_TOKEN_THRESHOLD, p as MAX_STRIP_VARIANT_PASSES } from "../../constants-AtPhF-Ct.mjs";
+import { c as selectorKey, d as tokenizeClassString, i as classifyToken, l as stateKey, n as bucketsMergeCompatible, o as indexOfFirstVariantColon, t as bucketsCompatible, u as stripVariants } from "../../tokenizer-CeZx73Zu.mjs";
+import { a as mergeCnUnconditionalLiteralPoolForTest, r as forEachStringLiteralInClassExpression } from "../../collectors-cn-BS8TTQ8O.mjs";
+import { a as isCnOrTvIdentifier, i as indentOfLineContaining, l as unwrapCnInsideTvCallReplacement, n as applyEditsDescending, o as lineOf, r as buildKnownCnTvBindings, s as moduleLooksLikeCnTvReexport, t as KNOWN_CN_TV_MODULES } from "../../ast-helpers-MDRYuIAk.mjs";
+import { n as walkTsxFiles, t as DEFAULT_SKIP_DIRS } from "../../walk-DjgQn66n.mjs";
+import { t as analyzeDirectory } from "../../analyze-DvtJ3j9m.mjs";
+import { t as printAnalyzeReport } from "../../report-DYxvw34T.mjs";
+import { a as suggestCnGroups, i as mergeSingletons, n as capGroups, o as summarizeGroupBucketLabels, r as mergeEaseTimingIntoFollowingAnimatedState, t as areCnTailwindPartitionsEquivalent } from "../../grouping-c1grpCQT.mjs";
+import { a as formatJsxCnAttributeValue, i as formatCnCall, n as formatArray, r as formatCnArguments, t as escapeTsStringLiteralContent } from "../../formatters-DGE8jJ53.mjs";
+import { n as ensureCnImport, t as cnModuleSpecifierForFile } from "../../imports-DSVq1xhB.mjs";
+import { t as groupFile } from "../../group-file-ClW7XdD6.mjs";
+import { n as ArrangeErrorCode, t as ArrangeError } from "../../errors-CpU1ogfA.mjs";
+import { n as runOnTarget, t as runArrangeSync } from "../../run-target-CJWrqNT4.mjs";
+import { n as createNodeCliLogger, t as createNodeCliFs } from "../../node-io-DFRbHO6m.mjs";
+import "../../arrange-BqP2DI3w.mjs";
+export { ArrangeError, ArrangeErrorCode, DEFAULT_ARRANGE_TARGET, DEFAULT_SKIP_DIRS, KNOWN_CN_TV_MODULES, LONG_STRING_TOKEN_THRESHOLD, MAX_STRIP_VARIANT_PASSES, analyzeDirectory, applyEditsDescending, areCnTailwindPartitionsEquivalent, bucketsCompatible, bucketsMergeCompatible, buildKnownCnTvBindings, capGroups, classifyToken, cnModuleSpecifierForFile, createNodeCliFs, createNodeCliLogger, ensureCnImport, escapeTsStringLiteralContent, forEachStringLiteralInClassExpression, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue, groupFile, indentOfLineContaining, indexOfFirstVariantColon, isCnOrTvIdentifier, lineOf, mergeCnUnconditionalLiteralPoolForTest, mergeEaseTimingIntoFollowingAnimatedState, mergeSingletons, moduleLooksLikeCnTvReexport, printAnalyzeReport, runArrangeSync, runOnTarget, selectorKey, stateKey, stripVariants, suggestCnGroups, summarizeGroupBucketLabels, tokenizeClassString, unwrapCnInsideTvCallReplacement, walkTsxFiles };

package/dist/lib/arrange/infra/walk.mjs

@@ -0,0 +1,2 @@
+import { n as walkTsxFiles, t as DEFAULT_SKIP_DIRS } from "../../../walk-DjgQn66n.mjs";
+export { DEFAULT_SKIP_DIRS, walkTsxFiles };

package/dist/lib/arrange/infra/walk.test.mjs

@@ -0,0 +1,50 @@
+import { n as walkTsxFiles, t as DEFAULT_SKIP_DIRS } from "../../../walk-DjgQn66n.mjs";
+import { t as createNodeCliFs } from "../../../node-io-DFRbHO6m.mjs";
+import "../../../arrange-BqP2DI3w.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/lib/arrange/infra/walk.test.ts
+const arrangeFs = createNodeCliFs();
+describe("DEFAULT_SKIP_DIRS", () => {
+	it("contains common generated directories", () => {
+		expect(DEFAULT_SKIP_DIRS.has("node_modules")).toBe(true);
+		expect(DEFAULT_SKIP_DIRS.has(".git")).toBe(true);
+		expect(DEFAULT_SKIP_DIRS.has("dist")).toBe(true);
+		expect(DEFAULT_SKIP_DIRS.has(".turbo")).toBe(true);
+	});
+});
+describe("walkTsxFiles", () => {
+	it("collects .ts/.tsx, skips .d.ts and nested skipped directories", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "arr-walk-"));
+		try {
+			fs.mkdirSync(path.join(dir, "a", "node_modules", "x"), { recursive: true });
+			fs.mkdirSync(path.join(dir, ".git", "hooks"), { recursive: true });
+			fs.writeFileSync(path.join(dir, "root.ts"), "", "utf8");
+			fs.writeFileSync(path.join(dir, "root.tsx"), "", "utf8");
+			fs.writeFileSync(path.join(dir, "types.d.ts"), "", "utf8");
+			fs.writeFileSync(path.join(dir, "a", "node_modules", "x", "ignored.tsx"), "", "utf8");
+			fs.writeFileSync(path.join(dir, ".git", "hooks", "ignored.ts"), "", "utf8");
+			const rel = walkTsxFiles(dir, arrangeFs).map((p) => path.relative(dir, p).split(path.sep).join("/")).sort();
+			expect(rel).toEqual(["root.ts", "root.tsx"]);
+		} finally {
+			fs.rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("returns empty array for empty directory", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "arr-walk-empty-"));
+		try {
+			expect(walkTsxFiles(dir, arrangeFs)).toEqual([]);
+		} finally {
+			fs.rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+});
+//#endregion
+export {};

package/dist/lib/arrange/presentation/formatters.mjs

@@ -0,0 +1,2 @@
+import { a as formatJsxCnAttributeValue, i as formatCnCall, n as formatArray, r as formatCnArguments, t as escapeTsStringLiteralContent } from "../../../formatters-DGE8jJ53.mjs";
+export { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue };

package/dist/lib/arrange/presentation/formatters.test.mjs

@@ -0,0 +1,73 @@
+import { a as formatJsxCnAttributeValue, i as formatCnCall, n as formatArray, r as formatCnArguments, t as escapeTsStringLiteralContent } from "../../../formatters-DGE8jJ53.mjs";
+import "../../../arrange-BqP2DI3w.mjs";
+//#region src/lib/arrange/presentation/formatters.test.ts
+describe("escapeTsStringLiteralContent", () => {
+	it("escapes backslashes and quotes", () => {
+		expect(escapeTsStringLiteralContent(String.raw`x\"y`)).toBe(String.raw`x\\\"y`);
+	});
+	it("keeps plain strings unchanged", () => {
+		expect(escapeTsStringLiteralContent("plain")).toBe("plain");
+	});
+	it("handles empty strings", () => {
+		expect(escapeTsStringLiteralContent("")).toBe("");
+	});
+});
+describe("formatCnArguments", () => {
+	it("renders indented args without wrapping cn()", () => {
+		expect(formatCnArguments(["flex gap-2", "text-sm"], { indent: "    " })).toBe(["    \"flex gap-2\",", "    \"text-sm\""].join("\n"));
+	});
+	it("adds comma on last group when commaAfterLastGroup=true", () => {
+		expect(formatCnArguments(["a", "b"], { commaAfterLastGroup: true })).toBe(["  \"a\",", "  \"b\","].join("\n"));
+	});
+	it("appends trailing className line when requested", () => {
+		expect(formatCnArguments(["a", "b"], { trailingClassName: true })).toBe([
+			"  \"a\",",
+			"  \"b\",",
+			"  className,"
+		].join("\n"));
+	});
+	it("escapes literals", () => {
+		expect(formatCnArguments(["x\"y"])).toBe("  \"x\\\"y\"");
+	});
+});
+describe("formatCnCall", () => {
+	it("omits trailing comma for single group", () => {
+		expect(formatCnCall(["only"])).toBe([
+			"cn(",
+			"  \"only\"",
+			")"
+		].join("\n"));
+	});
+	it("renders multiline cn() with trailing commas for multi-arg", () => {
+		expect(formatCnCall(["a", "b"])).toBe([
+			"cn(",
+			"  \"a\",",
+			"  \"b\",",
+			")"
+		].join("\n"));
+	});
+	it("supports trailing className", () => {
+		expect(formatCnCall(["a", "b"], { trailingClassName: true })).toContain("className,");
+	});
+});
+describe("formatArray", () => {
+	it("renders multiline string array", () => {
+		expect(formatArray(["a", "b"])).toBe([
+			"[",
+			"  \"a\",",
+			"  \"b\",",
+			"]"
+		].join("\n"));
+	});
+});
+describe("formatJsxCnAttributeValue", () => {
+	it("formats className={cn(...)} with source-derived indentation", () => {
+		const source = `export function F() {\n  return <div className="x" />;\n}`;
+		const out = formatJsxCnAttributeValue(["flex gap-2", "text-sm"], source, source.indexOf("\""));
+		expect(out.startsWith("{cn(")).toBe(true);
+		expect(out.endsWith(")}")).toBe(true);
+		expect(out).toContain("\"flex gap-2\",");
+	});
+});
+//#endregion
+export {};

package/dist/lib/arrange/presentation/report.mjs

@@ -0,0 +1,2 @@
+import { t as printAnalyzeReport } from "../../../report-DYxvw34T.mjs";
+export { printAnalyzeReport };

package/dist/lib/config/domain/schema.mjs

@@ -0,0 +1,2 @@
+import { a as mirrorConfigSchema, i as hookSchema, n as codefastConfigSchema, r as codefastTagConfigSchema, t as codefastArrangeConfigSchema } from "../../../schema-Or8RAARd.mjs";
+export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema };

package/dist/lib/config/index.mjs

@@ -0,0 +1,4 @@
+import { a as mirrorConfigSchema, i as hookSchema, n as codefastConfigSchema, r as codefastTagConfigSchema, t as codefastArrangeConfigSchema } from "../../schema-Or8RAARd.mjs";
+import { n as resetConfigLoaderCacheForTests, t as loadConfig } from "../../loader-DpN-zl5g.mjs";
+import "../../config-DVia_f9a.mjs";
+export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, loadConfig, mirrorConfigSchema, resetConfigLoaderCacheForTests };

package/dist/lib/config/infra/loader.mjs

@@ -0,0 +1,2 @@
+import { n as resetConfigLoaderCacheForTests, t as loadConfig } from "../../../loader-DpN-zl5g.mjs";
+export { loadConfig, resetConfigLoaderCacheForTests };

package/dist/lib/config/infra/loader.test.mjs

@@ -0,0 +1,116 @@
+import { n as resetConfigLoaderCacheForTests, t as loadConfig } from "../../../loader-DpN-zl5g.mjs";
+import { t as createNodeCliFs } from "../../../node-io-DFRbHO6m.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/lib/config/infra/loader.test.ts
+describe("loadConfig", () => {
+	const cliFs = createNodeCliFs();
+	async function withCwd(cwd, fn) {
+		const prev = process.cwd();
+		process.chdir(cwd);
+		resetConfigLoaderCacheForTests();
+		try {
+			return await fn();
+		} finally {
+			process.chdir(prev);
+			resetConfigLoaderCacheForTests();
+		}
+	}
+	it("loads mirror + lifecycle hooks from codefast.config.cjs", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "codefast-config-hooks-"));
+		try {
+			fs.writeFileSync(path.join(root, "codefast.config.cjs"), [
+				"module.exports = {",
+				"  mirror: { skipPackages: [\"@acme/private\"] },",
+				"  tag: { onAfterWrite: async ({ files }) => {",
+				"    if (files.length === 0) return;",
+				"  } },",
+				"  arrange: { onAfterWrite: ({ files }) => files.length },",
+				"};",
+				""
+			].join("\n"), "utf8");
+			await withCwd(root, async () => {
+				const { config, warnings } = await loadConfig(cliFs);
+				expect(warnings).toEqual([]);
+				expect(config.mirror).toEqual({ skipPackages: ["@acme/private"] });
+				expect(typeof config.tag?.onAfterWrite).toBe("function");
+				expect(typeof config.arrange?.onAfterWrite).toBe("function");
+			});
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("requires mirror config to be nested under the mirror key", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "codefast-config-mirror-top-"));
+		try {
+			fs.writeFileSync(path.join(root, "codefast.config.json"), JSON.stringify({ skipPackages: ["@acme/legacy"] }), "utf8");
+			await withCwd(root, async () => {
+				await expect(loadConfig(cliFs)).rejects.toThrow("Invalid config schema");
+				await expect(loadConfig(cliFs)).rejects.toThrow("Unrecognized key: \"skipPackages\"");
+			});
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("throws schema validation errors for invalid hook values", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "codefast-config-invalid-hook-"));
+		try {
+			fs.writeFileSync(path.join(root, "codefast.config.json"), JSON.stringify({
+				tag: { onAfterWrite: "not-a-function" },
+				arrange: { onAfterWrite: 123 }
+			}), "utf8");
+			await withCwd(root, async () => {
+				await expect(loadConfig(cliFs)).rejects.toThrow("Invalid config schema");
+				await expect(loadConfig(cliFs)).rejects.toThrow("tag.onAfterWrite");
+			});
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("resolves config with upward search from process.cwd()", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "codefast-config-upward-"));
+		const nested = path.join(root, "packages", "ui", "src");
+		try {
+			fs.mkdirSync(nested, { recursive: true });
+			fs.writeFileSync(path.join(root, "codefast.config.json"), JSON.stringify({ mirror: { skipPackages: ["@acme/infra"] } }), "utf8");
+			await withCwd(nested, async () => {
+				const { config } = await loadConfig(cliFs);
+				expect(config.mirror).toEqual({ skipPackages: ["@acme/infra"] });
+			});
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	it("uses singleton cache within one process", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "codefast-config-cache-"));
+		try {
+			fs.writeFileSync(path.join(root, "codefast.config.json"), JSON.stringify({ mirror: { skipPackages: ["@acme/one"] } }), "utf8");
+			await withCwd(root, async () => {
+				const first = await loadConfig(cliFs);
+				fs.writeFileSync(path.join(root, "codefast.config.json"), JSON.stringify({ mirror: { skipPackages: ["@acme/two"] } }), "utf8");
+				const second = await loadConfig(cliFs);
+				expect(second.config.mirror).toEqual(first.config.mirror);
+			});
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+});
+//#endregion
+export {};

package/dist/lib/infra/caught-unknown-message.mjs

@@ -0,0 +1,2 @@
+import { t as messageFromCaughtUnknown } from "../../caught-unknown-message-CRhkDWO7.mjs";
+export { messageFromCaughtUnknown };

package/dist/lib/infra/config-reporter.mjs

@@ -0,0 +1,2 @@
+import { t as printConfigSchemaWarnings } from "../../config-reporter-SCcWDZc1.mjs";
+export { printConfigSchemaWarnings };

package/dist/lib/infra/fs-contract.mjs

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

package/dist/lib/infra/node-io.mjs

@@ -0,0 +1,2 @@
+import { n as createNodeCliLogger, t as createNodeCliFs } from "../../node-io-DFRbHO6m.mjs";
+export { createNodeCliFs, createNodeCliLogger };

package/dist/lib/infra/workspace/repo-root.mjs

@@ -0,0 +1,2 @@
+import { t as findRepoRoot } from "../../../repo-root-HmtIEm6J.mjs";
+export { findRepoRoot };

package/dist/lib/infra/workspace/repo-root.test.mjs

@@ -0,0 +1,45 @@
+import { t as findRepoRoot } from "../../../repo-root-HmtIEm6J.mjs";
+import path from "node:path";
+//#region src/lib/infra/workspace/repo-root.test.ts
+function makeFs(existsSync) {
+	return {
+		existsSync,
+		statSync: () => ({
+			isDirectory: () => true,
+			isFile: () => false
+		}),
+		readFileSync: () => "",
+		writeFileSync: () => void 0,
+		readdirSync: () => [],
+		readFile: async () => "",
+		writeFile: async () => void 0,
+		readdir: async () => [],
+		rename: async () => void 0,
+		unlink: async () => void 0
+	};
+}
+describe("findRepoRoot", () => {
+	it("returns the nearest ancestor containing pnpm-workspace.yaml", () => {
+		const root = "/tmp/repo";
+		const marker = path.join(root, "pnpm-workspace.yaml");
+		const cwdSpy = jest.spyOn(process, "cwd").mockReturnValue("/tmp/repo/packages/cli");
+		try {
+			const fs = makeFs((targetPath) => targetPath === marker);
+			expect(findRepoRoot(fs)).toBe(root);
+		} finally {
+			cwdSpy.mockRestore();
+		}
+	});
+	it("includes searched candidate paths when root cannot be resolved", () => {
+		const cwdSpy = jest.spyOn(process, "cwd").mockReturnValue("/tmp/no-repo");
+		try {
+			const fs = makeFs(() => false);
+			expect(() => findRepoRoot(fs)).toThrow(/Searched from:/);
+			expect(() => findRepoRoot(fs)).toThrow(/\/tmp\/no-repo/);
+		} finally {
+			cwdSpy.mockRestore();
+		}
+	});
+});
+//#endregion
+export {};

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

@@ -0,0 +1,2 @@
+import { n as generateExports, t as createPathTransform } from "../../../engine-DRTdkc5u.mjs";
+export { createPathTransform, generateExports };

package/dist/lib/mirror/application/sync.mjs

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