@ijuantm/simpl-addon 2.6.5 → 2.7.0

package/install.js

@@ -9,33 +9,52 @@ const {exec} = require('child_process');
 
 const execAsync = promisify(exec);
 
-const COLORS = {
+const C = {
   reset: '\x1b[0m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m',
-  cyan: '\x1b[36m', blue: '\x1b[34m', gray: '\x1b[90m', bold: '\x1b[1m', dim: '\x1b[2m'
+  cyan: '\x1b[36m', blue: '\x1b[34m', gray: '\x1b[90m', bold: '\x1b[1m', dim: '\x1b[2m',
 };
 
 const CDN_BASE = 'https://cdn.simpl.iwanvanderwal.nl/framework';
 const LOCAL_RELEASES_DIR = process.env.SIMPL_LOCAL_RELEASES || path.join(process.cwd(), 'local-releases');
 const BOX_WIDTH = 62;
+const PAD = '  ';
 
-const log = (message = '', color = 'reset') => console.log(`${COLORS[color]}${message}${COLORS.reset}`);
+const styled = (msg, ...styles) => styles.join('') + msg + C.reset;
+const line = (msg = '') => console.log(msg);
+const out = (msg, color = C.reset) => console.log(color + msg + C.reset);
+const prefixed = (symbol, color, msg, bold = false, dim = false) => out(PAD + color + symbol + C.reset + ' ' + (bold ? styled(msg, C.bold) : dim ? styled(msg, C.dim) : msg));
+
+const success = (msg, bold = false) => prefixed('✓', C.green, msg, bold);
+const error = (msg, bold = false) => prefixed('✕', C.red, msg, bold);
+const warn = (msg, bold = false) => prefixed('⚠', C.yellow, msg, bold);
+const info = (msg) => prefixed('ℹ', C.cyan, msg, false, true);
+const task = (msg) => out(PAD + msg);
+const item = (msg, dim = false) => out(PAD + C.cyan + '•' + C.reset + ' ' + (dim ? styled(msg, C.dim) : msg));
 
 const box = (title) => {
-  log();
-  log(` ╭${'─'.repeat(BOX_WIDTH)}╮`);
-  const contentWidth = BOX_WIDTH - 2; // Remove the two padding characters on each side
-  const remainingSpace = contentWidth - (typeof title === 'string' ? title.length : 0);
-  const padding = remainingSpace > 0 ? ' '.repeat(remainingSpace) : '';
-  log(` │ ${COLORS.bold}${title}${COLORS.reset}${padding}│`);
-  log(` ╰${'─'.repeat(BOX_WIDTH)}╯`);
-  log();
+  const plain = title.replace(/\x1b\[[0-9;]*m/g, '');
+  const truncated = plain.length > BOX_WIDTH - 2 ? plain.slice(0, BOX_WIDTH - 5) + '...' : plain;
+  const displayTitle = title.replace(plain, truncated);
+  const spaces = ' '.repeat(BOX_WIDTH - 2 - truncated.length);
+  line();
+  out(PAD + '╭' + '─'.repeat(BOX_WIDTH) + '╮');
+  out(PAD + '│ ' + styled(displayTitle, C.bold) + spaces + ' │');
+  out(PAD + '╰' + '─'.repeat(BOX_WIDTH) + '╯');
+  line();
+};
+
+const divider = () => {
+  line();
+  out(PAD + '─'.repeat(16), C.dim);
+  line();
 };
 
+const printAnswer = (question, value) => out(`${question}: ${C.cyan}${value}${C.reset}`);
+
 const fetchUrl = (url) => new Promise((resolve, reject) => {
   https.get(url, res => {
-    if (res.statusCode === 302 || res.statusCode === 301) return fetchUrl(res.headers.location).then(resolve).catch(reject);
+    if (res.statusCode === 301 || res.statusCode === 302) return fetchUrl(res.headers.location).then(resolve).catch(reject);
     if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage || 'Request failed'}`));
-
     let data = '';
     res.on('data', chunk => data += chunk);
     res.on('end', () => resolve(data));
@@ -44,52 +63,38 @@ const fetchUrl = (url) => new Promise((resolve, reject) => {
 
 const downloadFile = (url, dest) => new Promise((resolve, reject) => {
   const file = fs.createWriteStream(dest);
+  const fail = (err) => {
+    try {
+      fs.unlinkSync(dest);
+    } catch {
+    }
+    reject(err);
+  };
 
   https.get(url, res => {
-    if (res.statusCode === 302 || res.statusCode === 301) {
+    if (res.statusCode === 301 || res.statusCode === 302) {
       fs.unlinkSync(dest);
       return downloadFile(res.headers.location, dest).then(resolve).catch(reject);
     }
-    if (res.statusCode !== 200) {
-      fs.unlinkSync(dest);
-      return reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage || 'Request failed'}`));
-    }
-
+    if (res.statusCode !== 200) return fail(new Error(`HTTP ${res.statusCode}: ${res.statusMessage || 'Request failed'}`));
     res.pipe(file);
     file.on('finish', () => {
       file.close();
       resolve();
     });
-  }).on('error', err => {
-    fs.unlinkSync(dest);
-    reject(err);
-  });
-
-  file.on('error', err => {
-    fs.unlinkSync(dest);
-    reject(err);
-  });
+  }).on('error', fail);
+  file.on('error', fail);
 });
 
 const promptUser = (question, defaultValue = '') => new Promise(resolve => {
   const rl = readline.createInterface({input: process.stdin, output: process.stdout});
-  const prompt = defaultValue ? `${question} ${COLORS.dim}(${defaultValue})${COLORS.reset}: ` : `${question}: `;
+  const prompt = defaultValue ? `${question} ${C.dim}(${defaultValue})${C.reset}: ` : `${question}: `;
   rl.question(prompt, answer => {
     rl.close();
     resolve(answer.trim() || defaultValue);
   });
 });
 
-const printAnswer = (question, value) => console.log(`${question}: ${COLORS.cyan}${value}${COLORS.reset}`);
-
-const getSimplVersion = () => {
-  const simplFile = path.join(process.cwd(), '.simpl');
-  if (!fs.existsSync(simplFile)) throw new Error('Not a Simpl project. Missing .simpl file in current directory.');
-  const config = JSON.parse(fs.readFileSync(simplFile, 'utf8'));
-  if (!config.version) throw new Error('Invalid .simpl file: missing version field');
-  return config.version;
-};
-
 const parseArgs = (args) => {
   const result = {addon: null, unknownFlags: [], help: false, list: false};
   for (const arg of args) {
@@ -124,77 +129,71 @@ const closestMatch = (input, options) => {
   return bestDist <= Math.max(3, Math.floor(input.length / 2)) ? best : null;
 };
 
+const listAddons = (addons) => addons.forEach((name, i) => out(PAD + C.cyan + `${i + 1}.` + C.reset + ' ' + name));
+
 const promptAddon = async (addons, firstInput = null) => {
   const askSuggestion = async (input) => {
     const suggestion = closestMatch(input, addons);
-    log();
-    log(` ${COLORS.red}✗${COLORS.reset} Add-on ${COLORS.bold}${input}${COLORS.reset} not found`);
-
+    line();
+    error(`Add-on ${styled(input, C.bold)} not found`);
     if (suggestion) {
-      log(` Did you mean: ${COLORS.blue}${suggestion}${COLORS.reset}?`);
-      log();
-
+      out(PAD + `Did you mean: ${C.blue}${suggestion}${C.reset}?`);
+      line();
       while (true) {
-        const answer = await promptUser(` Use "${suggestion}"? ${COLORS.dim}(yes / no (lists available add-ons))${COLORS.reset}`);
-        const a = answer.toLowerCase();
+        const a = (await promptUser(PAD + `Use "${suggestion}"? ${C.dim}(yes / no (lists available add-ons))${C.reset}`)).toLowerCase();
         if (a === 'yes' || a === 'y') return suggestion;
         if (a === 'no' || a === 'n') break;
-        log(` ${COLORS.yellow}⚠${COLORS.reset} ${COLORS.dim}Please answer yes or no${COLORS.reset}`);
+        warn('Please answer yes or no');
       }
     }
-
-    log();
-    log(` ${COLORS.bold}Available add-ons:${COLORS.reset}`, 'blue');
+    line();
+    out(PAD + styled('Available add-ons:', C.bold), C.blue);
     listAddons(addons);
-    log();
+    line();
     return null;
   };
 
   let pending = firstInput;
   while (true) {
-    const input = pending || await promptUser(` Add-on to install ${COLORS.dim}(name or number)${COLORS.reset}`);
+    const input = pending || await promptUser(PAD + `Add-on to install ${C.dim}(name or number)${C.reset}`);
     pending = null;
-
     if (!input) {
-      log(` ${COLORS.yellow}⚠${COLORS.reset} ${COLORS.dim}Selection cannot be empty${COLORS.reset}`);
-      log();
+      warn('Selection cannot be empty');
+      line();
       continue;
     }
-
-    const numInput = parseInt(input, 10);
-    if (!isNaN(numInput) && numInput >= 1 && numInput <= addons.length) return addons[numInput - 1];
+    const num = parseInt(input, 10);
+    if (!isNaN(num) && num >= 1 && num <= addons.length) return addons[num - 1];
     if (addons.includes(input)) return input;
-
     const resolved = await askSuggestion(input);
     if (resolved) return resolved;
   }
 };
 
-const listAddons = (addons) => addons.forEach((name, i) => log(` ${COLORS.cyan}${i + 1}.${COLORS.reset} ${name}`));
-
 const showHelp = () => {
   box('Simpl Add-on Installer');
-  log(` ${COLORS.bold}Usage:${COLORS.reset}`, 'blue');
-  log(` ${COLORS.dim}npx @ijuantm/simpl-addon${COLORS.reset}`);
-  log(` ${COLORS.dim}npx @ijuantm/simpl-addon --addon=<name>${COLORS.reset}`);
-  log(` ${COLORS.dim}npx @ijuantm/simpl-addon --help${COLORS.reset}`);
-  log();
-  log(` ${COLORS.bold}Options:${COLORS.reset}`, 'blue');
-  log(` ${COLORS.dim}--addon=<name>, -a=<name>${COLORS.reset} Add-on to install`);
-  log(` ${COLORS.dim}--list, -l${COLORS.reset} List available add-ons`);
-  log(` ${COLORS.dim}--help, -h${COLORS.reset} Show this help message`);
-  log();
-  log(` ${COLORS.bold}Note:${COLORS.reset}`, 'blue');
-  log(` Run this command from the root of your Simpl project.`);
-  log(` The add-on version will match your Simpl framework version.`);
-  log();
+  out(PAD + styled('Usage:', C.bold), C.blue);
+  out(PAD + styled('npx @ijuantm/simpl-addon', C.dim));
+  out(PAD + styled('npx @ijuantm/simpl-addon --addon=<name>', C.dim));
+  out(PAD + styled('npx @ijuantm/simpl-addon --help', C.dim));
+  line();
+  out(PAD + styled('Options:', C.bold), C.blue);
+  out(PAD + styled('--addon=<name>, -a=<name>', C.dim) + ' Add-on to install');
+  out(PAD + styled('--list, -l', C.dim) + '              List available add-ons');
+  out(PAD + styled('--help, -h', C.dim) + '              Show this help message');
+  line();
+  out(PAD + styled('Note:', C.bold), C.blue);
+  item('Run this command from the root of your Simpl project.');
+  item('The add-on version will match your Simpl framework version.');
+  line();
 };
 
 const checkServerAvailability = () => new Promise(resolve => {
   https.get(`${CDN_BASE}/versions.json`, {timeout: 5000}, res => {
     res.resume();
     resolve(res.statusCode === 200);
-  }).on('error', () => resolve(false)).on('timeout', () => resolve(false));
+  })
+    .on('error', () => resolve(false)).on('timeout', () => resolve(false));
 });
 
 const getVersionsData = async () => {
@@ -202,28 +201,32 @@ const getVersionsData = async () => {
   return JSON.parse(await fetchUrl(`${CDN_BASE}/versions.json`));
 };
 
+const getSimplVersion = () => {
+  const simplFile = path.join(process.cwd(), '.simpl');
+  if (!fs.existsSync(simplFile)) throw new Error('Not a Simpl project. Missing .simpl file in current directory.');
+  const config = JSON.parse(fs.readFileSync(simplFile, 'utf8'));
+  if (!config.version) throw new Error('Invalid .simpl file: missing version field');
+  return config.version;
+};
+
 const getAvailableAddons = async (version) => {
   const localAddonsDir = path.join(LOCAL_RELEASES_DIR, version, 'add-ons');
-
   if (fs.existsSync(localAddonsDir)) return fs.readdirSync(localAddonsDir, {withFileTypes: true})
-    .filter(entry => entry.isFile() && entry.name.endsWith('.zip'))
-    .map(entry => entry.name.replace('.zip', ''))
+    .filter(e => e.isFile() && e.name.endsWith('.zip'))
+    .map(e => e.name.slice(0, -4))
     .sort();
-
-  const versionMeta = (await getVersionsData()).versions[version];
-  return (versionMeta?.['add-ons'] || []).sort();
+  return ((await getVersionsData()).versions[version]?.['add-ons'] || []).sort();
 };
 
 const extractMarkers = (content) => {
   const markers = [];
   content.split('\n').forEach((line, i) => {
-    const afterMatch = line.match(/@addon-insert:after\s*\(\s*(["'])(.*?)\1\s*\)/);
-    const beforeMatch = line.match(/@addon-insert:before\s*\(\s*(["'])(.*?)\1\s*\)/);
-    const replaceMatch = line.match(/@addon-insert:replace\s*\(\s*(["'])(.*?)\1\s*\)/);
-
-    if (afterMatch) markers.push({type: 'after', lineIndex: i, searchText: afterMatch[2]});
-    else if (beforeMatch) markers.push({type: 'before', lineIndex: i, searchText: beforeMatch[2]});
-    else if (replaceMatch) markers.push({type: 'replace', lineIndex: i, markerName: replaceMatch[2]});
+    const after = line.match(/@addon-insert:after\s*\(\s*(["'])(.*?)\1\s*\)/);
+    const before = line.match(/@addon-insert:before\s*\(\s*(["'])(.*?)\1\s*\)/);
+    const replace = line.match(/@addon-insert:replace\s*\(\s*(["'])(.*?)\1\s*\)/);
+    if (after) markers.push({type: 'after', lineIndex: i, searchText: after[2]});
+    else if (before) markers.push({type: 'before', lineIndex: i, searchText: before[2]});
+    else if (replace) markers.push({type: 'replace', lineIndex: i, markerName: replace[2]});
     else if (line.includes('@addon-insert:prepend')) markers.push({type: 'prepend', lineIndex: i});
     else if (line.includes('@addon-insert:append')) markers.push({type: 'append', lineIndex: i});
   });
@@ -239,20 +242,21 @@ const collectContentBetweenMarkers = (lines, startIndex) => {
   return content;
 };
 
-const normalizeContent = (lines) => lines.map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('#') && !l.startsWith('/*') && !l.startsWith('*')).join('|');
+const normalizeContent = (lines) => lines.map(l => l.trim())
+  .filter(l => l && !l.startsWith('//') && !l.startsWith('#') && !l.startsWith('/*') && !l.startsWith('*'))
+  .join('|');
 
 const processEnvContent = (content, targetContent) => {
   const envVarsToAdd = [], comments = [];
-  content.forEach(line => {
+  for (const line of content) {
     const trimmed = line.trim();
     if (trimmed.startsWith('#') || !trimmed) {
       comments.push(line);
-      return;
+      continue;
     }
-
     const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
     if (match && !new RegExp(`^${match[1]}=`, 'm').test(targetContent)) envVarsToAdd.push(line);
-  });
+  }
   return {content: [...comments, ...envVarsToAdd], count: envVarsToAdd.length};
 };
 
@@ -267,28 +271,24 @@ const mergeFile = (targetPath, addonContent, markers, isEnv = false) => {
   const operations = [];
   let newContent = targetContent;
 
-  markers.forEach(marker => {
+  for (const marker of markers) {
     let content = collectContentBetweenMarkers(addonLines, marker.lineIndex);
-    if (content.length === 0) return;
-
+    if (!content.length) continue;
     let lineCount = content.length;
 
     if (isEnv) {
       const processed = processEnvContent(content, newContent);
       content = processed.content;
       lineCount = processed.count;
-
-      if (content.length === 0) {
+      if (!content.length) {
         operations.push({success: false, type: marker.type, lines: 0, searchText: marker.searchText});
-        return;
+        continue;
       }
     } else {
       const signature = normalizeContent(content);
-      const targetSignature = normalizeContent(newContent.split('\n'));
-
-      if (signature && targetSignature.includes(signature)) {
+      if (signature && normalizeContent(newContent.split('\n')).includes(signature)) {
         operations.push({success: false, type: marker.type, lines: content.length, searchText: marker.searchText || marker.markerName});
-        return;
+        continue;
       }
     }
 
@@ -302,65 +302,63 @@ const mergeFile = (targetPath, addonContent, markers, isEnv = false) => {
     } else if (marker.type === 'replace' && marker.markerName) {
       const targetLines = newContent.split('\n');
       const replaceIndex = findInsertIndex(targetLines, marker.markerName, 'before');
-
       if (replaceIndex === -1) {
         operations.push({success: false, type: 'notfound', searchText: marker.markerName});
-        return;
+        continue;
       }
-
       targetLines.splice(replaceIndex, 1, ...content);
       newContent = targetLines.join('\n');
       operations.push({success: true, type: 'replace', lines: lineCount, markerName: marker.markerName});
     } else if ((marker.type === 'after' || marker.type === 'before') && marker.searchText) {
       const targetLines = newContent.split('\n');
       const insertIndex = findInsertIndex(targetLines, marker.searchText, marker.type);
-
       if (insertIndex === -1) {
         operations.push({success: false, type: 'notfound', searchText: marker.searchText});
-        return;
+        continue;
       }
-
       targetLines.splice(insertIndex, 0, ...content);
       newContent = targetLines.join('\n');
       operations.push({success: true, type: marker.type, lines: lineCount, searchText: marker.searchText});
     }
-  });
+  }
 
   if (newContent !== targetContent) fs.writeFileSync(targetPath, newContent, 'utf8');
   return {modified: newContent !== targetContent, operations};
 };
 
 const printMergeResults = (relativePath, isEnv, result) => {
-  const indent = ' ';
   const varText = isEnv ? 'environment variable' : 'line';
   let hasChanges = false;
 
-  result.operations.forEach(op => {
+  for (const op of result.operations) {
     if (op.success) {
       hasChanges = true;
-      if (op.type === 'prepend') log(`${indent}${COLORS.green}✓${COLORS.reset} Prepended ${COLORS.bold}${op.lines}${COLORS.reset} ${varText}${op.lines !== 1 ? 's' : ''} to file start`);
-      else if (op.type === 'append') log(`${indent}${COLORS.green}✓${COLORS.reset} Appended ${COLORS.bold}${op.lines}${COLORS.reset} ${varText}${op.lines !== 1 ? 's' : ''} to file end`);
-      else if (op.type === 'replace') log(`${indent}${COLORS.green}✓${COLORS.reset} Replaced marker ${COLORS.cyan}${op.markerName}${COLORS.reset} with ${COLORS.bold}${op.lines}${COLORS.reset} ${varText}${op.lines !== 1 ? 's' : ''}`);
-      else if (op.type === 'after') log(`${indent}${COLORS.green}✓${COLORS.reset} Inserted ${COLORS.bold}${op.lines}${COLORS.reset} ${varText}${op.lines !== 1 ? 's' : ''} ${COLORS.cyan}after${COLORS.reset} ${COLORS.dim}${op.searchText}${COLORS.reset}`);
-      else if (op.type === 'before') log(`${indent}${COLORS.green}✓${COLORS.reset} Inserted ${COLORS.bold}${op.lines}${COLORS.reset} ${varText}${op.lines !== 1 ? 's' : ''} ${COLORS.cyan}before${COLORS.reset} ${COLORS.dim}${op.searchText}${COLORS.reset}`);
+      const count = `${styled(String(op.lines), C.bold)} ${varText}${op.lines !== 1 ? 's' : ''}`;
+      if (op.type === 'prepend') success(`Prepended ${count} to file start`);
+      else if (op.type === 'append') success(`Appended ${count} to file end`);
+      else if (op.type === 'replace') success(`Replaced marker ${C.cyan}${op.markerName}${C.reset} with ${count}`);
+      else if (op.type === 'after') success(`Inserted ${count} ${C.cyan}after${C.reset} ${styled(op.searchText, C.dim)}`);
+      else if (op.type === 'before') success(`Inserted ${count} ${C.cyan}before${C.reset} ${styled(op.searchText, C.dim)}`);
     } else if (op.type === 'notfound') {
-      const target = op.markerName ? `marker ${COLORS.dim}${op.markerName}${COLORS.reset}` : `${COLORS.dim}${op.searchText}${COLORS.reset}`;
-      log(`${indent}${COLORS.yellow}⚠${COLORS.reset} ${COLORS.yellow}Could not find target:${COLORS.reset} ${target}`);
-    } else log(`${indent}${COLORS.gray}○${COLORS.reset} ${COLORS.dim}Content already exists (${op.type})${COLORS.reset}`);
-  });
+      warn(`Could not find target: ${op.markerName ? `marker ${styled(op.markerName, C.dim)}` : styled(op.searchText, C.dim)}`);
+    } else {
+      info(`Content already exists (${op.type})`);
+    }
+  }
 
   return hasChanges;
 };
 
 const extractZip = async (zipPath, destDir) => {
   fs.mkdirSync(destDir, {recursive: true});
-  const cmd = process.platform === 'win32' ? `powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"` : `unzip -q "${zipPath}" -d "${destDir}"`;
+  const cmd = process.platform === 'win32'
+    ? `powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`
+    : `unzip -q "${zipPath}" -d "${destDir}"`;
   await execAsync(cmd);
-
   const entries = fs.readdirSync(destDir, {withFileTypes: true});
   if (entries.length === 1 && entries[0].isDirectory()) {
     const nestedDir = path.join(destDir, entries[0].name);
-    fs.readdirSync(nestedDir).forEach(item => fs.renameSync(path.join(nestedDir, item), path.join(destDir, item)));
+    for (const item of fs.readdirSync(nestedDir)) fs.renameSync(path.join(nestedDir, item), path.join(destDir, item));
     fs.rmdirSync(nestedDir);
   }
   return destDir;
@@ -369,18 +367,19 @@ const extractZip = async (zipPath, destDir) => {
 const processAddonFiles = (addonDir, targetDir) => {
   const copied = [], skipped = [], toMerge = [];
 
-  const processDirectory = (dir, basePath = '') => fs.readdirSync(dir, {withFileTypes: true}).forEach(entry => {
-    if (entry.name === 'README.md') return;
+  const processDirectory = (dir, basePath = '') => {
+    for (const entry of fs.readdirSync(dir, {withFileTypes: true})) {
+      if (entry.name === 'README.md') continue;
+      const srcPath = path.join(dir, entry.name);
+      const relativePath = path.join(basePath, entry.name).replace(/\\/g, '/');
+      const destPath = path.join(targetDir, relativePath);
 
-    const srcPath = path.join(dir, entry.name);
-    const relativePath = path.join(basePath, entry.name).replace(/\\/g, '/');
-    const destPath = path.join(targetDir, relativePath);
+      if (entry.isDirectory()) {
+        processDirectory(srcPath, relativePath);
+        continue;
+      }
 
-    if (entry.isDirectory()) {
-      processDirectory(srcPath, relativePath);
-    } else {
       const content = fs.readFileSync(srcPath, 'utf8');
-
       if (fs.existsSync(destPath)) {
         const markers = extractMarkers(content);
         if (markers.length > 0 || entry.name === '.env') toMerge.push({content, destPath, relativePath, markers});
@@ -391,7 +390,7 @@ const processAddonFiles = (addonDir, targetDir) => {
         copied.push(relativePath);
       }
     }
-  });
+  };
 
   processDirectory(addonDir);
   return {copied, skipped, toMerge};
@@ -403,8 +402,8 @@ const downloadAddon = async (addonName, version, targetDir) => {
 
   try {
     if (fs.existsSync(localZipPath)) {
-      log();
-      log(` 💻 Using local add-on files`, 'bold');
+      line();
+      task('💻 Using local add-on files');
       const sourceDir = await extractZip(localZipPath, tempExtract);
       const result = processAddonFiles(sourceDir, targetDir);
       fs.rmSync(tempExtract, {recursive: true, force: true});
@@ -412,7 +411,6 @@ const downloadAddon = async (addonName, version, targetDir) => {
     }
 
     if (!await checkServerAvailability()) throw new Error('CDN server is currently unreachable');
-
     const tempZip = path.join(process.cwd(), `temp-addon-${addonName}.zip`);
     await downloadFile(`${CDN_BASE}/${version}/add-ons/${addonName}.zip`, tempZip);
     const sourceDir = await extractZip(tempZip, tempExtract);
@@ -420,213 +418,192 @@ const downloadAddon = async (addonName, version, targetDir) => {
     fs.unlinkSync(tempZip);
     fs.rmSync(tempExtract, {recursive: true, force: true});
     return result;
-  } catch (error) {
+  } catch (err) {
     if (fs.existsSync(tempExtract)) fs.rmSync(tempExtract, {recursive: true, force: true});
-    throw error;
+    throw err;
   }
 };
 
 const mergeFiles = (toMerge) => {
-  if (toMerge.length === 0) return {merged: [], failed: [], unchanged: []};
-
+  if (!toMerge.length) return {merged: [], failed: [], unchanged: []};
   const merged = [], failed = [], unchanged = [];
 
-  toMerge.forEach(({content, destPath, relativePath, markers}) => {
+  for (const {content, destPath, relativePath, markers} of toMerge) {
     const isEnv = path.basename(destPath) === '.env';
-    log(`\n ${COLORS.cyan}•${COLORS.reset} ${COLORS.dim}${relativePath}${COLORS.reset}`);
-
+    line();
+    info(styled(relativePath, C.dim));
     try {
-      const result = mergeFile(destPath, content, markers, isEnv);
-      if (printMergeResults(relativePath, isEnv, result)) merged.push(relativePath);
+      if (printMergeResults(relativePath, isEnv, mergeFile(destPath, content, markers, isEnv))) merged.push(relativePath);
       else unchanged.push(relativePath);
-    } catch (error) {
-      log(` ${COLORS.red}✗ Error:${COLORS.reset} ${error.message}`);
+    } catch (err) {
+      error(`Error: ${err.message}`);
       failed.push(relativePath);
     }
-  });
+  }
 
   return {merged, failed, unchanged};
 };
 
 const main = async () => {
-  const args = process.argv.slice(2);
-  const parsed = parseArgs(args);
+  const parsed = parseArgs(process.argv.slice(2));
 
   if (parsed.help) {
     showHelp();
     process.exit(0);
   }
 
-  // Warn about unknown flags and suggest closest known ones
   for (const flag of parsed.unknownFlags) {
     const flagName = flag.includes('=') ? flag.slice(0, flag.indexOf('=')) : flag;
     const suggestion = closestMatch(flagName, KNOWN_FLAGS);
-    log();
-    log(` ${COLORS.yellow}⚠${COLORS.reset} Unknown option: ${COLORS.bold}${flag}${COLORS.reset}`, 'yellow');
-    if (suggestion) log(` ${COLORS.dim}Did you mean ${COLORS.reset}${COLORS.cyan}${suggestion}${COLORS.reset}${COLORS.dim}?${COLORS.reset}`);
+    line();
+    warn(`Unknown option: ${styled(flag, C.bold)}`);
+    if (suggestion) info(`Did you mean ${C.cyan}${suggestion}${C.reset}?`);
   }
-
-  if (parsed.unknownFlags.length > 0) {
-    log(` ${COLORS.dim}Run with --help to see all available options.${COLORS.reset}`);
-    log();
+  if (parsed.unknownFlags.length) {
+    info('Run with --help to see all available options.');
+    line();
     process.exit(1);
   }
 
   let version;
-
   try {
     version = getSimplVersion();
-  } catch (error) {
-    log();
-    log(` ${COLORS.red}✗${COLORS.reset} ${error.message}`);
-    log();
+  } catch (err) {
+    line();
+    error(err.message);
+    line();
     process.exit(1);
   }
 
-  log();
-  box(`Simpl Add-on Installer${COLORS.dim}(v${version})${COLORS.reset}`);
+  line();
+  box(`Simpl Add-on Installer ${C.dim}(v${version})${C.reset}`);
 
   let versionsData;
-
   try {
     versionsData = await getVersionsData();
-  } catch (error) {
-    log();
-    log(` ${COLORS.red}✗${COLORS.reset} Failed to fetch version data`);
-    if (error.message === 'CDN server is currently unreachable') log(` ${COLORS.dim}The CDN server is currently unavailable. Please try again later.${COLORS.reset}`);
-    log();
+  } catch {
+    error('Failed to fetch version data');
+    info('The CDN server is currently unavailable. Please try again later.');
+    line();
     process.exit(1);
   }
 
   const versionMeta = versionsData.versions[version];
   if (!versionMeta) {
-    log();
-    log(` ${COLORS.red}✗${COLORS.reset} Version ${COLORS.bold}${version}${COLORS.reset} not found`);
-    log();
+    line();
+    error(`Version ${styled(version, C.bold)} not found`);
+    line();
     process.exit(1);
   }
 
   if (versionMeta['script-compatible'] === false) {
-    log();
-    log(` ${COLORS.red}✗${COLORS.reset} Version ${COLORS.bold}${version}${COLORS.reset} is not compatible with this installer`);
-    log();
-    log(` ${COLORS.bold}Manual download:${COLORS.reset}`, 'blue');
-    log(` ${COLORS.cyan}${CDN_BASE}/${version}/add-ons/`, 'cyan');
-    log();
-    log(` ${COLORS.bold}Available add-ons for this version:${COLORS.reset}`, 'blue');
-
+    line();
+    error(`Version ${styled(version, C.bold)} is not compatible with this installer`);
+    line();
+    out(PAD + styled('Manual download:', C.bold), C.blue);
+    item(`${C.cyan}${CDN_BASE}/${version}/add-ons/`);
+    line();
+    out(PAD + styled('Available add-ons for this version:', C.bold), C.blue);
     const addons = versionMeta['add-ons'] || [];
-    if (addons.length === 0) log(` ${COLORS.dim}No add-ons available${COLORS.reset}`);
-    else addons.forEach(name => {
-      log(` ${COLORS.cyan}•${COLORS.reset} ${name}: ${COLORS.dim}${CDN_BASE}/${version}/add-ons/${name}.zip${COLORS.reset}`);
-    });
-
-    log();
+    if (!addons.length) info('No add-ons available');
+    else for (const name of addons) item(`${name}: ${styled(`${CDN_BASE}/${version}/add-ons/${name}.zip`, C.dim)}`);
+    line();
     process.exit(1);
   }
 
   if (!parsed.addon) {
-    log();
-    log(' 🗄️ Fetching available add-ons...', 'bold');
+    line();
+    task('🗄️ Fetching available add-ons...');
   }
 
   let addons;
-
   try {
     addons = await getAvailableAddons(version);
-  } catch (error) {
-    log();
-    log(` ${COLORS.red}✗${COLORS.reset} Failed to fetch add-ons`);
-    if (error.message === 'CDN server is currently unreachable') log(` ${COLORS.dim}The CDN server is currently unavailable. Please try again later.${COLORS.reset}`);
-    log();
+  } catch {
+    line();
+    error('Failed to fetch add-ons');
+    info('The CDN server is currently unavailable. Please try again later.');
+    line();
     process.exit(1);
   }
 
-  if (addons.length === 0) {
-    log();
-    log(` ${COLORS.yellow}⚠${COLORS.reset} No add-ons available for this version`);
-    log();
+  if (!addons.length) {
+    line();
+    warn('No add-ons available for this version');
+    line();
     process.exit(0);
   }
 
   if (parsed.list) {
-    log();
-    log(` ${COLORS.bold}Available add-ons:${COLORS.reset}`, 'blue');
+    line();
+    out(PAD + styled('Available add-ons:', C.bold), C.blue);
     listAddons(addons);
-    log();
+    line();
     process.exit(0);
   }
 
   let addonName;
-
   if (parsed.addon) {
     addonName = await promptAddon(addons, parsed.addon);
-    printAnswer(' Add-on to install', addonName);
+    printAnswer(PAD + 'Add-on to install', addonName);
   } else {
-    log();
-    log(` ${COLORS.bold}Available add-ons:${COLORS.reset}`, 'blue');
+    line();
+    out(PAD + styled('Available add-ons:', C.bold), C.blue);
     listAddons(addons);
-    log();
-
+    line();
     addonName = await promptAddon(addons);
   }
 
-  log();
-  box(`Installing: ${COLORS.cyan}${addonName}${COLORS.reset} ${COLORS.dim}(v${version})${COLORS.reset}`);
-  log(` 📦 Downloading ${COLORS.cyan}${addonName}${COLORS.reset} add-on...`, 'bold');
+  line();
+  box(`Installing: ${C.cyan}${addonName}${C.reset} ${C.dim}(v${version})${C.reset}`);
+  task(`📦 Downloading ${C.cyan}${addonName}${C.reset} add-on...`);
 
   let copied, skipped, toMerge;
-
   try {
     ({copied, skipped, toMerge} = await downloadAddon(addonName, version, process.cwd()));
-  } catch (error) {
-    log();
-    log(` ${COLORS.red}✗${COLORS.reset} Installation failed`);
-    if (error.message === 'CDN server is currently unreachable') log(` ${COLORS.dim}The CDN server is currently unavailable. Please try again later.${COLORS.reset}`);
-    else log(` ${COLORS.dim}Please verify the add-on exists and try again${COLORS.reset}`);
-    log();
+  } catch (err) {
+    line();
+    error('Installation failed');
+    if (err.message === 'CDN server is currently unreachable') info('The CDN server is currently unavailable. Please try again later.');
+    else info('Please verify the add-on exists and try again');
+    line();
     process.exit(1);
   }
 
-  if (copied.length > 0) {
-    log();
-    log(` ${COLORS.green}✓${COLORS.reset} Copied ${COLORS.bold}${copied.length}${COLORS.reset} new file${copied.length !== 1 ? 's' : ''}`);
+  if (copied.length) {
+    line();
+    success(`Copied ${styled(String(copied.length), C.bold)} new file${copied.length !== 1 ? 's' : ''}`);
   }
 
-  if (skipped.length > 0) {
-    log();
-    log(` ${COLORS.gray}○${COLORS.reset} ${COLORS.dim}Skipped ${skipped.length} file${skipped.length !== 1 ? 's' : ''} (no merge markers):${COLORS.reset}`);
-    skipped.forEach(file => log(` ${COLORS.dim}• ${file}${COLORS.reset}`));
+  if (skipped.length) {
+    line();
+    info(`Skipped ${skipped.length} file${skipped.length !== 1 ? 's' : ''} (no merge markers):`);
+    for (const file of skipped) item(file, true);
   }
 
-  if (toMerge.length > 0) {
-    log();
-    log(' 🔀 Merging existing files...', 'bold');
+  if (toMerge.length) {
+    line();
+    task('🔀 Merging existing files...');
     const {merged, failed, unchanged} = mergeFiles(toMerge);
-
-    log();
-    log(' ' + '─'.repeat(16), 'gray');
-    log();
-
-    if (merged.length > 0) log(` ${COLORS.green}✓${COLORS.reset} Successfully merged ${COLORS.bold}${merged.length}${COLORS.reset} file${merged.length !== 1 ? 's' : ''}`);
-    if (unchanged.length > 0) log(` ${COLORS.gray}○${COLORS.reset} ${COLORS.dim}${unchanged.length} file${unchanged.length !== 1 ? 's' : ''} unchanged (content already exists)${COLORS.reset}`);
-
-    if (failed.length > 0) {
-      log();
-      log(` ${COLORS.yellow}⚠${COLORS.reset} ${COLORS.yellow}${failed.length} file${failed.length !== 1 ? 's' : ''} failed to merge${COLORS.reset}`);
-      log(` ${COLORS.yellow}Please review manually:${COLORS.reset}`);
-      failed.forEach(file => log(` ${COLORS.cyan}• ${file}${COLORS.reset}`));
+    divider();
+    if (merged.length) success(`Successfully merged ${styled(String(merged.length), C.bold)} file${merged.length !== 1 ? 's' : ''}`);
+    if (unchanged.length) info(`${unchanged.length} file${unchanged.length !== 1 ? 's' : ''} unchanged (content already exists)`);
+    if (failed.length) {
+      line();
+      warn(`${failed.length} file${failed.length !== 1 ? 's' : ''} failed to merge`);
+      warn('Please review manually:');
+      for (const file of failed) item(file);
     }
   }
 
-  log();
-  log(` ${COLORS.green}✓${COLORS.reset} ${COLORS.bold}${COLORS.green}Installation complete!${COLORS.reset}`, 'green');
-  log();
+  line();
+  success(styled('Installation complete!', C.bold, C.green), true);
+  line();
 };
 
 main().catch(() => {
-  log();
-  log(` ${COLORS.red}✗${COLORS.reset} Fatal error occurred`);
-  log();
+  line();
+  error('Fatal error occurred');
+  line();
   process.exit(1);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ijuantm/simpl-addon",
   "description": "CLI tool to install Simpl framework add-ons.",
-  "version": "2.6.5",
+  "version": "2.7.0",
   "scripts": {
     "link": "npm link",
     "unlink": "npm unlink -g @ijuantm/simpl-addon"