@codefast/cli 0.3.14 → 0.3.16-canary.0

package/dist/arrange/output.mjs

@@ -0,0 +1,79 @@
+import { logger } from "../core/logger.mjs";
+import "./domain/constants.mjs";
+import { lineOf } from "./domain/ast/helpers.mjs";
+import path from "node:path";
+//#region src/arrange/output.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function printAnalyzeReport(resolvedTargetPath, report) {
+	logger.out(`Path: ${path.resolve(resolvedTargetPath)}`);
+	logger.out(`.ts/.tsx files: ${report.files}`);
+	logger.out(`cn(...) call sites: ${report.cnCallExpressions}`);
+	logger.out(`tv(...) call sites: ${report.tvCallExpressions}`);
+	logger.out(`\nLong cn(...) string literals (≥18 tokens — consider splitting arguments): ${report.longCnStringLiterals.length}`);
+	for (const findingEntry of report.longCnStringLiterals.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (report.longCnStringLiterals.length > 40) logger.out(`  … and ${report.longCnStringLiterals.length - 40} more`);
+	logger.out(`\nLong tv({...}) string literals in base/variants/… (≥18 tokens): ${report.longTvStringLiterals.length}`);
+	for (const findingEntry of report.longTvStringLiterals.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (report.longTvStringLiterals.length > 40) logger.out(`  … and ${report.longTvStringLiterals.length - 40} more`);
+	logger.out(`\nJSX className="..." or className={'...'} (static strings, ≥18 tokens): ${report.longJsxClassNameLiterals.length}`);
+	for (const findingEntry of report.longJsxClassNameLiterals.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (report.longJsxClassNameLiterals.length > 40) logger.out(`  … and ${report.longJsxClassNameLiterals.length - 40} more`);
+	logger.out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${report.cnInsideTvCalls.length}`);
+	for (const findingEntry of report.cnInsideTvCalls.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.argCount} args)  ${findingEntry.preview}`);
+	if (report.cnInsideTvCalls.length > 40) logger.out(`  … and ${report.cnInsideTvCalls.length - 40} more`);
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function printSyncResult(result, write) {
+	logger.out(`\nTotal: ${result.filePaths.length} file(s), ${result.totalFound} site(s) (cn/tv/JSX className) to review.`);
+	if (write) logger.out(`Applied: ${result.totalChanged} site(s) updated.`);
+	else logger.out(`(Run "apply" to write changes, or "pnpm cli:arrange-apply" / "pnpm exec codefast arrange apply")`);
+	if (write ? result.totalChanged > 0 : result.totalFound > 0) logger.out("Note: class order may change across concern groups — smoke-test the UI if you rely on cascade order.");
+	if (result.hookError !== null) logger.err(result.hookError);
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function printGroupFilePreviewFromWork(work) {
+	printGroupFilePreviewBody({
+		filePath: work.filePath,
+		reportTotal: work.reportTotal,
+		cnInTvNoReplacement: work.cnInTvNoReplacement,
+		cnInTvCalls: work.cnInTvCalls,
+		unwrapReplacementByCall: work.unwrapReplacementByCall,
+		sourceText: work.sourceText,
+		domainSf: work.domainSfForLineNumbers,
+		unwrapEdits: work.unwrapEdits,
+		plannedGroupEdits: work.plannedGroupEdits
+	});
+}
+function printGroupFilePreviewBody(args) {
+	const { filePath, reportTotal, cnInTvNoReplacement, cnInTvCalls, unwrapReplacementByCall, sourceText, domainSf, unwrapEdits, plannedGroupEdits } = args;
+	let header = `\n── ${filePath} (${reportTotal} site(s)`;
+	if (cnInTvNoReplacement > 0) header += `; plus ${cnInTvNoReplacement} cn() inside tv left unchanged (0 args)`;
+	header += `) ──`;
+	logger.out(header);
+	for (const call of cnInTvCalls) {
+		const replacement = unwrapReplacementByCall.get(call);
+		if (replacement === void 0) {
+			logger.out(`  Line ${lineOf(domainSf, call)} [tv ⊃ cn]: cn(...) has no arguments — skipped`);
+			continue;
+		}
+		const start = call.pos;
+		const end = call.end;
+		if (sourceText.slice(start, end) === replacement) continue;
+		logger.out(`  Line ${lineOf(domainSf, call)} [tv ⊃ cn → string/array]:`);
+		logger.out(`  ${replacement.split("\n").join("\n  ")}`);
+	}
+	if (unwrapEdits.length > 0 && plannedGroupEdits.length > 0) logger.out("  ([cn] / [tv] / [JSX className] lines below reflect content after unwrap of cn inside tv.)");
+	for (const plan of plannedGroupEdits) {
+		logger.out(`  Line ${lineOf(plan.lineSf, plan.reportNode)} [${plan.label}]:`);
+		logger.out(`  ${plan.replacement.split("\n").join("\n  ")}`);
+		logger.out(`  // Buckets: ${JSON.stringify(plan.bucketSummary)}`);
+	}
+}
+//#endregion
+export { printAnalyzeReport, printGroupFilePreviewFromWork, printSyncResult };

package/dist/arrange/process-file.mjs

@@ -0,0 +1,42 @@
+import { parseDomainSourceFile } from "./source-parse.mjs";
+import { buildGroupFileUnwrapState, countPersistedGroupFileEdits, groupFileDryRunNoEdits, groupFileEditsTouchJsxCn, groupFilePreviewTotals, groupFileWorkHasNothingToReport, mergeGroupFileBodyText, tryBuildGroupFileWorkPlan } from "./domain/grouping-service.mjs";
+import { ensureCnImport } from "./domain/imports.mjs";
+//#region src/arrange/process-file.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function processArrangeGroupFile(fs, args) {
+	const { filePath, options } = args;
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	const domainSfInitial = parseDomainSourceFile(filePath, sourceText);
+	const unwrap = buildGroupFileUnwrapState(domainSfInitial, sourceText);
+	const work = tryBuildGroupFileWorkPlan({
+		filePath,
+		sourceText,
+		domainSfInitial,
+		domainSfGrouped: parseDomainSourceFile(filePath, unwrap.textAfterUnwrap),
+		withClassName: options.withClassName,
+		unwrap
+	});
+	if (work === null) return groupFileDryRunNoEdits(filePath);
+	if (!options.write) {
+		if (groupFileWorkHasNothingToReport(work)) return groupFileDryRunNoEdits(filePath);
+		return {
+			...groupFilePreviewTotals(work),
+			workPlan: work
+		};
+	}
+	const persistedEditCount = countPersistedGroupFileEdits(work);
+	let newText = mergeGroupFileBodyText(work);
+	if (persistedEditCount > 0) {
+		if (groupFileEditsTouchJsxCn(work)) newText = ensureCnImport(parseDomainSourceFile(filePath, newText), options.cnImport);
+		fs.writeFileSync(filePath, newText, "utf8");
+	}
+	return {
+		filePath,
+		totalFound: persistedEditCount + work.cnInTvNoReplacement,
+		changed: persistedEditCount
+	};
+}
+//#endregion
+export { processArrangeGroupFile };

package/dist/arrange/resolve-target.mjs

@@ -0,0 +1,24 @@
+import path from "node:path";
+//#region src/arrange/resolve-target.ts
+const packageJsonFileName = "package.json";
+/**
+* @since 0.3.16-canary.0
+*/
+function resolveArrangeTargetPath(fs, args) {
+	const explicitTargetPath = args.rawTarget ? path.isAbsolute(args.rawTarget) ? path.resolve(args.rawTarget) : path.resolve(args.currentWorkingDirectory, args.rawTarget) : void 0;
+	if (explicitTargetPath) return fs.canonicalPathSync(explicitTargetPath);
+	const resolvedDefaultTarget = findNearestPackageDirectory(fs, args.currentWorkingDirectory) ?? args.currentWorkingDirectory;
+	return fs.canonicalPathSync(resolvedDefaultTarget);
+}
+function findNearestPackageDirectory(fs, currentWorkingDirectory) {
+	let currentDir = path.resolve(currentWorkingDirectory);
+	while (true) {
+		const packageJsonPath = path.join(currentDir, packageJsonFileName);
+		if (fs.existsSync(packageJsonPath)) return currentDir;
+		const parentDirectory = path.dirname(currentDir);
+		if (parentDirectory === currentDir) return;
+		currentDir = parentDirectory;
+	}
+}
+//#endregion
+export { resolveArrangeTargetPath };

package/dist/arrange/scan-target.mjs

@@ -0,0 +1,20 @@
+import { messageFrom } from "../core/errors.mjs";
+import { logger } from "../core/logger.mjs";
+import { walkTsxFiles } from "../core/workspace/typescript-walk.mjs";
+import path from "node:path";
+//#region src/arrange/scan-target.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function scanArrangeTargets(fs, targetPath) {
+	const resolvedTargetPath = path.resolve(targetPath);
+	if (fs.statSync(resolvedTargetPath).isDirectory()) try {
+		return walkTsxFiles(resolvedTargetPath, fs);
+	} catch (caughtError) {
+		logger.err(`[file-walker] ${messageFrom(caughtError)}`);
+		throw caughtError;
+	}
+	return [resolvedTargetPath];
+}
+//#endregion
+export { scanArrangeTargets };

package/dist/arrange/source-parse.mjs

@@ -0,0 +1,18 @@
+import { messageFrom } from "../core/errors.mjs";
+import { logger } from "../core/logger.mjs";
+import { TypeScriptAstTranslator } from "./typescript-ast-translator.mjs";
+//#region src/arrange/source-parse.ts
+const translator = new TypeScriptAstTranslator();
+/**
+* @since 0.3.16-canary.0
+*/
+function parseDomainSourceFile(filePath, sourceText) {
+	try {
+		return translator.translateSourceFile(filePath, sourceText);
+	} catch (caughtError) {
+		logger.err(`[domain-source-parser] ${messageFrom(caughtError)}`);
+		throw caughtError;
+	}
+}
+//#endregion
+export { parseDomainSourceFile };

package/dist/arrange/suggest.mjs

@@ -0,0 +1,15 @@
+import { suggestCnGroups, summarizeGroupBucketLabels } from "./domain/grouping.mjs";
+import { formatArray, formatCnCall } from "./domain/source-text-formatters.mjs";
+//#region src/arrange/suggest.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function suggestCnGroupsFromCli(request) {
+	const groups = suggestCnGroups(request.inlineClasses);
+	return {
+		primaryLine: request.emitTvStyleArray ? formatArray(groups) : formatCnCall(groups, { trailingClassName: request.trailingClassName }),
+		bucketsCommentLine: `// Buckets: ${JSON.stringify(summarizeGroupBucketLabels(groups))}`
+	};
+}
+//#endregion
+export { suggestCnGroupsFromCli };

package/dist/arrange/sync.mjs

@@ -0,0 +1,51 @@
+import { messageFrom } from "../core/errors.mjs";
+import { ok } from "../core/result.mjs";
+import { scanArrangeTargets } from "./scan-target.mjs";
+import { processArrangeGroupFile } from "./process-file.mjs";
+//#region src/arrange/sync.ts
+async function runOnAfterWriteHook(hook, modifiedFiles) {
+	if (!hook || modifiedFiles.length === 0) return null;
+	try {
+		await hook({ files: modifiedFiles });
+		return null;
+	} catch (caughtHookError) {
+		return `[arrange] onAfterWrite hook failed: ${messageFrom(caughtHookError)}`;
+	}
+}
+/**
+* @since 0.3.16-canary.0
+*/
+async function runArrangeSync(fs, request) {
+	const filePaths = scanArrangeTargets(fs, request.targetPath);
+	const modifiedFiles = [];
+	const previewPlans = [];
+	let totalFound = 0;
+	let totalChanged = 0;
+	const groupOptions = {
+		write: request.write,
+		withClassName: !!request.withClassName,
+		cnImport: request.cnImport
+	};
+	for (const filePath of filePaths) {
+		const fileProcessResult = processArrangeGroupFile(fs, {
+			filePath,
+			options: groupOptions
+		});
+		totalFound += fileProcessResult.totalFound;
+		totalChanged += fileProcessResult.changed;
+		if (fileProcessResult.changed > 0) modifiedFiles.push(fileProcessResult.filePath);
+		if (fileProcessResult.workPlan) previewPlans.push(fileProcessResult.workPlan);
+	}
+	const arrangeConfig = request.config;
+	const hookError = request.write && modifiedFiles.length > 0 ? await runOnAfterWriteHook(arrangeConfig?.onAfterWrite, modifiedFiles) : null;
+	return ok({
+		filePaths,
+		modifiedFiles,
+		totalFound,
+		totalChanged,
+		hookError,
+		previewPlans
+	});
+}
+//#endregion
+export { runArrangeSync };

package/dist/arrange/typescript-ast-translator.mjs

@@ -0,0 +1,354 @@
+import "./domain/ast/ast-node.mjs";
+import ts from "typescript";
+//#region src/arrange/typescript-ast-translator.ts
+/**
+* Anti-corruption layer: maps TypeScript compiler AST to arrange domain AST.
+* This module is the only place that imports `typescript` for arrange AST translation.
+*/
+/**
+* @since 0.3.16-canary.0
+*/
+var TypeScriptAstTranslator = class {
+	translateSourceFile(filePath, sourceText) {
+		return this.parseDomainSourceFile(filePath, sourceText);
+	}
+	translateUnknown(n, parent, sf) {
+		const self = {
+			kind: 1,
+			pos: n.getStart(sf),
+			end: n.getEnd(),
+			parent,
+			children: []
+		};
+		const childList = [];
+		ts.forEachChild(n, (child) => {
+			childList.push(this.translateNode(child, self, sf));
+		});
+		return {
+			...self,
+			children: childList
+		};
+	}
+	mapBinaryOperator(operatorToken) {
+		if (operatorToken.kind === ts.SyntaxKind.PlusToken) return 0;
+		return 1;
+	}
+	translateNode(n, parent, sf) {
+		const pos = n.getStart(sf);
+		const end = n.getEnd();
+		switch (n.kind) {
+			case ts.SyntaxKind.Identifier: return {
+				kind: 2,
+				pos,
+				end,
+				parent,
+				text: n.text
+			};
+			case ts.SyntaxKind.StringLiteral: return {
+				kind: 3,
+				pos,
+				end,
+				parent,
+				text: n.text
+			};
+			case ts.SyntaxKind.NoSubstitutionTemplateLiteral: return {
+				kind: 4,
+				pos,
+				end,
+				parent,
+				text: n.text
+			};
+			case ts.SyntaxKind.ImportDeclaration: {
+				const decl = n;
+				const self = {
+					kind: 5,
+					pos,
+					end,
+					parent,
+					importClause: void 0,
+					moduleSpecifier: void 0
+				};
+				if (decl.importClause) self.importClause = this.translateNode(decl.importClause, self, sf);
+				self.moduleSpecifier = this.translateNode(decl.moduleSpecifier, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.ImportClause: {
+				const clause = n;
+				const self = {
+					kind: 6,
+					pos,
+					end,
+					parent,
+					isTypeOnly: clause.isTypeOnly,
+					name: void 0,
+					namedBindings: void 0
+				};
+				if (clause.name) self.name = this.translateNode(clause.name, self, sf);
+				if (clause.namedBindings) self.namedBindings = this.translateNode(clause.namedBindings, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.NamedImports: {
+				const named = n;
+				const self = {
+					kind: 7,
+					pos,
+					end,
+					parent,
+					elements: []
+				};
+				const elements = [];
+				for (const element of named.elements) elements.push(this.translateNode(element, self, sf));
+				return {
+					...self,
+					elements
+				};
+			}
+			case ts.SyntaxKind.NamespaceImport: {
+				const ns = n;
+				const self = {
+					kind: 8,
+					pos,
+					end,
+					parent,
+					name: void 0
+				};
+				self.name = this.translateNode(ns.name, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.ImportSpecifier: {
+				const spec = n;
+				const self = {
+					kind: 9,
+					pos,
+					end,
+					parent,
+					propertyName: void 0,
+					name: void 0
+				};
+				if (spec.propertyName) self.propertyName = this.translateNode(spec.propertyName, self, sf);
+				self.name = this.translateNode(spec.name, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.CallExpression: {
+				const call = n;
+				const self = {
+					kind: 10,
+					pos,
+					end,
+					parent,
+					expression: void 0,
+					arguments: []
+				};
+				self.expression = this.translateNode(call.expression, self, sf);
+				self.arguments = call.arguments.map((arg) => this.translateNode(arg, self, sf));
+				return self;
+			}
+			case ts.SyntaxKind.PropertyAccessExpression: {
+				const pa = n;
+				const self = {
+					kind: 11,
+					pos,
+					end,
+					parent,
+					expression: void 0,
+					name: void 0
+				};
+				self.expression = this.translateNode(pa.expression, self, sf);
+				self.name = this.translateNode(pa.name, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.ObjectLiteralExpression: {
+				const obj = n;
+				const self = {
+					kind: 12,
+					pos,
+					end,
+					parent,
+					properties: []
+				};
+				const properties = [];
+				for (const prop of obj.properties) properties.push(this.translateNode(prop, self, sf));
+				return {
+					...self,
+					properties
+				};
+			}
+			case ts.SyntaxKind.PropertyAssignment: {
+				const prop = n;
+				const self = {
+					kind: 13,
+					pos,
+					end,
+					parent,
+					name: void 0,
+					initializer: void 0
+				};
+				self.name = this.translateNode(prop.name, self, sf);
+				self.initializer = this.translateNode(prop.initializer, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.ArrayLiteralExpression: {
+				const arr = n;
+				const self = {
+					kind: 14,
+					pos,
+					end,
+					parent,
+					elements: []
+				};
+				const elements = [];
+				for (const element of arr.elements) elements.push(this.translateNode(element, self, sf));
+				return {
+					...self,
+					elements
+				};
+			}
+			case ts.SyntaxKind.SpreadElement: {
+				const sp = n;
+				const self = {
+					kind: 15,
+					pos,
+					end,
+					parent,
+					expression: void 0
+				};
+				self.expression = this.translateNode(sp.expression, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.ParenthesizedExpression: {
+				const pe = n;
+				const self = {
+					kind: 16,
+					pos,
+					end,
+					parent,
+					expression: void 0
+				};
+				self.expression = this.translateNode(pe.expression, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.AsExpression: {
+				const ae = n;
+				const self = {
+					kind: 17,
+					pos,
+					end,
+					parent,
+					expression: void 0
+				};
+				self.expression = this.translateNode(ae.expression, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.SatisfiesExpression: {
+				const se = n;
+				const self = {
+					kind: 18,
+					pos,
+					end,
+					parent,
+					expression: void 0
+				};
+				self.expression = this.translateNode(se.expression, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.NonNullExpression: {
+				const nn = n;
+				const self = {
+					kind: 19,
+					pos,
+					end,
+					parent,
+					expression: void 0
+				};
+				self.expression = this.translateNode(nn.expression, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.ConditionalExpression: {
+				const ce = n;
+				const self = {
+					kind: 20,
+					pos,
+					end,
+					parent,
+					condition: void 0,
+					whenTrue: void 0,
+					whenFalse: void 0
+				};
+				self.condition = this.translateNode(ce.condition, self, sf);
+				self.whenTrue = this.translateNode(ce.whenTrue, self, sf);
+				self.whenFalse = this.translateNode(ce.whenFalse, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.BinaryExpression: {
+				const be = n;
+				const self = {
+					kind: 21,
+					pos,
+					end,
+					parent,
+					left: void 0,
+					operator: this.mapBinaryOperator(be.operatorToken),
+					right: void 0
+				};
+				self.left = this.translateNode(be.left, self, sf);
+				self.right = this.translateNode(be.right, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.ExpressionStatement: {
+				const es = n;
+				const self = {
+					kind: 22,
+					pos,
+					end,
+					parent,
+					expression: void 0
+				};
+				self.expression = this.translateNode(es.expression, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.JsxAttribute: {
+				const ja = n;
+				const self = {
+					kind: 23,
+					pos,
+					end,
+					parent,
+					name: void 0,
+					initializer: void 0
+				};
+				self.name = this.translateNode(ja.name, self, sf);
+				if (ja.initializer) self.initializer = this.translateNode(ja.initializer, self, sf);
+				return self;
+			}
+			case ts.SyntaxKind.JsxExpression: {
+				const je = n;
+				const self = {
+					kind: 24,
+					pos,
+					end,
+					parent,
+					expression: void 0
+				};
+				if (je.expression) self.expression = this.translateNode(je.expression, self, sf);
+				return self;
+			}
+			default: return this.translateUnknown(n, parent, sf);
+		}
+	}
+	translateTypeScriptSourceFile(tsSf) {
+		const text = tsSf.getFullText();
+		const statements = tsSf.statements.map((statement) => this.translateNode(statement, null, tsSf));
+		return {
+			fileName: tsSf.fileName,
+			text,
+			statements
+		};
+	}
+	parseDomainSourceFile(filePath, sourceText) {
+		const scriptKind = filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+		const tsSf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, scriptKind);
+		return this.translateTypeScriptSourceFile(tsSf);
+	}
+};
+//#endregion
+export { TypeScriptAstTranslator };

package/dist/arrange/workspace.mjs

@@ -0,0 +1,31 @@
+import { AppError, messageFrom } from "../core/errors.mjs";
+import { err, ok } from "../core/result.mjs";
+import { loadCodefastConfig } from "../core/config.mjs";
+import { findRepoRoot } from "../core/workspace/resolver.mjs";
+import { resolveArrangeTargetPath } from "./resolve-target.mjs";
+//#region src/arrange/workspace.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function prepareArrangeWorkspace(fs, args) {
+	const resolvedTarget = resolveArrangeTargetPath(fs, {
+		currentWorkingDirectory: args.currentWorkingDirectory,
+		rawTarget: args.rawTarget
+	});
+	if (!fs.existsSync(resolvedTarget)) return err(new AppError("NOT_FOUND", `Not found: ${resolvedTarget}`));
+	let rootDir;
+	try {
+		rootDir = findRepoRoot(args.currentWorkingDirectory, fs);
+	} catch (caughtError) {
+		return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+	}
+	const loadedOutcome = await loadCodefastConfig(rootDir, fs);
+	if (!loadedOutcome.ok) return loadedOutcome;
+	return ok({
+		resolvedTarget,
+		rootDir,
+		config: loadedOutcome.value.config
+	});
+}
+//#endregion
+export { prepareArrangeWorkspace };

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from "./program.mjs";
+import { runCli } from "./cli.mjs";
 import process from "node:process";
 //#region src/bin.ts
 const code = await runCli(process.argv);