yehle 0.0.8

package/dist/core/utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.toSlug = toSlug;
+exports.sleep = sleep;
+exports.truncate = truncate;
+const utils_1 = require("consola/utils");
+/**
+ * Capitalizes the first letter of the input string.
+ * @param string - The input string to capitalize.
+ * @returns The string with the first character converted to uppercase.
+ */
+function capitalizeFirstLetter(string) {
+    return string[0].toUpperCase() + string.slice(1);
+}
+/**
+ * Convert an arbitrary string into a URL and npm-friendly slug.
+ * @param value - The input string to slugify (e.g., package or repo name).
+ * @returns A normalized slug suitable for package/repo names.
+ */
+function toSlug(value) {
+    // Normalize case/whitespace and extract last path-like segment (supports URLs and Windows paths)
+    const normalized = value.trim().toLowerCase();
+    const segments = normalized.split(/[\\/]+/).filter(Boolean);
+    let base = segments.length ? segments[segments.length - 1] : normalized;
+    // Handle npm scopes like "@scope/name" (base will typically be "name", but keep safe)
+    base = base.replace(/^@/, "");
+    // Strip common VCS suffix if present
+    base = base.replace(/\.git$/, "");
+    // Replace invalid characters with a hyphen
+    base = base.replaceAll(/[^a-z0-9._-]+/g, "-");
+    // Collapse multiple hyphens
+    base = base.replaceAll(/-+/g, "-");
+    // Trim leading and trailing hyphens
+    base = base.replace(/^-+/, "");
+    base = base.replace(/-+$/, "");
+    return base;
+}
+/**
+ * Sleep for the specified number of milliseconds.
+ * @param ms - The number of milliseconds to sleep.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Truncate a string to a maximum visible length, respecting ANSI sequences.
+ * If truncated, appends "...". ANSI styling is not preserved in the truncated section.
+ * @param s - The input string to truncate.
+ * @param max - The maximum visible length.
+ */
+function truncate(s, max) {
+    const raw = (0, utils_1.stripAnsi)(s);
+    if (raw.length <= max)
+        return s;
+    return `${raw.slice(0, Math.max(0, max - 3))}...`;
+}

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = run;
+const cac_1 = __importDefault(require("cac"));
+const resources_1 = require("./resources");
+function run() {
+    const app = (0, cac_1.default)("yehle");
+    // Register commands
+    (0, resources_1.registerResourcesCli)(app);
+    // Register the help command
+    app.help();
+    // Parse argv and, on parse errors, re-run with contextual --help
+    const args = process.argv.slice(2).filter(Boolean);
+    // Show global help when just the root command is called
+    if (args.length === 0) {
+        app.outputHelp();
+        return;
+    }
+    // Attempt to run the command
+    try {
+        app.parse(process.argv);
+    }
+    catch {
+        // If the command failed (due to incorrect arguments, missing commands, etc)
+        // Attempt to show help for the command by appending --help to the original args
+        try {
+            app.parse([...process.argv, "--help"]);
+        }
+        catch {
+            // Final fallback: show top-level help
+            app.outputHelp();
+        }
+    }
+}

package/dist/resources/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerResourcesCli = registerResourcesCli;
+const logger_1 = __importDefault(require("../cli/logger"));
+const command_1 = __importDefault(require("./package/command"));
+async function registerResourcesCli(app) {
+    // Top-level description
+    app.usage("<resource> [options]");
+    // Register the `package` command
+    app
+        .command("package", "Generate a package")
+        .option("--name <name>", "Package name")
+        .option("--lang <lang>", "Target language (e.g., typescript)")
+        .option("--public", "Public package (will setup for publishing to a package registry)")
+        .option("--template <template>", "Starter template for the package")
+        .action(async (options) => {
+        try {
+            await (0, command_1.default)({
+                lang: options.lang,
+                name: options.name,
+                template: options.template,
+                public: options.public ? Boolean(options.public) : undefined,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger_1.default.error(msg);
+        }
+    });
+}

package/dist/resources/package/command.js

@@ -0,0 +1,148 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.generatePackage = generatePackage;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = __importStar(require("../../cli/logger"));
+const tasks_1 = __importDefault(require("../../cli/tasks"));
+const git_1 = require("../../core/git");
+const pkg_manager_1 = require("../../core/pkg-manager");
+const utils_1 = require("../../core/utils");
+const config_1 = require("./config");
+const setup_1 = require("./setup");
+async function generatePackage(options = {}) {
+    await logger_1.default.intro("generating package...");
+    // Gather configuration (skip prompts when options are provided)
+    const generateConfig = await (0, config_1.getGeneratePackageConfiguration)({
+        lang: options.lang,
+        name: options.name,
+        template: options.template,
+        public: options.public,
+    });
+    let packageManagerVersion = "";
+    const packageManager = pkg_manager_1.LANGUAGE_PACKAGE_MANAGER[generateConfig.lang];
+    const resolvedTargetDir = node_path_1.default.resolve(process.cwd(), (0, utils_1.toSlug)(generateConfig.name));
+    // Preflight checks
+    console.log();
+    await tasks_1.default.runWithTasks("Preflight checks", async () => {
+        // Check target directory
+        let isEmpty = true;
+        if (node_fs_1.default.existsSync(resolvedTargetDir)) {
+            try {
+                const files = node_fs_1.default.readdirSync(resolvedTargetDir);
+                isEmpty = files.length === 0;
+            }
+            catch {
+                isEmpty = true;
+            }
+        }
+        if (!isEmpty)
+            throw new Error(`Target directory is not empty: ${resolvedTargetDir}`);
+        // Check package manager availability
+        packageManagerVersion = await (0, pkg_manager_1.ensurePackageManager)(packageManager);
+    });
+    // Create the package
+    let targetDir = "";
+    await tasks_1.default.runWithTasks("Preparing package", undefined, [
+        {
+            title: "Create package directory",
+            task: async () => {
+                targetDir = await (0, setup_1.createPackageDirectory)(process.cwd(), (0, utils_1.toSlug)(generateConfig.name));
+            },
+        },
+        {
+            title: `Add "${generateConfig.template}" template`,
+            task: async () => {
+                await (0, setup_1.writePackageTemplateFiles)(targetDir, generateConfig);
+            },
+        },
+        {
+            title: "Modify template with user preferences",
+            task: async () => {
+                await (0, setup_1.applyTemplateModifications)(targetDir, generateConfig, packageManagerVersion);
+            },
+        },
+    ]);
+    let githubSecrets = [];
+    await tasks_1.default.runWithTasks("Finishing up", undefined, [
+        {
+            title: "Initialize git",
+            task: async () => {
+                await (0, git_1.initGitRepo)(targetDir);
+            },
+        },
+        {
+            title: "Make initial commit",
+            task: async () => {
+                await (0, git_1.makeInitialCommit)(targetDir);
+            },
+        },
+        {
+            title: "Fetch github secrets list",
+            task: async () => {
+                githubSecrets = await (0, setup_1.getRequiredGithubSecrets)(targetDir);
+            },
+        },
+    ]);
+    const installCmd = (0, pkg_manager_1.getInstallScript)(packageManager);
+    let currentStep = 1;
+    console.log();
+    console.log(chalk_1.default.bold("Package generated successfully! Next steps:"));
+    console.log();
+    const cdCommand = `cd ${(0, utils_1.toSlug)(generateConfig.name)}`;
+    console.log(`  ${currentStep}. Enter your package directory using ${(0, logger_1.primaryText)(cdCommand)},`);
+    currentStep += 1;
+    console.log(`  ${currentStep}. Push your initial commit with ${(0, logger_1.primaryText)("git push -u origin main")}`);
+    currentStep += 1;
+    if (githubSecrets.length > 0) {
+        console.log(`  ${currentStep}. Configure the following repository secrets in your GitHub project :`);
+        currentStep += 1;
+        githubSecrets.forEach((secret) => {
+            console.log(`    - ${(0, logger_1.primaryText)(secret)}`);
+        });
+    }
+    console.log(`  ${currentStep}. Install dependencies with ${(0, logger_1.primaryText)(installCmd)}`);
+    currentStep += 1;
+    console.log(`  ${currentStep}. Happy building, fellow wizard!`);
+    console.log();
+    console.log(`Stuck? Open an issue at ${(0, logger_1.primaryText)("https://github.com/agrawal-rohit/yehle/issues")}`);
+    console.log();
+}
+exports.default = generatePackage;

package/dist/resources/package/config.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templatePublicPaths = exports.Language = void 0;
+exports.getGeneratePackageConfiguration = getGeneratePackageConfiguration;
+exports.getPackageLanguage = getPackageLanguage;
+exports.getPackageName = getPackageName;
+exports.getPackageTemplate = getPackageTemplate;
+exports.getPackageVisibility = getPackageVisibility;
+exports.promptAuthorName = promptAuthorName;
+exports.promptAuthorGitEmail = promptAuthorGitEmail;
+exports.promptAuthorGitUsername = promptAuthorGitUsername;
+const logger_1 = require("../../cli/logger");
+const prompts_1 = __importDefault(require("../../cli/prompts"));
+const tasks_1 = __importDefault(require("../../cli/tasks"));
+const constants_1 = require("../../core/constants");
+const git_1 = require("../../core/git");
+const pkg_manager_1 = require("../../core/pkg-manager");
+const template_registry_1 = require("../../core/template-registry");
+const utils_1 = require("../../core/utils");
+/** Supported programming languages for the package. */
+var Language;
+(function (Language) {
+    Language["TYPESCRIPT"] = "typescript";
+})(Language || (exports.Language = Language = {}));
+exports.templatePublicPaths = {
+    shared: [
+        "CODE_OF_CONDUCT.md",
+        "CONTRIBUTING.md",
+        "issue_template",
+        "pull_request_template.md",
+    ],
+    [Language.TYPESCRIPT]: ["release.mustache.yml"],
+};
+/**
+ * Gather relevant configuration to proceed with the package creation
+ * @returns A JSON object with the package configuration
+ */
+async function getGeneratePackageConfiguration(cliFlags = {}) {
+    const lang = await getPackageLanguage(cliFlags);
+    const name = await getPackageName(lang, cliFlags);
+    const template = await getPackageTemplate(lang, cliFlags);
+    const isPublic = await getPackageVisibility(lang, cliFlags);
+    let authorName;
+    let authorGitEmail;
+    let authorGitUsername;
+    if (isPublic) {
+        authorName = await promptAuthorName();
+        authorGitEmail = await promptAuthorGitEmail();
+        authorGitUsername = await promptAuthorGitUsername();
+    }
+    const answers = {
+        lang: lang,
+        name: name,
+        template: template,
+        public: isPublic,
+        authorName: authorName,
+        authorGitEmail: authorGitEmail,
+        authorGitUsername: authorGitUsername,
+    };
+    return answers;
+}
+/**
+ * Gets the package language based on CLI flags or prompts the user if not provided.
+ * @param cliFlags - CLI flags that may include a predefined language selection.
+ * @returns The selected programming language type.
+ */
+async function getPackageLanguage(cliFlags = {}) {
+    const languageOptions = Object.keys(Language).map((key) => ({
+        label: (0, utils_1.capitalizeFirstLetter)(Language[key]),
+        value: Language[key],
+    }));
+    const language = cliFlags.lang ??
+        (await prompts_1.default.selectInput("Which language would you prefer to use?", {
+            options: languageOptions,
+        }, Language.TYPESCRIPT));
+    const validLanguages = new Set(languageOptions.map((opt) => opt.value));
+    if (!validLanguages.has(language))
+        throw new Error(`Unsupported language: ${language} (valid: ${Array.from(validLanguages).join(", ")})`);
+    return language;
+}
+/**
+ * Gets the package name based on CLI flags or prompts the user if not provided.
+ * Also validates the package name against the selected language.
+ * @param language - The selected programming language.
+ * @param cliFlags - CLI flags that may include a predefined name.
+ * @returns The validated package name.
+ */
+async function getPackageName(language, cliFlags = {}) {
+    const name = cliFlags.name ??
+        (await prompts_1.default.textInput("What should we call your package?", { required: true }, "my-package"));
+    (0, pkg_manager_1.validatePackageName)(name, language);
+    return name;
+}
+async function getPackageTemplate(language, cliFlags = {}) {
+    let candidateTemplates = [];
+    // If it's running in local mode, fetch templates without spinner
+    if (constants_1.IS_LOCAL_MODE) {
+        candidateTemplates = await (0, template_registry_1.listAvailableTemplates)(language, "package");
+    }
+    // Otherwise, show a loading spinner until the templates are fetched from Github
+    else {
+        console.log();
+        await tasks_1.default.runWithTasks("Checking available package templates", async () => {
+            candidateTemplates = await (0, template_registry_1.listAvailableTemplates)(language, "package");
+        });
+    }
+    if (!candidateTemplates || candidateTemplates.length === 0)
+        throw new Error(`No templates found for language: ${language}`);
+    const templateOptions = candidateTemplates.map((template) => ({
+        label: (0, utils_1.capitalizeFirstLetter)(template),
+        value: template,
+    }));
+    let template = cliFlags.template;
+    // If only a single template is available, just use that
+    if (templateOptions.length === 1) {
+        template = templateOptions[0].value;
+        console.log((0, logger_1.primaryText)(`(Only one package template is available, using "${template}".)`));
+    }
+    if (!template)
+        template = await prompts_1.default.selectInput("Which starter template would you like to use?", { options: templateOptions }, candidateTemplates[0]);
+    if (!candidateTemplates.includes(template))
+        throw new Error(`Unsupported template: ${template} (valid: ${Array.from(candidateTemplates).join(", ")})`);
+    return template;
+}
+/**
+ * Gets the package visibility (public or private) based on CLI flags or prompts the user if not provided.
+ * Uses the package registry for the selected language in the prompt.
+ * @param language - The selected programming language.
+ * @param cliFlags - CLI flags that may include a predefined visibility setting.
+ * @returns The boolean indicating if the package is public.
+ */
+async function getPackageVisibility(language, cliFlags = {}) {
+    const packageRegistry = pkg_manager_1.LANGUAGE_PACKAGE_REGISTRY[language];
+    const isPublic = cliFlags.public ??
+        (await prompts_1.default.confirmInput(`Should this package be publicly available? (released to the ${packageRegistry} registry)`, undefined, true));
+    return isPublic;
+}
+/** Prompt for author's full name (defaults to Git config when available). */
+async function promptAuthorName() {
+    const gitName = await (0, git_1.getGitUsername)();
+    return await prompts_1.default.textInput("What is the author's name?", undefined, gitName);
+}
+/** Prompt for author's Git email (defaults to Git config when available). */
+async function promptAuthorGitEmail() {
+    const inferredGitEmail = await (0, git_1.getGitEmail)();
+    return await prompts_1.default.textInput("What is the author's email?", undefined, inferredGitEmail);
+}
+/** Prompt for author's GitHub username (suggests a value based on Git name). */
+async function promptAuthorGitUsername() {
+    const gitName = await (0, git_1.getGitUsername)();
+    const suggestedUsername = gitName
+        ? gitName.toLowerCase().replaceAll(/\s+/g, "")
+        : undefined;
+    const finalGitUserName = await prompts_1.default.textInput("Under which GitHub account would this repository be stored?", undefined, suggestedUsername);
+    return (0, utils_1.toSlug)(finalGitUserName);
+}

package/dist/resources/package/setup.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageDirectory = createPackageDirectory;
+exports.applyTemplateModifications = applyTemplateModifications;
+exports.getRequiredGithubSecrets = getRequiredGithubSecrets;
+exports.writePackageTemplateFiles = writePackageTemplateFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const MIT_json_1 = __importDefault(require("spdx-license-list/licenses/MIT.json"));
+const fs_1 = require("../../core/fs");
+const template_registry_1 = require("../../core/template-registry");
+const config_1 = require("./config");
+/**
+ * Creates the package directory based on the provided package name.
+ * @param cwd - Current working directory (e.g., process.cwd()).
+ * @param packageName - The name of the package, used as the directory name.
+ * @returns The absolute path to the created package directory.
+ */
+async function createPackageDirectory(cwd, packageName) {
+    const targetDir = node_path_1.default.resolve(cwd, packageName);
+    await (0, fs_1.ensureDirAsync)(targetDir);
+    return targetDir;
+}
+/**
+ * Create the package.json using the provided answers and package manager version.
+ * @param targetDir - Absolute path to the package directory.
+ * @param generateConfig - Generate configuration describing the new package.
+ * @param packageManagerVersion - A string like "pnpm@9.0.0" to record in package.json's packageManager.
+ * @returns The final package.json object that was persisted to disk.
+ * @throws If an existing package.json is invalid JSON.
+ */
+async function applyTemplateModifications(targetDir, generateConfig, packageManagerVersion) {
+    const chosenTemplateDir = await (0, template_registry_1.resolveTemplatesDir)(generateConfig.lang, `package/${generateConfig.template}`);
+    const hasPlayground = await (0, fs_1.isDirAsync)(node_path_1.default.join(chosenTemplateDir, "playground"));
+    const templateMetadata = {
+        packageManagerVersion,
+        templateHasPlayground: hasPlayground,
+        ...generateConfig,
+    };
+    await (0, fs_1.renderMustacheTemplates)(targetDir, templateMetadata);
+    // Remove public files after rendering, so templated files match by basename
+    if (!generateConfig.public) {
+        const publicFiles = [
+            ...config_1.templatePublicPaths.shared,
+            ...(config_1.templatePublicPaths[generateConfig.lang] ?? []),
+        ];
+        await (0, fs_1.removeFilesByBasename)(targetDir, publicFiles);
+    }
+}
+async function getRequiredGithubSecrets(targetDir) {
+    const secrets = new Set();
+    try {
+        const workflowsDir = node_path_1.default.join(targetDir, ".github", "workflows");
+        const entries = await node_fs_1.default.promises.readdir(workflowsDir, {
+            withFileTypes: true,
+        });
+        const files = entries
+            .filter((e) => e.isFile())
+            .map((e) => node_path_1.default.join(workflowsDir, e.name));
+        const secretRegex = /secrets\.([A-Z0-9_]+)/g;
+        for (const file of files) {
+            const content = await node_fs_1.default.promises.readFile(file, "utf8");
+            for (const match of content.matchAll(secretRegex)) {
+                const key = match[1];
+                if (key && key.toUpperCase() !== "GITHUB_TOKEN") {
+                    secrets.add(key);
+                }
+            }
+        }
+    }
+    catch {
+        // No workflows directory found; ignore
+    }
+    return Array.from(secrets).sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Write the chosen template files for a resource into the target directory.
+ * @param targetDir - Package root directory to write into.
+ * @param generateConfig - Generate configuration describing the new package.
+ * @returns A promise that resolves when the template files have been written.
+ */
+async function writePackageTemplateFiles(targetDir, generateConfig) {
+    // Global shared: templates/shared
+    const globalShared = await (0, template_registry_1.resolveTemplatesDir)("shared");
+    await (0, fs_1.copyDirSafeAsync)(globalShared, targetDir);
+    // Language shared: templates/<lang>/shared
+    const langShared = await (0, template_registry_1.resolveTemplatesDir)(generateConfig.lang, "shared");
+    await (0, fs_1.copyDirSafeAsync)(langShared, targetDir);
+    // Item-specific shared: templates/<lang>/package/shared
+    const itemShared = await (0, template_registry_1.resolveTemplatesDir)(generateConfig.lang, "package/shared");
+    await (0, fs_1.copyDirSafeAsync)(itemShared, targetDir);
+    // Item-specific template: templates/<lang>/package/<template>
+    const chosenTemplateDir = await (0, template_registry_1.resolveTemplatesDir)(generateConfig.lang, `package/${generateConfig.template}`);
+    await (0, fs_1.copyDirSafeAsync)(chosenTemplateDir, targetDir);
+    // Add MIT license
+    if (generateConfig.public && generateConfig.authorName) {
+        const year = new Date().getFullYear().toString();
+        const licenseText = MIT_json_1.default.licenseText
+            .replace("<year>", year)
+            .replace("<copyright holders>", generateConfig.authorName);
+        await (0, fs_1.writeFileAsync)(node_path_1.default.join(targetDir, "LICENSE"), licenseText);
+    }
+}

package/dist/resources/package/typescript.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTypescriptPackageName = validateTypescriptPackageName;
+const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
+/**
+ * Validates a JavaScript package name to ensure it conforms to NPM package name rules.
+ * @param {string} name - The package name to validate.
+ * @returns {true | string} true if the name is valid for new packages; otherwise an error string describing the issues.
+ */
+function validateTypescriptPackageName(name) {
+    const res = (0, validate_npm_package_name_1.default)(name);
+    if (res.validForNewPackages)
+        return true;
+    const errors = [...(res.errors || []), ...(res.warnings || [])].join(", ");
+    return `Invalid package name: ${errors}`;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+	"version": "0.0.8",
+	"name": "yehle",
+	"description": "An opinionated book of spells for the modern developer",
+	"bin": "./bin/cli.js",
+	"files": [
+		"dist",
+		"bin",
+		"README.md",
+		"LICENSE"
+	],
+	"author": "Rohit Agrawal <https://github.com/agrawal-rohit>",
+	"repository": "https://github.com/agrawal-rohit/yehle",
+	"homepage": "https://github.com/agrawal-rohit/yehle#readme",
+	"license": "MIT",
+	"private": false,
+	"bugs": "https://github.com/agrawal-rohit/yehle/issues",
+	"scripts": {
+		"test": "vitest",
+		"test-mutations": "stryker run",
+		"build": "tsc",
+		"typecheck": "tsc --noEmit",
+		"lint": "pnpm exec biome lint --write",
+		"format": "pnpm exec biome format --write",
+		"check": "pnpm run typecheck && pnpm exec biome check --write",
+		"check:ci": "pnpm run typecheck && pnpm exec biome check",
+		"cov": "vitest run --coverage --passWithNoTests",
+		"prepack": "pnpm run build",
+		"prepare": "husky"
+	},
+	"dependencies": {
+		"cac": "^6.7.14",
+		"chalk": "^5.6.2",
+		"consola": "^3.2.3",
+		"giget": "^2.0.0",
+		"listr2": "^9.0.5",
+		"log-update": "^7.0.2",
+		"mustache": "^4.2.0",
+		"spdx-license-list": "^6.10.0",
+		"validate-npm-package-name": "7.0.1"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.2.3",
+		"@commitlint/cli": "^19.8.1",
+		"@commitlint/config-conventional": "^19.8.1",
+		"@stryker-mutator/core": "^9.4.0",
+		"@stryker-mutator/vitest-runner": "^9.4.0",
+		"@stryker-mutator/typescript-checker": "^9.4.0",
+		"@types/jest": "^30.0.0",
+		"@types/mustache": "^4.2.5",
+		"@types/node": "^24.3.1",
+		"@types/validate-npm-package-name": "^4.0.2",
+		"@vitest/coverage-v8": "3.2.4",
+		"git-cliff": "^2.10.1",
+		"glob": ">=10.5.0",
+		"husky": "^9.1.7",
+		"jest": "^30.1.3",
+		"lint-staged": "^16.1.6",
+		"typescript": "^5.9.2",
+		"vitest": "^3.2.4"
+	},
+	"packageManager": "pnpm@10.15.1+sha512.34e538c329b5553014ca8e8f4535997f96180a1d0f614339357449935350d924e22f8614682191264ec33d1462ac21561aff97f6bb18065351c162c7e8f6de67"
+}