@codefast/cli 0.3.14-canary.1 → 0.3.14

package/dist/lib/config/infrastructure/config-loader.adapter.mjs

@@ -0,0 +1,306 @@
+import { CliFsToken } from "../../core/contracts/tokens.mjs";
+import { codefastConfigSchema } from "./config-schema.adapter.mjs";
+import path from "node:path";
+import { inject, injectable } from "@codefast/di";
+import { ZodError } from "zod";
+import jiti from "jiti";
+//#region src/lib/config/infrastructure/config-loader.adapter.ts
+function toPrimitive(input, hint) {
+	if (typeof input !== "object" || input === null) return input;
+	var prim = input[Symbol.toPrimitive];
+	if (prim !== void 0) {
+		var res = prim.call(input, hint || "default");
+		if (typeof res !== "object") return res;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (hint === "string" ? String : Number)(input);
+}
+function toPropertyKey(arg) {
+	var key = toPrimitive(arg, "string");
+	return typeof key === "symbol" ? key : String(key);
+}
+function checkInRHS(value) {
+	if (Object(value) !== value) throw TypeError("right-hand side of 'in' should be an object, got " + (value !== null ? typeof value : "null"));
+	return value;
+}
+function setFunctionName(fn, name, prefix) {
+	if (typeof name === "symbol") {
+		name = name.description;
+		name = name ? "[" + name + "]" : "";
+	}
+	try {
+		Object.defineProperty(fn, "name", {
+			configurable: true,
+			value: prefix ? prefix + " " + name : name
+		});
+	} catch (_) {}
+	return fn;
+}
+function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis, instanceBrand, parentClass) {
+	var symbolMetadata = Symbol.metadata || Symbol.for("Symbol.metadata");
+	var defineProperty = Object.defineProperty;
+	var create = Object.create;
+	var metadata;
+	var existingNonFields = [create(null), create(null)];
+	var hasClassDecs = classDecs.length;
+	var _;
+	function createRunInitializers(initializers, useStaticThis, hasValue) {
+		return function(thisArg, value) {
+			if (useStaticThis) {
+				value = thisArg;
+				thisArg = targetClass;
+			}
+			for (var i = 0; i < initializers.length; i++) value = initializers[i].apply(thisArg, hasValue ? [value] : []);
+			return hasValue ? value : thisArg;
+		};
+	}
+	function assertCallable(fn, hint1, hint2, throwUndefined) {
+		if (typeof fn !== "function") {
+			if (throwUndefined || fn !== void 0) throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined"));
+		}
+		return fn;
+	}
+	function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, initializers, ret, isStatic, isPrivate, isField, hasPrivateBrand) {
+		function assertInstanceIfPrivate(target) {
+			if (!hasPrivateBrand(target)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var decs = [].concat(decInfo[0]);
+		var decVal = decInfo[3];
+		var isClass = !ret;
+		var isAccessor = kind === 1;
+		var isGetter = kind === 3;
+		var isSetter = kind === 4;
+		var isMethod = kind === 2;
+		function bindPropCall(name, useStaticThis, before) {
+			return function(_this, value) {
+				if (useStaticThis) {
+					value = _this;
+					_this = Class;
+				}
+				if (before) before(_this);
+				return desc[name].call(_this, value);
+			};
+		}
+		var desc1 = {};
+		var init = [];
+		var key = isGetter ? "get" : isSetter || isAccessor ? "set" : "value";
+		if (!isClass) {
+			if (isPrivate) {
+				if (isField || isAccessor) desc1 = {
+					get: setFunctionName(function() {
+						return decVal(this);
+					}, name, "get"),
+					set: function(value) {
+						decInfo[4](this, value);
+					}
+				};
+				else desc1[key] = decVal;
+				if (!isField) setFunctionName(desc1[key], name, isMethod ? "" : key);
+			} else if (!isField) desc1 = Object.getOwnPropertyDescriptor(Class, name);
+			if (!isField && !isPrivate) {
+				_ = existingNonFields[+isStatic][name];
+				if (_ && (_ ^ kind) !== 7) throw new Error("Decorating two elements with the same name (" + desc1[key].name + ") is not supported yet");
+				existingNonFields[+isStatic][name] = kind < 3 ? 1 : kind;
+			}
+		}
+		var newValue = Class;
+		for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {
+			var dec = assertCallable(decs[i], "A decorator", "be", true);
+			var decThis = decoratorsHaveThis ? decs[i - 1] : void 0;
+			var decoratorFinishedRef = {};
+			var ctx = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][kind],
+				name,
+				metadata,
+				addInitializer: (function(decoratorFinishedRef, initializer) {
+					if (decoratorFinishedRef.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					assertCallable(initializer, "An initializer", "be", true);
+					initializers.push(initializer);
+				}).bind(null, decoratorFinishedRef)
+			};
+			if (isClass) {
+				_ = dec.call(decThis, newValue, ctx);
+				decoratorFinishedRef.v = 1;
+				if (assertCallable(_, "class decorators", "return")) newValue = _;
+				continue;
+			}
+			ctx.static = isStatic;
+			ctx.private = isPrivate;
+			_ = ctx.access = { has: isPrivate ? hasPrivateBrand.bind() : function(target) {
+				return name in target;
+			} };
+			if (!isSetter) _.get = isPrivate ? isMethod ? function(_this) {
+				assertInstanceIfPrivate(_this);
+				return desc1.value;
+			} : bindPropCall("get", 0, assertInstanceIfPrivate) : function(target) {
+				return target[name];
+			};
+			if (!isMethod && !isGetter) _.set = isPrivate ? bindPropCall("set", 0, assertInstanceIfPrivate) : function(target, value) {
+				target[name] = value;
+			};
+			newValue = dec.call(decThis, isAccessor ? {
+				get: desc1.get,
+				set: desc1.set
+			} : desc1[key], ctx);
+			decoratorFinishedRef.v = 1;
+			if (isAccessor) {
+				if (typeof newValue === "object" && newValue) {
+					if (_ = assertCallable(newValue.get, "accessor.get")) desc1.get = _;
+					if (_ = assertCallable(newValue.set, "accessor.set")) desc1.set = _;
+					if (_ = assertCallable(newValue.init, "accessor.init")) init.unshift(_);
+				} else if (newValue !== void 0) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) if (isField) init.unshift(newValue);
+			else desc1[key] = newValue;
+		}
+		if (kind < 2) ret.push(createRunInitializers(init, isStatic, 1), createRunInitializers(initializers, isStatic, 0));
+		if (!isField && !isClass) if (isPrivate) if (isAccessor) ret.splice(-1, 0, bindPropCall("get", isStatic), bindPropCall("set", isStatic));
+		else ret.push(isMethod ? desc1[key] : assertCallable.call.bind(desc1[key]));
+		else defineProperty(Class, name, desc1);
+		return newValue;
+	}
+	function applyMemberDecs() {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var pushInitializers = function(initializers) {
+			if (initializers) ret.push(createRunInitializers(initializers));
+		};
+		var applyMemberDecsOfKind = function(isStatic, isField) {
+			for (var i = 0; i < memberDecs.length; i++) {
+				var decInfo = memberDecs[i];
+				var kind = decInfo[1];
+				var kindOnly = kind & 7;
+				if ((kind & 8) == isStatic && !kindOnly == isField) {
+					var name = decInfo[2];
+					var isPrivate = !!decInfo[3];
+					var decoratorsHaveThis = kind & 16;
+					applyDec(isStatic ? targetClass : targetClass.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : toPropertyKey(name), kindOnly, kindOnly < 2 ? [] : isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, !!isStatic, isPrivate, isField, isStatic && isPrivate ? function(_) {
+						return checkInRHS(_) === targetClass;
+					} : instanceBrand);
+				}
+			}
+		};
+		applyMemberDecsOfKind(8, 0);
+		applyMemberDecsOfKind(0, 0);
+		applyMemberDecsOfKind(8, 1);
+		applyMemberDecsOfKind(0, 1);
+		pushInitializers(protoInitializers);
+		pushInitializers(staticInitializers);
+		return ret;
+	}
+	function defineMetadata(Class) {
+		return defineProperty(Class, symbolMetadata, {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	if (parentClass !== void 0) metadata = parentClass[symbolMetadata];
+	metadata = create(metadata == null ? null : metadata);
+	_ = applyMemberDecs();
+	if (!hasClassDecs) defineMetadata(targetClass);
+	return {
+		e: _,
+		get c() {
+			var initializers = [];
+			return hasClassDecs && [defineMetadata(targetClass = applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, initializers)), createRunInitializers(initializers, 1)];
+		}
+	};
+}
+let _dec, _initClass;
+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, jitiBaseDir) {
+	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(fs, startDir) {
+	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, fs, startDir),
+		warnings,
+		configPath
+	};
+}
+_dec = injectable([inject(CliFsToken)]);
+let _ConfigLoaderAdapterImpl;
+(class {
+	fs;
+	static {
+		({c: [_ConfigLoaderAdapterImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(fs) {
+		this.fs = fs;
+	}
+	async loadConfig(startDir) {
+		const cacheKey = path.resolve(startDir);
+		if (!cachedLoads.has(cacheKey)) cachedLoads.set(cacheKey, loadOnce(this.fs, cacheKey));
+		const cached = cachedLoads.get(cacheKey);
+		if (cached === void 0) throw new Error("config loader cache invariant violated");
+		return cached;
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _ConfigLoaderAdapterImpl as ConfigLoaderAdapterImpl };

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region src/lib/config/infra/config-schema.adapter.ts
+//#region src/lib/config/infrastructure/config-schema.adapter.ts
 const hookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
 const mirrorConfigSchema = z.object({
 	skipPackages: z.array(z.string()).optional(),
@@ -22,4 +22,4 @@ const codefastConfigSchema = z.object({
 	arrange: codefastArrangeConfigSchema.optional()
 }).strict();
 //#endregion
-export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema };
+export { codefastConfigSchema };

package/dist/lib/{arrange/presentation/present-analyze-report.presenter.mjs → config/infrastructure/config-warning-reporter.adapter.mjs}

@@ -1,7 +1,6 @@
-import { CliLoggerToken } from "../../core/operational/contracts/tokens.mjs";
-import { presentAnalyzeCliReport } from "./present-analyze-cli.presenter.mjs";
+import { CliLoggerToken } from "../../core/contracts/tokens.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/arrange/presentation/present-analyze-report.presenter.ts
+//#region src/lib/config/infrastructure/config-warning-reporter.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -212,22 +211,24 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
+const YELLOW = "\x1B[33m";
+const RESET = "\x1B[0m";
 _dec = injectable([inject(CliLoggerToken)]);
-let _PresentAnalyzeReportPresenterImpl;
+let _ConfigWarningReporterAdapter;
 (class {
 	logger;
 	static {
-		({c: [_PresentAnalyzeReportPresenterImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_ConfigWarningReporterAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
 	constructor(logger) {
 		this.logger = logger;
 	}
-	present(resolvedTargetPath, report) {
-		presentAnalyzeCliReport(this.logger, resolvedTargetPath, report);
+	reportSchemaWarnings(warnings) {
+		for (const warningMessage of warnings) this.logger.out(`${YELLOW}⚠ ${warningMessage}${RESET}`);
 	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _PresentAnalyzeReportPresenterImpl as PresentAnalyzeReportPresenterImpl };
+export { _ConfigWarningReporterAdapter as ConfigWarningReporterAdapter };

package/dist/lib/core/{presentation/try-load-codefast-config.presenter.mjs → application/load-codefast-config.use-case.mjs}

@@ -1,8 +1,10 @@
-import { CliFsToken, CliLoggerToken } from "../operational/contracts/tokens.mjs";
-import { ConfigLoaderPortToken } from "../../config/contracts/tokens.mjs";
-import { tryLoadCodefastConfig } from "./load-codefast-config.presenter.mjs";
+import { AppError } from "../domain/errors.domain.mjs";
+import { err, ok } from "../domain/result.model.mjs";
+import { messageFromCaughtUnknown } from "../domain/caught-unknown-message.value-object.mjs";
+import { ConfigLoaderPortToken, ConfigWarningReporterPortToken } from "../../config/contracts/tokens.mjs";
+import { loadCodefastConfig } from "../../config/application/services/load-config.service.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/core/presentation/try-load-codefast-config.presenter.ts
+//#region src/lib/core/application/load-codefast-config.use-case.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -213,33 +215,31 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-_dec = injectable([
-	inject(CliFsToken),
-	inject(CliLoggerToken),
-	inject(ConfigLoaderPortToken)
-]);
-let _TryLoadCodefastConfigPresenterImpl;
+_dec = injectable([inject(ConfigLoaderPortToken), inject(ConfigWarningReporterPortToken)]);
+let _LoadCodefastConfigUseCaseImpl;
 (class {
-	fs;
-	logger;
 	configLoader;
+	warningReporter;
 	static {
-		({c: [_TryLoadCodefastConfigPresenterImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_LoadCodefastConfigUseCaseImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(fs, logger, configLoader) {
-		this.fs = fs;
-		this.logger = logger;
+	constructor(configLoader, warningReporter) {
 		this.configLoader = configLoader;
+		this.warningReporter = warningReporter;
 	}
-	execute(rootDir) {
-		return tryLoadCodefastConfig({
-			fs: this.fs,
-			logger: this.logger
-		}, this.configLoader, rootDir);
+	async execute(rootDir) {
+		try {
+			const loadedConfig = await loadCodefastConfig(this.configLoader, rootDir);
+			if (!loadedConfig.ok) return loadedConfig;
+			this.warningReporter.reportSchemaWarnings(loadedConfig.value.warnings);
+			return ok({ config: loadedConfig.value.config });
+		} catch (caughtError) {
+			return err(new AppError("INFRA_FAILURE", messageFromCaughtUnknown(caughtError), caughtError));
+		}
 	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _TryLoadCodefastConfigPresenterImpl as TryLoadCodefastConfigPresenterImpl };
+export { _LoadCodefastConfigUseCaseImpl as LoadCodefastConfigUseCaseImpl };

package/dist/lib/core/{presentation/global-cli-options.presenter.mjs → application/services/global-cli-options-parser.service.mjs}

@@ -1,9 +1,9 @@
-import { parseWithSchema } from "../application/schema-parse.util.mjs";
+import { parseWithSchema } from "./schema-validator.service.mjs";
 import { z } from "zod";
-//#region src/lib/core/presentation/global-cli-options.presenter.ts
+//#region src/lib/core/application/services/global-cli-options-parser.service.ts
 const globalCliOptionsSchema = z.object({ color: z.boolean().optional() });
 function parseGlobalCliOptions(raw) {
 	return parseWithSchema(globalCliOptionsSchema, raw);
 }
 //#endregion
-export { globalCliOptionsSchema, parseGlobalCliOptions };
+export { parseGlobalCliOptions };

package/dist/lib/core/application/services/schema-validator.service.mjs

@@ -0,0 +1,17 @@
+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
+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) {
+	const parsed = schema.safeParse(input);
+	if (!parsed.success) return err(new AppError("VALIDATION_ERROR", formatSchemaIssues(parsed.error.issues)));
+	return ok(parsed.data);
+}
+//#endregion
+export { parseWithSchema };

package/dist/lib/core/contracts/tokens.mjs

@@ -1,5 +1,10 @@
 import { token } from "@codefast/di";
 //#region src/lib/core/contracts/tokens.ts
-const TryLoadCodefastConfigPresenterToken = token("TryLoadCodefastConfigPresenter");
+const CliFsToken = token("CliFs");
+const CliLoggerToken = token("CliLogger");
+const CliPathToken = token("CliPath");
+const RepoRootResolverPortToken = token("RepoRootResolverPort");
+const CliRuntimeToken = token("CliRuntime");
+const LoadCodefastConfigUseCaseToken = token("LoadCodefastConfigUseCase");
 //#endregion
-export { TryLoadCodefastConfigPresenterToken };
+export { CliFsToken, CliLoggerToken, CliPathToken, CliRuntimeToken, LoadCodefastConfigUseCaseToken, RepoRootResolverPortToken };

package/dist/lib/core/core.module.mjs

@@ -1,9 +1,9 @@
-import { CliPathToken } from "./operational/contracts/tokens.mjs";
-import { nodeCliPath } from "./infra/path.adapter.mjs";
+import { CliPathToken } from "./contracts/tokens.mjs";
+import { NodeCliPathAdapter as _NodeCliPathAdapter } from "./infrastructure/path.adapter.mjs";
 import { Module } from "@codefast/di";
 //#region src/lib/core/core.module.ts
 const CoreModule = Module.create("cli-core", (moduleBuilder) => {
-	moduleBuilder.bind(CliPathToken).toConstantValue(nodeCliPath);
+	moduleBuilder.bind(CliPathToken).to(_NodeCliPathAdapter).singleton();
 });
 //#endregion
 export { CoreModule };

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

@@ -1,4 +1,4 @@
-//#region src/lib/core/application/utils/caught-unknown-message.util.ts
+//#region src/lib/core/domain/caught-unknown-message.value-object.ts
 /**
 * Stable, user-facing text for values caught as `unknown`.
 * Avoids `String(unknown)` / `[object Object]` and satisfies strict `no-base-to-string`.

package/dist/lib/core/domain/errors.domain.mjs

@@ -1,16 +1,17 @@
 //#region src/lib/core/domain/errors.domain.ts
 /**
 * Cross-context application errors for Result-based use cases (CLI orchestration).
-*/ function appError(code, message, cause) {
-	if (cause === void 0) return {
-		code,
-		message
-	};
-	return {
-		code,
-		message,
-		cause
-	};
-}
+* Does not extend the global `Error` type — instances are carried in `Result` values, not thrown.
+*/ 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;
+	}
+};
 //#endregion
-export { appError };
+export { AppError };

package/dist/lib/core/domain/result.model.mjs

@@ -13,11 +13,5 @@ function err(error) {
 		error
 	};
 }
-function isOk(result) {
-	return result.ok === true;
-}
-function isErr(result) {
-	return result.ok === false;
-}
 //#endregion
-export { err, isErr, isOk, ok };
+export { err, ok };

package/dist/lib/core/infrastructure/infrastructure.module.mjs

@@ -0,0 +1,30 @@
+import { CliFsToken, CliLoggerToken, CliRuntimeToken, LoadCodefastConfigUseCaseToken, RepoRootResolverPortToken } from "../contracts/tokens.mjs";
+import { ConfigLoaderPortToken, ConfigWarningReporterPortToken } from "../../config/contracts/tokens.mjs";
+import { ConfigLoaderAdapterImpl as _ConfigLoaderAdapterImpl } from "../../config/infrastructure/config-loader.adapter.mjs";
+import { ConfigWarningReporterAdapter as _ConfigWarningReporterAdapter } from "../../config/infrastructure/config-warning-reporter.adapter.mjs";
+import { LoadCodefastConfigUseCaseImpl as _LoadCodefastConfigUseCaseImpl } from "../application/load-codefast-config.use-case.mjs";
+import { CoreModule } from "../core.module.mjs";
+import { isCliTelemetryEnabled, withCliPortTelemetry } from "./port-telemetry.decorator.mjs";
+import { RepoRootResolverAdapter as _RepoRootResolverAdapter } from "./repo-root-resolver.adapter.mjs";
+import { NodeCliFsAdapter as _NodeCliFsAdapter, NodeCliLoggerAdapter as _NodeCliLoggerAdapter, NodeCliRuntimeAdapter as _NodeCliRuntimeAdapter } from "../../infrastructure/node-io.adapter.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/core/infrastructure/infrastructure.module.ts
+const InfrastructureModule = Module.create("cli-infrastructure", (moduleBuilder) => {
+	moduleBuilder.import(CoreModule);
+	moduleBuilder.bind(CliLoggerToken).to(_NodeCliLoggerAdapter).singleton();
+	moduleBuilder.bind(CliRuntimeToken).to(_NodeCliRuntimeAdapter).singleton();
+	moduleBuilder.bind(RepoRootResolverPortToken).to(_RepoRootResolverAdapter).singleton();
+	moduleBuilder.bind(CliFsToken).to(_NodeCliFsAdapter).singleton().onActivation((ctx, rawFs) => {
+		if (!isCliTelemetryEnabled()) return rawFs;
+		return withCliPortTelemetry({
+			portName: "CliFs",
+			implementation: rawFs,
+			logger: ctx.resolve(CliLoggerToken)
+		});
+	});
+	moduleBuilder.bind(ConfigLoaderPortToken).to(_ConfigLoaderAdapterImpl).singleton();
+	moduleBuilder.bind(ConfigWarningReporterPortToken).to(_ConfigWarningReporterAdapter).singleton();
+	moduleBuilder.bind(LoadCodefastConfigUseCaseToken).to(_LoadCodefastConfigUseCaseImpl).singleton();
+});
+//#endregion
+export { InfrastructureModule };