@aifabrix/builder 2.40.2 → 2.42.0

package/lib/validation/validate-batch.js

@@ -0,0 +1,149 @@
+/**
+ * Batch validation helpers for validate --integration / --builder.
+ * @fileoverview Builds batch results and runs validation across multiple apps
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { listIntegrationAppNames, listBuilderAppNames } = require('../utils/paths');
+
+/**
+ * Collects error strings from a single validation result (various shapes).
+ * @param {Object} result - Single-app validation result
+ * @returns {string[]} Error messages
+ */
+function collectResultErrors(result) {
+  const errs = [];
+  if (result.errors && Array.isArray(result.errors)) {
+    errs.push(...result.errors);
+  }
+  if (result.application && result.application.errors && Array.isArray(result.application.errors)) {
+    errs.push(...result.application.errors);
+  }
+  if (result.steps) {
+    ['application', 'components', 'manifest'].forEach(step => {
+      const s = result.steps[step];
+      if (s && s.errors && Array.isArray(s.errors)) {
+        errs.push(...s.errors);
+      }
+    });
+  }
+  return errs;
+}
+
+/**
+ * Collects warning strings from a single validation result.
+ * @param {Object} result - Single-app validation result
+ * @returns {string[]} Warning messages
+ */
+function collectResultWarnings(result) {
+  const w = [];
+  if (result.warnings && Array.isArray(result.warnings)) {
+    w.push(...result.warnings);
+  }
+  if (result.application && result.application.warnings && Array.isArray(result.application.warnings)) {
+    w.push(...result.application.warnings);
+  }
+  if (result.steps) {
+    ['application', 'components', 'manifest'].forEach(step => {
+      const s = result.steps[step];
+      if (s && s.warnings && Array.isArray(s.warnings)) {
+        w.push(...s.warnings);
+      }
+    });
+  }
+  return w;
+}
+
+/**
+ * Builds batch result from per-app results. Each item has appName and either result or error.
+ * @param {Array<{appName: string, result?: Object, error?: string}>} items - Per-app results
+ * @returns {{ batch: true, valid: boolean, results: Array, errors: string[], warnings: string[] }}
+ */
+function buildBatchResult(items) {
+  const errors = [];
+  const warnings = [];
+  items.forEach(item => {
+    if (item.error) {
+      errors.push(`${item.appName}: ${item.error}`);
+    } else if (item.result) {
+      collectResultErrors(item.result).forEach(e => errors.push(`${item.appName}: ${e}`));
+      collectResultWarnings(item.result).forEach(w => warnings.push(`${item.appName}: ${w}`));
+    }
+  });
+  const valid = items.every(item => item.result && item.result.valid);
+  return {
+    batch: true,
+    valid,
+    results: items,
+    errors,
+    warnings
+  };
+}
+
+/**
+ * Validates all apps under integration/ (each as external system).
+ * @async
+ * @param {Function} validateAppOrFile - validateAppOrFile(appName, options) from validate.js
+ * @param {Object} [options] - Validation options
+ * @returns {Promise<{ batch: true, valid: boolean, results: Array, errors: string[], warnings: string[] }>}
+ */
+async function validateAllIntegrations(validateAppOrFile, options = {}) {
+  const names = listIntegrationAppNames();
+  const items = [];
+  for (const appName of names) {
+    try {
+      const result = await validateAppOrFile(appName, options);
+      items.push({ appName, result });
+    } catch (error) {
+      items.push({ appName, error: error.message || String(error) });
+    }
+  }
+  return buildBatchResult(items);
+}
+
+/**
+ * Validates all apps under builder/.
+ * @async
+ * @param {Function} validateAppOrFile - validateAppOrFile(appName, options) from validate.js
+ * @param {Object} [options] - Validation options
+ * @returns {Promise<{ batch: true, valid: boolean, results: Array, errors: string[], warnings: string[] }>}
+ */
+async function validateAllBuilderApps(validateAppOrFile, options = {}) {
+  const names = listBuilderAppNames();
+  const items = [];
+  for (const appName of names) {
+    try {
+      const result = await validateAppOrFile(appName, options);
+      items.push({ appName, result });
+    } catch (error) {
+      items.push({ appName, error: error.message || String(error) });
+    }
+  }
+  return buildBatchResult(items);
+}
+
+/**
+ * Validates all integration and builder apps in one run.
+ * @async
+ * @param {Function} validateAppOrFile - validateAppOrFile(appName, options) from validate.js
+ * @param {Object} [options] - Validation options
+ * @returns {Promise<{ batch: true, valid: boolean, results: Array, errors: string[], warnings: string[] }>}
+ */
+async function validateAll(validateAppOrFile, options = {}) {
+  const [integrationResult, builderResult] = await Promise.all([
+    validateAllIntegrations(validateAppOrFile, options),
+    validateAllBuilderApps(validateAppOrFile, options)
+  ]);
+  const mergedResults = [...integrationResult.results, ...builderResult.results];
+  return buildBatchResult(mergedResults);
+}
+
+module.exports = {
+  buildBatchResult,
+  collectResultErrors,
+  collectResultWarnings,
+  validateAllIntegrations,
+  validateAllBuilderApps,
+  validateAll
+};

package/lib/validation/validate-datasource-keys-api.js

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Async validation of datasourceKeys against dataplane API
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { getPlatformDetails } = require('../api/wizard.api');
+const { validateDatasourceKeysForPlatform } = require('./wizard-datasource-validation');
+
+/**
+ * Validate datasourceKeys against platform's available datasources; throws if invalid
+ * @async
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Auth config
+ * @param {string} platformKey - Platform key
+ * @param {string[]} datasourceKeys - Datasource keys to validate
+ * @throws {Error} If any key is invalid
+ */
+async function validateDatasourceKeysBeforePlatformConfig(dataplaneUrl, authConfig, platformKey, datasourceKeys) {
+  if (!Array.isArray(datasourceKeys) || datasourceKeys.length === 0) return;
+  const platformDetails = await getPlatformDetails(dataplaneUrl, authConfig, platformKey);
+  const datasources = platformDetails?.data?.datasources ?? platformDetails?.datasources ?? [];
+  const { valid, invalidKeys } = validateDatasourceKeysForPlatform(datasourceKeys, datasources);
+  if (!valid) {
+    const availableKeys = datasources.map(d => d.key).filter(Boolean);
+    throw new Error(
+      `Invalid datasource keys: [${invalidKeys.join(', ')}]. ` +
+      `Available for platform '${platformKey}': [${availableKeys.join(', ')}].`
+    );
+  }
+}
+
+module.exports = { validateDatasourceKeysBeforePlatformConfig };

package/lib/validation/validate-display.js

@@ -8,6 +8,7 @@
  * @version 2.0.0
  */
 
+const path = require('path');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { loadConfigFile } = require('../utils/config-format');
@@ -242,22 +243,25 @@ function displayApplicationStep(application) {
  * @returns {void}
  */
 function displayComponentsStep(components) {
-  if (!components.files || components.files.length === 0) {
+  const hasFiles = components.files && components.files.length > 0;
+  const hasErrors = components.errors && components.errors.length > 0;
+  if (!hasFiles && !hasErrors) {
     return;
   }
 
   logger.log(chalk.blue('\nExternal Integration Files:'));
-  components.files.forEach(file => {
-    if (file.valid) {
-      logger.log(chalk.green(`  ✓ ${file.file} (${file.type})`));
-    } else {
-      logger.log(chalk.red(`  ✗ ${file.file} (${file.type})`));
-    }
-  });
-
-  if (components.errors && components.errors.length > 0) {
+  if (hasFiles) {
+    components.files.forEach(file => {
+      if (file.valid) {
+        logger.log(chalk.green(`  ✓ ${file.file} (${file.type})`));
+      } else {
+        logger.log(chalk.red(`  ✗ ${file.file} (${file.type})`));
+      }
+    });
+  }
+  if (hasErrors) {
     components.errors.forEach(error => {
-      logger.log(chalk.red(`    • ${error}`));
+      logger.log(chalk.red(`  • ${error}`));
     });
   }
 }
@@ -301,7 +305,9 @@ function displayDimensionsStep(datasourceFiles) {
  */
 function displayManifestStep(manifest, componentFiles) {
   logger.log(chalk.blue('\nDeployment Manifest:'));
-  if (manifest.valid) {
+  if (manifest.skipped) {
+    logger.log(chalk.yellow('  ⊘ Skipped (fix errors above first)'));
+  } else if (manifest.valid) {
     logger.log(chalk.green('  ✓ Full deployment manifest is valid'));
     if (componentFiles) {
       const datasourceFiles = componentFiles.filter(f => f.type === 'datasource' || f.type === 'external-datasource');
@@ -311,10 +317,14 @@ function displayManifestStep(manifest, componentFiles) {
     }
   } else {
     logger.log(chalk.red('  ✗ Full deployment manifest validation failed:'));
-    if (manifest.errors && manifest.errors.length > 0) {
-      manifest.errors.forEach(error => {
-        logger.log(chalk.red(`    • ${error}`));
+    const errs = manifest.errors && manifest.errors.length > 0 ? manifest.errors : [];
+    if (errs.length > 0) {
+      errs.forEach(error => {
+        const msg = typeof error === 'string' ? error : String(error);
+        logger.log(chalk.red(`    • ${msg}`));
       });
+    } else {
+      logger.log(chalk.red('    • No error details available (check schema and manifest structure).'));
     }
   }
   if (manifest.warnings && manifest.warnings.length > 0) {
@@ -338,7 +348,7 @@ function displayStepByStepValidation(result) {
 
   displayApplicationStep(result.steps.application);
 
-  if (result.steps.components.files && result.steps.components.files.length > 0) {
+  if (!result.steps.components.valid || (result.steps.components.files && result.steps.components.files.length > 0)) {
     displayComponentsStep(result.steps.components);
   }
 
@@ -356,6 +366,68 @@ function displayStepByStepValidation(result) {
   if (result.warnings && result.warnings.length > 0) {
     displayAggregatedWarnings(result.warnings);
   }
+
+  displayOverallStatus(result);
+  if (result.appPath) {
+    logger.log(chalk.gray(`\n${path.resolve(result.appPath)}`));
+  }
+}
+
+/**
+ * Displays batch validation results (per-app blocks then summary).
+ * Expects batchResult.batch === true and batchResult.results.
+ * @function displayBatchValidationResults
+ * @param {Object} batchResult - Batch result from validateAllIntegrations / validateAllBuilderApps / validateAll
+ */
+function displayBatchValidationResults(batchResult) {
+  if (!batchResult || batchResult.batch !== true || !Array.isArray(batchResult.results)) {
+    return;
+  }
+
+  const results = batchResult.results;
+  results.forEach(item => {
+    logger.log(chalk.blue(`\n--- ${item.appName} ---`));
+    if (item.error) {
+      logger.log(chalk.red(`  ✗ ${item.error}`));
+    } else if (item.result) {
+      displayValidationResults(item.result);
+    }
+  });
+
+  const passed = results.filter(r => r.result && r.result.valid).length;
+  const failed = results.length - passed;
+  logger.log(chalk.blue('\n--- Summary ---'));
+  if (failed === 0) {
+    logger.log(chalk.green(`✓ ${passed} passed, 0 failed`));
+    logger.log(chalk.green('Overall: Passed'));
+  } else {
+    logger.log(chalk.red(`✗ ${passed} passed, ${failed} failed`));
+    logger.log(chalk.red('Overall: Failed'));
+  }
+}
+
+/**
+ * Displays overall validation status
+ * @param {Object} result - Validation result
+ */
+function displayOverallStatus(result) {
+  let hasErrors = result.errors && result.errors.length > 0;
+  if (!hasErrors && result.steps) {
+    const stepErrors = [result.steps.application, result.steps.components, result.steps.manifest]
+      .filter(Boolean)
+      .some(s => s.errors && s.errors.length > 0);
+    if (stepErrors) {
+      hasErrors = true;
+    }
+  }
+  const hasWarnings = result.warnings && result.warnings.length > 0;
+  if (hasErrors) {
+    logger.log(chalk.red('\nOverall: Failed'));
+  } else if (hasWarnings) {
+    logger.log(chalk.yellow('\nOverall: Passed with warnings'));
+  } else {
+    logger.log(chalk.green('\nOverall: Passed'));
+  }
 }
 
 /**
@@ -390,10 +462,16 @@ function displayValidationResults(result) {
   // Combine all warnings
   const allWarnings = [...(result.warnings || []), ...dimensionWarnings];
   displayAggregatedWarnings(allWarnings);
+
+  displayOverallStatus(result);
+  if (result.appPath) {
+    logger.log(chalk.gray(`\n${path.resolve(result.appPath)}`));
+  }
 }
 
 module.exports = {
   displayValidationResults,
+  displayBatchValidationResults,
   displayStepByStepValidation,
   displayApplicationValidation,
   displayExternalFilesValidation,

package/lib/validation/validate.js

@@ -16,11 +16,16 @@ const { resolveExternalFiles } = require('../utils/schema-resolver');
 const { loadExternalSystemSchema, loadExternalDataSourceSchema, detectSchemaType } = require('../utils/schema-loader');
 const { formatValidationErrors } = require('../utils/error-formatter');
 const { detectAppType } = require('../utils/paths');
+const batch = require('./validate-batch');
 const { logOfflinePathWhenType } = require('../utils/cli-utils');
 const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
-const { displayValidationResults } = require('./validate-display');
+const { displayValidationResults, displayBatchValidationResults } = require('./validate-display');
 const { generateControllerManifest } = require('../generator/external-controller-manifest');
 const { validateControllerManifest } = require('./external-manifest-validator');
+const {
+  validateOAuth2GrantTypeAndAuthorizationUrl,
+  validateConfigurationNoStandardAuthVariables
+} = require('./external-system-auth-rules');
 
 /**
  * Validates a file path (detects type and validates)
@@ -191,6 +196,8 @@ async function validateExternalFile(filePath, type) {
 
   if (normalizedType === 'system') {
     validateRoleReferences(parseResult.parsed, errors);
+    validateOAuth2GrantTypeAndAuthorizationUrl(parseResult.parsed, errors);
+    validateConfigurationNoStandardAuthVariables(parseResult.parsed, errors);
   }
 
   return {
@@ -398,6 +405,7 @@ async function validateExternalSystemComplete(appName, options = {}) {
     throw new Error('App name is required and must be a string');
   }
 
+  const { appPath } = await detectAppType(appName, options);
   const steps = {
     application: { valid: false, errors: [], warnings: [] },
     components: { valid: false, errors: [], warnings: [], files: [] },
@@ -414,11 +422,13 @@ async function validateExternalSystemComplete(appName, options = {}) {
 
   // If components have errors, return early (don't validate manifest)
   if (!steps.components.valid) {
+    steps.manifest = { valid: true, errors: [], warnings: [], skipped: true };
     return {
       valid: false,
       errors: [...steps.application.errors, ...steps.components.errors],
       warnings: [...steps.application.warnings, ...steps.components.warnings],
-      steps
+      steps,
+      appPath
     };
   }
 
@@ -433,7 +443,8 @@ async function validateExternalSystemComplete(appName, options = {}) {
     valid: allErrors.length === 0,
     errors: allErrors,
     warnings: allWarnings,
-    steps
+    steps,
+    appPath
   };
 }
 
@@ -451,29 +462,31 @@ async function validateAppOrFile(appOrFile, options = {}) {
   const { appPath, isExternal } = await detectAppType(appName);
   logOfflinePathWhenType(appPath);
 
-  if (isExternal) {
-    return await validateExternalSystemComplete(appName, options);
-  }
+  if (isExternal) return await validateExternalSystemComplete(appName, options);
 
   const appValidation = await validator.validateApplication(appName, options);
   const rbacValidation = await validateRbacForExternalSystem(isExternal, appName);
-
   const variablesPath = resolveApplicationConfigPath(appPath);
   const earlyReturn = loadVariablesAndCheckExternalIntegration(variablesPath, appValidation);
-  if (earlyReturn) {
-    return earlyReturn;
-  }
+  if (earlyReturn) return earlyReturn;
 
   const externalValidations = await validateExternalFilesForApp(appName, options);
-  return aggregateValidationResults(appValidation, externalValidations, rbacValidation);
+  const result = aggregateValidationResults(appValidation, externalValidations, rbacValidation);
+  result.appPath = appPath;
+  return result;
 }
 
 module.exports = {
   validateAppOrFile,
   validateExternalSystemComplete,
   displayValidationResults,
+  displayBatchValidationResults,
   validateExternalFile,
   validateExternalFilesForApp,
-  validateFilePath
+  validateFilePath,
+  validateAllIntegrations: (opts = {}) => batch.validateAllIntegrations(validateAppOrFile, opts),
+  validateAllBuilderApps: (opts = {}) => batch.validateAllBuilderApps(validateAppOrFile, opts),
+  validateAll: (opts = {}) => batch.validateAll(validateAppOrFile, opts),
+  buildBatchResult: batch.buildBatchResult
 };
 

package/lib/validation/validator.js

@@ -21,6 +21,8 @@ const { checkEnvironment } = require('../utils/environment-checker');
 const { formatValidationErrors } = require('../utils/error-formatter');
 const { detectAppType, resolveApplicationConfigPath } = require('../utils/paths');
 const { loadConfigFile } = require('../utils/config-format');
+const { validateAuthKvCoverage } = require('./env-template-auth');
+const { validateKvReferencesInLines } = require('./env-template-kv');
 
 /**
  * Validates application config file against application schema
@@ -250,7 +252,7 @@ async function validateEnvTemplate(appName, options = {}) {
   }
 
   // Support both builder/ and integration/ directories using detectAppType
-  const { appPath } = await detectAppType(appName, options);
+  const { appPath, isExternal } = await detectAppType(appName, options);
   const templatePath = path.join(appPath, 'env.template');
 
   if (!fs.existsSync(templatePath)) {
@@ -281,14 +283,10 @@ async function validateEnvTemplate(appName, options = {}) {
     }
   });
 
-  // Check for kv:// reference format
-  const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
-  let match;
-  while ((match = kvPattern.exec(content)) !== null) {
-    const secretKey = match[1];
-    if (!secretKey) {
-      errors.push('Invalid kv:// reference format');
-    }
+  validateKvReferencesInLines(lines, errors);
+
+  if (isExternal) {
+    await validateAuthKvCoverage(appPath, content, errors, warnings, options);
   }
 
   return {
@@ -365,6 +363,69 @@ function validateDeploymentJson(deployment) {
   };
 }
 
+/** Pattern matching ${VAR} style unresolved variables in strings */
+const UNRESOLVED_VAR_REGEX = /\$\{[^}]+\}/g;
+
+/**
+ * Recursively finds all string values in obj that contain ${...} placeholders.
+ * Used to ensure deployment manifest has no unresolved variables before deploy.
+ *
+ * @function findUnresolvedVariablesInObject
+ * @param {Object} obj - Object to scan (e.g. deployment manifest)
+ * @param {string} [prefix=''] - Path prefix for error reporting
+ * @returns {string[]} List of paths with example placeholder (e.g. "port: ${PORT}")
+ *
+ * @example
+ * findUnresolvedVariablesInObject({ port: '${PORT}' }) // ['port: ${PORT}']
+ */
+function findUnresolvedVariablesInObject(obj, prefix = '') {
+  const found = [];
+  if (obj === null || obj === undefined) {
+    return found;
+  }
+  if (typeof obj === 'string') {
+    const matches = obj.match(UNRESOLVED_VAR_REGEX);
+    if (matches && matches.length > 0) {
+      const pathLabel = prefix || 'value';
+      found.push(`${pathLabel}: ${matches[0]}`);
+    }
+    return found;
+  }
+  if (Array.isArray(obj)) {
+    obj.forEach((item, i) => {
+      found.push(...findUnresolvedVariablesInObject(item, `${prefix}[${i}]`));
+    });
+    return found;
+  }
+  if (typeof obj === 'object') {
+    for (const [key, value] of Object.entries(obj)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      found.push(...findUnresolvedVariablesInObject(value, path));
+    }
+    return found;
+  }
+  return found;
+}
+
+/**
+ * Validates that deployment manifest contains no unresolved ${...} variables.
+ * Throws if any are found, with a message to use secret variables or literal values.
+ *
+ * @function validateNoUnresolvedVariablesInDeployment
+ * @param {Object} deployment - Deployment manifest object
+ * @throws {Error} If any ${...} placeholders are found
+ */
+function validateNoUnresolvedVariablesInDeployment(deployment) {
+  const unresolved = findUnresolvedVariablesInObject(deployment);
+  if (unresolved.length > 0) {
+    const examples = [...new Set(unresolved)].slice(0, 5).join(', ');
+    throw new Error(
+      `Deployment manifest contains unresolved variables (e.g. ${examples}). ` +
+      'Use secret variables (kv://) in env.template for sensitive values, and set the application port as a number in application.yaml.'
+    );
+  }
+}
+
 /**
  * Validates all application configuration files
  * Runs complete validation suite for an application
@@ -411,6 +472,8 @@ module.exports = {
   validateRbac,
   validateEnvTemplate,
   validateDeploymentJson,
+  validateNoUnresolvedVariablesInDeployment,
+  findUnresolvedVariablesInObject,
   validateObjectAgainstApplicationSchema,
   checkEnvironment,
   formatValidationErrors,

package/lib/validation/wizard-datasource-validation.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Wizard datasource validation helpers - validate datasourceKeys and entityName against dataplane
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Validate that all datasourceKeys exist in the platform's available datasources
+ * @function validateDatasourceKeysForPlatform
+ * @param {string[]} datasourceKeys - User-provided datasource keys
+ * @param {Array<{key: string, displayName?: string, entity?: string}>} availableDatasources - Platform datasources
+ * @returns {{ valid: boolean, invalidKeys: string[] }} Validation result
+ */
+function validateDatasourceKeysForPlatform(datasourceKeys, availableDatasources) {
+  if (!Array.isArray(datasourceKeys) || datasourceKeys.length === 0) {
+    return { valid: true, invalidKeys: [] };
+  }
+  const availableKeys = Array.isArray(availableDatasources)
+    ? availableDatasources.map(d => (d && typeof d === 'object' && d.key) ? d.key : null).filter(Boolean)
+    : [];
+  const invalidKeys = datasourceKeys.filter(k => !availableKeys.includes(k));
+  return {
+    valid: invalidKeys.length === 0,
+    invalidKeys
+  };
+}
+
+/**
+ * Validate that entityName exists in the discovered entities list
+ * @function validateEntityNameForOpenApi
+ * @param {string} entityName - User-provided entity name
+ * @param {Array<{name: string}>} entities - Discovered entities from OpenAPI
+ * @returns {{ valid: boolean }} Validation result
+ */
+function validateEntityNameForOpenApi(entityName, entities) {
+  if (!entityName || typeof entityName !== 'string' || entityName.trim() === '') {
+    return { valid: true };
+  }
+  const entityNames = Array.isArray(entities)
+    ? entities.map(e => (e && typeof e === 'object' && e.name) ? e.name : null).filter(Boolean)
+    : [];
+  return {
+    valid: entityNames.includes(entityName)
+  };
+}
+
+module.exports = {
+  validateDatasourceKeysForPlatform,
+  validateEntityNameForOpenApi
+};

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.40.2",
+  "version": "2.42.0",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {
     "aifabrix": "bin/aifabrix.js",
-    "aifx": "bin/aifabrix.js"
+    "af": "bin/aifabrix.js"
   },
   "scripts": {
     "test": "node tests/scripts/test-wrapper.js",
     "test:ci": "bash tests/scripts/ci-simulate.sh",
+    "test:same-as-github": "cross-env CI=true npm run lint && cross-env CI=true node tests/scripts/test-wrapper.js",
     "test:coverage": "cross-env RUN_COVERAGE=1 node tests/scripts/test-wrapper.js",
     "test:coverage:nyc": "nyc --reporter=text --reporter=lcov --reporter=html jest --config jest.config.coverage.js --runInBand",
     "test:watch": "jest --watch",
@@ -71,13 +72,16 @@
   },
   "dependencies": {
     "ajv": "^8.12.0",
+    "ajv-formats": "^3.0.1",
     "axios": "^1.6.0",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "handlebars": "^4.7.8",
     "inquirer": "^8.2.5",
+    "inquirer-autocomplete-prompt": "^2.0.0",
     "js-yaml": "^4.1.0",
-    "ora": "^5.4.1"
+    "ora": "^5.4.1",
+    "yaml": "^2.4.0"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.29.0",
@@ -86,6 +90,7 @@
     "cross-env": "^10.1.0",
     "eslint": "^8.55.0",
     "jest": "^30.2.0",
+    "markdownlint-cli": "^0.47.0",
     "nyc": "^17.1.0"
   },
   "repository": {