@codefast/cli 0.3.14 → 0.3.16-canary.0

package/dist/{program.mjs → cli.mjs}

@@ -1,10 +1,12 @@
-import { createCliRuntimeContainer, resolveCliCommands } from "./lib/bootstrap/composition-root.mjs";
+import { createArrangeCommand } from "./arrange/command.mjs";
+import { createMirrorCommand } from "./mirror/command.mjs";
+import { createTagCommand } from "./tag/command.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
+//#region src/cli.ts
 function readVersion() {
 	try {
 		const dir = path.dirname(fileURLToPath(import.meta.url));
@@ -15,25 +17,18 @@ function readVersion() {
 		return "unknown";
 	}
 }
-function createProgram(commands) {
+/**
+* @since 0.3.16-canary.0
+*/
+async function runCli(argv) {
 	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)");
-	for (const cliCommand of commands) cliCommand.register(program);
-	return program;
-}
-async function runCli(argv) {
-	const runtimeContainer = createCliRuntimeContainer();
-	try {
-		if (process.env.NODE_ENV !== "production") {
-			runtimeContainer.validate();
-			await runtimeContainer.initializeAsync();
-		}
-		await createProgram(resolveCliCommands(runtimeContainer)).parseAsync(argv, { from: "node" });
-		const code = process.exitCode ?? 0;
-		return typeof code === "number" ? code : Number(code) || 0;
-	} finally {
-		await runtimeContainer.dispose();
-	}
+	program.addCommand(createArrangeCommand());
+	program.addCommand(createMirrorCommand());
+	program.addCommand(createTagCommand());
+	await program.parseAsync(argv, { from: "node" });
+	const code = process.exitCode ?? 0;
+	return typeof code === "number" ? code : Number(code) || 0;
 }
 //#endregion
 export { runCli };

package/dist/core/cli/format-error.mjs

@@ -0,0 +1,15 @@
+//#region src/core/cli/format-error.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function formatAppError(error) {
+	const { code, message } = error;
+	switch (code) {
+		case "NOT_FOUND": return `[NOT_FOUND] ${message}`;
+		case "VALIDATION_ERROR": return `[VALIDATION_ERROR] ${message}`;
+		case "INFRA_FAILURE": return `[INFRA_FAILURE] ${message}`;
+		default: return `Unhandled error code: ${String(code)}`;
+	}
+}
+//#endregion
+export { formatAppError };

package/dist/core/cli/global-options.mjs

@@ -0,0 +1,10 @@
+import { z } from "zod";
+//#region src/core/cli/global-options.ts
+/**
+* Commander global opts shape validated before mirror prelude (`color` from `--no-color`).
+*
+* @since 0.3.16-canary.0
+*/
+const globalCliCommanderOptionsSchema = z.object({ color: z.boolean().optional() });
+//#endregion
+export { globalCliCommanderOptionsSchema };

package/dist/core/cli/positional.mjs

@@ -0,0 +1,11 @@
+//#region src/core/cli/positional.ts
+/**
+* Coerce a raw Commander positional argument to a string, or undefined when absent.
+*
+* @since 0.3.16-canary.0
+*/
+function readOptionalPositionalArg(candidate) {
+	return typeof candidate === "string" ? candidate : void 0;
+}
+//#endregion
+export { readOptionalPositionalArg };

package/dist/core/cli/result-handle.mjs

@@ -0,0 +1,51 @@
+import { formatAppError } from "./format-error.mjs";
+import "../exit-codes.mjs";
+import { logger } from "../logger.mjs";
+import { isVerboseCliDiagnostics } from "../verbose-diagnostics.mjs";
+import process from "node:process";
+//#region src/core/cli/result-handle.ts
+function exitCodeForAppError(error) {
+	switch (error.code) {
+		case "NOT_FOUND": return 1;
+		case "VALIDATION_ERROR": return 2;
+		case "INFRA_FAILURE": return 1;
+		default: return error.code;
+	}
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function handleResult(outcome, onSuccess) {
+	if (!outcome.ok) {
+		logger.err(formatAppError(outcome.error));
+		if (isVerboseCliDiagnostics() && outcome.error.code === "INFRA_FAILURE" && outcome.error.cause instanceof Error && outcome.error.cause.stack !== void 0) logger.err(outcome.error.cause.stack);
+		process.exitCode = exitCodeForAppError(outcome.error);
+		return false;
+	}
+	onSuccess(outcome.value);
+	return true;
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function consumeCliAppError(outcome, options) {
+	if (!outcome.ok) {
+		logger.err(formatAppError(outcome.error));
+		if (isVerboseCliDiagnostics() && outcome.error.code === "INFRA_FAILURE" && outcome.error.cause instanceof Error && outcome.error.cause.stack !== void 0) logger.err(outcome.error.cause.stack);
+		process.exitCode = exitCodeForAppError(outcome.error);
+		return false;
+	}
+	if (options?.successMessage !== void 0) logger.out(options.successMessage);
+	return true;
+}
+/**
+* @since 0.3.16-canary.0
+*/
+async function runCliResultAsync(outcomePromise, onSuccess) {
+	const outcome = await outcomePromise;
+	if (!consumeCliAppError(outcome)) return;
+	const exit = await onSuccess(outcome.value);
+	process.exitCode = exit === void 0 ? 0 : exit;
+}
+//#endregion
+export { consumeCliAppError, handleResult, runCliResultAsync };

package/dist/core/config/loader.mjs

@@ -0,0 +1,79 @@
+import { codefastConfigRootSchema } from "./schema.mjs";
+import path from "node:path";
+import jiti from "jiti";
+//#region src/core/config/loader.ts
+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) {
+	const parsed = codefastConfigRootSchema.safeParse(raw);
+	if (!parsed.success) throw new Error(formatZodError(parsed.error, filePath));
+	return parsed.data;
+}
+const configJsPriority = [
+	"codefast.config.mjs",
+	"codefast.config.js",
+	"codefast.config.cjs"
+];
+const configJson = "codefast.config.json";
+const cachedLoads = /* @__PURE__ */ new Map();
+function listConfigCandidates(startDir, fs) {
+	const candidates = [];
+	let current = path.resolve(startDir);
+	while (true) {
+		for (const name of configJsPriority) {
+			const candidate = path.join(current, name);
+			if (fs.existsSync(candidate)) candidates.push(candidate);
+		}
+		const jsonCandidate = path.join(current, configJson);
+		if (fs.existsSync(jsonCandidate)) candidates.push(jsonCandidate);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return candidates;
+}
+async function readConfigFromPath(filePath, jitiBaseDir, fs) {
+	if (path.extname(filePath) === ".json") {
+		const content = await fs.readFile(filePath, "utf8");
+		return parseLoadedConfig(JSON.parse(content), filePath);
+	}
+	const moduleConfig = jiti(jitiBaseDir, {
+		interopDefault: true,
+		moduleCache: false
+	})(filePath);
+	return parseLoadedConfig(typeof moduleConfig === "object" && moduleConfig !== null && "default" in moduleConfig ? moduleConfig.default : moduleConfig, filePath);
+}
+async function loadOnce(startDir, fs) {
+	const warnings = [];
+	const configPaths = listConfigCandidates(startDir, fs);
+	if (configPaths.length === 0) return {
+		config: {},
+		warnings
+	};
+	const configPath = configPaths[0];
+	if (configPath === void 0) return {
+		config: {},
+		warnings
+	};
+	return {
+		config: await readConfigFromPath(configPath, startDir, fs),
+		warnings,
+		configPath
+	};
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function loadConfigPayload(startDir, fs) {
+	const cacheKey = path.resolve(startDir);
+	if (!cachedLoads.has(cacheKey)) cachedLoads.set(cacheKey, loadOnce(cacheKey, fs));
+	const cached = cachedLoads.get(cacheKey);
+	if (cached === void 0) throw new Error("config loader cache invariant violated");
+	return cached;
+}
+//#endregion
+export { loadConfigPayload };

package/dist/{lib/config/infrastructure/config-schema.adapter.mjs → core/config/schema.mjs}

@@ -1,6 +1,9 @@
 import { z } from "zod";
-//#region src/lib/config/infrastructure/config-schema.adapter.ts
-const hookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
+//#region src/core/config/schema.ts
+const afterWriteHookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
+/**
+* @since 0.3.16-canary.0
+*/
 const mirrorConfigSchema = z.object({
 	skipPackages: z.array(z.string()).optional(),
 	pathTransformations: z.record(z.string(), z.object({ removePrefix: z.string().optional() }).strict()).optional(),
@@ -11,15 +14,26 @@ const mirrorConfigSchema = z.object({
 		forceExportFiles: z.boolean().optional()
 	}).strict()])).optional()
 }).strict();
+/**
+* @since 0.3.16-canary.0
+*/
 const codefastTagConfigSchema = z.object({
 	skipPackages: z.array(z.string()).optional(),
-	onAfterWrite: hookSchema.optional()
+	onAfterWrite: afterWriteHookSchema.optional()
 }).strict();
-const codefastArrangeConfigSchema = z.object({ onAfterWrite: hookSchema.optional() }).strict();
-const codefastConfigSchema = z.object({
+/**
+* @since 0.3.16-canary.0
+*/
+const codefastArrangeConfigSchema = z.object({ onAfterWrite: afterWriteHookSchema.optional() }).strict();
+/**
+* Root `codefast.config` Zod schema — single source of truth for both validation and TS types.
+*
+* @since 0.3.16-canary.0
+*/
+const codefastConfigRootSchema = z.object({
 	mirror: mirrorConfigSchema.optional(),
 	tag: codefastTagConfigSchema.optional(),
 	arrange: codefastArrangeConfigSchema.optional()
 }).strict();
 //#endregion
-export { codefastConfigSchema };
+export { codefastArrangeConfigSchema, codefastConfigRootSchema, codefastTagConfigSchema, mirrorConfigSchema };

package/dist/core/config/warnings.mjs

@@ -0,0 +1,12 @@
+import { logger } from "../logger.mjs";
+//#region src/core/config/warnings.ts
+const yellowAnsi = "\x1B[33m";
+const resetAnsi = "\x1B[0m";
+/**
+* @since 0.3.16-canary.0
+*/
+function reportSchemaWarnings(warnings) {
+	for (const warningMessage of warnings) logger.out(`${yellowAnsi}⚠ ${warningMessage}${resetAnsi}`);
+}
+//#endregion
+export { reportSchemaWarnings };

package/dist/core/config.mjs

@@ -0,0 +1,19 @@
+import { AppError, messageFrom } from "./errors.mjs";
+import { err, ok } from "./result.mjs";
+import { loadConfigPayload } from "./config/loader.mjs";
+import { reportSchemaWarnings } from "./config/warnings.mjs";
+//#region src/core/config.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function loadCodefastConfig(rootDir, fs) {
+	try {
+		const { config, warnings } = await loadConfigPayload(rootDir, fs);
+		reportSchemaWarnings(warnings);
+		return ok({ config });
+	} catch (caughtError) {
+		return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+	}
+}
+//#endregion
+export { loadCodefastConfig };

package/dist/{lib/core/domain/caught-unknown-message.value-object.mjs → core/errors.mjs}

@@ -1,8 +1,24 @@
-//#region src/lib/core/domain/caught-unknown-message.value-object.ts
+//#region src/core/errors.ts
+/**
+* @since 0.3.16-canary.0
+*/
+var AppError = class {
+	name = "AppError";
+	code;
+	message;
+	cause;
+	constructor(code, message, cause) {
+		this.code = code;
+		this.message = message;
+		if (cause !== void 0) this.cause = cause;
+	}
+};
 /**
 * Stable, user-facing text for values caught as `unknown`.
-* Avoids `String(unknown)` / `[object Object]` and satisfies strict `no-base-to-string`.
-*/ function messageFromCaughtUnknown(value) {
+*
+* @since 0.3.16-canary.0
+*/
+function messageFrom(value) {
 	if (value instanceof Error) return value.message;
 	if (typeof value === "string") return value;
 	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
@@ -16,4 +32,4 @@
 	return "[unserializable non-Error value]";
 }
 //#endregion
-export { messageFromCaughtUnknown };
+export { AppError, messageFrom };

package/dist/core/exit-codes.mjs

@@ -0,0 +1,17 @@
+//#region src/core/exit-codes.ts
+/**
+* Process exit codes for the `codefast` CLI.
+*
+* @since 0.3.16-canary.0
+*/
+const CLI_EXIT_SUCCESS = 0;
+/**
+* @since 0.3.16-canary.0
+*/
+const CLI_EXIT_GENERAL_ERROR = 1;
+/**
+* @since 0.3.16-canary.0
+*/
+const CLI_EXIT_USAGE = 2;
+//#endregion
+export { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS, CLI_EXIT_USAGE };

package/dist/core/filesystem/node.mjs

@@ -0,0 +1,32 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import fsPromises from "node:fs/promises";
+//#region src/core/filesystem/node.ts
+/**
+* @since 0.3.16-canary.0
+*/
+const nodeFilesystem = {
+	existsSync: fsSync.existsSync,
+	statSync: fsSync.statSync,
+	readFileSync: fsSync.readFileSync,
+	writeFileSync: fsSync.writeFileSync,
+	readdirSync: fsSync.readdirSync,
+	canonicalPathSync(inputPath) {
+		try {
+			return fsSync.realpathSync.native(inputPath);
+		} catch {
+			return path.resolve(inputPath);
+		}
+	},
+	readFile: (filePath, enc) => fsPromises.readFile(filePath, enc),
+	writeFile: (filePath, data, enc) => fsPromises.writeFile(filePath, data, enc),
+	readdir: async (filePath, opts) => {
+		const raw = await fsPromises.readdir(filePath, opts);
+		if (!opts?.withFileTypes) return raw;
+		return raw;
+	},
+	rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+	unlink: (filePath) => fsPromises.unlink(filePath)
+};
+//#endregion
+export { nodeFilesystem };

package/dist/core/logger.mjs

@@ -0,0 +1,15 @@
+import process from "node:process";
+//#region src/core/logger.ts
+/**
+* @since 0.3.16-canary.0
+*/
+const logger = {
+	out(line) {
+		process.stdout.write(`${line}\n`);
+	},
+	err(line) {
+		process.stderr.write(`${line}\n`);
+	}
+};
+//#endregion
+export { logger };

package/dist/{lib/core/domain/result.model.mjs → core/result.mjs}

@@ -1,12 +1,16 @@
-//#region src/lib/core/domain/result.model.ts
+//#region src/core/result.ts
 /**
-* Lightweight functional Result type for use-case boundaries.
-*/ function ok(value) {
+* @since 0.3.16-canary.0
+*/
+function ok(value) {
 	return {
 		ok: true,
 		value
 	};
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function err(error) {
 	return {
 		ok: false,

package/dist/{lib/core/application/services/schema-validator.service.mjs → core/schema-parse.mjs}

@@ -1,14 +1,15 @@
-import { AppError } from "../../domain/errors.domain.mjs";
-import { err, ok } from "../../domain/result.model.mjs";
-//#region src/lib/core/application/services/schema-validator.service.ts
+import { AppError } from "./errors.mjs";
+import { err, ok } from "./result.mjs";
+//#region src/core/schema-parse.ts
 function formatSchemaIssues(issues) {
 	return issues.map((issue) => {
 		return `${issue.path.length > 0 ? `${issue.path.join(".")}: ` : ""}${issue.message}`;
 	}).join("; ");
 }
 /**
-* Validates `input` with `schema`, returning {@link AppError} (code `VALIDATION_ERROR`) on failure.
-*/ function parseWithSchema(schema, input) {
+* @since 0.3.16-canary.0
+*/
+function parseWithSchema(schema, input) {
 	const parsed = schema.safeParse(input);
 	if (!parsed.success) return err(new AppError("VALIDATION_ERROR", formatSchemaIssues(parsed.error.issues)));
 	return ok(parsed.data);

package/dist/{lib/shared/source-code/domain/text-edit.model.mjs → core/source-text-edit.mjs}

@@ -1,14 +1,13 @@
-//#region src/lib/shared/source-code/domain/text-edit.model.ts
-/**
-* Pure string utilities for applying non-overlapping text edits and reading line indentation.
-*/ function lineStartIndexContaining(source, pos) {
+//#region src/core/source-text-edit.ts
+function lineStartIndexContaining(source, pos) {
 	const searchPos = Math.max(0, Math.min(pos, source.length));
 	const prevLineBreak = Math.max(source.lastIndexOf("\n", searchPos - 1), source.lastIndexOf("\r", searchPos - 1));
 	return prevLineBreak === -1 ? 0 : prevLineBreak + 1;
 }
 /**
-* Returns only the leading whitespace (tabs / spaces) of the line containing `pos`.
-*/ function indentOfLineContaining(source, pos) {
+* @since 0.3.16-canary.0
+*/
+function indentOfLineContaining(source, pos) {
 	const lineStart = lineStartIndexContaining(source, pos);
 	let lineEnd = source.length;
 	for (let i = lineStart; i < source.length; i++) {
@@ -22,17 +21,16 @@
 	return /^[\t ]*/.exec(line)?.[0] ?? "";
 }
 /**
-* Source slice `[lineStart, pos)` for the line containing `pos`. Aligns continuation lines with
-* a token not at column 0 (e.g. `base: ["foo"` → prefix before the opening `"` of `"foo"`).
-*/ function textPrefixFromLineStartToPosition(source, pos) {
+* @since 0.3.16-canary.0
+*/
+function textPrefixFromLineStartToPosition(source, pos) {
 	const searchPos = Math.max(0, Math.min(pos, source.length));
-	return source.slice(lineStartIndexContaining(source, pos), searchPos);
+	return source.slice(lineStartIndexContaining(source, searchPos), searchPos);
 }
 /**
-* If `tokenEnd` is followed by optional ASCII whitespace then `,`, returns the index after that
-* comma. Otherwise returns `tokenEnd`. Useful when a replacement already ends with `,` and the
-* following source comma must be absorbed.
-*/ function endAfterOptionalCommaFollowingInSource(source, tokenEnd) {
+* @since 0.3.16-canary.0
+*/
+function endAfterOptionalCommaFollowingInSource(source, tokenEnd) {
 	let index = tokenEnd;
 	while (index < source.length) {
 		const ch = source[index];
@@ -45,6 +43,9 @@
 	}
 	return tokenEnd;
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function applyEditsDescending(sourceText, edits) {
 	const sorted = [...edits].sort((editA, editB) => editB.start - editA.start);
 	let out = sourceText;

package/dist/core/verbose-diagnostics.mjs

@@ -0,0 +1,11 @@
+import process from "node:process";
+//#region src/core/verbose-diagnostics.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function isVerboseCliDiagnostics() {
+	const raw = process.env.CODEFAST_VERBOSE;
+	return raw === "1" || raw === "true";
+}
+//#endregion
+export { isVerboseCliDiagnostics };