@codefast/cli 0.3.12 → 0.3.13-canary.0

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/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 };