@expressots/cli 4.0.0-preview.2 → 4.0.0-preview.3

package/bin/templates/cli.js

@@ -11,6 +11,7 @@ exports.templatesCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const manager_1 = require("./manager");
 const config_1 = require("../config");
+const cli_ui_1 = require("../utils/cli-ui");
 const templatesCommand = () => {
     return {
         command: "templates <action> [args...]",
@@ -77,8 +78,9 @@ const templatesCommand = () => {
                     await showStatus();
                     break;
                 default:
-                    console.log(chalk_1.default.red(`Unknown action: ${action}`));
+                    (0, cli_ui_1.printError)(`Unknown action: ${action}`, "templates");
                     console.log(chalk_1.default.gray("Run 'expressots templates --help' for usage."));
+                    process.exit(1);
             }
         },
     };
@@ -88,7 +90,7 @@ exports.templatesCommand = templatesCommand;
  * List available templates
  */
 async function listTemplates(category, platform) {
-    console.log(chalk_1.default.cyan("\n📋 Available Templates\n"));
+    (0, cli_ui_1.printSection)("📋 Available Templates");
     const manager = (0, manager_1.getTemplateManager)();
     const templates = await manager.listTemplates();
     // Show template source
@@ -161,7 +163,7 @@ async function listTemplates(category, platform) {
  * Update template cache
  */
 async function updateTemplates() {
-    console.log(chalk_1.default.cyan("\n🔄 Updating Templates...\n"));
+    (0, cli_ui_1.printSection)("🔄 Updating Templates...");
     const manager = (0, manager_1.getTemplateManager)();
     const result = await manager.updateCache();
     if (result.updated > 0) {
@@ -182,7 +184,7 @@ async function updateTemplates() {
  * Clear template cache
  */
 async function clearCache() {
-    console.log(chalk_1.default.cyan("\n🗑️  Clearing Template Cache...\n"));
+    (0, cli_ui_1.printSection)("🗑️  Clearing Template Cache...");
     const manager = (0, manager_1.getTemplateManager)();
     const stats = manager.getCacheStats();
     manager.clearCache();
@@ -240,7 +242,7 @@ async function manageRepository(args) {
     const subAction = args[0];
     if (!subAction) {
         const config = configManager.getTemplateConfig();
-        console.log(chalk_1.default.cyan("\n📦 Template Repository Configuration\n"));
+        (0, cli_ui_1.printSection)("📦 Template Repository Configuration");
         console.log(`  Repository: ${chalk_1.default.yellow(config.repository)}`);
         console.log(`  Branch:     ${chalk_1.default.cyan(config.branch)}`);
         console.log(`  Cache TTL:  ${config.cacheTTL} seconds`);

package/bin/utils/add-module-to-container.d.ts

@@ -1,3 +1,14 @@
-declare function addModuleToContainer(name: string, modulePath?: string, path?: string, folderName?: string): Promise<void>;
-declare function addModuleToContainerNestedPath(name: string, path?: string, folderName?: string): Promise<void>;
-export { addModuleToContainer, addModuleToContainerNestedPath };
+/**
+ * Register a scaffolded module in `app.ts`.
+ *
+ * The import specifier is derived from the module file's real location
+ * (`moduleOutputPath`) so it always resolves to the file on disk, regardless of
+ * the path style used to scaffold it.
+ *
+ * @param moduleClassName - Exported module symbol, e.g. `UserModule`.
+ * @param moduleOutputPath - Path to the generated `*.module.ts` file.
+ * @param folderToScaffold - Destination root, e.g. `src/useCases`.
+ * @param folderName - Folder basename used to resolve the path alias, e.g. `useCases`.
+ */
+declare function addModuleToContainerByPath(moduleClassName: string, moduleOutputPath: string, folderToScaffold: string, folderName: string): Promise<void>;
+export { addModuleToContainerByPath };

package/bin/utils/add-module-to-container.js

@@ -1,21 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addModuleToContainerNestedPath = exports.addModuleToContainer = void 0;
-const chalk_1 = __importDefault(require("chalk"));
+exports.addModuleToContainerByPath = void 0;
 const glob_1 = require("glob");
 const node_fs_1 = __importDefault(require("node:fs"));
+const nodePath = __importStar(require("node:path"));
 const cli_ui_1 = require("./cli-ui");
 const compiler_1 = __importDefault(require("./compiler"));
 const update_tsconfig_paths_1 = require("./update-tsconfig-paths");
 const APP_CONTAINER = "app.ts";
-async function validateAppContainer() {
+/**
+ * Locate `app.ts` and read its raw content. We deliberately avoid any
+ * line-based parsing here so multi-line imports and nested array literals
+ * survive untouched.
+ */
+async function readAppContainer() {
     const { sourceRoot } = await compiler_1.default.loadConfig();
-    const imports = [];
-    const notImports = [];
-    // Locate the container file
     const path = (0, glob_1.globSync)(`./${sourceRoot}/${APP_CONTAINER}`, {
         absolute: true,
         ignore: "**/node_modules/**",
@@ -24,121 +49,315 @@ async function validateAppContainer() {
         (0, cli_ui_1.printError)("Module not added to Container. Container file not found!", APP_CONTAINER);
         process.exit(1);
     }
-    // Read the container file
-    const fileContent = await node_fs_1.default.promises.readFile(path[0], "utf8");
-    // Collect imports and other lines
-    fileContent.split("\n").forEach((line) => {
-        if (line.startsWith("import")) {
-            imports.push(line);
+    const content = await node_fs_1.default.promises.readFile(path[0], "utf8");
+    return { path: path[0], content };
+}
+/**
+ * Detect the indentation (leading whitespace) of the line containing `index`.
+ */
+function getLineIndent(source, index) {
+    const lineStart = source.lastIndexOf("\n", index - 1) + 1;
+    const match = /^[\t ]*/.exec(source.slice(lineStart));
+    return match ? match[0] : "";
+}
+/**
+ * Skip over a string literal starting at `i` (the index of the opening quote).
+ * Handles `"..."`, `'...'`, and template strings ``` `...` ``` including escapes.
+ * Returns the index just past the closing quote.
+ */
+function skipString(source, i) {
+    const quote = source[i];
+    i++;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === "\\") {
+            i += 2;
+            continue;
+        }
+        if (ch === quote)
+            return i + 1;
+        i++;
+    }
+    return source.length;
+}
+/**
+ * Skip over a `// line` or `/* block *\/` comment starting at `i`.
+ * Returns the index just past the comment, or `i` unchanged if not a comment.
+ */
+function skipComment(source, i) {
+    if (source[i] === "/" && source[i + 1] === "/") {
+        const nl = source.indexOf("\n", i);
+        return nl === -1 ? source.length : nl;
+    }
+    if (source[i] === "/" && source[i + 1] === "*") {
+        const close = source.indexOf("*/", i + 2);
+        return close === -1 ? source.length : close + 2;
+    }
+    return i;
+}
+/**
+ * Find the index immediately after the last top-level `import ... ;`
+ * statement. Returns 0 if no imports are present. The scan is string- and
+ * comment-aware so multi-line imports and quoted semicolons don't confuse it.
+ */
+function findLastImportEnd(source) {
+    let i = 0;
+    let lastEnd = 0;
+    while (i < source.length) {
+        while (i < source.length && /\s/.test(source[i]))
+            i++;
+        const afterComment = skipComment(source, i);
+        if (afterComment !== i) {
+            i = afterComment;
+            continue;
         }
-        else {
-            notImports.push(line);
+        if (!source.startsWith("import", i))
+            break;
+        // Walk forward until the terminating semicolon, ignoring strings/comments.
+        let j = i + "import".length;
+        while (j < source.length) {
+            const ch = source[j];
+            if (ch === '"' || ch === "'" || ch === "`") {
+                j = skipString(source, j);
+                continue;
+            }
+            const afterCmt = skipComment(source, j);
+            if (afterCmt !== j) {
+                j = afterCmt;
+                continue;
+            }
+            if (ch === ";") {
+                j++;
+                break;
+            }
+            j++;
         }
-    });
-    // Regex to detect and extract modules from configContainer
-    const moduleRegex = /this\.configContainer\(\s*\[\s*([\s\S]*?)\s*]\s*\)/;
-    const moduleMatch = fileContent.match(moduleRegex);
-    if (!moduleMatch) {
-        (0, cli_ui_1.printError)("The App class does not contain a valid configContainer([]) declaration!", APP_CONTAINER);
-        process.exit(1);
+        lastEnd = j;
+        i = j;
     }
-    // Extract modules if present
-    const modules = moduleMatch[1]
-        .trim()
-        .split(",")
-        .filter((m) => m.trim() !== "")
-        .map((m) => m.trim());
-    return {
-        regex: moduleRegex,
-        path: path[0],
-        content: fileContent,
-        modules,
-        imports,
-        notImports,
-    };
+    return lastEnd;
 }
-async function addModuleToContainer(name, modulePath, path, folderName) {
-    const containerData = await validateAppContainer();
-    const moduleName = (name[0].toUpperCase() + name.slice(1)).trimStart();
-    const { opinionated } = await compiler_1.default.loadConfig();
-    let usecaseDir;
-    if (opinionated) {
-        // Use dynamic path alias based on the actual folder
-        // Default to @useCases for backward compatibility
-        const pathAlias = folderName
-            ? (0, update_tsconfig_paths_1.getPathAliasForFolder)(folderName)
-            : "@useCases";
-        usecaseDir = `${pathAlias}/`;
-    }
-    else {
-        usecaseDir = `./`;
-    }
-    let newImport = "";
-    const modulePathRegex = /^[^/]=$/;
-    if (!modulePathRegex.test(modulePath)) {
-        if (path.split("/").length > 1) {
-            newImport = `import { ${moduleName}Module } from "${usecaseDir}${name.toLowerCase()}/${name.toLowerCase()}.module";`;
+/**
+ * Locate the call expression `callName(` starting at or after `from`, then
+ * return the `[start, end]` indices (inclusive of the opening `(` and matching
+ * `)`) of its argument list. Returns null if not found.
+ *
+ * The matcher respects strings, comments, and balanced brackets so the inner
+ * `CreateModule([...])` does not prematurely close the outer call.
+ */
+function findCallRange(source, callName, from = 0) {
+    const needle = `${callName}(`;
+    const start = source.indexOf(needle, from);
+    if (start === -1)
+        return null;
+    const open = start + needle.length - 1; // index of '('
+    let depthParen = 1;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let i = open + 1;
+    while (i < source.length && depthParen > 0) {
+        const ch = source[i];
+        if (ch === '"' || ch === "'" || ch === "`") {
+            i = skipString(source, i);
+            continue;
         }
-        else {
-            newImport = `import { ${moduleName}Module } from "${usecaseDir}${name.toLowerCase()}.module";`;
+        const afterCmt = skipComment(source, i);
+        if (afterCmt !== i) {
+            i = afterCmt;
+            continue;
         }
+        if (ch === "(")
+            depthParen++;
+        else if (ch === ")")
+            depthParen--;
+        else if (ch === "[")
+            depthBracket++;
+        else if (ch === "]")
+            depthBracket--;
+        else if (ch === "{")
+            depthBrace++;
+        else if (ch === "}")
+            depthBrace--;
+        i++;
     }
-    else {
-        newImport = `import { ${moduleName}Module } from "${usecaseDir}${name}/${name.toLowerCase()}.module";`;
+    if (depthParen !== 0 || depthBracket !== 0 || depthBrace !== 0)
+        return null;
+    return { open, close: i - 1 }; // close = index of ')'
+}
+/**
+ * Locate the first array literal `[...]` at or after `from`, returning the
+ * indices of the opening `[` and matching `]`. Bracket-balanced and
+ * string/comment safe.
+ */
+function findArrayRange(source, from) {
+    let i = from;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === "[")
+            break;
+        if (ch === '"' || ch === "'" || ch === "`") {
+            i = skipString(source, i);
+            continue;
+        }
+        const afterCmt = skipComment(source, i);
+        if (afterCmt !== i) {
+            i = afterCmt;
+            continue;
+        }
+        i++;
     }
-    if (containerData.imports.includes(newImport) &&
-        containerData.modules.includes(`${moduleName}Module`)) {
-        return;
+    if (i >= source.length || source[i] !== "[")
+        return null;
+    const open = i;
+    let depth = 1;
+    let j = open + 1;
+    while (j < source.length && depth > 0) {
+        const ch = source[j];
+        if (ch === '"' || ch === "'" || ch === "`") {
+            j = skipString(source, j);
+            continue;
+        }
+        const afterCmt = skipComment(source, j);
+        if (afterCmt !== j) {
+            j = afterCmt;
+            continue;
+        }
+        if (ch === "[")
+            depth++;
+        else if (ch === "]")
+            depth--;
+        j++;
+    }
+    if (depth !== 0)
+        return null;
+    return { open, close: j - 1 };
+}
+/**
+ * Insert `name` as a new entry in the array literal that starts at `arrayOpen`
+ * (the index of `[`) and ends at `arrayClose` (the index of the matching `]`).
+ *
+ * Preserves the original formatting: trailing-comma style is honoured, inline
+ * arrays stay inline, and multi-line arrays receive the new entry on its own
+ * line with matching indentation. If `name` is already present in the array
+ * the source is returned unchanged.
+ */
+function insertIntoArray(source, arrayOpen, arrayClose, name) {
+    const inner = source.slice(arrayOpen + 1, arrayClose);
+    // Skip insertion if the identifier is already a top-level token in the array.
+    const tokenRegex = /\b[A-Za-z_$][\w$]*\b/g;
+    let match;
+    while ((match = tokenRegex.exec(inner)) !== null) {
+        if (match[0] === name)
+            return source;
+    }
+    if (inner.trim().length === 0) {
+        return source.slice(0, arrayOpen + 1) + name + source.slice(arrayClose);
+    }
+    // Find the last meaningful character inside the array (skip trailing
+    // whitespace before `]`).
+    let lastChar = arrayClose - 1;
+    while (lastChar > arrayOpen && /\s/.test(source[lastChar]))
+        lastChar--;
+    const hasTrailingComma = source[lastChar] === ",";
+    const isMultiLine = inner.includes("\n");
+    if (!isMultiLine) {
+        const insertion = hasTrailingComma ? ` ${name}` : `, ${name}`;
+        return (source.slice(0, lastChar + 1) +
+            insertion +
+            source.slice(lastChar + 1));
+    }
+    // Multi-line: match the indentation of the last item and place the new
+    // entry on its own line just before the closing bracket.
+    const itemIndent = getLineIndent(source, lastChar);
+    const insertAt = lastChar + 1;
+    const insertion = (hasTrailingComma ? "" : ",") + `\n${itemIndent}${name},`;
+    return source.slice(0, insertAt) + insertion + source.slice(insertAt);
+}
+/**
+ * Insert a new import statement after the last existing one, preserving any
+ * blank line that already separates imports from code. If the import is
+ * already present (textually) the file is returned unchanged.
+ */
+function insertImport(source, importLine) {
+    if (source.includes(importLine))
+        return source;
+    const insertAt = findLastImportEnd(source);
+    if (insertAt === 0) {
+        // No existing imports: prepend at top.
+        const sep = source.startsWith("\n") ? "" : "\n";
+        return importLine + "\n" + sep + source;
+    }
+    const before = source.slice(0, insertAt);
+    const after = source.slice(insertAt);
+    return before + "\n" + importLine + after;
+}
+/**
+ * Add `${moduleName}Module` to the container declaration in `app.ts`.
+ *
+ * Handles both layouts:
+ *   - v4 wrapper:  this.configContainer([CreateModule([...]), ModuleA, ModuleB])
+ *   - legacy flat: this.configContainer([ModuleA, ModuleB])
+ *
+ * Scaffolded modules are always inserted into the outer `configContainer([...])`
+ * array as peer entries alongside `CreateModule([...])`. The inner
+ * `CreateModule([...])` is reserved for orphan controllers that don't have
+ * their own module file.
+ */
+function addModuleToContainerSource(source, className) {
+    const configCall = findCallRange(source, "this.configContainer");
+    if (!configCall) {
+        (0, cli_ui_1.printError)("The App class does not contain a valid configContainer([]) declaration!", APP_CONTAINER);
+        process.exit(1);
+    }
+    const outerArray = findArrayRange(source, configCall.open + 1);
+    if (!outerArray || outerArray.close > configCall.close) {
+        (0, cli_ui_1.printError)("configContainer must be called with an array literal argument.", APP_CONTAINER);
+        process.exit(1);
     }
-    containerData.imports.push(newImport);
-    containerData.modules.push(`${moduleName}Module`);
-    const newModule = containerData.modules.join(", ");
-    const newModuleDeclaration = `this.configContainer([${newModule}])`;
-    const newFileContent = [
-        ...containerData.imports,
-        ...containerData.notImports,
-    ]
-        .join("\n")
-        .replace(containerData.regex, newModuleDeclaration);
-    console.log(" ", chalk_1.default.greenBright(`[container]`.padEnd(14)), chalk_1.default.bold.white(`${moduleName}Module added to ${APP_CONTAINER}! ✔️`));
-    await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
+    return insertIntoArray(source, outerArray.open, outerArray.close, className);
 }
-exports.addModuleToContainer = addModuleToContainer;
-async function addModuleToContainerNestedPath(name, path, folderName) {
-    const containerData = await validateAppContainer();
-    const moduleName = (name[0].toUpperCase() + name.slice(1)).trimStart();
-    const { opinionated } = await compiler_1.default.loadConfig();
-    let usecaseDir;
+/**
+ * Build the import specifier for a scaffolded module from its real on-disk
+ * location. In opinionated mode the path alias for the destination folder is
+ * used (e.g. `@useCases/user-create/user.module`); otherwise a relative import
+ * from the source root is produced. Deriving the specifier from the actual file
+ * path guarantees the generated import always matches where the module was
+ * written, independent of the path style (sugar/single/nested).
+ */
+async function buildModuleImportSpec(moduleOutputPath, folderToScaffold, folderName) {
+    const { opinionated, sourceRoot } = await compiler_1.default.loadConfig();
+    const normalize = (p) => p.replace(/\\/g, "/").replace(/\.ts$/, "");
     if (opinionated) {
-        // Use dynamic path alias based on the actual folder
-        // Default to @useCases for backward compatibility
-        const pathAlias = folderName
-            ? (0, update_tsconfig_paths_1.getPathAliasForFolder)(folderName)
-            : "@useCases";
-        usecaseDir = `${pathAlias}/`;
-    }
-    else {
-        usecaseDir = `./`;
-    }
-    if (path.endsWith("/")) {
-        path = path.slice(0, -1);
-    }
-    const newImport = `import { ${moduleName}Module } from "${usecaseDir}${path}.module";`;
-    if (containerData.imports.includes(newImport) &&
-        containerData.modules.includes(`${moduleName}Module`)) {
-        return;
+        const rel = normalize(nodePath.relative(folderToScaffold, moduleOutputPath));
+        return `${(0, update_tsconfig_paths_1.getPathAliasForFolder)(folderName)}/${rel}`;
     }
-    containerData.imports.push(newImport);
-    containerData.modules.push(`${moduleName}Module`);
-    const newModule = containerData.modules.join(", ");
-    const newModuleDeclaration = `this.configContainer([${newModule}])`;
-    const newFileContent = [
-        ...containerData.imports,
-        ...containerData.notImports,
-    ]
-        .join("\n")
-        .replace(containerData.regex, newModuleDeclaration);
-    console.log(" ", chalk_1.default.greenBright(`[container]`.padEnd(14)), chalk_1.default.bold.white(`${moduleName}Module added to ${APP_CONTAINER}! ✔️`));
-    await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
+    const rel = normalize(nodePath.relative(sourceRoot, moduleOutputPath));
+    return `./${rel}`;
+}
+async function applyContainerEdit(className, importLine) {
+    const info = await readAppContainer();
+    let next = insertImport(info.content, importLine);
+    next = addModuleToContainerSource(next, className);
+    if (next === info.content)
+        return;
+    await node_fs_1.default.promises.writeFile(info.path, next, "utf8");
+    (0, cli_ui_1.printSuccess)(`${className} registered in ${APP_CONTAINER}`, "container");
+}
+/**
+ * Register a scaffolded module in `app.ts`.
+ *
+ * The import specifier is derived from the module file's real location
+ * (`moduleOutputPath`) so it always resolves to the file on disk, regardless of
+ * the path style used to scaffold it.
+ *
+ * @param moduleClassName - Exported module symbol, e.g. `UserModule`.
+ * @param moduleOutputPath - Path to the generated `*.module.ts` file.
+ * @param folderToScaffold - Destination root, e.g. `src/useCases`.
+ * @param folderName - Folder basename used to resolve the path alias, e.g. `useCases`.
+ */
+async function addModuleToContainerByPath(moduleClassName, moduleOutputPath, folderToScaffold, folderName) {
+    const importSpec = await buildModuleImportSpec(moduleOutputPath, folderToScaffold, folderName);
+    const importLine = `import { ${moduleClassName} } from "${importSpec}";`;
+    await applyContainerEdit(moduleClassName, importLine);
 }
-exports.addModuleToContainerNestedPath = addModuleToContainerNestedPath;
+exports.addModuleToContainerByPath = addModuleToContainerByPath;

package/bin/utils/cli-ui.d.ts

@@ -26,7 +26,26 @@ export declare function printGenerateError(schematic: string, file: string): Pro
  * Print generate success (simplified format for scaffolding)
  */
 export declare function printGenerateSuccess(schematic: string, file: string): Promise<void>;
+/**
+ * Print a section title. Intended for interactive/listing output (e.g.
+ * `templates list`, `costs compare`) where the structured logger format
+ * (`[ExpressoTS] timestamp LEVEL`) would be noisy. Leading newline keeps
+ * sections visually separated.
+ */
+export declare function printSection(title: string): void;
+/**
+ * Print an indented bullet point under a section.
+ */
+export declare function printBullet(text: string): void;
+/**
+ * Print a dim horizontal divider sized to the terminal width (capped).
+ */
+export declare function printDivider(): void;
+/**
+ * Print an aligned key/value pair (e.g. `Source:  remote`).
+ */
+export declare function printKeyValue(key: string, value: string, padding?: number): void;
 /**
  * Print the ExpressoTS CLI header
  */
-export declare function printHeader(): void;
+export declare function printHeader(version?: string): void;

package/bin/utils/cli-ui.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printHeader = exports.printGenerateSuccess = exports.printGenerateError = exports.printDebug = exports.printInfo = exports.printWarning = exports.printSuccess = exports.printError = void 0;
+exports.printHeader = exports.printKeyValue = exports.printDivider = exports.printBullet = exports.printSection = exports.printGenerateSuccess = exports.printGenerateError = exports.printDebug = exports.printInfo = exports.printWarning = exports.printSuccess = exports.printError = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const process_1 = require("process");
 /**
@@ -105,10 +105,48 @@ async function printGenerateSuccess(schematic, file) {
     log("INFO", schematic, `${file.split(".")[0]} created!`, "✔️");
 }
 exports.printGenerateSuccess = printGenerateSuccess;
+/**
+ * Print a section title. Intended for interactive/listing output (e.g.
+ * `templates list`, `costs compare`) where the structured logger format
+ * (`[ExpressoTS] timestamp LEVEL`) would be noisy. Leading newline keeps
+ * sections visually separated.
+ */
+function printSection(title) {
+    process_1.stdout.write(`\n${chalk_1.default.bold.cyan(title)}\n`);
+}
+exports.printSection = printSection;
+/**
+ * Print an indented bullet point under a section.
+ */
+function printBullet(text) {
+    process_1.stdout.write(`  ${chalk_1.default.gray("-")} ${text}\n`);
+}
+exports.printBullet = printBullet;
+/**
+ * Print a dim horizontal divider sized to the terminal width (capped).
+ */
+function printDivider() {
+    const cols = typeof process.stdout.columns === "number" && process.stdout.columns > 0
+        ? process.stdout.columns
+        : 80;
+    const width = Math.min(Math.max(cols, 20), 80);
+    process_1.stdout.write(`${chalk_1.default.dim("\u2500".repeat(width))}\n`);
+}
+exports.printDivider = printDivider;
+/**
+ * Print an aligned key/value pair (e.g. `Source:  remote`).
+ */
+function printKeyValue(key, value, padding = 12) {
+    process_1.stdout.write(`  ${chalk_1.default.bold(`${key}:`.padEnd(padding))} ${value}\n`);
+}
+exports.printKeyValue = printKeyValue;
 /**
  * Print the ExpressoTS CLI header
  */
-function printHeader() {
-    process_1.stdout.write(`\n${chalk_1.default.bold.green("🐎 ExpressoTS CLI")}\n\n`);
+function printHeader(version) {
+    const title = version
+        ? `🐎 ExpressoTS CLI v${version}`
+        : "🐎 ExpressoTS CLI";
+    process_1.stdout.write(`\n${chalk_1.default.bold.green(title)}\n\n`);
 }
 exports.printHeader = printHeader;