nibula 1.0.0

package/.eleventy.js

@@ -0,0 +1,96 @@
+const esbuild = require("esbuild");
+const glob = require("glob");
+const Image = require("@11ty/eleventy-img");
+const markdownIt = require('markdown-it');
+const fs = require("fs");
+const path = require("path");
+
+const OUTPUT_DIR = "out";
+
+module.exports = function (eleventyConfig) {
+
+  function copyRecursiveSync(src, dest) {
+    if (!fs.existsSync(src)) return;
+    if (src.includes('.git')) return;
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      fs.mkdirSync(dest, { recursive: true });
+      for (const child of fs.readdirSync(src)) {
+        copyRecursiveSync(path.join(src, child), path.join(dest, child));
+      }
+    } else {
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(src, dest);
+    }
+  }
+
+  const md = markdownIt({ html: true });
+
+  eleventyConfig.addShortcode('mdFile', function(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return md.render(content);
+  });
+
+  eleventyConfig.addPassthroughCopy({
+    "node_modules/github-markdown-css/github-markdown-dark.css": "css/github-markdown-dark.css",
+    "node_modules/github-markdown-css/github-markdown-light.css": "css/github-markdown-light.css",
+  });
+
+  eleventyConfig.on("eleventy.before", () => {
+    copyRecursiveSync("src/backend", `${OUTPUT_DIR}/backend`);
+  });
+
+  eleventyConfig.addPassthroughCopy("src/frontend/.htaccess");
+  eleventyConfig.addPassthroughCopy("src/frontend/web.config");
+  eleventyConfig.addPassthroughCopy("src/frontend/assets");
+  eleventyConfig.addPassthroughCopy("src/frontend/data");
+  eleventyConfig.addPassthroughCopy("src/frontend/robots.txt");
+
+  eleventyConfig.addPassthroughCopy({
+    "node_modules/bootstrap/dist/js/bootstrap.bundle.min.js": "js/bootstrap.bundle.min.js",
+    "node_modules/bootstrap-icons/font/fonts": "css/fonts",
+
+    // Foundation
+    // "node_modules/foundation-sites/dist/js/foundation.min.js": "js/foundation.min.js",
+
+    // UIkit
+    // "node_modules/uikit/dist/js/uikit.min.js": "js/uikit.min.js",
+    // "node_modules/uikit/dist/js/uikit-icons.min.js": "js/uikit-icons.min.js",
+
+    // Bulma — CSS only, no JS passthrough needed
+  });
+
+  eleventyConfig.addShortcode("image", async function (src, alt) {
+    let metadata = await Image(src, {
+      widths: [320, 480, 720, 1280, 1920, 2048, 2560, 3840, 4096, 7680],
+      formats: ["webp", "jpeg"],
+      outputDir: `${OUTPUT_DIR}/assets/images/`,
+      urlPath: "/assets/images/",
+    });
+
+    return Image.generateHTML(metadata, {
+      alt,
+      sizes: "(max-width: 768px) 100vw, 50vw",
+      loading: "lazy",
+      decoding: "async",
+    });
+  });
+
+  eleventyConfig.addWatchTarget("./src/frontend/scss");
+  eleventyConfig.addWatchTarget("./src/frontend/_routes");
+  eleventyConfig.addWatchTarget("./src/frontend/data");
+
+  eleventyConfig.setServerOptions({
+  watch: [`${OUTPUT_DIR}/js/**/*.js`]
+  });
+
+  return {
+    dir: {
+      input: "src/frontend",
+      output: OUTPUT_DIR,
+      includes: "components",
+      layouts: "layouts",
+      data: "data",
+    },
+  };
+};

package/.eleventyignore

@@ -0,0 +1,4 @@
+src/frontend/assets/**
+src/frontend/js/**
+src/frontend/scss/**
+src/backend/**

package/LICENSE

@@ -0,0 +1,170 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other
+      modifications represent, as a whole, an original work of authorship.
+      For the purposes of this License, Derivative Works shall not include
+      works that remain separable from, or merely link (or bind by name)
+      to the interfaces of, the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the
+      purposes of this definition, "submitted" means any form of electronic,
+      verbal, or written communication sent to the Licensor or its
+      representatives, including but not limited to communication on
+      electronic mailing lists, source code control systems, and issue
+      tracking systems that are managed by, or on behalf of, the Licensor
+      for the purpose of discussing and improving the Work, but excluding
+      communication that is conspicuously marked or otherwise designated
+      in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and incorporated
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a NOTICE text file, You must include a
+          readable copy of the attribution notices contained within such
+          NOTICE file, in at least one of the following places: within
+          a NOTICE text file distributed as part of the Derivative Works;
+          within the Source form or documentation, if provided along with
+          the Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or agreed
+      to in writing, Licensor provides the Work (and each Contributor
+      provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES
+      OR CONDITIONS OF ANY KIND, either express or implied, including,
+      without limitation, any warranties or conditions of TITLE,
+      NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
+      PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Liability While Redistributing. You may choose
+      to offer, and charge a fee for, acceptance of support, warranty,
+      indemnity, or other liability obligations and/or rights consistent
+      with this License. However, in accepting such obligations, You may
+      act only on Your own behalf and on Your sole responsibility, not on
+      behalf of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability incurred
+      by, or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Michele Garofalo
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied. See the License for the specific language governing
+   permissions and limitations under the License.

package/NOTICE

@@ -0,0 +1,5 @@
+Nibula
+Copyright 2026 Michele Garofalo
+
+This product includes software developed by Michele Garofalo.
+https://github.com/Rhaastrake/Nibula

package/README.md

@@ -0,0 +1,105 @@
+# ✏️ Nibula
+
+**Nibula** is an open source static site generator built on top of [Eleventy](https://www.11ty.dev/), with one clear mission: make the jump from plain, hand-written websites to a real project setup as gentle as possible — without ever pulling you away from the web you already know.
+
+If you've only ever written HTML, CSS, and a bit of JavaScript, moving to a "framework" usually feels like starting over: new syntax, new rules, new folder structures, and a pile of documentation before you can even see a page on screen. Nibula is designed to avoid exactly that. You keep working with the **three languages that matter — HTML, CSS, and JavaScript** — and the tool quietly handles the tedious parts around them. The goal is simple: even someone with little experience should always know *where to put their hands*.
+
+It's a great fit for **showcase and brochure-style websites** (portfolios, landing pages, small business sites), where you want something clean and fast without dragging in a heavy framework.
+
+### ✨ Why Nibula?
+
+Building a website from scratch involves a lot of moving parts: templating, build steps, SEO files, server config, project structure. Nibula takes care of all of that for you, so you can focus on what actually matters — **your content and your ideas** — while still learning skills that transfer anywhere on the web.
+
+- 🔧 **Zero-config ready** — install, create, and you're live in minutes
+- 🧭 **Stays close to vanilla** — real HTML, CSS, and JS, so nothing you learn goes to waste
+- 🔎 **SEO made simple** — managed from one central place; `sitemap`, `llms.txt`, and `robots.txt` are generated automatically
+- 🖱️ **A helpful CLI** — create a page with one command instead of hand-writing ten separate files
+- ⚙️ **Server configs handled for you** — `.htaccess` and `web.config` are generated automatically, and an `nginx.conf` is provided so that anyone comfortable with nginx already has what they need to run the site outside of shared hosting
+- 🎨 **Pick your CSS framework** — choose from 4 pre-installed options (or none), and switch later in a few guided steps
+- 🧩 **Your own modules** — add your own CSS and JS/TS modules freely and easily
+- 🪶 **Lightweight by default** — SCSS frameworks can be filtered so you ship only what you actually use
+- 🌍 **Open source** — free to use, free to modify, free to share
+
+![Version](https://img.shields.io/badge/version-2.9.0-blue)
+![License](https://img.shields.io/badge/license-Apache--2.0-blue)
+![Eleventy](https://img.shields.io/badge/11ty-v3.1.2-black)
+
+## JavaScript or TypeScript — your choice
+
+When you create a project, you decide how you want to work:
+
+- **JavaScript** — the simplest path, ideal if you're still getting comfortable.
+- **TypeScript** — for more experienced users who want stronger typing and tooling.
+
+Either way, the project structure stays the same, so you can start easy and level up later.
+
+## Backend included
+
+Essential server-side functionality comes built in — no extra setup required. Backend support will soon let you **choose between PHP, Node, and Python**, so the project can grow with you.
+
+## Customizable, but with sensible defaults
+
+Nibula ships with a clean, opinionated layout so beginners are never lost. But it isn't a cage: as long as you follow a few small conventions and the defined paths, you're free to customize the subpaths of your **components, backend endpoints, and JS/SCSS modules** however you like.
+
+## Prerequisites
+
+* **Node.js**: v18.0.0 or higher
+* **Composer**: latest stable version
+* *Optional:* the **Better Nunjucks** VS Code extension by Ed Heltzel
+
+## Installation
+
+Install the Nibula CLI once, globally:
+
+```
+npm install -g nibula
+```
+
+This gives you the `nib` command (Alternatives: `nbl`, `nibula`).
+
+## Create a project
+
+From the folder where you keep your websites, run:
+
+```
+nib new your-project
+```
+
+The scaffolder is interactive: you choose the language (JavaScript/TypeScript) and the CSS framework, and all dependencies are installed automatically.
+
+Then start the dev server and visit `localhost:8080`:
+
+```
+cd your-project
+nib run
+```
+
+## Commands
+
+Run these from anywhere inside a project (except `nib new`, which you run wherever you want to create the project):
+
+| Command | Description |
+|---|---|
+| `nib new <name>` | Create your new project |
+| `nib run` | Start the dev server and build the output folder at runtime |
+| `nib cli` | Open the page-management assistant |
+| `nib build` | Build the output folder runtime |
+| `nib clean` | Remove the output directory |
+| `nib update` | Update the CLI to the latest version |
+
+Before scaffolding, `nib new` checks the npm registry for a newer version and offers to update first (via `nib update`). If the registry is unreachable, the check is skipped and creation proceeds normally.
+
+## Managing pages
+
+Instead of creating and wiring up multiple files by hand, let the interactive assistant do it for you. To create, remove, or rename pages and configure the output path, run:
+
+```bash
+nib cli
+```
+
+See [docs/Assistant CLI.md](docs/Assistant%20CLI.md) for details.
+
+## Roadmap
+
+* [ ] Add support for multiple themes
+* [ ] Backend integration choice — switch between PHP, Python, or Node

package/_tools/assistant.js

@@ -0,0 +1,152 @@
+const readline = require('readline');
+
+const { addPage, removePage, renamePage, pageExists } = require('./modules/updatePage');
+const { updateOutputPath, getCurrentOutputPath } = require('./modules/updateOutputPath');
+const { validatePageName, validateOutputPath, checkRequiredFiles } = require('./modules/validation');
+const { toKebabCase } = require('./modules/utils');
+const { color } = require('./modules/constants');
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+});
+
+function sanitizeInput(value) {
+    return (value ?? '').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));
+        });
+    });
+}
+
+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${color.red}✖ ${error}${color.reset}`);
+        return null;
+    }
+    return name;
+}
+
+async function handleCreate() {
+    const name = await askPageName(`\n${color.green}❯${color.reset} Name of the new page: `);
+    if (name) addPage(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 handleRename() {
+    const oldName = await askPageName(`\n${color.yellow}❯${color.reset} Page to rename: `);
+    if (!oldName) return;
+
+    const newName = await askPageName(`${color.yellow}❯${color.reset} New name: `);
+    if (!newName) return;
+
+    if (oldName === newName) {
+        console.log(`\n${color.yellow}⚠ Old and new name are the same.${color.reset}`);
+        return;
+    }
+    renamePage(oldName, newName);
+}
+
+async function handleOutputPath() {
+    const current = getCurrentOutputPath();
+    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${color.red}✖ ${error}${color.reset}`);
+        return;
+    }
+    updateOutputPath(input);
+}
+
+const MENU_ACTIONS = {
+    '1': handleCreate,
+    '2': handleRemove,
+    '3': handleRename,
+    '4': handleOutputPath,
+};
+
+function renderMenu() {
+    console.log(`\n${color.cyan}${color.bold}╭─────────────────╮`);
+    console.log(`│    Nibula CLI   │`);
+    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() {
+    const missing = checkRequiredFiles();
+    if (missing.length > 0) {
+        console.log(`\n${color.red}✖ This project is missing required files:${color.reset}`);
+        for (const item of missing) {
+            console.log(`  ${color.red}-${color.reset} ${item.label}`);
+        }
+        console.log(`\n${color.dim}The project may be incomplete or created with a different Nibula version.${color.reset}`);
+        rl.close();
+        process.exit(1);
+    }
+
+    while (true) {
+        renderMenu();
+
+        const choice = await ask(`${color.cyan}❯${color.reset} Choose an option: `);
+        if (choice === null) break;
+
+        const action = MENU_ACTIONS[choice];
+        if (!action) {
+            console.log(`\n${color.red}✖ Invalid option.${color.reset}`);
+            continue;
+        }
+
+        try {
+            await action();
+        } catch (err) {
+            console.log(`\n${color.red}✖ Unexpected error: ${err.message}${color.reset}`);
+        }
+    }
+
+    rl.close();
+    process.exit(0);
+}
+
+main();

package/_tools/buildJs.js

@@ -0,0 +1,37 @@
+const esbuild = require('esbuild');
+const glob = require('glob');
+const path = require('path');
+const fs = require('fs');
+const { findProjectRoot, NOT_INSIDE_PROJECT_MESSAGE } = require('./modules/constants');
+
+const root = findProjectRoot(process.cwd());
+if (!root) {
+    console.error(NOT_INSIDE_PROJECT_MESSAGE);
+    process.exit(1);
+}
+
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+const outputDir = pkg.outputDir || 'out';
+const isWatch = process.argv.includes('--watch');
+
+const posix = (p) => p.split(path.sep).join('/');
+const jsFiles = glob.sync(posix(path.join(root, 'src/frontend/js/pages/*.js')));
+const tsFiles = glob.sync(posix(path.join(root, 'src/frontend/ts/pages/*.ts')));
+const entryPoints = [...jsFiles, ...tsFiles];
+
+if (entryPoints.length === 0) {
+    process.exit(0);
+}
+
+const options = {
+    entryPoints,
+    bundle: true,
+    outdir: path.join(root, outputDir, 'js/pages'),
+    minify: !isWatch,
+};
+
+if (isWatch) {
+    esbuild.context(options).then((ctx) => ctx.watch()).catch(() => process.exit(1));
+} else {
+    esbuild.build(options).catch(() => process.exit(1));
+}

package/_tools/cleanOutput.js

@@ -0,0 +1,25 @@
+const fs = require('fs');
+const path = require('path');
+const { findProjectRoot, NOT_INSIDE_PROJECT_MESSAGE } = require('./modules/constants');
+
+const root = findProjectRoot(process.cwd());
+if (!root) {
+    console.error(NOT_INSIDE_PROJECT_MESSAGE);
+    process.exit(1);
+}
+
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+
+if (!pkg.outputDir) {
+    console.log('(!) outputDir not found in package.json');
+    process.exit(1);
+}
+
+const outputDir = path.resolve(root, pkg.outputDir);
+
+if (fs.existsSync(outputDir)) {
+    fs.rmSync(outputDir, { recursive: true, force: true });
+    console.log(`(✓) cleaned → ${outputDir}`);
+} else {
+    console.log(`(i) nothing to clean → ${outputDir}`);
+}

package/_tools/modules/constants.js

@@ -0,0 +1,66 @@
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const TEMPLATES_DIR = path.join(PACKAGE_ROOT, '_tools', 'res', 'templates');
+
+const PROJECT_MARKER = '.eleventy.js';
+
+const PROTECTED_PAGES = Object.freeze(['homepage', '404']);
+
+const color = Object.freeze({
+    reset:   '\x1b[0m',
+    bold:    '\x1b[1m',
+    dim:     '\x1b[2m',
+    red:     '\x1b[31m',
+    green:   '\x1b[32m',
+    yellow:  '\x1b[33m',
+    blue:    '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan:    '\x1b[36m',
+});
+
+const NOT_INSIDE_PROJECT_MESSAGE = `${color.red}Not inside a Nibula project.${color.reset}`;
+
+function findProjectRoot(start) {
+    let dir = path.resolve(start ?? process.cwd());
+    while (true) {
+        if (fs.existsSync(path.join(dir, PROJECT_MARKER))) return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) return null;
+        dir = parent;
+    }
+}
+
+let cachedRoot = null;
+
+function projectRoot() {
+    if (cachedRoot) return cachedRoot;
+    const root = findProjectRoot();
+    if (!root) {
+        console.error(NOT_INSIDE_PROJECT_MESSAGE);
+        process.exit(1);
+    }
+    cachedRoot = root;
+    return root;
+}
+
+function frontendDir() {
+    return path.join(projectRoot(), 'src', 'frontend');
+}
+
+const PATHS = Object.freeze({
+    get root()           { return projectRoot(); },
+    get routes()         { return path.join(frontendDir(), '_routes'); },
+    get scssPages()      { return path.join(frontendDir(), 'scss', 'pages'); },
+    get jsPages()        { return path.join(frontendDir(), 'js', 'pages'); },
+    get tsPages()        { return path.join(frontendDir(), 'ts', 'pages'); },
+    get siteData()       { return path.join(frontendDir(), 'data', 'site.json'); },
+    get pageComponents() { return path.join(frontendDir(), 'layouts', 'page-components.njk'); },
+    get eleventyConfig() { return path.join(projectRoot(), '.eleventy.js'); },
+    get packageJson()    { return path.join(projectRoot(), 'package.json'); },
+    get tsconfig()       { return path.join(projectRoot(), 'tsconfig.json'); },
+    templates:           TEMPLATES_DIR,
+});
+
+module.exports = { PATHS, PROJECT_MARKER, PROTECTED_PAGES, color, NOT_INSIDE_PROJECT_MESSAGE, findProjectRoot };