@agiflowai/aicode-utils 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,10 +1,365 @@
 import { createRequire } from "node:module";
+import * as path$1 from "node:path";
 import path from "node:path";
 import * as fs from "fs-extra";
+import * as os from "node:os";
+import pino from "pino";
+import chalk from "chalk";
 
 //#region rolldown:runtime
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+//#endregion
+//#region src/constants/projectType.ts
+/**
+* Project type constants
+*/
+const ProjectType = {
+	MONOLITH: "monolith",
+	MONOREPO: "monorepo"
+};
+/**
+* Config source constants
+*/
+const ConfigSource = {
+	PROJECT_JSON: "project.json",
+	TOOLKIT_YAML: "toolkit.yaml"
+};
+
+//#endregion
+//#region src/utils/logger.ts
+const logsDir = path$1.join(os.tmpdir(), "scaffold-mcp-logs");
+const logger = pino({
+	level: process.env.LOG_LEVEL || "debug",
+	timestamp: pino.stdTimeFunctions.isoTime
+}, pino.destination({
+	dest: path$1.join(logsDir, "scaffold-mcp.log"),
+	mkdir: true,
+	sync: true
+}));
+const log = {
+	debug: (msg, ...args) => logger.debug({ args }, msg),
+	info: (msg, ...args) => logger.info({ args }, msg),
+	warn: (msg, ...args) => logger.warn({ args }, msg),
+	error: (msg, ...args) => logger.error({ args }, msg)
+};
+
+//#endregion
+//#region src/services/TemplatesManagerService.ts
+var TemplatesManagerService = class TemplatesManagerService {
+	static SCAFFOLD_CONFIG_FILE = "scaffold.yaml";
+	static TEMPLATES_FOLDER = "templates";
+	static TOOLKIT_CONFIG_FILE = "toolkit.yaml";
+	/**
+	* Find the templates directory by searching upwards from the starting path.
+	*
+	* Algorithm:
+	* 1. Start from the provided path (default: current working directory)
+	* 2. Search upwards to find the workspace root (where .git exists or filesystem root)
+	* 3. Check if toolkit.yaml exists at workspace root
+	*    - If yes, read templatesPath from toolkit.yaml
+	*    - If no, default to 'templates' folder in workspace root
+	* 4. Verify the templates directory exists
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The absolute path to the templates directory
+	* @throws Error if templates directory is not found
+	*/
+	static async findTemplatesPath(startPath = process.cwd()) {
+		const workspaceRoot = await TemplatesManagerService.findWorkspaceRoot(startPath);
+		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManagerService.TOOLKIT_CONFIG_FILE);
+		if (await fs.pathExists(toolkitConfigPath)) {
+			const yaml = await import("js-yaml");
+			const content = await fs.readFile(toolkitConfigPath, "utf-8");
+			const config = yaml.load(content);
+			if (config?.templatesPath) {
+				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
+				if (await fs.pathExists(templatesPath$1)) return templatesPath$1;
+				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
+			}
+		}
+		const templatesPath = path.join(workspaceRoot, TemplatesManagerService.TEMPLATES_FOLDER);
+		if (await fs.pathExists(templatesPath)) return templatesPath;
+		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
+	}
+	/**
+	* Find the workspace root by searching upwards for .git folder
+	*/
+	static async findWorkspaceRoot(startPath) {
+		let currentPath = path.resolve(startPath);
+		const rootPath = path.parse(currentPath).root;
+		while (true) {
+			const gitPath = path.join(currentPath, ".git");
+			if (await fs.pathExists(gitPath)) return currentPath;
+			if (currentPath === rootPath) return process.cwd();
+			currentPath = path.dirname(currentPath);
+		}
+	}
+	/**
+	* Get the templates path synchronously.
+	* Use this when you need immediate access and are sure templates exist.
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The absolute path to the templates directory
+	* @throws Error if templates directory is not found
+	*/
+	static findTemplatesPathSync(startPath = process.cwd()) {
+		const workspaceRoot = TemplatesManagerService.findWorkspaceRootSync(startPath);
+		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManagerService.TOOLKIT_CONFIG_FILE);
+		if (fs.pathExistsSync(toolkitConfigPath)) {
+			const yaml = __require("js-yaml");
+			const content = fs.readFileSync(toolkitConfigPath, "utf-8");
+			const config = yaml.load(content);
+			if (config?.templatesPath) {
+				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
+				if (fs.pathExistsSync(templatesPath$1)) return templatesPath$1;
+				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
+			}
+		}
+		const templatesPath = path.join(workspaceRoot, TemplatesManagerService.TEMPLATES_FOLDER);
+		if (fs.pathExistsSync(templatesPath)) return templatesPath;
+		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
+	}
+	/**
+	* Find the workspace root synchronously by searching upwards for .git folder
+	*/
+	static findWorkspaceRootSync(startPath) {
+		let currentPath = path.resolve(startPath);
+		const rootPath = path.parse(currentPath).root;
+		while (true) {
+			const gitPath = path.join(currentPath, ".git");
+			if (fs.pathExistsSync(gitPath)) return currentPath;
+			if (currentPath === rootPath) return process.cwd();
+			currentPath = path.dirname(currentPath);
+		}
+	}
+	/**
+	* Check if templates are initialized at the given path
+	*
+	* @param templatesPath - Path to check for templates
+	* @returns true if templates folder exists and is a directory
+	*/
+	static async isInitialized(templatesPath) {
+		if (!await fs.pathExists(templatesPath)) return false;
+		return (await fs.stat(templatesPath)).isDirectory();
+	}
+	/**
+	* Get the scaffold config file name
+	*/
+	static getConfigFileName() {
+		return TemplatesManagerService.SCAFFOLD_CONFIG_FILE;
+	}
+	/**
+	* Get the templates folder name
+	*/
+	static getTemplatesFolderName() {
+		return TemplatesManagerService.TEMPLATES_FOLDER;
+	}
+	/**
+	* Read toolkit.yaml configuration from workspace root
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The toolkit configuration object or null if not found
+	*/
+	static async readToolkitConfig(startPath = process.cwd()) {
+		const workspaceRoot = await TemplatesManagerService.findWorkspaceRoot(startPath);
+		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManagerService.TOOLKIT_CONFIG_FILE);
+		if (!await fs.pathExists(toolkitConfigPath)) return null;
+		const yaml = await import("js-yaml");
+		const content = await fs.readFile(toolkitConfigPath, "utf-8");
+		return yaml.load(content);
+	}
+	/**
+	* Read toolkit.yaml configuration from workspace root (sync)
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The toolkit configuration object or null if not found
+	*/
+	static readToolkitConfigSync(startPath = process.cwd()) {
+		const workspaceRoot = TemplatesManagerService.findWorkspaceRootSync(startPath);
+		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManagerService.TOOLKIT_CONFIG_FILE);
+		if (!fs.pathExistsSync(toolkitConfigPath)) return null;
+		const yaml = __require("js-yaml");
+		const content = fs.readFileSync(toolkitConfigPath, "utf-8");
+		return yaml.load(content);
+	}
+	/**
+	* Write toolkit.yaml configuration to workspace root
+	*
+	* @param config - The toolkit configuration to write
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	*/
+	static async writeToolkitConfig(config, startPath = process.cwd()) {
+		const workspaceRoot = await TemplatesManagerService.findWorkspaceRoot(startPath);
+		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManagerService.TOOLKIT_CONFIG_FILE);
+		const content = (await import("js-yaml")).dump(config, { indent: 2 });
+		await fs.writeFile(toolkitConfigPath, content, "utf-8");
+	}
+	/**
+	* Get the workspace root directory
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The workspace root directory path
+	*/
+	static async getWorkspaceRoot(startPath = process.cwd()) {
+		return TemplatesManagerService.findWorkspaceRoot(startPath);
+	}
+	/**
+	* Get the workspace root directory (sync)
+	*
+	* @param startPath - The path to start searching from (defaults to process.cwd())
+	* @returns The workspace root directory path
+	*/
+	static getWorkspaceRootSync(startPath = process.cwd()) {
+		return TemplatesManagerService.findWorkspaceRootSync(startPath);
+	}
+};
+
+//#endregion
+//#region src/services/ProjectConfigResolver.ts
+/**
+* ProjectConfigResolver
+*
+* Resolves project configuration from multiple sources with priority:
+* 1. project.json (monorepo - Nx/Lerna/Turborepo)
+* 2. toolkit.yaml at workspace root (monolith)
+*/
+var ProjectConfigResolver = class ProjectConfigResolver {
+	/**
+	* Resolve project configuration with priority fallback
+	*
+	* Priority order:
+	* 1. Check for project.json (monorepo case)
+	* 2. Check for toolkit.yaml at workspace root (monolith case)
+	* 3. Error with helpful message
+	*
+	* @param projectPath - Absolute path to the project directory
+	* @param explicitTemplate - Optional explicit template override
+	* @returns Project configuration result
+	* @throws Error if no configuration found
+	*/
+	static async resolveProjectConfig(projectPath, explicitTemplate) {
+		try {
+			const absolutePath = path.resolve(projectPath);
+			if (explicitTemplate) return {
+				type: ProjectType.MONOLITH,
+				sourceTemplate: explicitTemplate,
+				configSource: ConfigSource.TOOLKIT_YAML
+			};
+			const projectJsonPath = path.join(absolutePath, "project.json");
+			if (await fs.pathExists(projectJsonPath)) {
+				const projectJson = await fs.readJson(projectJsonPath);
+				if (projectJson.sourceTemplate && typeof projectJson.sourceTemplate === "string" && projectJson.sourceTemplate.trim()) return {
+					type: ProjectType.MONOREPO,
+					sourceTemplate: projectJson.sourceTemplate.trim(),
+					configSource: ConfigSource.PROJECT_JSON
+				};
+			}
+			try {
+				const workspaceRoot = await TemplatesManagerService.getWorkspaceRoot(absolutePath);
+				const toolkitConfig = await TemplatesManagerService.readToolkitConfig(workspaceRoot);
+				if (toolkitConfig?.projectType === "monolith" && toolkitConfig.sourceTemplate) return {
+					type: ProjectType.MONOLITH,
+					sourceTemplate: toolkitConfig.sourceTemplate,
+					configSource: ConfigSource.TOOLKIT_YAML,
+					workspaceRoot
+				};
+			} catch (error) {}
+			throw new Error(ProjectConfigResolver.getHelpfulErrorMessage(absolutePath));
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("No project configuration found")) throw error;
+			throw new Error(`Failed to resolve project configuration at ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Get helpful error message when no configuration is found
+	*/
+	static getHelpfulErrorMessage(projectPath) {
+		return `No project configuration found at ${projectPath}.
+
+For monorepo projects:
+  - Ensure project.json exists with sourceTemplate field
+
+For monolith projects:
+  - Create toolkit.yaml at workspace root:
+
+    projectType: monolith
+    sourceTemplate: your-template-name
+
+  - OR use --template flag:
+    scaffold-mcp scaffold add <feature> --template <template-name>
+
+Run 'scaffold-mcp scaffold list --help' for more info.`;
+	}
+	/**
+	* Check if project has configuration (without throwing error)
+	*
+	* @param projectPath - Absolute path to the project directory
+	* @returns true if configuration exists, false otherwise
+	* @throws Error if there's a filesystem error (not just missing config)
+	*/
+	static async hasConfiguration(projectPath) {
+		try {
+			await ProjectConfigResolver.resolveProjectConfig(projectPath);
+			return true;
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("No project configuration found")) return false;
+			throw new Error(`Error checking project configuration: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Create toolkit.yaml for monolith projects
+	*
+	* @param sourceTemplate - The template identifier
+	* @param workspaceRoot - Optional workspace root path (defaults to current directory)
+	*/
+	static async createToolkitYaml(sourceTemplate, workspaceRoot) {
+		try {
+			const rootPath = workspaceRoot || await TemplatesManagerService.getWorkspaceRoot(process.cwd());
+			const existingConfig = await TemplatesManagerService.readToolkitConfig(rootPath);
+			const toolkitConfig = {
+				version: existingConfig?.version || "1.0",
+				templatesPath: existingConfig?.templatesPath || "./templates",
+				projectType: "monolith",
+				sourceTemplate
+			};
+			await TemplatesManagerService.writeToolkitConfig(toolkitConfig, rootPath);
+			log.info("Created toolkit.yaml with monolith configuration");
+		} catch (error) {
+			throw new Error(`Failed to create toolkit.yaml: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Create or update project.json for monorepo projects
+	*
+	* @param projectPath - Absolute path to the project directory
+	* @param projectName - Name of the project
+	* @param sourceTemplate - The template identifier
+	*/
+	static async createProjectJson(projectPath, projectName, sourceTemplate) {
+		const projectJsonPath = path.join(projectPath, "project.json");
+		try {
+			let projectJson;
+			if (await fs.pathExists(projectJsonPath)) projectJson = await fs.readJson(projectJsonPath);
+			else {
+				const relativePath = path.relative(projectPath, process.cwd());
+				projectJson = {
+					name: projectName,
+					$schema: relativePath ? `${relativePath}/node_modules/nx/schemas/project-schema.json` : "node_modules/nx/schemas/project-schema.json",
+					sourceRoot: projectPath,
+					projectType: "application"
+				};
+			}
+			projectJson.sourceTemplate = sourceTemplate;
+			const content = JSON.stringify(projectJson, null, 2);
+			await fs.writeFile(projectJsonPath, `${content}\n`);
+			log.info(`Created/updated project.json with sourceTemplate: ${sourceTemplate}`);
+		} catch (error) {
+			throw new Error(`Failed to create project.json: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+};
+
 //#endregion
 //#region src/services/ProjectFinderService.ts
 var ProjectFinderService = class {
@@ -199,117 +554,117 @@ var ScaffoldProcessingService = class {
 };
 
 //#endregion
-//#region src/services/TemplatesManagerService.ts
-var TemplatesManagerService = class TemplatesManagerService {
-	static SCAFFOLD_CONFIG_FILE = "scaffold.yaml";
-	static TEMPLATES_FOLDER = "templates";
-	static TOOLKIT_CONFIG_FILE = "toolkit.yaml";
-	/**
-	* Find the templates directory by searching upwards from the starting path.
-	*
-	* Algorithm:
-	* 1. Start from the provided path (default: current working directory)
-	* 2. Search upwards to find the workspace root (where .git exists or filesystem root)
-	* 3. Check if toolkit.yaml exists at workspace root
-	*    - If yes, read templatesPath from toolkit.yaml
-	*    - If no, default to 'templates' folder in workspace root
-	* 4. Verify the templates directory exists
-	*
-	* @param startPath - The path to start searching from (defaults to process.cwd())
-	* @returns The absolute path to the templates directory
-	* @throws Error if templates directory is not found
-	*/
-	static async findTemplatesPath(startPath = process.cwd()) {
-		const workspaceRoot = await TemplatesManagerService.findWorkspaceRoot(startPath);
-		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManagerService.TOOLKIT_CONFIG_FILE);
-		if (await fs.pathExists(toolkitConfigPath)) {
-			const yaml = await import("js-yaml");
-			const content = await fs.readFile(toolkitConfigPath, "utf-8");
-			const config = yaml.load(content);
-			if (config?.templatesPath) {
-				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
-				if (await fs.pathExists(templatesPath$1)) return templatesPath$1;
-				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
-			}
-		}
-		const templatesPath = path.join(workspaceRoot, TemplatesManagerService.TEMPLATES_FOLDER);
-		if (await fs.pathExists(templatesPath)) return templatesPath;
-		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
-	}
-	/**
-	* Find the workspace root by searching upwards for .git folder
-	*/
-	static async findWorkspaceRoot(startPath) {
-		let currentPath = path.resolve(startPath);
-		const rootPath = path.parse(currentPath).root;
-		while (true) {
-			const gitPath = path.join(currentPath, ".git");
-			if (await fs.pathExists(gitPath)) return currentPath;
-			if (currentPath === rootPath) return process.cwd();
-			currentPath = path.dirname(currentPath);
-		}
-	}
-	/**
-	* Get the templates path synchronously.
-	* Use this when you need immediate access and are sure templates exist.
-	*
-	* @param startPath - The path to start searching from (defaults to process.cwd())
-	* @returns The absolute path to the templates directory
-	* @throws Error if templates directory is not found
-	*/
-	static findTemplatesPathSync(startPath = process.cwd()) {
-		const workspaceRoot = TemplatesManagerService.findWorkspaceRootSync(startPath);
-		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManagerService.TOOLKIT_CONFIG_FILE);
-		if (fs.pathExistsSync(toolkitConfigPath)) {
-			const yaml = __require("js-yaml");
-			const content = fs.readFileSync(toolkitConfigPath, "utf-8");
-			const config = yaml.load(content);
-			if (config?.templatesPath) {
-				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
-				if (fs.pathExistsSync(templatesPath$1)) return templatesPath$1;
-				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
-			}
-		}
-		const templatesPath = path.join(workspaceRoot, TemplatesManagerService.TEMPLATES_FOLDER);
-		if (fs.pathExistsSync(templatesPath)) return templatesPath;
-		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
-	}
-	/**
-	* Find the workspace root synchronously by searching upwards for .git folder
-	*/
-	static findWorkspaceRootSync(startPath) {
-		let currentPath = path.resolve(startPath);
-		const rootPath = path.parse(currentPath).root;
-		while (true) {
-			const gitPath = path.join(currentPath, ".git");
-			if (fs.pathExistsSync(gitPath)) return currentPath;
-			if (currentPath === rootPath) return process.cwd();
-			currentPath = path.dirname(currentPath);
-		}
-	}
-	/**
-	* Check if templates are initialized at the given path
-	*
-	* @param templatesPath - Path to check for templates
-	* @returns true if templates folder exists and is a directory
-	*/
-	static async isInitialized(templatesPath) {
-		if (!await fs.pathExists(templatesPath)) return false;
-		return (await fs.stat(templatesPath)).isDirectory();
+//#region src/utils/print.ts
+/**
+* Themed console utilities for consistent CLI output
+*/
+const print = {
+	info: (message) => {
+		console.log(chalk.cyan(message));
+	},
+	success: (message) => {
+		console.log(chalk.green(message));
+	},
+	warning: (message) => {
+		console.log(chalk.yellow(message));
+	},
+	error: (message, error) => {
+		if (error) {
+			const errorMsg = error instanceof Error ? error.message : error;
+			console.error(chalk.red(message), errorMsg);
+		} else console.error(chalk.red(message));
+	},
+	debug: (message) => {
+		console.log(chalk.gray(message));
+	},
+	header: (message) => {
+		console.log(chalk.bold.cyan(message));
+	},
+	item: (message) => {
+		console.log(chalk.gray(`   - ${message}`));
+	},
+	indent: (message) => {
+		console.log(chalk.gray(`   ${message}`));
+	},
+	highlight: (message) => {
+		console.log(chalk.bold.green(message));
+	},
+	newline: () => {
+		console.log();
 	}
-	/**
-	* Get the scaffold config file name
-	*/
-	static getConfigFileName() {
-		return TemplatesManagerService.SCAFFOLD_CONFIG_FILE;
+};
+/**
+* Emoji icons for consistent visual markers
+*/
+const icons = {
+	rocket: "🚀",
+	check: "✅",
+	cross: "❌",
+	warning: "⚠️",
+	info: "ℹ️",
+	package: "📦",
+	folder: "📁",
+	file: "📄",
+	config: "📝",
+	wrench: "🔧",
+	chart: "📊",
+	bulb: "💡",
+	download: "⬇️",
+	upload: "⬆️",
+	gear: "⚙️",
+	clipboard: "📋",
+	skip: "⏭"
+};
+/**
+* Themed message helpers
+*/
+const messages = {
+	info: (message) => {
+		print.info(`${icons.info} ${message}`);
+	},
+	success: (message) => {
+		print.success(`${icons.check} ${message}`);
+	},
+	error: (message, error) => {
+		print.error(`${icons.cross} ${message}`, error);
+	},
+	warning: (message) => {
+		print.warning(`${icons.warning} ${message}`);
+	},
+	hint: (message) => {
+		print.warning(`${icons.bulb} ${message}`);
+	},
+	loading: (message) => {
+		print.info(`${icons.rocket} ${message}`);
 	}
-	/**
-	* Get the templates folder name
-	*/
-	static getTemplatesFolderName() {
-		return TemplatesManagerService.TEMPLATES_FOLDER;
+};
+/**
+* Section formatters
+*/
+const sections = {
+	header: (title) => {
+		print.newline();
+		print.header(`${title}`);
+		print.newline();
+	},
+	list: (title, items) => {
+		print.header(`\n${title}\n`);
+		items.forEach((item) => print.item(item));
+	},
+	nextSteps: (steps) => {
+		print.header(`\n${icons.clipboard} Next steps:`);
+		steps.forEach((step) => print.indent(step));
+	},
+	createdFiles: (files, maxShow = 10) => {
+		print.header(`\n${icons.folder} Created files:`);
+		files.slice(0, maxShow).forEach((file) => print.item(file));
+		if (files.length > maxShow) print.indent(`... and ${files.length - maxShow} more files`);
+	},
+	warnings: (warnings) => {
+		print.warning(`\n${icons.warning} Warnings:`);
+		warnings.forEach((warning) => print.item(warning));
 	}
 };
 
 //#endregion
-export { ProjectFinderService, ScaffoldProcessingService, TemplatesManagerService };
+export { ConfigSource, ProjectConfigResolver, ProjectFinderService, ProjectType, ScaffoldProcessingService, TemplatesManagerService, icons, log, logger, messages, print, sections };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agiflowai/aicode-utils",
   "description": "Shared utilities and types for AI-powered code generation, scaffolding, and analysis",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "AGPL-3.0",
   "author": "AgiflowIO",
   "repository": {
@@ -30,8 +30,10 @@
     "README.md"
   ],
   "dependencies": {
+    "chalk": "5.6.2",
     "fs-extra": "11.3.2",
-    "js-yaml": "4.1.0"
+    "js-yaml": "4.1.0",
+    "pino": "^10.0.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",