@nclamvn/vibecode-cli 1.5.0 → 1.6.0

package/.vibecode/learning/fixes.json

@@ -0,0 +1 @@
+[]

package/.vibecode/learning/preferences.json

@@ -0,0 +1 @@
+{}

package/bin/vibecode.js

@@ -21,6 +21,8 @@ import {
   agentCommand,
   debugCommand,
   assistCommand,
+  undoCommand,
+  learnCommand,
   VERSION
 } from '../src/index.js';
 
@@ -176,7 +178,41 @@ program
   });
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Parse
+// Phase H Commands - Undo/Rollback
 // ─────────────────────────────────────────────────────────────────────────────
 
-program.parse();
+program
+  .command('undo')
+  .description('⏪ Undo/rollback: Restore files to previous state')
+  .option('-l, --list', 'List available backups')
+  .option('-s, --step <n>', 'Restore to N steps ago', parseInt)
+  .option('-c, --clear', 'Clear all backups')
+  .option('-f, --force', 'Force operation without confirmation')
+  .action(undoCommand);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase H5 Commands - Learning Mode
+// ─────────────────────────────────────────────────────────────────────────────
+
+program
+  .command('learn')
+  .description('🧠 View and manage AI learnings from feedback')
+  .option('-s, --stats', 'Show learning statistics')
+  .option('-c, --clear', 'Clear all learnings')
+  .option('-e, --export', 'Export learnings to file')
+  .option('-f, --force', 'Skip confirmation prompts')
+  .action(learnCommand);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Parse - If no command provided, show interactive wizard
+// ─────────────────────────────────────────────────────────────────────────────
+
+if (process.argv.length === 2) {
+  // No command provided - show interactive wizard
+  import('../src/commands/wizard.js').then(m => m.wizardCommand()).catch(err => {
+    console.error('Failed to load wizard:', err.message);
+    program.help();
+  });
+} else {
+  program.parse();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nclamvn/vibecode-cli",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Build software with discipline - AI coding with guardrails",
   "main": "src/index.js",
   "type": "module",
@@ -10,7 +10,9 @@
   "scripts": {
     "start": "node bin/vibecode.js",
     "lint": "eslint src/",
-    "test": "echo \"Tests coming in Phase B\" && exit 0"
+    "test": "node src/ui/__tests__/error-translator.test.js",
+    "test:errors": "node src/ui/__tests__/error-translator.test.js",
+    "test:errors:verbose": "node src/ui/__tests__/error-translator.test.js --verbose"
   },
   "keywords": [
     "cli",

package/src/agent/orchestrator.js

@@ -11,6 +11,9 @@ import fs from 'fs-extra';
 import { spawnClaudeCode, isClaudeCodeAvailable } from '../providers/index.js';
 import { runTests } from '../core/test-runner.js';
 import { ensureDir, appendToFile } from '../utils/files.js';
+import { ProgressDashboard } from '../ui/dashboard.js';
+import { translateError, showError, inlineError } from '../ui/error-translator.js';
+import { BackupManager } from '../core/backup.js';
 
 /**
  * Orchestrator states
@@ -63,9 +66,14 @@ export class Orchestrator {
       testAfterEachModule: options.testAfterEachModule ?? true,
       continueOnFailure: options.continueOnFailure ?? false,
       parallelBuilds: options.parallelBuilds ?? false, // Future feature
-      timeout: options.timeout || 30 * 60 * 1000 // 30 minutes per module
+      timeout: options.timeout || 30 * 60 * 1000, // 30 minutes per module
+      useDashboard: options.useDashboard ?? true, // Use visual dashboard
+      verbose: options.verbose ?? false
     };
 
+    // Dashboard instance
+    this.dashboard = null;
+
     // Build state
     this.buildState = {
       startTime: null,
@@ -167,6 +175,10 @@ export class Orchestrator {
   async build(description, options = {}) {
     this.buildState.startTime = Date.now();
 
+    // Create backup before agent build
+    const backup = new BackupManager(this.projectPath);
+    await backup.createBackup('agent-build');
+
     try {
       // Step 1: Decompose project
       this.setState(ORCHESTRATOR_STATES.DECOMPOSING);
@@ -217,40 +229,86 @@ export class Orchestrator {
       totalTime: 0
     };
 
-    for (const moduleId of decomposition.buildOrder) {
-      // Check if we should stop
-      if (this.state === ORCHESTRATOR_STATES.PAUSED) {
-        await this.log('Build paused');
-        break;
-      }
+    // Create and start dashboard if enabled
+    if (this.config.useDashboard) {
+      this.dashboard = new ProgressDashboard({
+        title: 'VIBECODE AGENT',
+        projectName: path.basename(this.projectPath),
+        mode: `Agent (${decomposition.totalModules} modules)`
+      });
+
+      // Set modules for dashboard
+      this.dashboard.setModules(decomposition.buildOrder.map(id => {
+        const mod = this.decompositionEngine.getModule(id);
+        return { name: mod?.name || id };
+      }));
+
+      this.dashboard.start();
+    }
 
-      // Check if module can be built (dependencies satisfied)
-      if (!this.decompositionEngine.canBuildModule(moduleId)) {
-        const depStatus = decomposition.dependencyGraph[moduleId];
-        const failedDeps = depStatus?.dependsOn.filter(d =>
-          this.buildState.failedModules.includes(d)
-        );
-
-        if (failedDeps?.length > 0) {
-          await this.log(`Skipping ${moduleId}: dependencies failed (${failedDeps.join(', ')})`, 'warn');
-          this.buildState.skippedModules.push(moduleId);
-          results.modules[moduleId] = { status: 'skipped', reason: 'dependencies_failed' };
-          continue;
+    try {
+      for (const moduleId of decomposition.buildOrder) {
+        // Check if we should stop
+        if (this.state === ORCHESTRATOR_STATES.PAUSED) {
+          await this.log('Build paused');
+          break;
         }
-      }
 
-      // Build the module
-      const moduleResult = await this.buildModule(moduleId, decomposition);
-      results.modules[moduleId] = moduleResult;
+        // Check if module can be built (dependencies satisfied)
+        if (!this.decompositionEngine.canBuildModule(moduleId)) {
+          const depStatus = decomposition.dependencyGraph[moduleId];
+          const failedDeps = depStatus?.dependsOn.filter(d =>
+            this.buildState.failedModules.includes(d)
+          );
+
+          if (failedDeps?.length > 0) {
+            await this.log(`Skipping ${moduleId}: dependencies failed (${failedDeps.join(', ')})`, 'warn');
+            this.buildState.skippedModules.push(moduleId);
+            results.modules[moduleId] = { status: 'skipped', reason: 'dependencies_failed' };
+
+            // Update dashboard
+            if (this.dashboard) {
+              const mod = this.decompositionEngine.getModule(moduleId);
+              this.dashboard.failModule(mod?.name || moduleId);
+            }
+            continue;
+          }
+        }
 
-      if (!moduleResult.success) {
-        results.success = false;
+        // Update dashboard - start module
+        if (this.dashboard) {
+          const mod = this.decompositionEngine.getModule(moduleId);
+          this.dashboard.startModule(mod?.name || moduleId);
+        }
 
-        if (!this.config.continueOnFailure) {
-          await this.log(`Stopping build due to module failure: ${moduleId}`, 'error');
-          break;
+        // Build the module
+        const moduleResult = await this.buildModule(moduleId, decomposition);
+        results.modules[moduleId] = moduleResult;
+
+        // Update dashboard - complete/fail module
+        if (this.dashboard) {
+          const mod = this.decompositionEngine.getModule(moduleId);
+          if (moduleResult.success) {
+            this.dashboard.completeModule(mod?.name || moduleId, true);
+          } else {
+            this.dashboard.failModule(mod?.name || moduleId);
+          }
+        }
+
+        if (!moduleResult.success) {
+          results.success = false;
+
+          if (!this.config.continueOnFailure) {
+            await this.log(`Stopping build due to module failure: ${moduleId}`, 'error');
+            break;
+          }
         }
       }
+    } finally {
+      // Stop dashboard
+      if (this.dashboard) {
+        this.dashboard.stop();
+      }
     }
 
     results.totalTime = Date.now() - this.buildState.startTime;
@@ -269,10 +327,11 @@ export class Orchestrator {
     this.buildState.currentModule = moduleId;
     this.emit(EVENTS.MODULE_START, { moduleId, module });
 
-    const spinner = ora({
+    // Only use spinner if dashboard is not enabled
+    const spinner = !this.config.useDashboard ? ora({
       text: chalk.cyan(`Building module: ${module.name}`),
       prefixText: this.getProgressPrefix()
-    }).start();
+    }).start() : null;
 
     // Record in memory
     if (this.memoryEngine) {
@@ -308,7 +367,8 @@ export class Orchestrator {
         if (buildResult.success) {
           // Run tests if configured
           if (this.config.testAfterEachModule) {
-            spinner.text = chalk.cyan(`Testing module: ${module.name}`);
+            if (spinner) spinner.text = chalk.cyan(`Testing module: ${module.name}`);
+            if (this.dashboard) this.dashboard.addLog(`Testing: ${module.name}`);
             this.setState(ORCHESTRATOR_STATES.TESTING);
 
             const testResult = await runTests(this.projectPath);
@@ -319,7 +379,7 @@ export class Orchestrator {
           }
 
           // Success!
-          spinner.succeed(chalk.green(`Module complete: ${module.name}`));
+          if (spinner) spinner.succeed(chalk.green(`Module complete: ${module.name}`));
 
           this.decompositionEngine.updateModuleStatus(moduleId, 'completed', {
             files: buildResult.files || []
@@ -347,11 +407,20 @@ export class Orchestrator {
 
       } catch (error) {
         lastError = error;
-        await this.log(`Module ${moduleId} attempt ${attempts} failed: ${error.message}`, 'error');
+        const translated = translateError(error);
+        await this.log(`Module ${moduleId} attempt ${attempts} failed: ${translated.title} - ${error.message}`, 'error');
+
+        // Show translated error if not using dashboard
+        if (!this.config.useDashboard) {
+          console.log(inlineError(error));
+        } else if (this.dashboard) {
+          this.dashboard.addLog(`Error: ${translated.title}`);
+        }
 
         // Try self-healing
         if (this.selfHealingEngine && attempts < this.config.maxModuleRetries) {
-          spinner.text = chalk.yellow(`Healing module: ${module.name}`);
+          if (spinner) spinner.text = chalk.yellow(`Healing module: ${module.name}`);
+          if (this.dashboard) this.dashboard.addLog(`Healing: ${module.name}`);
           this.setState(ORCHESTRATOR_STATES.HEALING);
           this.emit(EVENTS.HEALING_START, { moduleId, error });
 
@@ -387,7 +456,7 @@ export class Orchestrator {
     }
 
     // Module failed
-    spinner.fail(chalk.red(`Module failed: ${module.name}`));
+    if (spinner) spinner.fail(chalk.red(`Module failed: ${module.name}`));
 
     this.decompositionEngine.updateModuleStatus(moduleId, 'failed', {
       error: lastError?.message

package/src/commands/build.js

@@ -22,6 +22,8 @@ import { STATES } from '../config/constants.js';
 import { getBuildReportTemplate } from '../config/templates.js';
 import { ensureDir, pathExists, appendToFile, readMarkdown, writeJson } from '../utils/files.js';
 import { printBox, printError, printSuccess, printWarning, printNextStep } from '../ui/output.js';
+import { showError, inlineError } from '../ui/error-translator.js';
+import { BackupManager } from '../core/backup.js';
 import {
   spawnClaudeCode,
   isClaudeCodeAvailable,
@@ -75,7 +77,7 @@ export async function buildCommand(options = {}) {
     }
 
   } catch (error) {
-    printError(error.message);
+    showError(error, { verbose: options.verbose });
     process.exit(1);
   }
 }
@@ -85,6 +87,10 @@ export async function buildCommand(options = {}) {
  * "Contract LOCKED = License to build"
  */
 async function handleAutoBuild(currentState, projectName, sessionId, sessionPath, specHash, options) {
+  // Create backup before build
+  const backup = new BackupManager();
+  await backup.createBackup('build-auto');
+
   // Check state - must be PLAN_CREATED or BUILD_IN_PROGRESS or REVIEW_FAILED
   const validStates = [STATES.PLAN_CREATED, STATES.BUILD_IN_PROGRESS, STATES.REVIEW_FAILED];
   if (!validStates.includes(currentState)) {
@@ -227,7 +233,7 @@ ${evidence.screenshots > 0 ? `  ✅ ${evidence.screenshots} screenshots` : '
 
   } catch (error) {
     await appendToFile(logPath, `\nERROR: ${error.message}\n`);
-    printError(`Auto build failed: ${error.message}`);
+    showError(error);
     process.exit(1);
   }
 }
@@ -240,6 +246,10 @@ async function handleIterativeBuild(currentState, projectName, sessionId, sessio
   const maxIterations = options.max || 3;
   const strictMode = options.strict || false;
 
+  // Create backup before iterative build
+  const backup = new BackupManager();
+  await backup.createBackup('build-iterate');
+
   // Check state - must be PLAN_CREATED or BUILD_IN_PROGRESS or REVIEW_FAILED
   const validStates = [STATES.PLAN_CREATED, STATES.BUILD_IN_PROGRESS, STATES.REVIEW_FAILED];
   if (!validStates.includes(currentState)) {
@@ -451,7 +461,7 @@ Starting build-test-fix loop...`;
       }
 
     } catch (error) {
-      console.log(chalk.red(`\n❌ Build error: ${error.message}`));
+      console.log('\n' + inlineError(error));
       await logIteration(logPath, iteration, `Error: ${error.message}`);
 
       iterationState = finalizeIterationState(iterationState, 'error');

package/src/commands/go.js

@@ -31,6 +31,8 @@ import {
   getCoderPackTemplate
 } from '../config/templates.js';
 import { printBox, printError, printSuccess } from '../ui/output.js';
+import { StepProgress, updateProgress, completeProgress } from '../ui/dashboard.js';
+import { BackupManager } from '../core/backup.js';
 import {
   spawnClaudeCode,
   isClaudeCodeAvailable,
@@ -78,6 +80,11 @@ export async function goCommand(description, options = {}) {
   // Show magic header
   showMagicHeader(description, projectName);
 
+  // Create backup of current directory before go command
+  // (backup in parent directory since we're creating a new project)
+  const backup = new BackupManager(process.cwd());
+  await backup.createBackup('go-magic');
+
   // Define steps
   const steps = [
     { name: 'INIT', label: 'Creating project', weight: 5 },
@@ -304,12 +311,12 @@ function generateProjectName(description) {
 /**
  * Render progress bar
  */
-function renderProgressBar(percent) {
+function renderProgressBar(percent, label = '') {
   const width = 40;
   const filled = Math.round(width * percent / 100);
   const empty = width - filled;
   const bar = chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
-  return `[${bar}] ${String(percent).padStart(3)}%`;
+  return `[${bar}] ${String(percent).padStart(3)}%${label ? ' ' + label : ''}`;
 }
 
 /**

package/src/commands/learn.js

@@ -0,0 +1,294 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Learn Command
+// Phase H5: View and manage AI learnings
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import fs from 'fs/promises';
+import path from 'path';
+import { LearningEngine } from '../core/learning.js';
+
+/**
+ * Learn Command - View and manage AI learnings
+ *
+ * Usage:
+ *   vibecode learn           - Interactive menu
+ *   vibecode learn --stats   - Show learning statistics
+ *   vibecode learn --clear   - Clear all learnings
+ *   vibecode learn --export  - Export learnings to file
+ */
+export async function learnCommand(options = {}) {
+  const learning = new LearningEngine();
+
+  if (options.stats) {
+    await showStats(learning);
+    return;
+  }
+
+  if (options.clear) {
+    await clearLearnings(learning, options.force);
+    return;
+  }
+
+  if (options.export) {
+    await exportLearnings(learning);
+    return;
+  }
+
+  // Default: show interactive menu
+  await interactiveLearn(learning);
+}
+
+/**
+ * Show learning statistics
+ */
+async function showStats(learning) {
+  const stats = await learning.getStats();
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  📊 LEARNING STATISTICS                                            │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  console.log(chalk.white(`  📁 Project Learnings`));
+  console.log(chalk.gray(`     Tổng fixes: ${stats.local.total}`));
+  console.log(chalk.gray(`     Thành công: ${stats.local.success} (${stats.local.rate}%)`));
+  console.log('');
+
+  console.log(chalk.white(`  🌍 Global Learnings`));
+  console.log(chalk.gray(`     Tổng fixes: ${stats.global.total}`));
+  console.log(chalk.gray(`     Thành công: ${stats.global.success} (${stats.global.rate}%)`));
+  console.log('');
+
+  if (Object.keys(stats.byCategory).length > 0) {
+    console.log(chalk.white(`  📂 Theo Error Category`));
+    for (const [cat, data] of Object.entries(stats.byCategory)) {
+      const rate = data.total > 0 ? (data.success / data.total * 100).toFixed(0) : 0;
+      const bar = renderMiniBar(data.success, data.total);
+      console.log(chalk.gray(`     ${cat.padEnd(12)} ${bar} ${data.success}/${data.total} (${rate}%)`));
+    }
+    console.log('');
+  }
+
+  console.log(chalk.white(`  ⚙️  Preferences đã lưu: ${stats.preferences}`));
+
+  if (stats.lastLearning) {
+    const lastDate = new Date(stats.lastLearning).toLocaleString('vi-VN');
+    console.log(chalk.gray(`  📅 Learning gần nhất: ${lastDate}`));
+  }
+
+  console.log('');
+}
+
+/**
+ * Render a mini progress bar
+ */
+function renderMiniBar(value, total) {
+  const width = 10;
+  const filled = total > 0 ? Math.round(width * value / total) : 0;
+  const empty = width - filled;
+  return chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+}
+
+/**
+ * Clear all local learnings
+ */
+async function clearLearnings(learning, force) {
+  const stats = await learning.getStats();
+
+  if (stats.local.total === 0) {
+    console.log(chalk.yellow('\n📭 Không có learnings nào để xoá.\n'));
+    return;
+  }
+
+  if (!force) {
+    console.log(chalk.yellow(`\n⚠️  Sắp xoá ${stats.local.total} learnings của project này.\n`));
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Xác nhận xoá tất cả learnings?',
+        default: false
+      }
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.gray('\n👋 Đã huỷ.\n'));
+      return;
+    }
+  }
+
+  await learning.clearLocal();
+  console.log(chalk.green(`\n✅ Đã xoá ${stats.local.total} learnings.\n`));
+}
+
+/**
+ * Export learnings to file
+ */
+async function exportLearnings(learning) {
+  const stats = await learning.getStats();
+  const fixes = await learning.loadJson(
+    path.join(learning.localPath, 'fixes.json'),
+    []
+  );
+  const prefs = await learning.loadJson(
+    path.join(learning.localPath, 'preferences.json'),
+    {}
+  );
+
+  if (fixes.length === 0 && Object.keys(prefs).length === 0) {
+    console.log(chalk.yellow('\n📭 Không có learnings nào để export.\n'));
+    return;
+  }
+
+  const exportData = {
+    exportedAt: new Date().toISOString(),
+    projectPath: learning.projectPath,
+    stats,
+    fixes: fixes.map(f => ({
+      id: f.id,
+      errorType: f.errorType,
+      errorCategory: f.errorCategory,
+      success: f.success,
+      userFeedback: f.userFeedback,
+      projectType: f.projectType,
+      timestamp: f.timestamp
+    })),
+    preferences: prefs
+  };
+
+  const exportPath = `vibecode-learnings-${Date.now()}.json`;
+  await fs.writeFile(exportPath, JSON.stringify(exportData, null, 2));
+
+  console.log(chalk.green(`\n✅ Đã export ${fixes.length} learnings → ${exportPath}\n`));
+}
+
+/**
+ * Interactive learning menu
+ */
+async function interactiveLearn(learning) {
+  const stats = await learning.getStats();
+
+  const successBar = renderMiniBar(stats.local.success, stats.local.total);
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  🧠 VIBECODE LEARNING                                              │
+│                                                                    │
+│  AI học từ feedback của bạn để cải thiện suggestions.             │
+│                                                                    │
+│  Success rate: ${successBar} ${String(stats.local.rate + '%').padEnd(30)}│
+│  Total learnings: ${String(stats.local.total).padEnd(44)}│
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Bạn muốn làm gì?',
+      choices: [
+        { name: '📊 Xem thống kê chi tiết', value: 'stats' },
+        { name: '📤 Export learnings', value: 'export' },
+        { name: '🗑️  Xoá learnings', value: 'clear' },
+        new inquirer.Separator(),
+        { name: '👋 Thoát', value: 'exit' }
+      ]
+    }
+  ]);
+
+  switch (action) {
+    case 'stats':
+      await showStats(learning);
+      break;
+    case 'export':
+      await exportLearnings(learning);
+      break;
+    case 'clear':
+      await clearLearnings(learning, false);
+      break;
+  }
+}
+
+/**
+ * Ask for feedback after a fix
+ * Called from debug/fix commands
+ */
+export async function askFeedback(fixInfo) {
+  console.log('');
+  const { feedback } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'feedback',
+      message: 'Fix này có đúng không?',
+      choices: [
+        { name: '✅ Đúng, hoạt động tốt', value: 'success' },
+        { name: '❌ Không đúng', value: 'failed' },
+        { name: '🔄 Đúng một phần', value: 'partial' },
+        { name: '⏭️  Bỏ qua', value: 'skip' }
+      ]
+    }
+  ]);
+
+  if (feedback === 'skip') {
+    return null;
+  }
+
+  const learning = new LearningEngine();
+  let userCorrection = null;
+
+  if (feedback === 'failed' || feedback === 'partial') {
+    const { correction } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'correction',
+        message: 'Mô tả ngắn vấn đề hoặc cách fix đúng (Enter để bỏ qua):',
+      }
+    ]);
+    userCorrection = correction || null;
+  }
+
+  await learning.recordFix({
+    errorType: fixInfo.errorType,
+    errorMessage: fixInfo.errorMessage,
+    errorCategory: fixInfo.errorCategory,
+    fixApplied: fixInfo.fixApplied,
+    success: feedback === 'success',
+    userFeedback: feedback,
+    userCorrection
+  });
+
+  if (feedback === 'success') {
+    console.log(chalk.green('  ✅ Đã ghi nhận. Cảm ơn!\n'));
+  } else {
+    console.log(chalk.yellow('  📝 Đã ghi nhận feedback.\n'));
+  }
+
+  return feedback;
+}
+
+/**
+ * Show learning-based suggestion (if available)
+ */
+export async function showLearningSuggestion(errorType, errorCategory) {
+  const learning = new LearningEngine();
+  const suggestion = await learning.getSuggestion(errorType, errorCategory);
+
+  if (suggestion && suggestion.confidence > 0.6) {
+    const confidencePercent = (suggestion.confidence * 100).toFixed(0);
+    console.log(chalk.cyan(`  💡 Dựa trên ${suggestion.basedOn} fixes trước (độ tin cậy: ${confidencePercent}%)`));
+
+    if (suggestion.suggestion) {
+      const shortSuggestion = suggestion.suggestion.substring(0, 100);
+      console.log(chalk.gray(`     Gợi ý: ${shortSuggestion}${suggestion.suggestion.length > 100 ? '...' : ''}`));
+    }
+    console.log('');
+    return suggestion;
+  }
+
+  return null;
+}