yehle 0.0.8

package/dist/core/fs.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDirAsync = isDirAsync;
+exports.ensureDirAsync = ensureDirAsync;
+exports.writeFileAsync = writeFileAsync;
+exports.copyFileSafeAsync = copyFileSafeAsync;
+exports.copyDirSafeAsync = copyDirSafeAsync;
+exports.removeMatchingFilesRecursively = removeMatchingFilesRecursively;
+exports.removeFilesByBasename = removeFilesByBasename;
+exports.renderMustacheTemplates = renderMustacheTemplates;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const mustache_1 = __importDefault(require("mustache"));
+/**
+ * Check whether a path exists and is a directory.
+ * @param dirPath - Directory path to check.
+ * @returns True if the path exists and is a directory, false otherwise.
+ */
+async function isDirAsync(dirPath) {
+    try {
+        const st = await node_fs_1.default.promises.stat(dirPath);
+        return st.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure a directory exists (mkdir -p).
+ * @param dirPath - Directory to create if missing.
+ */
+async function ensureDirAsync(dirPath) {
+    await node_fs_1.default.promises.mkdir(dirPath, { recursive: true });
+}
+/**
+ * Write data to a file, ensuring parent directories exist.
+ * @param filePath - Absolute or relative path to the file.
+ * @param data - File contents.
+ */
+async function writeFileAsync(filePath, data) {
+    const dir = node_path_1.default.dirname(filePath);
+    await ensureDirAsync(dir);
+    await node_fs_1.default.promises.writeFile(filePath, data, "utf8");
+}
+/**
+ * Copy a file if it exists, ensuring destination directory exists.
+ * No-ops when source is missing or is not a regular file.
+ * @param src - Source file path.
+ * @param dest - Destination file path.
+ */
+async function copyFileSafeAsync(src, dest) {
+    try {
+        const stat = await node_fs_1.default.promises.stat(src);
+        if (!stat.isFile())
+            return;
+    }
+    catch {
+        return;
+    }
+    await ensureDirAsync(node_path_1.default.dirname(dest));
+    await node_fs_1.default.promises.copyFile(src, dest);
+}
+/**
+ * Recursively copy a directory tree. If the source directory does not exist, it no-ops.
+ * @param srcDir - Source directory path.
+ * @param destDir - Destination directory path.
+ */
+async function copyDirSafeAsync(srcDir, destDir) {
+    try {
+        const st = await node_fs_1.default.promises.stat(srcDir);
+        if (!st.isDirectory())
+            return;
+    }
+    catch {
+        return;
+    }
+    await ensureDirAsync(destDir);
+    const entries = await node_fs_1.default.promises.readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = node_path_1.default.join(srcDir, entry.name);
+        const destPath = node_path_1.default.join(destDir, entry.name);
+        if (entry.isDirectory())
+            await copyDirSafeAsync(srcPath, destPath);
+        else if (entry.isFile())
+            await copyFileSafeAsync(srcPath, destPath);
+    }
+}
+/**
+ * Recursively remove files or directories in a directory tree that match a predicate.
+ * The predicate is called with: (basename, fullPath, dirent).
+ * Directories that match are deleted (recursively); non-matching directories are traversed.
+ * @param rootDir - Root directory to traverse.
+ * @param predicate - Function returning true when the entry should be removed.
+ */
+async function removeMatchingFilesRecursively(rootDir, predicate) {
+    let entries = [];
+    try {
+        entries = await node_fs_1.default.promises.readdir(rootDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = node_path_1.default.join(rootDir, entry.name);
+        // If the directory itself matches, remove it entirely; otherwise traverse it.
+        if (entry.isDirectory()) {
+            if (predicate(entry.name, full, entry)) {
+                await node_fs_1.default.promises.rm(full, { recursive: true, force: true });
+                continue;
+            }
+            await removeMatchingFilesRecursively(full, predicate);
+        }
+        // If the file matches, remove the file
+        else if (entry.isFile()) {
+            if (predicate(entry.name, full, entry)) {
+                await node_fs_1.default.promises.rm(full, { force: true });
+            }
+        }
+    }
+}
+/**
+ * Convenience wrapper to remove any files or directories whose basename is in the provided list,
+ * regardless of which subfolder they are in.
+ * @param rootDir - Root directory to traverse.
+ * @param fileNames - Iterable of basenames to remove.
+ */
+async function removeFilesByBasename(rootDir, fileNames) {
+    const set = new Set(fileNames);
+    await removeMatchingFilesRecursively(rootDir, (name) => set.has(name));
+}
+/**
+ * Recursively find all *.mustache.* files in targetDir, render them using the provided data,
+ * write the rendered content to the same path with ".mustache." removed, and remove the original.
+ * Example: package.mustache.json -> package.json, config.mustache.ts -> config.ts
+ * @param targetDir - Root directory to search.
+ * @param data - Key/value pairs used for mustache interpolation.
+ */
+async function renderMustacheTemplates(targetDir, data) {
+    let entries = [];
+    try {
+        entries = await node_fs_1.default.promises.readdir(targetDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = node_path_1.default.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await renderMustacheTemplates(full, data);
+        }
+        else if (entry.isFile() && /\.mustache\./i.test(entry.name)) {
+            const raw = await node_fs_1.default.promises.readFile(full, "utf8");
+            // Preserve GitHub Actions expressions like ${{ secrets.X }} by masking them before rendering.
+            const ghExprPattern = /\$\{\{[\s\S]*?\}\}/g;
+            const ghExprs = [];
+            const masked = raw.replaceAll(ghExprPattern, (m) => {
+                const token = `__GH_EXPR_${ghExprs.length}__`;
+                ghExprs.push(m);
+                return token;
+            });
+            const previousEscape = mustache_1.default.escape;
+            try {
+                // Disable HTML escaping to preserve literal "/" and other characters during render
+                // This is safe because the rendered content is written to files, not directly to HTML output
+                mustache_1.default.escape = (s) => s;
+                let rendered = mustache_1.default.render(masked, data);
+                // Restore masked GitHub Actions expressions
+                ghExprs.forEach((expr, i) => {
+                    const token = `__GH_EXPR_${i}__`;
+                    rendered = rendered.split(token).join(expr);
+                });
+                const dest = node_path_1.default.join(node_path_1.default.dirname(full), entry.name.replace(/\.mustache\./i, "."));
+                await node_fs_1.default.promises.writeFile(dest, rendered, "utf8");
+                await node_fs_1.default.promises.rm(full, { force: true });
+            }
+            finally {
+                // Restore original Mustache escape behavior
+                mustache_1.default.escape = previousEscape;
+            }
+        }
+    }
+}

package/dist/core/git.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitUsername = getGitUsername;
+exports.getGitEmail = getGitEmail;
+exports.isGitRepo = isGitRepo;
+exports.initGitRepo = initGitRepo;
+exports.makeInitialCommit = makeInitialCommit;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const shell_1 = require("./shell");
+/**
+ * Read a git config value for a given key from the current environment.
+ * This will look up git configuration (local/global/system) based on how git resolves it.
+ * @param key - Fully qualified git config key (e.g., "user.name", "user.email")
+ * @returns The config value if set; undefined otherwise
+ */
+async function readGitConfig(key) {
+    try {
+        const out = await (0, shell_1.runAsync)(`git config --get ${key}`, { stdio: "pipe" });
+        const s = out.trim();
+        return s.length ? s : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get git user.name from current git configuration.
+ * @returns The configured git user.name, or undefined if not available.
+ */
+async function getGitUsername() {
+    return await readGitConfig("user.name");
+}
+/**
+ * Get git user.email from current git configuration.
+ * @returns The configured git user.email, or undefined if not available.
+ */
+async function getGitEmail() {
+    return await readGitConfig("user.email");
+}
+/**
+ * Determine whether a directory already contains a git repository.
+ * @param cwd - Absolute path to the target directory
+ * @returns true if a .git directory exists inside cwd; false otherwise
+ */
+function isGitRepo(cwd) {
+    return node_fs_1.default.existsSync(node_path_1.default.join(cwd, ".git"));
+}
+/**
+ * Initialize a git repository in the provided directory.
+ * @param cwd - Absolute path to the target directory where git should be initialized
+ * @throws Error when initialization fails due to underlying git issues
+ */
+async function initGitRepo(cwd) {
+    if (isGitRepo(cwd))
+        return;
+    const defaultBranch = "main";
+    try {
+        await (0, shell_1.runAsync)(`git init -b ${defaultBranch}`, { cwd, stdio: "ignore" });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to initialize git repository in ${cwd}: ${msg}`);
+    }
+}
+/**
+ * Initialize a git repository in the provided directory.
+ * @param cwd - Absolute path to the target directory where git should be initialized
+ * @throws Error when initialization fails due to underlying git issues
+ */
+async function makeInitialCommit(cwd) {
+    try {
+        // Ensure a repository exists
+        if (!isGitRepo(cwd))
+            await initGitRepo(cwd);
+        // Stage all files and create an initial commit
+        await (0, shell_1.runAsync)("git add -A", { cwd, stdio: "ignore" });
+        await (0, shell_1.runAsync)('git commit -m "chore: initial commit"', {
+            cwd,
+            stdio: "ignore",
+        });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to create initial git commit in ${cwd}: ${msg}`);
+    }
+}

package/dist/core/pkg-manager.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_PACKAGE_REGISTRY = exports.LANGUAGE_PACKAGE_MANAGER = void 0;
+exports.validatePackageName = validatePackageName;
+exports.ensurePackageManager = ensurePackageManager;
+exports.getInstallScript = getInstallScript;
+const config_1 = require("../resources/package/config");
+const typescript_1 = require("../resources/package/typescript");
+const shell_1 = require("./shell");
+/** Maps each supported language to its default package manager. */
+exports.LANGUAGE_PACKAGE_MANAGER = {
+    [config_1.Language.TYPESCRIPT]: "pnpm",
+};
+/** Maps each supported language to its package registry. */
+exports.LANGUAGE_PACKAGE_REGISTRY = {
+    [config_1.Language.TYPESCRIPT]: "NPM",
+};
+/**
+ * Validates the given package name based on the language type.
+ * @param name - The name of the package to validate.
+ * @param language - The programming language context to validate against.
+ * @throws Will throw an error if the package name is invalid for TypeScript.
+ */
+function validatePackageName(name, language) {
+    switch (language) {
+        case config_1.Language.TYPESCRIPT: {
+            const validation = (0, typescript_1.validateTypescriptPackageName)(name);
+            if (validation !== true)
+                throw new Error(typeof validation === "string" ? validation : "Invalid package name");
+            break;
+        }
+        default:
+            throw new Error(`Unsupported language: ${language}`);
+    }
+}
+/**
+ * Ensure the selected package manager is available on the system
+ * and return a packageManager identifier string (e.g., "bun@1.2.0")
+ * @param pm - The package manager to verify/resolve.
+ */
+async function ensurePackageManager(pm) {
+    switch (pm) {
+        case "pnpm": {
+            if (!(await (0, shell_1.commandExistsAsync)("pnpm")))
+                throw new Error("pnpm is not installed. Please install PNPM and re-run.");
+            const version = await (0, shell_1.runAsync)("pnpm --version");
+            return `pnpm@${version}`;
+        }
+        default:
+            throw new Error(`Unsupported package manager: ${pm}`);
+    }
+}
+/**
+ * Get the install command for the specified package manager to display in the next-steps box.
+ * @param pm - The package manager to use.
+ * @returns The shell command to install dependencies (e.g., "pnpm install").
+ */
+function getInstallScript(pm) {
+    switch (pm) {
+        case "pnpm":
+            return "pnpm install";
+        default:
+            throw new Error(`Unsupported package manager: ${pm}`);
+    }
+}

package/dist/core/shell.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAsync = runAsync;
+exports.commandExistsAsync = commandExistsAsync;
+const node_child_process_1 = require("node:child_process");
+/**
+ * Parses a command string into a command name and an array of arguments.
+ * Supports quoted arguments and spaces within arguments.
+ * @param cmd - The command string to parse.
+ * @returns An object containing the command name and an array of arguments.
+ */
+function parseCommand(cmd) {
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    for (const char of cmd) {
+        if (char === '"' && !inQuotes) {
+            inQuotes = true;
+        }
+        else if (char === '"' && inQuotes) {
+            inQuotes = false;
+        }
+        else if (char === " " && !inQuotes) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current)
+        tokens.push(current);
+    const [command, ...args] = tokens;
+    return { command, args };
+}
+/**
+ * Run a command asynchronously and resolve with stdout (trimmed) for "pipe" stdio, or an empty string for "inherit" or "ignore" stdio.
+ * The command string is parsed into command and arguments to avoid shell interpretation.
+ * @param cmd - The command string to run (will be parsed into command and args).
+ * @param opts - Optional run options to customize execution.
+ * @returns Promise resolving to the trimmed stdout for "pipe" stdio, or empty string for others.
+ */
+function runAsync(cmd, opts = {}) {
+    const { cwd, stdio = "pipe", env, timeoutMs } = opts;
+    const { command, args } = parseCommand(cmd);
+    if (stdio === "inherit") {
+        return new Promise((resolve, reject) => {
+            const child = (0, node_child_process_1.spawn)(command, args, {
+                cwd,
+                env: { ...process.env, ...env },
+                stdio: "inherit",
+                timeout: timeoutMs,
+            });
+            child.on("error", reject);
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve("");
+                else
+                    reject(new Error(`Command failed: ${cmd} (exit ${code})`));
+            });
+        });
+    }
+    // Default: capture stdout using spawn
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            env: { ...process.env, ...env },
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: timeoutMs,
+        });
+        let stdout = "";
+        child.stdout.on("data", (data) => {
+            stdout += data;
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve(stdout.trim());
+            else
+                reject(new Error(`Command failed: ${cmd} (exit ${code})`));
+        });
+    });
+}
+/**
+ * Checks asynchronously if a command exists on the system's PATH.
+ * Uses 'where' on Windows and 'command -v' on other platforms.
+ * @param command - The command name to check.
+ * @returns Promise resolving to true if the command exists, false otherwise.
+ */
+async function commandExistsAsync(command) {
+    try {
+        if (process.platform === "win32") {
+            await runAsync(`where ${command}`, { stdio: "ignore" });
+        }
+        else {
+            await runAsync(`command -v ${command}`, { stdio: "ignore" });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/template-registry.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTemplatesDir = resolveTemplatesDir;
+exports.listAvailableTemplates = listAvailableTemplates;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const giget_1 = require("giget");
+const constants_1 = require("./constants");
+const fs_1 = require("./fs");
+/** Name of the shared templates directory that may be filtered out from listings. */
+const SHARED_DIR_NAME = "shared";
+/** Default GitHub owner to fetch templates from in remote mode.*/
+const DEFAULT_GITHUB_OWNER = "agrawal-rohit";
+/** Default GitHub repository to fetch templates from in remote mode. */
+const DEFAULT_GITHUB_REPO = "yehle";
+/** HTTP headers used when communicating with the GitHub API. */
+const GITHUB_HEADERS = {
+    "User-Agent": "yehle-cli",
+    Accept: "application/vnd.github.v3+json",
+};
+/**
+ * Resolve the absolute path to the local templates root directory.
+ * @returns The absolute path if the directory exists at `./templates`; otherwise null.
+ */
+async function getLocalTemplatesRoot() {
+    const localTemplatesPath = node_path_1.default.resolve(process.cwd(), "templates");
+    if (await (0, fs_1.isDirAsync)(localTemplatesPath))
+        return localTemplatesPath;
+    return null;
+}
+/**
+ * Resolves the absolute path to the local templates subdirectory for a given language and resource.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns The path to the language subdirectory or resource directory if it exists; otherwise null.
+ */
+async function getLocalTemplatesSubdir(language, resource) {
+    const root = await getLocalTemplatesRoot();
+    if (!root)
+        return null;
+    const langRoot = node_path_1.default.join(root, language);
+    if (!(await (0, fs_1.isDirAsync)(langRoot)))
+        return null;
+    if (resource) {
+        const resourceDir = node_path_1.default.join(langRoot, resource);
+        if (await (0, fs_1.isDirAsync)(resourceDir))
+            return resourceDir;
+        return null;
+    }
+    return langRoot;
+}
+/**
+ * @param dir The directory to list child directories from.
+ * @returns An array of child directory names, excluding shared if not included.
+ */
+async function listChildDirs(dir) {
+    if (!(await (0, fs_1.isDirAsync)(dir)))
+        return [];
+    const entries = await node_fs_1.default.promises.readdir(dir, { withFileTypes: true });
+    const names = entries
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name)
+        .filter((n) => n.toLowerCase() !== SHARED_DIR_NAME);
+    return names;
+}
+/**
+ * Build a GitHub API Contents URL for a templates subtree.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns The constructed API URL.
+ */
+function buildContentsURL(language, resource) {
+    const subpath = ["templates", language, resource].filter(Boolean).join("/");
+    return `https://api.github.com/repos/${DEFAULT_GITHUB_OWNER}/${DEFAULT_GITHUB_REPO}/contents/${subpath}`;
+}
+/**
+ * Build a giget specification for a subtree within the default repo.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns The constructed giget spec string.
+ */
+function buildGigetSpec(language, resource) {
+    const subpath = ["templates", language, resource].filter(Boolean).join("/");
+    return `github:${DEFAULT_GITHUB_OWNER}/${DEFAULT_GITHUB_REPO}/${subpath}`;
+}
+/**
+ * Check whether a remote templates subtree exists in GitHub.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns True if the subtree exists or is uncertain, false if definitely not.
+ */
+async function subtreeExistsRemote(language, resource) {
+    try {
+        const url = buildContentsURL(language, resource);
+        const res = await fetch(url, { headers: GITHUB_HEADERS });
+        if (res.status === 404)
+            return false; // definitely not there
+        if (!res.ok)
+            return true; // uncertain; assume exists and let giget verify
+        const data = await res.json();
+        if (Array.isArray(data))
+            return true;
+        if (data &&
+            typeof data === "object" &&
+            data.type === "dir")
+            return true;
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Attempt to normalize the downloaded directory to the expected subtree.
+ * @param downloadedDir - The path to the downloaded directory.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns The normalized directory path.
+ */
+async function normalizeDownloadedDir(downloadedDir, language, resource) {
+    const candidates = resource
+        ? [
+            node_path_1.default.join(downloadedDir, "templates", language, resource),
+            node_path_1.default.join(downloadedDir, language, resource),
+            node_path_1.default.join(downloadedDir, resource),
+            downloadedDir,
+        ]
+        : [
+            node_path_1.default.join(downloadedDir, "templates", language),
+            node_path_1.default.join(downloadedDir, language),
+            downloadedDir,
+        ];
+    for (const cand of candidates) {
+        if (await (0, fs_1.isDirAsync)(cand))
+            return cand;
+    }
+    return downloadedDir;
+}
+/**
+ * Download a remote templates subtree to a temporary directory and return the normalized path.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns The path to the downloaded and normalized directory.
+ */
+async function downloadRemoteTemplatesSubdir(language, resource) {
+    const spec = buildGigetSpec(language, resource);
+    const promise = (async () => {
+        const exists = await subtreeExistsRemote(language, resource);
+        if (!exists) {
+            const resourcePart = resource ? `/${resource}` : "";
+            throw new Error(`Remote templates path does not exist: templates/${language}${resourcePart} (repo: ${DEFAULT_GITHUB_OWNER}/${DEFAULT_GITHUB_REPO}).`);
+        }
+        const tmpRoot = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), "yehle-templates-"));
+        try {
+            const res = await (0, giget_1.downloadTemplate)(spec, { dir: tmpRoot, force: true });
+            const normalized = await normalizeDownloadedDir(res.dir, language, resource);
+            return normalized;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`Failed to download templates from "${spec}". ${msg}. ` +
+                `Ensure the path exists and that network/GitHub access are available.`);
+        }
+    })();
+    return promise;
+}
+/**
+ * List child directories from the GitHub Contents API without downloading the subtree.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns An array of child directory names.
+ */
+async function listRemoteChildDirsViaAPI(language, resource) {
+    const url = buildContentsURL(language, resource);
+    const res = await fetch(url, { headers: GITHUB_HEADERS });
+    if (!res.ok)
+        throw new Error(`Failed to fetch from GitHub API: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (!Array.isArray(data))
+        throw new Error("Invalid response from GitHub API: expected array of contents");
+    const names = data
+        .filter((entry) => entry?.type === "dir" && typeof entry.name === "string")
+        .map((entry) => entry.name)
+        .filter((n) => n.toLowerCase() !== SHARED_DIR_NAME);
+    return names;
+}
+/**
+ * Resolve the on-disk directory that contains templates for a given language and resource.
+ * @param language - The programming language for the templates.
+ * @param resource - Optional resource within the language.
+ * @returns An object with the path and source of the templates directory.
+ */
+async function resolveTemplatesDir(language, resource) {
+    if (constants_1.IS_LOCAL_MODE) {
+        const localDir = await getLocalTemplatesSubdir(language, resource);
+        if (localDir)
+            return localDir;
+        const root = (await getLocalTemplatesRoot()) || "<no local templates root>";
+        const resourcePart = resource ? ` and resource "${resource}"` : "";
+        throw new Error(`Local templates not found at ${root} for language "${language}"${resourcePart}.`);
+    }
+    // Remote mode
+    const remoteDir = await downloadRemoteTemplatesSubdir(language, resource);
+    if (await (0, fs_1.isDirAsync)(remoteDir))
+        return remoteDir;
+    const resourcePart = resource ? ` and resource "${resource}"` : "";
+    throw new Error(`No remote templates found for language "${language}"${resourcePart} in ${DEFAULT_GITHUB_OWNER}/${DEFAULT_GITHUB_REPO}.`);
+}
+/**
+ * List available template names (subdirectories) for a given language and resource.
+ * @param language - The programming language for the templates.
+ * @param resource - The resource type
+ * @returns An array of available template names.
+ */
+async function listAvailableTemplates(language, resource) {
+    if (constants_1.IS_LOCAL_MODE) {
+        const resourceDir = await getLocalTemplatesSubdir(language, resource);
+        if (!resourceDir)
+            return [];
+        return listChildDirs(resourceDir);
+    }
+    // Prefer API listing
+    const apiNames = await listRemoteChildDirsViaAPI(language, resource);
+    return apiNames;
+}