@codefast/cli 0.3.14-canary.2 → 0.3.15

package/dist/shell/infrastructure/adapters/typescript-source-file-walker.adapter.mjs

@@ -0,0 +1,259 @@
+import { CliFilesystemPortToken } from "../../application/cli-runtime.tokens.mjs";
+import path from "node:path";
+import { inject, injectable } from "@codefast/di";
+//#region src/shell/infrastructure/adapters/typescript-source-file-walker.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;
+_dec = injectable([inject(CliFilesystemPortToken)]);
+let _TypeScriptSourceFileWalkerAdapter;
+(class {
+	fs;
+	static {
+		({c: [_TypeScriptSourceFileWalkerAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(fs) {
+		this.fs = fs;
+	}
+	defaultSkipDirectoryNames = new Set([
+		"node_modules",
+		"dist",
+		".git",
+		".turbo",
+		".next",
+		".cache",
+		"out",
+		"build",
+		"coverage",
+		".vercel",
+		".output"
+	]);
+	walkTsxFiles(rootDirectoryPath) {
+		const result = [];
+		this.visitTsxPaths(result, rootDirectoryPath);
+		return result;
+	}
+	visitTsxPaths(result, entryPath) {
+		if (this.fs.statSync(entryPath).isDirectory()) {
+			for (const childName of this.fs.readdirSync(entryPath)) {
+				if (this.defaultSkipDirectoryNames.has(childName)) continue;
+				this.visitTsxPaths(result, path.join(entryPath, childName));
+			}
+			return;
+		}
+		if (entryPath.endsWith(".d.ts")) return;
+		if (entryPath.endsWith(".tsx") || entryPath.endsWith(".ts")) result.push(entryPath);
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _TypeScriptSourceFileWalkerAdapter as TypeScriptSourceFileWalkerAdapter };

package/dist/shell/infrastructure/commander/commander-cli-host.adapter.mjs

@@ -0,0 +1,69 @@
+import { Command, Option } from "commander";
+//#region src/shell/infrastructure/commander/commander-cli-host.adapter.ts
+/** Traverses {@link CommandTree} onto a Commander {@link Command} node. */ var CommanderCliHostAdapter = class CommanderCliHostAdapter {
+	rootProgram;
+	constructor(rootProgram) {
+		this.rootProgram = rootProgram;
+	}
+	/** Attaches every top-level CLI root command subtree under one program root. */ static registerTrees(programRoot, trees) {
+		const adapter = new CommanderCliHostAdapter(programRoot);
+		for (const subtree of trees) adapter.registerRoot(subtree);
+	}
+	static isLikelyPlainOptionsRecord(candidate) {
+		return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+	}
+	static extractDispatchParts(args) {
+		if (args.length < 2) throw new Error("[internal] Commander action invoked with too few arguments");
+		const commandLeafCandidate = args[args.length - 1];
+		if (!(commandLeafCandidate instanceof Command)) throw new Error("[internal] Commander action trailing argument must be Command");
+		const candidateOptions = args[args.length - 2];
+		return {
+			positionalArguments: typeof candidateOptions !== "undefined" && CommanderCliHostAdapter.isLikelyPlainOptionsRecord(candidateOptions) ? args.slice(0, -2) : args.slice(0, -1),
+			localOptionRecord: CommanderCliHostAdapter.isLikelyPlainOptionsRecord(candidateOptions) ? candidateOptions : {},
+			commandLeaf: commandLeafCandidate
+		};
+	}
+	static applyRouteWire(leafCommand, wire) {
+		switch (wire.kind) {
+			case "optionalPositional": return leafCommand.argument(wire.argumentTemplate, wire.helpBlurb);
+			case "greedyPositional": return leafCommand.argument(wire.argumentTemplate, wire.helpBlurb);
+			case "booleanFlag": return leafCommand.option(wire.flagPhrase, wire.helpBlurb, wire.whenUnsetUses);
+			case "stringPlaceholderFlag": return leafCommand.option(wire.flagPhraseWithPlaceholder, wire.helpBlurb);
+			case "synonymousBooleanAliases": return leafCommand.addOption(new Option(wire.commaJoinedFlags, wire.helpBlurb).default(false));
+		}
+	}
+	static wireLeafDispatch(leafCommand, dispatch) {
+		leafCommand.action(async (...passedArguments) => {
+			const { positionalArguments, localOptionRecord, commandLeaf } = CommanderCliHostAdapter.extractDispatchParts(passedArguments);
+			await dispatch(positionalArguments, localOptionRecord, { readMergedGlobalsOptionRecords: () => {
+				const bridgeCommand = commandLeaf;
+				const mergedViaGlobalsBridge = bridgeCommand.optsWithGlobals?.();
+				if (mergedViaGlobalsBridge) return mergedViaGlobalsBridge;
+				return bridgeCommand.opts();
+			} });
+		});
+	}
+	static attachSubtree(parentBridge, node) {
+		let branchCommand = parentBridge.command(node.name).description(node.description);
+		if (node.aliases !== void 0) for (const aliasPiece of node.aliases) branchCommand = branchCommand.alias(aliasPiece);
+		const childBranchCount = node.children?.length ?? 0;
+		const hasLeafDispatcher = typeof node.action !== "undefined";
+		if (childBranchCount > 0 && hasLeafDispatcher) throw new Error(`[cli] Command "${node.name}" cannot combine children with a leaf action dispatch`);
+		if (childBranchCount > 0) {
+			for (const nestedChild of node.children) CommanderCliHostAdapter.attachSubtree(branchCommand, nestedChild);
+			return;
+		}
+		if (hasLeafDispatcher) {
+			let leafConfigured = branchCommand;
+			const routePieces = node.route ?? [];
+			for (const segment of routePieces) leafConfigured = CommanderCliHostAdapter.applyRouteWire(leafConfigured, segment);
+			CommanderCliHostAdapter.wireLeafDispatch(leafConfigured, node.action);
+			return;
+		}
+	}
+	registerRoot(treeRoot) {
+		CommanderCliHostAdapter.attachSubtree(this.rootProgram, treeRoot);
+	}
+};
+//#endregion
+export { CommanderCliHostAdapter };

package/dist/{lib/infrastructure/node-io.adapter.mjs → shell/infrastructure/node/node-cli-fs.adapter.mjs}

@@ -1,9 +1,8 @@
-import process from "node:process";
 import fsSync from "node:fs";
 import path from "node:path";
 import { injectable } from "@codefast/di";
 import fsPromises from "node:fs/promises";
-//#region src/lib/infrastructure/node-io.adapter.ts
+//#region src/shell/infrastructure/node/node-cli-fs.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -213,14 +212,7 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 		}
 	};
 }
-let _dec, _initClass, _dec1, _initClass1, _dec2, _initClass2;
-function canonicalPathSyncNode(inputPath) {
-	try {
-		return fsSync.realpathSync.native(inputPath);
-	} catch {
-		return path.resolve(inputPath);
-	}
-}
+let _dec, _initClass;
 _dec = injectable([]);
 let _NodeCliFsAdapter;
 (class {
@@ -228,11 +220,11 @@ let _NodeCliFsAdapter;
 		({c: [_NodeCliFsAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
 	existsSync = fsSync.existsSync;
-	canonicalPathSync = canonicalPathSyncNode;
 	statSync = fsSync.statSync;
 	readFileSync = fsSync.readFileSync;
 	writeFileSync = fsSync.writeFileSync;
 	readdirSync = fsSync.readdirSync;
+	canonicalPathSync = (inputPath) => this.canonicalPathSyncNode(inputPath);
 	readFile = (p, enc) => fsPromises.readFile(p, enc);
 	writeFile = (p, data, enc) => fsPromises.writeFile(p, data, enc);
 	readdir = async (p, opts) => {
@@ -242,44 +234,16 @@ let _NodeCliFsAdapter;
 	};
 	rename = (oldPath, newPath) => fsPromises.rename(oldPath, newPath);
 	unlink = (p) => fsPromises.unlink(p);
-	static {
-		_initClass();
-	}
-});
-_dec1 = injectable([]);
-let _NodeCliLoggerAdapter;
-(class {
-	static {
-		({c: [_NodeCliLoggerAdapter, _initClass1]} = _apply_decs_2311(this, [_dec1], []));
-	}
-	out(line) {
-		process.stdout.write(`${line}\n`);
-	}
-	err(line) {
-		process.stderr.write(`${line}\n`);
-	}
-	static {
-		_initClass1();
-	}
-});
-_dec2 = injectable([]);
-let _NodeCliRuntimeAdapter;
-(class {
-	static {
-		({c: [_NodeCliRuntimeAdapter, _initClass2]} = _apply_decs_2311(this, [_dec2], []));
-	}
-	cwd() {
-		return process.cwd();
-	}
-	setExitCode(code) {
-		process.exitCode = code;
-	}
-	isStdoutTty() {
-		return !!process.stdout.isTTY;
+	canonicalPathSyncNode(inputPath) {
+		try {
+			return fsSync.realpathSync.native(inputPath);
+		} catch {
+			return path.resolve(inputPath);
+		}
 	}
 	static {
-		_initClass2();
+		_initClass();
 	}
 });
 //#endregion
-export { _NodeCliFsAdapter as NodeCliFsAdapter, _NodeCliLoggerAdapter as NodeCliLoggerAdapter, _NodeCliRuntimeAdapter as NodeCliRuntimeAdapter };
+export { _NodeCliFsAdapter as NodeCliFsAdapter };

package/dist/{lib/arrange/adapters/secondary/workspace-resolver.adapter.mjs → shell/infrastructure/node/node-cli-logger.adapter.mjs}

@@ -1,7 +1,6 @@
-import { CliFsToken } from "../../../core/contracts/tokens.mjs";
-import { findRepoRoot } from "../../../infrastructure/workspace/repo-root-resolver.service.mjs";
-import { inject, injectable } from "@codefast/di";
-//#region src/lib/arrange/adapters/secondary/workspace-resolver.adapter.ts
+import process from "node:process";
+import { injectable } from "@codefast/di";
+//#region src/shell/infrastructure/node/node-cli-logger.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -212,22 +211,21 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-_dec = injectable([inject(CliFsToken)]);
-let _WorkspaceResolverAdapter;
+_dec = injectable([]);
+let _NodeCliLoggerAdapter;
 (class {
-	fs;
 	static {
-		({c: [_WorkspaceResolverAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_NodeCliLoggerAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(fs) {
-		this.fs = fs;
+	out(line) {
+		process.stdout.write(`${line}\n`);
 	}
-	findRepoRoot(fromDirectory) {
-		return findRepoRoot(this.fs, fromDirectory);
+	err(line) {
+		process.stderr.write(`${line}\n`);
 	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _WorkspaceResolverAdapter as WorkspaceResolverAdapter };
+export { _NodeCliLoggerAdapter as NodeCliLoggerAdapter };

package/dist/{lib/core/infrastructure/path.adapter.mjs → shell/infrastructure/node/node-cli-path.adapter.mjs}

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { injectable } from "@codefast/di";
-//#region src/lib/core/infrastructure/path.adapter.ts
+//#region src/shell/infrastructure/node/node-cli-path.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];

package/dist/{lib/core/infrastructure/repo-root-resolver.adapter.mjs → shell/infrastructure/node/node-cli-runtime.adapter.mjs}

@@ -1,7 +1,6 @@
-import { CliFsToken } from "../contracts/tokens.mjs";
-import { findRepoRoot } from "../../infrastructure/workspace/repo-root-resolver.service.mjs";
-import { inject, injectable } from "@codefast/di";
-//#region src/lib/core/infrastructure/repo-root-resolver.adapter.ts
+import process from "node:process";
+import { injectable } from "@codefast/di";
+//#region src/shell/infrastructure/node/node-cli-runtime.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;
-_dec = injectable([inject(CliFsToken)]);
-let _RepoRootResolverAdapter;
+_dec = injectable([]);
+let _NodeCliRuntimeAdapter;
 (class {
-	fs;
 	static {
-		({c: [_RepoRootResolverAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_NodeCliRuntimeAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(fs) {
-		this.fs = fs;
+	cwd() {
+		return process.cwd();
 	}
-	findRepoRoot(fromDirectory) {
-		return findRepoRoot(this.fs, fromDirectory);
+	setExitCode(code) {
+		process.exitCode = code;
+	}
+	isStdoutTty() {
+		return !!process.stdout.isTTY;
 	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _RepoRootResolverAdapter as RepoRootResolverAdapter };
+export { _NodeCliRuntimeAdapter as NodeCliRuntimeAdapter };