@dbcube/schema-builder 1.0.15 → 1.0.17

package/dist/index.js

@@ -6,9 +6,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/lib/Schema.ts
-import fs2 from "fs";
+import fs4 from "fs";
 import { Engine, TableProcessor, Config as ConfigClass } from "@dbcube/core";
-import path2 from "path";
+import path3 from "path";
 
 // src/lib/FileUtils.ts
 import * as fs from "fs";
@@ -132,9 +132,13 @@ var FileUtils = class {
 };
 var FileUtils_default = FileUtils;
 
+// src/lib/Schema.ts
+import chalk2 from "chalk";
+
 // src/lib/UIUtils.ts
 import chalk from "chalk";
-var UIUtils = class {
+import fs2 from "fs";
+var UIUtils = class _UIUtils {
   /**
    * Shows animated progress for processing items
    */
@@ -213,20 +217,349 @@ ${chalk.cyan("\u{1F4CA}")} ${chalk.bold.green(`SUMMARY OF ${operationName.toUppe
 ${chalk.red("\u{1F6AB}")} ${chalk.bold.red("ERRORS FOUND")}`);
       console.log(chalk.red("\u2500".repeat(60)));
       summary.errors.forEach((error, index) => {
-        console.log(`${chalk.red("\u251C\u2500")} ${chalk.bold(error.itemName)}`);
-        console.log(`${chalk.red("\u2502  ")} ${chalk.gray("Error:")} ${chalk.red(error.error)}`);
+        console.log(`${chalk.red("[error]")} ${chalk.red(error.error)}`);
+        console.log("");
         if (error.filePath) {
-          const relativePath = error.filePath.replace(process.cwd().replace(/\\\\/g, "/"), ".");
-          const location = error.lineNumber ? `${relativePath}:${error.lineNumber}` : relativePath;
-          console.log(`${chalk.red("\u2502  ")} ${chalk.gray("Location:")} ${chalk.cyan(location)}`);
+          const location = error.lineNumber ? `${error.filePath}:${error.lineNumber}:7` : error.filePath;
+          console.log(`${chalk.cyan("[code]")} ${chalk.yellow(location)}`);
+          _UIUtils.showCodeContext(error.filePath, error.lineNumber || 1);
         }
         if (index < summary.errors.length - 1) {
-          console.log(`${chalk.red("\u2502")}`);
+          console.log("");
+        }
+      });
+    }
+  }
+  /**
+   * Shows code context around an error location
+   */
+  static showCodeContext(filePath, lineNumber, contextLines = 2) {
+    try {
+      const content = fs2.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+      const startLine = Math.max(0, lineNumber - contextLines - 1);
+      const endLine = Math.min(lines.length, lineNumber + contextLines);
+      for (let i = startLine; i < endLine; i++) {
+        const currentLineNum = i + 1;
+        const line = lines[i];
+        const lineNumStr = currentLineNum.toString().padStart(4, " ");
+        if (currentLineNum === lineNumber) {
+          console.log(`${chalk.gray(lineNumStr)} ${chalk.red("<-")}       ${chalk.white(line)}`);
+        } else {
+          console.log(`${chalk.gray(lineNumStr)}          ${chalk.white(line)}`);
+        }
+      }
+    } catch (error) {
+      console.log(chalk.gray("   (unable to show code context)"));
+    }
+  }
+};
+
+// src/lib/CubeValidator.ts
+import fs3 from "fs";
+import path2 from "path";
+var CubeValidator = class {
+  validTypes = ["varchar", "int", "string", "text", "boolean", "date", "datetime", "timestamp", "decimal", "float", "double", "enum", "json"];
+  validOptions = ["not null", "primary", "autoincrement", "unique", "zerofill", "index", "required", "unsigned"];
+  validProperties = ["type", "length", "options", "value", "defaultValue", "foreign", "enumValues", "description"];
+  knownAnnotations = ["database", "table", "meta", "columns", "fields", "dataset", "beforeAdd", "afterAdd", "beforeUpdate", "afterUpdate", "beforeDelete", "afterDelete", "compute", "column"];
+  /**
+   * Validates a cube file comprehensively
+   */
+  validateCubeFile(filePath) {
+    const errors = [];
+    try {
+      const content = fs3.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+      const fileName = path2.basename(filePath, path2.extname(filePath));
+      for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        if (line.trim() === "" || line.trim().startsWith("//")) {
+          continue;
+        }
+        this.validateAnnotations(line, lineIndex + 1, filePath, fileName, errors);
+        this.validateDataTypes(line, lineIndex + 1, filePath, fileName, errors, content);
+        this.validateColumnOptions(line, lineIndex + 1, filePath, fileName, errors, lines);
+        this.validateColumnProperties(line, lineIndex + 1, filePath, fileName, errors, content);
+        this.validateRequiredColumnProperties(lines, lineIndex + 1, filePath, fileName, errors);
+        this.validateGeneralSyntax(line, lineIndex + 1, filePath, fileName, errors);
+      }
+      this.validateOverallStructure(content, filePath, fileName, errors);
+    } catch (error) {
+      errors.push({
+        itemName: path2.basename(filePath, path2.extname(filePath)),
+        error: `Failed to read cube file: ${error.message}`,
+        filePath,
+        lineNumber: 1
+      });
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  validateAnnotations(line, lineNumber, filePath, fileName, errors) {
+    const annotationRegex = /@(\w+)/g;
+    let match;
+    while ((match = annotationRegex.exec(line)) !== null) {
+      const annotation = match[1];
+      if (!this.knownAnnotations.includes(annotation)) {
+        errors.push({
+          itemName: fileName,
+          error: `Unknown annotation '@${annotation}'. Valid annotations: ${this.knownAnnotations.join(", ")}`,
+          filePath,
+          lineNumber
+        });
+      }
+    }
+  }
+  validateDataTypes(line, lineNumber, filePath, fileName, errors, content) {
+    const typeRegex = /type:\s*["'](\w+)["']/g;
+    let match;
+    while ((match = typeRegex.exec(line)) !== null) {
+      const type = match[1];
+      if (!this.validTypes.includes(type)) {
+        errors.push({
+          itemName: fileName,
+          error: `Invalid data type '${type}'. Valid types: ${this.validTypes.join(", ")}`,
+          filePath,
+          lineNumber
+        });
+      }
+    }
+    if (line.includes('type: "varchar"')) {
+      const lines = content.split("\n");
+      const hasLengthNearby = lines.slice(Math.max(0, lineNumber - 1), Math.min(lineNumber + 4, lines.length)).some((nextLine) => nextLine.includes("length:"));
+      if (!hasLengthNearby) {
+        errors.push({
+          itemName: fileName,
+          error: "VARCHAR type requires a length specification",
+          filePath,
+          lineNumber
+        });
+      }
+    }
+  }
+  validateColumnOptions(line, lineNumber, filePath, fileName, errors, lines) {
+    const optionsMatch = line.match(/^\s*options\s*:\s*\[(.*)\]\s*;?\s*$/);
+    if (!optionsMatch) return;
+    const optionsContent = optionsMatch[1].trim();
+    const invalidSyntaxMatch = optionsContent.match(/[^",\s]+(?![^"]*")/);
+    if (invalidSyntaxMatch) {
+      errors.push({
+        itemName: fileName,
+        error: `Invalid syntax '${invalidSyntaxMatch[0]}' in options array. All values must be quoted strings`,
+        filePath,
+        lineNumber
+      });
+      return;
+    }
+    const optionMatches = optionsContent.match(/"([^"]*)"/g);
+    if (optionMatches) {
+      const columnType = this.getColumnTypeForOptions(lines, lineNumber - 1);
+      optionMatches.forEach((optionMatch) => {
+        const option = optionMatch.replace(/"/g, "");
+        if (option.trim() === "") {
+          errors.push({
+            itemName: fileName,
+            error: "Empty option found in options array. All options must have a value",
+            filePath,
+            lineNumber
+          });
+        } else if (!this.validOptions.includes(option)) {
+          errors.push({
+            itemName: fileName,
+            error: `Invalid option '${option}'. Valid options: ${this.validOptions.join(", ")}`,
+            filePath,
+            lineNumber
+          });
+        } else if (!this.isOptionCompatibleWithType(option, columnType)) {
+          errors.push({
+            itemName: fileName,
+            error: `Option '${option}' is not compatible with type '${columnType}'`,
+            filePath,
+            lineNumber
+          });
         }
       });
-      console.log("");
     }
   }
+  validateColumnProperties(line, lineNumber, filePath, fileName, errors, content) {
+    const propertyKeyRegex = /^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:/;
+    const propMatch = propertyKeyRegex.exec(line);
+    if (!propMatch) return;
+    const propertyName = propMatch[1];
+    if (/^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*:\s*\{/.test(line)) {
+      return;
+    }
+    if (this.isInsideColumnsBlock(content, lineNumber - 1)) {
+      if (!this.validProperties.includes(propertyName)) {
+        errors.push({
+          itemName: fileName,
+          error: `Invalid property '${propertyName}'. Valid properties: ${this.validProperties.join(", ")}`,
+          filePath,
+          lineNumber
+        });
+      }
+    }
+    if (/^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*$/.test(line)) {
+      errors.push({
+        itemName: fileName,
+        error: `Property '${propertyName}' is missing a value`,
+        filePath,
+        lineNumber
+      });
+    }
+  }
+  validateRequiredColumnProperties(lines, lineNumber, filePath, fileName, errors) {
+    const line = lines[lineNumber - 1];
+    if (!/^\s*\}\s*;?\s*$/.test(line)) {
+      return;
+    }
+    let columnStartLine = -1;
+    let columnName = "";
+    for (let i = lineNumber - 2; i >= 0; i--) {
+      const currentLine = lines[i];
+      const columnDefMatch = currentLine.match(/^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*\{/);
+      if (columnDefMatch) {
+        let openBraces = 0;
+        let closeBraces = 0;
+        for (let j = i; j < lineNumber; j++) {
+          openBraces += (lines[j].match(/\{/g) || []).length;
+          closeBraces += (lines[j].match(/\}/g) || []).length;
+        }
+        if (openBraces === closeBraces) {
+          columnStartLine = i;
+          columnName = columnDefMatch[1];
+          break;
+        }
+      }
+    }
+    if (columnStartLine === -1 || !columnName) return;
+    let hasType = false;
+    for (let i = columnStartLine + 1; i < lineNumber - 1; i++) {
+      if (lines[i].match(/^\s*type\s*:/)) {
+        hasType = true;
+        break;
+      }
+    }
+    if (!hasType && columnName !== "foreign" && columnName !== "defaultValue") {
+      errors.push({
+        itemName: fileName,
+        error: `Column '${columnName}' is missing required 'type' property`,
+        filePath,
+        lineNumber: columnStartLine + 1
+      });
+    }
+  }
+  validateGeneralSyntax(line, lineNumber, filePath, fileName, errors) {
+    const quotes = line.match(/["']/g);
+    if (quotes && quotes.length % 2 !== 0) {
+      errors.push({
+        itemName: fileName,
+        error: "Mismatched quotes detected",
+        filePath,
+        lineNumber
+      });
+    }
+    if (line.includes("@database") || line.includes("@table")) {
+      const stringAnnotationRegex = /@(database|table)\s*\(\s*"([^"]*)"\s*\)/;
+      if (!stringAnnotationRegex.test(line)) {
+        errors.push({
+          itemName: fileName,
+          error: 'Invalid annotation syntax. Expected format: @annotation("value")',
+          filePath,
+          lineNumber
+        });
+      }
+    }
+    if (line.includes("@meta")) {
+      const metaObjectRegex = /@meta\s*\(\s*\{/;
+      if (!metaObjectRegex.test(line)) {
+        errors.push({
+          itemName: fileName,
+          error: "Invalid @meta syntax. Expected format: @meta({ ... })",
+          filePath,
+          lineNumber
+        });
+      }
+    }
+  }
+  validateOverallStructure(content, filePath, fileName, errors) {
+    const lines = content.split("\n");
+    const hasDatabase = lines.some((line) => line.includes("@database"));
+    if (!hasDatabase) {
+      errors.push({
+        itemName: fileName,
+        error: "Missing required @database annotation",
+        filePath,
+        lineNumber: 1
+      });
+    }
+    if (filePath.includes(".table.cube")) {
+      const hasColumns = lines.some((line) => line.includes("@columns"));
+      if (!hasColumns) {
+        errors.push({
+          itemName: fileName,
+          error: "Table cube files require @columns annotation",
+          filePath,
+          lineNumber: 1
+        });
+      }
+    }
+  }
+  getColumnTypeForOptions(lines, optionsLineIndex) {
+    for (let i = optionsLineIndex - 1; i >= 0; i--) {
+      const line = lines[i];
+      const typeMatch = line.match(/^\s*type\s*:\s*"([^"]+)"/);
+      if (typeMatch) {
+        return typeMatch[1];
+      }
+      if (/^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*:\s*\{/.test(line)) {
+        break;
+      }
+    }
+    return "unknown";
+  }
+  isOptionCompatibleWithType(option, type) {
+    const compatibilityRules = {
+      "zerofill": ["int", "decimal", "float", "double"],
+      "unsigned": ["int", "decimal", "float", "double"],
+      "autoincrement": ["int"],
+      "primary": ["int", "varchar", "string"],
+      "not null": ["int", "varchar", "string", "text", "boolean", "date", "datetime", "timestamp", "decimal", "float", "double"],
+      "unique": ["int", "varchar", "string", "text"],
+      "index": ["int", "varchar", "string", "text", "date", "datetime", "timestamp"],
+      "required": ["int", "varchar", "string", "text", "boolean", "date", "datetime", "timestamp", "decimal", "float", "double"]
+    };
+    const compatibleTypes = compatibilityRules[option];
+    if (!compatibleTypes) {
+      return true;
+    }
+    return compatibleTypes.includes(type);
+  }
+  isInsideColumnsBlock(content, lineIndex) {
+    const lines = content.split("\n");
+    let columnsStartLine = -1;
+    let columnsEndLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes("@columns")) {
+        columnsStartLine = i;
+        let braceCount = 0;
+        for (let j = i; j < lines.length; j++) {
+          const currentLine = lines[j];
+          braceCount += (currentLine.match(/\{/g) || []).length;
+          braceCount -= (currentLine.match(/\}/g) || []).length;
+          if (braceCount === 0 && j > i) {
+            columnsEndLine = j;
+            break;
+          }
+        }
+        break;
+      }
+    }
+    return columnsStartLine !== -1 && columnsEndLine !== -1 && lineIndex > columnsStartLine && lineIndex < columnsEndLine;
+  }
 };
 
 // src/lib/Schema.ts
@@ -238,18 +571,27 @@ var Schema = class {
     this.engine = new Engine(name);
   }
   /**
-   * Validates that the database specified in cube file exists in configuration
+   * Validates cube file comprehensively including syntax, database configuration, and structure
    * @param filePath - Path to the cube file
-   * @returns true if valid, throws error if invalid
+   * @returns validation result with any errors found
    */
   validateDatabaseConfiguration(filePath) {
     try {
+      const cubeValidator = new CubeValidator();
+      const cubeValidation = cubeValidator.validateCubeFile(filePath);
+      if (!cubeValidation.isValid && cubeValidation.errors.length > 0) {
+        return {
+          isValid: false,
+          error: cubeValidation.errors[0]
+          // Return the first error found
+        };
+      }
       const dbResult = FileUtils_default.extractDatabaseNameFromCube(filePath);
       if (dbResult.status !== 200) {
         return {
           isValid: false,
           error: {
-            itemName: path2.basename(filePath, path2.extname(filePath)),
+            itemName: path3.basename(filePath, path3.extname(filePath)),
             error: `Error reading database directive: ${dbResult.message}`,
             filePath,
             lineNumber: this.findDatabaseLineNumber(filePath)
@@ -258,7 +600,7 @@ var Schema = class {
       }
       const cubeDbName = dbResult.message;
       const configInstance = new ConfigClass();
-      const configFilePath = path2.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = path3.resolve(process.cwd(), "dbcube.config.js");
       const configFn = __require(configFilePath);
       if (typeof configFn === "function") {
         configFn(configInstance);
@@ -285,7 +627,7 @@ var Schema = class {
         return {
           isValid: false,
           error: {
-            itemName: path2.basename(filePath, path2.extname(filePath)),
+            itemName: path3.basename(filePath, path3.extname(filePath)),
             error: `Database configuration '${cubeDbName}' not found in dbcube.config.js. Available: ${availableText}`,
             filePath,
             lineNumber: this.findDatabaseLineNumber(filePath)
@@ -297,7 +639,7 @@ var Schema = class {
       return {
         isValid: false,
         error: {
-          itemName: path2.basename(filePath, path2.extname(filePath)),
+          itemName: path3.basename(filePath, path3.extname(filePath)),
           error: `Database configuration validation failed: ${error.message}`,
           filePath,
           lineNumber: this.findDatabaseLineNumber(filePath)
@@ -310,7 +652,7 @@ var Schema = class {
    */
   findDatabaseLineNumber(filePath) {
     try {
-      const content = fs2.readFileSync(filePath, "utf8");
+      const content = fs4.readFileSync(filePath, "utf8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (lines[i].includes("@database")) {
@@ -324,7 +666,7 @@ var Schema = class {
   }
   async createDatabase() {
     const startTime = Date.now();
-    const rootPath = path2.resolve(process.cwd());
+    const rootPath = path3.resolve(process.cwd());
     UIUtils.showOperationHeader(" CREATING DATABASE", this.name, "\u{1F5C4}\uFE0F");
     await UIUtils.showItemProgress("Preparando e instalando base de datos", 1, 1);
     try {
@@ -368,8 +710,8 @@ var Schema = class {
   }
   async refreshTables() {
     const startTime = Date.now();
-    const cubesDir = path2.join(process.cwd(), "dbcube", "cubes");
-    if (!fs2.existsSync(cubesDir)) {
+    const cubesDir = path3.join(process.cwd(), "dbcube", "cubes");
+    if (!fs4.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "table.cube");
@@ -384,11 +726,11 @@ var Schema = class {
     const errors = [];
     for (let index = 0; index < cubeFiles.length; index++) {
       const file = cubeFiles[index];
-      const filePath = path2.isAbsolute(file) ? file : path2.join(cubesDir, file);
-      const stats = fs2.statSync(filePath);
+      const filePath = path3.isAbsolute(file) ? file : path3.join(cubesDir, file);
+      const stats = fs4.statSync(filePath);
       if (stats.isFile()) {
         const getTableName = FileUtils_default.extracTableNameFromCube(filePath);
-        const tableName = getTableName.status === 200 ? getTableName.message : path2.basename(file, ".table.cube");
+        const tableName = getTableName.status === 200 ? getTableName.message : path3.basename(file, ".table.cube");
         await UIUtils.showItemProgress(tableName, index + 1, cubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
@@ -470,8 +812,8 @@ var Schema = class {
   }
   async freshTables() {
     const startTime = Date.now();
-    const cubesDir = path2.join(process.cwd(), "dbcube", "cubes");
-    if (!fs2.existsSync(cubesDir)) {
+    const cubesDir = path3.join(process.cwd(), "dbcube", "cubes");
+    if (!fs4.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "table.cube");
@@ -486,11 +828,11 @@ var Schema = class {
     const errors = [];
     for (let index = 0; index < cubeFiles.length; index++) {
       const file = cubeFiles[index];
-      const filePath = path2.isAbsolute(file) ? file : path2.join(cubesDir, file);
-      const stats = fs2.statSync(filePath);
+      const filePath = path3.isAbsolute(file) ? file : path3.join(cubesDir, file);
+      const stats = fs4.statSync(filePath);
       if (stats.isFile()) {
         const getTableName = FileUtils_default.extracTableNameFromCube(filePath);
-        const tableName = getTableName.status === 200 ? getTableName.message : path2.basename(file, ".table.cube");
+        const tableName = getTableName.status === 200 ? getTableName.message : path3.basename(file, ".table.cube");
         await UIUtils.showItemProgress(tableName, index + 1, cubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
@@ -570,8 +912,8 @@ var Schema = class {
   }
   async executeSeeders() {
     const startTime = Date.now();
-    const cubesDir = path2.join(process.cwd(), "dbcube", "cubes");
-    if (!fs2.existsSync(cubesDir)) {
+    const cubesDir = path3.join(process.cwd(), "dbcube", "cubes");
+    if (!fs4.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "seeder.cube");
@@ -586,11 +928,11 @@ var Schema = class {
     const errors = [];
     for (let index = 0; index < cubeFiles.length; index++) {
       const file = cubeFiles[index];
-      const filePath = path2.isAbsolute(file) ? file : path2.join(cubesDir, file);
-      const stats = fs2.statSync(filePath);
+      const filePath = path3.isAbsolute(file) ? file : path3.join(cubesDir, file);
+      const stats = fs4.statSync(filePath);
       if (stats.isFile()) {
         const getSeederName = FileUtils_default.extracTableNameFromCube(filePath);
-        const seederName = getSeederName.status === 200 ? getSeederName.message : path2.basename(file, ".seeder.cube");
+        const seederName = getSeederName.status === 200 ? getSeederName.message : path3.basename(file, ".seeder.cube");
         await UIUtils.showItemProgress(seederName, index + 1, cubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
@@ -641,9 +983,9 @@ var Schema = class {
   }
   async executeTriggers() {
     const startTime = Date.now();
-    const cubesDir = path2.join(process.cwd(), "dbcube", "cubes");
-    const triggersDirExit = path2.join(process.cwd(), "dbcube", "triggers");
-    if (!fs2.existsSync(cubesDir)) {
+    const cubesDir = path3.join(process.cwd(), "dbcube", "cubes");
+    const triggersDirExit = path3.join(process.cwd(), "dbcube", "triggers");
+    if (!fs4.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "trigger.cube");
@@ -658,11 +1000,11 @@ var Schema = class {
     const errors = [];
     for (let index = 0; index < cubeFiles.length; index++) {
       const file = cubeFiles[index];
-      const filePath = path2.isAbsolute(file) ? file : path2.join(cubesDir, file);
-      const stats = fs2.statSync(filePath);
+      const filePath = path3.isAbsolute(file) ? file : path3.join(cubesDir, file);
+      const stats = fs4.statSync(filePath);
       if (stats.isFile()) {
         const getTriggerName = FileUtils_default.extracTableNameFromCube(filePath);
-        const triggerName = getTriggerName.status === 200 ? getTriggerName.message : path2.basename(file, ".trigger.cube");
+        const triggerName = getTriggerName.status === 200 ? getTriggerName.message : path3.basename(file, ".trigger.cube");
         await UIUtils.showItemProgress(triggerName, index + 1, cubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
@@ -715,29 +1057,11 @@ var Schema = class {
   }
 };
 function returnFormattedError(status, message) {
-  const RESET = "\x1B[0m";
-  const RED = "\x1B[31m";
-  const YELLOW = "\x1B[33m";
-  const BOLD = "\x1B[1m";
-  const CYAN = "\x1B[36m";
-  const GRAY = "\x1B[90m";
-  const UNDERLINE = "\x1B[4m";
-  const MAGENTA = "\x1B[35m";
-  let output = "";
-  let help = "";
-  const color = status === 600 ? YELLOW : RED;
-  if (message.includes("[help]")) {
-    const parts = message.split("[help]");
-    output += `
-${RED}${BOLD}${parts[0]}${RESET}`;
-    help += `
-${MAGENTA}${BOLD}[help]${RESET} ${GRAY}${parts[1]}${RESET}
-`;
-  } else {
-    output += `
-${color}${BOLD}${message}${RESET}
-`;
-  }
+  console.log(`
+${chalk2.red("\u{1F6AB}")} ${chalk2.bold.red("ERRORS FOUND")}`);
+  console.log(chalk2.red("\u2500".repeat(60)));
+  console.log(`${chalk2.red("[error]")} ${chalk2.red(message)}`);
+  console.log("");
   const err = new Error();
   const stackLines = err.stack?.split("\n") || [];
   const relevantStackLine = stackLines.find(
@@ -749,39 +1073,32 @@ ${color}${BOLD}${message}${RESET}
       const [, filePath, lineStr, columnStr] = match;
       const lineNum = parseInt(lineStr, 10);
       const errorLocation = `${filePath}:${lineStr}:${columnStr}`;
+      console.log(`${chalk2.cyan("[code]")} ${chalk2.yellow(errorLocation)}`);
       try {
-        const codeLines = fs2.readFileSync(filePath, "utf-8").split("\n");
+        const codeLines = fs4.readFileSync(filePath, "utf-8").split("\n");
         const start = Math.max(0, lineNum - 3);
         const end = Math.min(codeLines.length, lineNum + 2);
-        output += `
-${CYAN}${BOLD}[code] ${RESET}${YELLOW} ${UNDERLINE}${errorLocation}${RESET}
-`;
         for (let i = start; i < end; i++) {
           const line = codeLines[i];
           const lineLabel = `${i + 1}`.padStart(4, " ");
-          const pointer = i + 1 === lineNum ? `${RED}<-${RESET}` : "  ";
-          output += `${GRAY}${lineLabel}${RESET} ${pointer} ${line}
-`;
+          const pointer = i + 1 === lineNum ? `${chalk2.red("<-")}` : "  ";
+          console.log(`${chalk2.gray(lineLabel)} ${pointer}       ${chalk2.white(line)}`);
         }
       } catch (err2) {
-        output += `${YELLOW}\u26A0\uFE0F No se pudo leer el archivo de origen: ${filePath}${RESET}
-`;
-        output += `
-${CYAN}${BOLD}Stack Trace:${RESET}
-${stackLines.slice(2).join("\n")}
-`;
+        console.log(chalk2.gray("   (unable to show code context)"));
       }
     }
   }
-  output += help;
-  console.error(output);
+  console.log("");
   process.exit(1);
 }
 
 // src/index.ts
 var index_default = Schema;
 export {
+  CubeValidator,
   Schema,
+  UIUtils,
   index_default as default
 };
 //# sourceMappingURL=index.js.map