create-berna-stencil 2.6.0 → 2.6.2

package/README.md

@@ -16,7 +16,7 @@ Because it keeps you close to the fundamentals instead of hiding them, you spend
 - 📁 **Scalable structure** — a clean, opinionated project layout that grows with your needs
 - 🌍 **Open source** — free to use, free to modify, free to share
 
-![Version](https://img.shields.io/badge/version-2.6.0-blue)
+![Version](https://img.shields.io/badge/version-2.6.2-blue)
 ![License](https://img.shields.io/badge/license-Apache--2.0-blue)
 ![Eleventy](https://img.shields.io/badge/11ty-v3.1.2-black)
 

package/_tools/assistant.js

@@ -1,146 +1,150 @@
 const readline = require('readline');
-const { addPage, removePage, renamePage } = require('./modules/updatePage');
-const { updateOutputPath, getCurrentOutputPath } = require('./modules/updateOutputPath');
 
-const c = {
-    reset: "\x1b[0m",
-    bold: "\x1b[1m",
-    dim: "\x1b[2m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    magenta: "\x1b[35m",
-    cyan: "\x1b[36m"
+const { addPage, removePage, renamePage, pageExists } = require('./modules/updatePage');
+const { updateOutputPath, getCurrentOutputPath } = require('./modules/updateOutputPath');
+const { validatePageName, validateOutputPath } = require('./modules/validation');
+const { toKebabCase } = require('./modules/utils');
+
+const color = {
+    reset:   '\x1b[0m',
+    bold:    '\x1b[1m',
+    dim:     '\x1b[2m',
+    red:     '\x1b[31m',
+    green:   '\x1b[32m',
+    yellow:  '\x1b[33m',
+    magenta: '\x1b[35m',
+    cyan:    '\x1b[36m',
 };
 
-const readerInterface = readline.createInterface({
+const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    terminal: true
+    terminal: true,
 });
 
-const PROTECTED_PAGES  = ['homepage', '404'];
-const MAX_NAME_LENGTH  = 50;
-
-function toKebabCase(str) {
-    return str.trim().toLowerCase()
-        .replace(/[^a-z0-9\s_-]/g, '')
-        .replace(/[\s_]+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-
-function validatePageName(name) {
-    if (!name)                                 return 'Invalid name.';
-    if (name.length > MAX_NAME_LENGTH)         return `Name must be ${MAX_NAME_LENGTH} characters or fewer.`;
-    if (!/^[a-z0-9-]+$/.test(name))            return 'Page name can only contain lowercase letters, numbers, and hyphens.';
-    if (/^\d/.test(name))                      return 'Page name cannot start with a number.';
-    if (PROTECTED_PAGES.includes(name))        return `"${name}" is a protected page name.`;
-    return null;
-}
-
-function validateOutputPath(input) {
-    if (!input.trim())           return 'Invalid path.';
-    if (input.includes('..'))    return 'Path cannot contain "..".';
-    if (/[<>|?*"']/.test(input)) return 'Path contains invalid characters.';
-    return null;
+function sanitizeInput(value) {
+    return (value ?? '').replace(/[\x00-\x1F\x7F]/g, '').trim();
 }
 
-function sanitizeInput(str) {
-    return str.replace(/[\x00-\x1F\x7F]/g, '').trim();
+function ask(prompt) {
+    return new Promise((resolve) => {
+        const onClose = () => resolve(null);
+        rl.once('close', onClose);
+        rl.question(prompt, (answer) => {
+            rl.off('close', onClose);
+            resolve(sanitizeInput(answer));
+        });
+    });
 }
 
-function ask(prompt) {
-    return new Promise(resolve =>
-        readerInterface.question(prompt, answer => resolve(sanitizeInput(answer)))
-    );
+async function confirm(prompt) {
+    const answer = await ask(`${prompt} ${color.dim}[y/N]${color.reset} `);
+    return /^y(es)?$/i.test((answer ?? '').trim());
 }
 
 async function askPageName(prompt) {
     const raw = await ask(prompt);
+    if (raw === null) return null;
+
     const name = toKebabCase(raw);
     const error = validatePageName(name);
     if (error) {
-        console.log(`\n${c.red}✖ ${error}${c.reset}`);
+        console.log(`\n${color.red}✖ ${error}${color.reset}`);
         return null;
     }
     return name;
 }
 
-async function handleCreateRequest() {
-    const name = await askPageName(`\n${c.green}❯${c.reset} Enter the name of the new page: `);
-    if (name) addPage(name, null);
+async function handleCreate() {
+    const name = await askPageName(`\n${color.green}❯${color.reset} Name of the new page: `);
+    if (name) addPage(name);
 }
 
-async function handleRemoveRequest() {
-    const name = await askPageName(`\n${c.red}❯${c.reset} Enter the name of the page to remove: `);
-    if (name) removePage(name);
+async function handleRemove() {
+    const name = await askPageName(`\n${color.red}❯${color.reset} Name of the page to remove: `);
+    if (!name) return;
+
+    if (!pageExists(name)) {
+        console.log(`\n${color.yellow}⚠ Page "${name}" does not exist.${color.reset}`);
+        return;
+    }
+
+    const confirmed = await confirm(`This permanently deletes all files for "${name}".`);
+    if (!confirmed) {
+        console.log(`\n${color.dim}Cancelled.${color.reset}`);
+        return;
+    }
+    removePage(name);
 }
 
-async function handleRenameRequest() {
-    const oldName = await askPageName(`\n${c.yellow}❯${c.reset} Enter the name of the page to rename: `);
+async function handleRename() {
+    const oldName = await askPageName(`\n${color.yellow}❯${color.reset} Page to rename: `);
     if (!oldName) return;
 
-    const newName = await askPageName(`${c.yellow}❯${c.reset} Enter the new name: `);
+    const newName = await askPageName(`${color.yellow}❯${color.reset} New name: `);
     if (!newName) return;
 
     if (oldName === newName) {
-        console.log(`\n${c.yellow}⚠ Old and new name are the same.${c.reset}`);
+        console.log(`\n${color.yellow}⚠ Old and new name are the same.${color.reset}`);
         return;
     }
-
     renamePage(oldName, newName);
 }
 
-async function handleOutputPathRequest() {
+async function handleOutputPath() {
     const current = getCurrentOutputPath();
-    const label   = current ? `\n${c.dim}Current path: "${current}"${c.reset}\n` : '\n';
-    const input   = await ask(`${label}${c.magenta}❯${c.reset} Enter the new output path: `);
+    const label = current ? `\n${color.dim}Current path: "${current}"${color.reset}\n` : '\n';
+
+    const input = await ask(`${label}${color.magenta}❯${color.reset} New output path: `);
+    if (input === null) return;
 
     const error = validateOutputPath(input);
     if (error) {
-        console.log(`\n${c.red}✖ ${error}${c.reset}`);
-    } else {
-        updateOutputPath(input);
+        console.log(`\n${color.red}✖ ${error}${color.reset}`);
+        return;
     }
+    updateOutputPath(input);
 }
 
 const MENU_ACTIONS = {
-    '1': handleCreateRequest,
-    '2': handleRemoveRequest,
-    '3': handleRenameRequest,
-    '4': handleOutputPathRequest,
+    '1': handleCreate,
+    '2': handleRemove,
+    '3': handleRename,
+    '4': handleOutputPath,
 };
 
-async function displayMainMenu() {
-    console.log(`\n${c.cyan}${c.bold}╭────────────────────────╮`);
+function renderMenu() {
+    console.log(`\n${color.cyan}${color.bold}╭────────────────────────╮`);
     console.log(`│    Berna-Stencil CLI   │`);
-    console.log(`╰────────────────────────╯${c.reset}\n`);
-    console.log(`  ${c.green}1.${c.reset} Create page`);
-    console.log(`  ${c.red}2.${c.reset} Remove page`);
-    console.log(`  ${c.yellow}3.${c.reset} Rename page`);
-    console.log(`  ${c.magenta}4.${c.reset} Configure output path`);
-    console.log(`\n  ${c.dim}CTRL/CMD + C to exit${c.reset}\n`);
-
-    const choice = (await ask(`${c.cyan}❯${c.reset} Choose an option: `)).trim();
-
-    if (choice === '0') {
-        readerInterface.close();
-        process.exit(0);
-    }
+    console.log(`╰────────────────────────╯${color.reset}\n`);
+    console.log(`  ${color.green}1.${color.reset} Create page`);
+    console.log(`  ${color.red}2.${color.reset} Remove page`);
+    console.log(`  ${color.yellow}3.${color.reset} Rename page`);
+    console.log(`  ${color.magenta}4.${color.reset} Configure output path`);
+    console.log(`  ${color.dim}CTRL + C to exit\n`);
+}
+
+async function main() {
+    while (true) {
+        renderMenu();
+
+        const choice = await ask(`${color.cyan}❯${color.reset} Choose an option: `);
+
+        const action = MENU_ACTIONS[choice];
+        if (!action) {
+            console.log(`\n${color.red}✖ Invalid option.${color.reset}`);
+            continue;
+        }
 
-    const action = MENU_ACTIONS[choice];
-    if (action) {
         try {
             await action();
         } catch (err) {
-            console.log(`\n${c.red}✖ Unexpected error: ${err.message}${c.reset}`);
+            console.log(`\n${color.red}✖ Unexpected error: ${err.message}${color.reset}`);
         }
-    } else {
-        console.log(`\n${c.red}✖ Invalid option.${c.reset}`);
     }
 
-    displayMainMenu();
+    rl.close();
+    process.exit(0);
 }
 
-displayMainMenu();
+main();

package/_tools/modules/constants.js

@@ -0,0 +1,23 @@
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const FRONTEND_DIR = path.join(ROOT, 'src', 'frontend');
+
+const MAX_PAGE_NAME_LENGTH = 50;
+const PROTECTED_PAGES = Object.freeze(['homepage', '404']);
+
+const PATHS = Object.freeze({
+    root:           ROOT,
+    routes:         path.join(FRONTEND_DIR, '_routes'),
+    scssPages:      path.join(FRONTEND_DIR, 'scss', 'pages'),
+    jsPages:        path.join(FRONTEND_DIR, 'js', 'pages'),
+    tsPages:        path.join(FRONTEND_DIR, 'ts', 'pages'),
+    siteData:       path.join(FRONTEND_DIR, 'data', 'site.json'),
+    pageComponents: path.join(FRONTEND_DIR, 'layouts', 'pageComponents.njk'),
+    templates:      path.join(ROOT, '_tools', 'res', 'templates'),
+    eleventyConfig: path.join(ROOT, '.eleventy.js'),
+    packageJson:    path.join(ROOT, 'package.json'),
+    tsconfig:       path.join(ROOT, 'tsconfig.json'),
+});
+
+module.exports = { PATHS, MAX_PAGE_NAME_LENGTH, PROTECTED_PAGES };

package/_tools/modules/pageComponents.js

@@ -0,0 +1,77 @@
+const fs = require('fs');
+const { PATHS } = require('./constants');
+const { toCamelCase } = require('./utils');
+
+function readPageComponents() {
+    if (!fs.existsSync(PATHS.pageComponents)) {
+        console.log(`[skip] not found: ${PATHS.pageComponents}`);
+        return null;
+    }
+    return fs.readFileSync(PATHS.pageComponents, 'utf8');
+}
+
+function writePageComponents(content) {
+    fs.writeFileSync(PATHS.pageComponents, content);
+}
+
+function elifBlockRegex(camelName) {
+    return new RegExp(
+        `[ \\t]*\\{%\\s*elif\\s+title\\s*==\\s*"${camelName}"\\s*%\\}[\\s\\S]*?(?=[ \\t]*\\{%\\s*(?:elif|else|endif))`,
+    );
+}
+
+function addPageBlock(pageName) {
+    const content = readPageComponents();
+    if (!content) return;
+
+    const camelName = toCamelCase(pageName);
+    if (content.includes(`{% elif title == "${camelName}" %}`)) return;
+
+    if (!content.includes('{% else %}')) {
+        console.log('[skip] no {% else %} anchor in pageComponents.njk');
+        return;
+    }
+
+    const block =
+        `{% elif title == "${camelName}" %}\n` +
+        `  {#{% include "component.njk" %}#}\n\n`;
+
+    writePageComponents(content.replace('{% else %}', `${block}{% else %}`));
+    console.log(`[updated] page block added for "${camelName}"`);
+}
+
+function removePageBlock(pageName) {
+    const content = readPageComponents();
+    if (!content) return;
+
+    const camelName = toCamelCase(pageName);
+    if (!elifBlockRegex(camelName).test(content)) {
+        console.log(`[skip] page block for "${camelName}" not found`);
+        return;
+    }
+
+    const updated = content
+        .replace(elifBlockRegex(camelName), '')
+        .replace(/\n\s*\n\s*\n/g, '\n\n');
+
+    writePageComponents(updated);
+    console.log(`[cleaned] page block removed for "${camelName}"`);
+}
+
+function renamePageBlock(oldName, newName) {
+    const content = readPageComponents();
+    if (!content) return;
+
+    const oldLine = `{% elif title == "${toCamelCase(oldName)}" %}`;
+    const newLine = `{% elif title == "${toCamelCase(newName)}" %}`;
+
+    if (!content.includes(oldLine)) {
+        console.log(`[skip] page block for "${toCamelCase(oldName)}" not found`);
+        return;
+    }
+
+    writePageComponents(content.replace(oldLine, newLine));
+    console.log(`[renamed] page block "${toCamelCase(oldName)}" → "${toCamelCase(newName)}"`);
+}
+
+module.exports = { addPageBlock, removePageBlock, renamePageBlock };

package/_tools/modules/updateData.js

@@ -1,72 +1,60 @@
-const fileSystem = require('fs');
+const fs = require('fs');
+const { PATHS } = require('./constants');
 const { toCamelCase, toNiceTitle } = require('./utils');
 
-const SITE_DATA_PATH = 'src/frontend/data/site.json';
-
-// Returns the parsed site.json content, or null if the file doesn't exist
 function readSiteData() {
-    if (!fileSystem.existsSync(SITE_DATA_PATH)) return null;
-    return JSON.parse(fileSystem.readFileSync(SITE_DATA_PATH, 'utf8'));
+    if (!fs.existsSync(PATHS.siteData)) {
+        console.log(`[skip] not found: ${PATHS.siteData}`);
+        return null;
+    }
+    try {
+        const data = JSON.parse(fs.readFileSync(PATHS.siteData, 'utf8'));
+        if (!data.pages || typeof data.pages !== 'object') data.pages = {};
+        return data;
+    } catch (err) {
+        console.log(`[error] cannot parse site.json: ${err.message}`);
+        return null;
+    }
 }
 
-// Serializes and writes the data object back to site.json
 function writeSiteData(data) {
-    fileSystem.writeFileSync(SITE_DATA_PATH, JSON.stringify(data, null, 2));
+    fs.writeFileSync(PATHS.siteData, `${JSON.stringify(data, null, 2)}\n`);
 }
 
-// --- Public API ---
-
-// Adds a new page record to site.json
-// Skips silently if the file doesn't exist or the record is already present
 function addSiteData(pageName) {
     const data = readSiteData();
     if (!data) return;
 
     const camelName = toCamelCase(pageName);
-
     if (data.pages[camelName]) {
-        console.log(`[SKIP] Record "${camelName}" already exists.`);
+        console.log(`[skip] record "${camelName}" already exists`);
         return;
     }
 
-    // Build the default page record with SEO metadata and empty CDN arrays
     data.pages[camelName] = {
-        seo: {
-            title: toNiceTitle(pageName),
-            description: 'description',
-        },
-        cdn: {
-            css: [],
-            js: []
-        }
+        seo: { title: toNiceTitle(pageName), description: 'description' },
+        cdn: { css: [], js: [] },
     };
 
     writeSiteData(data);
-    console.log(`[UPDATED] Record "${camelName}" added.`);
+    console.log(`[updated] record "${camelName}" added`);
 }
 
-// Removes a page record from site.json
-// Skips silently if the file doesn't exist or the record is not found
 function removeSiteData(pageName) {
     const data = readSiteData();
     if (!data) return;
 
     const camelName = toCamelCase(pageName);
-
     if (!data.pages[camelName]) {
-        console.log(`[SKIP] Record "${camelName}" not found.`);
+        console.log(`[skip] record "${camelName}" not found`);
         return;
     }
 
     delete data.pages[camelName];
-
     writeSiteData(data);
-    console.log(`[CLEANED] Record "${camelName}" removed.`);
+    console.log(`[cleaned] record "${camelName}" removed`);
 }
 
-// Renames a page record in site.json
-// Preserves all existing fields (cdn, etc.) and only updates the SEO title
-// Skips if the source record doesn't exist or the target name is already taken
 function renameSiteData(oldName, newName) {
     const data = readSiteData();
     if (!data) return;
@@ -75,29 +63,22 @@ function renameSiteData(oldName, newName) {
     const newCamel = toCamelCase(newName);
 
     if (!data.pages[oldCamel]) {
-        console.log(`[SKIP] Record "${oldCamel}" not found.`);
+        console.log(`[skip] record "${oldCamel}" not found`);
         return;
     }
-
     if (data.pages[newCamel]) {
-        console.log(`[SKIP] Record "${newCamel}" already exists.`);
+        console.log(`[skip] record "${newCamel}" already exists`);
         return;
     }
 
-    // Spread the existing record to preserve cdn and any future fields,
-    // then override only the seo.title with the new page name
     data.pages[newCamel] = {
         ...data.pages[oldCamel],
-        seo: {
-            ...data.pages[oldCamel].seo,
-            title: toNiceTitle(newName),
-        }
+        seo: { ...data.pages[oldCamel].seo, title: toNiceTitle(newName) },
     };
-
     delete data.pages[oldCamel];
 
     writeSiteData(data);
-    console.log(`[UPDATED] Record "${oldCamel}" renamed to "${newCamel}".`);
+    console.log(`[updated] record "${oldCamel}" renamed to "${newCamel}"`);
 }
 
 module.exports = { addSiteData, removeSiteData, renameSiteData };

package/_tools/modules/updateOutputPath.js

@@ -1,113 +1,109 @@
-const fs   = require('fs');
+const fs = require('fs');
 const path = require('path');
+const { PATHS } = require('./constants');
 const { isTypeScriptProject } = require('./utils');
 
-const ELEVENTY_CONFIG = path.resolve(__dirname, '../../.eleventy.js');
-const PACKAGE_JSON    = path.resolve(__dirname, '../../package.json');
-const TSCONFIG        = path.resolve(__dirname, '../../tsconfig.json');
-
 const OUTPUT_DIR_REGEX = /const OUTPUT_DIR\s*=\s*['"`]([^'"`]*)['"`]/;
-
-// --- Helpers ---
+const TSCONFIG_OUTDIR_REGEX = /"outDir"\s*:\s*"[^"]*"/;
 
 function parseOutputDir(content) {
     const match = content.match(OUTPUT_DIR_REGEX);
     return match ? match[1] : null;
 }
 
-// --- Updaters ---
-
 function updateEleventyConfig(newPath) {
-    const content = fs.readFileSync(ELEVENTY_CONFIG, 'utf-8');
-
-    const updated = content.replace(
-        OUTPUT_DIR_REGEX,
-        `const OUTPUT_DIR = "${newPath}"`
-    );
+    const content = fs.readFileSync(PATHS.eleventyConfig, 'utf8');
+    const updated = content.replace(OUTPUT_DIR_REGEX, `const OUTPUT_DIR = "${newPath}"`);
 
     if (content === updated) {
-        console.log('(!) OUTPUT_DIR not found in .eleventy.js');
-        return false;
+        console.log('[skip] OUTPUT_DIR not found in .eleventy.js');
+        return;
     }
-
-    fs.writeFileSync(ELEVENTY_CONFIG, updated, 'utf-8');
-    console.log(`(✓) .eleventy.js updated → ${newPath}`);
-    return true;
+    fs.writeFileSync(PATHS.eleventyConfig, updated);
+    console.log(`[updated] .eleventy.js → ${newPath}`);
 }
 
 function updatePackageJson(newPath) {
-    const pkg = JSON.parse(fs.readFileSync(PACKAGE_JSON, 'utf-8'));
+    const pkg = JSON.parse(fs.readFileSync(PATHS.packageJson, 'utf8'));
+    const scriptGlob = isTypeScriptProject()
+        ? 'src/frontend/ts/pages/*.ts'
+        : 'src/frontend/js/pages/*.js';
 
     pkg.outputDir = newPath;
-
-    const usesTs = isTypeScriptProject();
-
+    pkg.scripts = pkg.scripts || {};
     pkg.scripts['build:css'] = `sass src/frontend/scss:${newPath}/css --no-source-map --style=compressed --quiet`;
     pkg.scripts['serve:css'] = `sass --watch src/frontend/scss:${newPath}/css --no-source-map --quiet`;
+    pkg.scripts['build:js']  = `esbuild "${scriptGlob}" --bundle --outdir=${newPath}/js/pages --minify`;
+    pkg.scripts['serve:js']  = `esbuild "${scriptGlob}" --bundle --outdir=${newPath}/js/pages --watch`;
 
-    if (usesTs) {
-        pkg.scripts['build:js']  = `esbuild "src/frontend/ts/pages/*.ts" --bundle --outdir=${newPath}/js/pages --minify`;
-        pkg.scripts['serve:js']  = `esbuild "src/frontend/ts/pages/*.ts" --bundle --outdir=${newPath}/js/pages --watch`;
-    } else {
-        pkg.scripts['build:js']  = `esbuild "src/frontend/js/pages/*.js" --bundle --outdir=${newPath}/js/pages --minify`;
-        pkg.scripts['serve:js']  = `esbuild "src/frontend/js/pages/*.js" --bundle --outdir=${newPath}/js/pages --watch`;
-    }
-
-    fs.writeFileSync(PACKAGE_JSON, JSON.stringify(pkg, null, 2), 'utf-8');
-    console.log(`(✓) package.json updated → ${newPath}`);
-    return true;
+    fs.writeFileSync(PATHS.packageJson, `${JSON.stringify(pkg, null, 2)}\n`);
+    console.log(`[updated] package.json → ${newPath}`);
 }
 
-const TSCONFIG_OUTDIR_REGEX = /"outDir"\s*:\s*"[^"]*"/;
-
 function updateTsConfig(newPath) {
     if (!isTypeScriptProject()) return;
 
-    const content = fs.readFileSync(TSCONFIG, 'utf-8');
+    const content = fs.readFileSync(PATHS.tsconfig, 'utf8');
     const updated = content.replace(TSCONFIG_OUTDIR_REGEX, `"outDir": "./${newPath}/ts"`);
 
     if (content === updated) {
-        console.log('(!) outDir not found in tsconfig.json');
+        console.log('[skip] outDir not found in tsconfig.json');
         return;
     }
-
-    fs.writeFileSync(TSCONFIG, updated, 'utf-8');
-    console.log(`(✓) tsconfig.json updated → ${newPath}/ts`);
+    fs.writeFileSync(PATHS.tsconfig, updated);
+    console.log(`[updated] tsconfig.json → ${newPath}/ts`);
 }
 
-// --- Public API ---
+function deleteOldOutput(oldPath) {
+    if (!oldPath) return;
 
-function updateOutputPath(newPath) {
-    const trimmed = newPath.trim().replace(/\\/g, '/');
+    const oldAbsPath = path.resolve(PATHS.root, oldPath);
+    const insideProject = oldAbsPath.startsWith(PATHS.root + path.sep);
+
+    if (!insideProject || oldAbsPath === PATHS.root) {
+        console.log(`[skip] refusing to delete "${oldAbsPath}" (outside project)`);
+        return;
+    }
+    if (fs.existsSync(oldAbsPath)) {
+        fs.rmSync(oldAbsPath, { recursive: true, force: true });
+        console.log(`[deleted] ${oldAbsPath}`);
+    }
+}
+
+function updateOutputPath(rawPath) {
+    const trimmed = (rawPath ?? '').trim().replace(/\\/g, '/');
+    if (!trimmed) {
+        console.log('[skip] empty output path');
+        return;
+    }
 
     const normalizedPath = trimmed === '.'
         ? 'out'
         : `${trimmed.replace(/\/$/, '')}/${path.basename(process.cwd())}-out`;
 
-    const eleventyContent = fs.readFileSync(ELEVENTY_CONFIG, 'utf-8');
-    const oldPath = parseOutputDir(eleventyContent);
-
-    if (oldPath) {
-        const oldAbsPath = path.resolve(__dirname, '../../', oldPath);
-        if (fs.existsSync(oldAbsPath)) {
-            fs.rmSync(oldAbsPath, { recursive: true, force: true });
-            console.log(`(✓) folder deleted → ${oldAbsPath}`);
-        } else {
-            console.log(`(i) folder not found, nothing to delete → ${oldAbsPath}`);
-        }
+    let oldPath = null;
+    try {
+        oldPath = parseOutputDir(fs.readFileSync(PATHS.eleventyConfig, 'utf8'));
+    } catch (err) {
+        console.log(`[error] cannot read .eleventy.js: ${err.message}`);
+        return;
     }
 
-    console.log(`\nupdating output path → "${normalizedPath}"...`);
+    deleteOldOutput(oldPath);
 
-    updatePackageJson(normalizedPath);
-    updateEleventyConfig(normalizedPath);
-    updateTsConfig(normalizedPath);
+    console.log(`\nupdating output path → "${normalizedPath}"`);
+    try {
+        updatePackageJson(normalizedPath);
+        updateEleventyConfig(normalizedPath);
+        updateTsConfig(normalizedPath);
+    } catch (err) {
+        console.log(`[error] could not update output path: ${err.message}`);
+    }
 }
 
 function getCurrentOutputPath() {
     try {
-        const content = fs.readFileSync(ELEVENTY_CONFIG, 'utf-8');
-        return parseOutputDir(content);
+        return parseOutputDir(fs.readFileSync(PATHS.eleventyConfig, 'utf8'));
     } catch {
         return null;
     }