@erudit-js/cli 3.0.0-dev.8 → 4.0.0-dev.1

package/README.md

@@ -1,12 +1,13 @@
-# 📟 Erudit CLI
-
-Command Line Interface for [Erudit](https://github.com/erudit-js/erudit).
-
-CLI is accessible via `erudit` or `erudit-cli` commands.
-
-## Commands
-
-- `init`
-- `dev`
-- `build`
-- `preview`
+# 📟 Erudit CLI
+
+Command Line Interface for [Erudit](https://github.com/erudit-js/erudit).
+
+CLI is accessible via `erudit` or `erudit-cli` commands.
+
+## Commands
+
+- `play` - starts an Erudit project in full dev mode
+- `build` - compiles Erudit project
+- `launch` - launches compiled Erudit project
+- `generate` - generates a fully static production-ready site from Erudit project
+- `preview` - preview generated static site

package/bin/erudit-cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../dist/index.js';
+
+run();

package/dist/commands/build.d.ts

@@ -0,0 +1,25 @@
+export declare const build: import("citty").CommandDef<{
+    preset: {
+        type: "string";
+        required: false;
+        description: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    eruditPath: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    projectPath: {
+        type: "positional";
+        description: string;
+        required: false;
+        default: string;
+    };
+}>;

package/dist/commands/build.js

@@ -0,0 +1,36 @@
+import { rmSync } from 'node:fs';
+import consola from 'consola';
+import { defineCommand } from 'citty';
+import { contentTargetsArg, eruditPathArg, nitroPresetArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
+import { logCommand } from '../shared/log.js';
+import { spawnNuxt } from '../shared/nuxt.js';
+import { prepare } from '../shared/prepare.js';
+export const build = defineCommand({
+    meta: {
+        name: 'Build',
+        description: 'Builds Erudit project for fast and convenient content writing',
+    },
+    args: {
+        ...projectPathArg,
+        ...eruditPathArg,
+        ...contentTargetsArg,
+        ...nitroPresetArg,
+    },
+    async run({ args }) {
+        logCommand('build');
+        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
+        await prepare({
+            projectPath,
+            eruditPath,
+            contentTargets: args.target,
+        });
+        const restParams = args.preset ? ` --preset ${args.preset}` : '';
+        consola.start('Starting Nuxt build...');
+        await spawnNuxt('build', projectPath, restParams);
+        // Just fucking remove @jsprose because not a single fucking option inside Nuxt/Nitro allows NOT TO bundle it!
+        rmSync(`${projectPath}/.output/server/node_modules/@jsprose`, {
+            recursive: true,
+            force: true,
+        });
+    },
+});

package/dist/commands/dev.d.ts

@@ -0,0 +1,20 @@
+export declare const dev: import("citty").CommandDef<{
+    target: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    eruditPath: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    projectPath: {
+        type: "positional";
+        description: string;
+        required: false;
+        default: string;
+    };
+}>;

package/dist/commands/dev.js

@@ -0,0 +1,28 @@
+import { consola } from 'consola';
+import { defineCommand } from 'citty';
+import { logCommand } from '../shared/log.js';
+import { prepare } from '../shared/prepare.js';
+import { spawnNuxt } from '../shared/nuxt.js';
+import { contentTargetsArg, eruditPathArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
+export const dev = defineCommand({
+    meta: {
+        name: 'Dev',
+        description: 'Runs Erudit project in development mode',
+    },
+    args: {
+        ...projectPathArg,
+        ...eruditPathArg,
+        ...contentTargetsArg,
+    },
+    async run({ args }) {
+        logCommand('dev');
+        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
+        await prepare({
+            projectPath,
+            eruditPath,
+            contentTargets: args.target,
+        });
+        consola.start('Starting Nuxt dev...');
+        await spawnNuxt('dev', projectPath);
+    },
+});

package/dist/commands/generate.d.ts

@@ -0,0 +1,25 @@
+export declare const generate: import("citty").CommandDef<{
+    preset: {
+        type: "string";
+        required: false;
+        description: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    eruditPath: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    projectPath: {
+        type: "positional";
+        description: string;
+        required: false;
+        default: string;
+    };
+}>;

package/dist/commands/generate.js

@@ -0,0 +1,29 @@
+import { defineCommand } from 'citty';
+import { contentTargetsArg, eruditPathArg, nitroPresetArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
+import { logCommand } from '../shared/log.js';
+import { prepare } from '../shared/prepare.js';
+import { spawnNuxt } from '../shared/nuxt.js';
+export const generate = defineCommand({
+    meta: {
+        name: 'Generate',
+        description: 'Generates static production-ready site from Erudit project',
+    },
+    args: {
+        ...projectPathArg,
+        ...eruditPathArg,
+        ...contentTargetsArg,
+        ...nitroPresetArg,
+    },
+    async run({ args }) {
+        logCommand('generate');
+        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
+        await prepare({
+            projectPath,
+            eruditPath,
+            contentTargets: args.target,
+        });
+        const restParams = args.preset ? `--preset ${args.preset}` : '';
+        console.log('Starting Nuxt generate...');
+        await spawnNuxt('generate', projectPath, restParams);
+    },
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+export declare const init: import("citty").CommandDef<{
+    path: {
+        type: "positional";
+        description: string;
+        required: true;
+        valueHint: string;
+    };
+}>;

package/dist/commands/init.js

@@ -0,0 +1,60 @@
+import { defineCommand } from 'citty';
+import { consola } from 'consola';
+import chalk from 'chalk';
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync, } from 'node:fs';
+import { resolvePath } from '../shared/path.js';
+export const init = defineCommand({
+    meta: {
+        name: 'Init',
+        description: 'Creates a new Erudit project at specified path',
+    },
+    args: {
+        path: {
+            type: 'positional',
+            description: 'Path for the new Erudit project',
+            required: true,
+            valueHint: chalk.gray(`"${chalk.greenBright('.')}" OR "${chalk.greenBright('path/to/project')}"`),
+        },
+    },
+    async run({ args }) {
+        consola.start('Resolving project path...');
+        const projectPath = resolvePath(args.path);
+        if (projectPath === undefined)
+            return;
+        if (existsSync(projectPath) && readdirSync(projectPath).length > 0)
+            throw new Error(`Directory "${chalk.yellowBright(projectPath)}" is not empty!`);
+        consola.success('Resolved project path:', chalk.greenBright(projectPath));
+        consola.start('Creating project directory...');
+        try {
+            try {
+                rmSync(projectPath, { recursive: true });
+            }
+            catch (error) {
+                if (error?.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+            mkdirSync(projectPath, { recursive: true });
+        }
+        catch (error) {
+            throw new Error(`Failed to prepare project directory "${chalk.yellowBright(projectPath)}"!\n\n${error}`);
+        }
+        consola.success('Project directory created!');
+        consola.start('Creating project files...');
+        consola.success('Project files created!');
+    },
+});
+function createPackageJson(projectPath) {
+    // TODO: Get correct package versions
+    writeFileSync(`${projectPath}/package.json`, JSON.stringify({
+        private: true,
+        name: projectPath.split('/').pop() || 'my-erudit-project',
+        type: 'module',
+        scripts: {
+            dev: 'erudit dev',
+            build: 'erudit build',
+            preview: 'erudit preview',
+            prepare: 'erudit prepare',
+        },
+    }));
+}

package/dist/commands/launch.d.ts

@@ -0,0 +1,8 @@
+export declare const launch: import("citty").CommandDef<{
+    project: {
+        type: "positional";
+        description: string;
+        required: false;
+        default: string;
+    };
+}>;

package/dist/commands/launch.js

@@ -0,0 +1,38 @@
+import { defineCommand } from 'citty';
+import { consola } from 'consola';
+import chalk from 'chalk';
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { resolvePath } from '../shared/path.js';
+export const launch = defineCommand({
+    meta: {
+        name: 'Launch',
+        description: 'Launch builded Erudit server',
+    },
+    args: {
+        project: {
+            type: 'positional',
+            description: 'Project path',
+            required: false,
+            default: '.',
+        },
+    },
+    async run({ args }) {
+        consola.start('Resolving project path...');
+        const projectPath = resolvePath(args.project);
+        consola.success('Resolved project path:', chalk.greenBright(projectPath));
+        const distPath = `${projectPath}/.output/server`;
+        if (!existsSync(distPath))
+            throw new Error(`No ".output/server" folder found! Did you run 'erudit build'?`);
+        spawn(`node index.mjs`, {
+            shell: true,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ERUDIT_COMMAND: 'launch',
+                ERUDIT_MODE: 'write',
+            },
+            cwd: distPath,
+        });
+    },
+});

package/dist/commands/main.d.ts

@@ -0,0 +1 @@
+export declare const main: import("citty").CommandDef<import("citty").ArgsDef>;

package/dist/commands/main.js

@@ -0,0 +1,29 @@
+import { defineCommand } from 'citty';
+import { brandColorLogotype } from '@erudit-js/core/brandTerminal';
+// Sub commands
+import { init } from './init.js';
+import { prepare } from './prepare.js';
+import { dev } from './dev.js';
+import { build } from './build.js';
+import { preview } from './preview.js';
+import { launch } from './launch.js';
+import { generate } from './generate.js';
+export const main = defineCommand({
+    meta: {
+        name: 'Erudit CLI',
+        description: 'Command Line Interface for Erudit!',
+        version: '4.0.0-dev.1',
+    },
+    subCommands: {
+        init,
+        prepare,
+        dev,
+        build,
+        generate,
+        preview,
+        launch,
+    },
+    setup() {
+        console.log(brandColorLogotype);
+    },
+});

package/dist/commands/prepare.d.ts

@@ -0,0 +1,14 @@
+export declare const prepare: import("citty").CommandDef<{
+    eruditPath: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    projectPath: {
+        type: "positional";
+        description: string;
+        required: false;
+        default: string;
+    };
+}>;

package/dist/commands/prepare.js

@@ -0,0 +1,27 @@
+import { consola } from 'consola';
+import { defineCommand } from 'citty';
+import { logCommand } from '../shared/log.js';
+import { prepare as _prepare } from '../shared/prepare.js';
+import { spawnNuxt } from '../shared/nuxt.js';
+import { eruditPathArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
+export const prepare = defineCommand({
+    meta: {
+        name: 'Prepare',
+        description: 'Creates a .erudit directory in your project and generates build files',
+    },
+    args: {
+        ...projectPathArg,
+        ...eruditPathArg,
+    },
+    async run({ args }) {
+        logCommand('prepare');
+        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
+        await _prepare({
+            projectPath,
+            eruditPath,
+        });
+        consola.start('Generating Nuxt build files...');
+        await spawnNuxt('prepare', projectPath);
+        consola.success('Nuxt is prepared!');
+    },
+});

package/dist/commands/preview.d.ts

@@ -0,0 +1,8 @@
+export declare const preview: import("citty").CommandDef<{
+    project: {
+        type: "positional";
+        description: string;
+        required: false;
+        default: string;
+    };
+}>;

package/dist/commands/preview.js

@@ -0,0 +1,37 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { consola } from 'consola';
+import chalk from 'chalk';
+import { resolvePath } from '../shared/path.js';
+export const preview = defineCommand({
+    meta: {
+        name: 'Preview',
+        description: 'Preview builded static Erudit site',
+    },
+    args: {
+        project: {
+            type: 'positional',
+            description: 'Project path',
+            required: false,
+            default: '.',
+        },
+    },
+    async run({ args }) {
+        consola.start('Resolving project path...');
+        const projectPath = resolvePath(args.project);
+        consola.success('Resolved project path:', chalk.greenBright(projectPath));
+        const distPath = `${projectPath}/.output/public`;
+        if (!existsSync(distPath)) {
+            throw new Error(`No ".output/public" folder found! Did you run 'erudit build'?`);
+        }
+        spawn(`npx http-server ${distPath} -p 3000`, {
+            shell: true,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ERUDIT_MODE: 'static',
+            },
+        });
+    },
+});

package/dist/index.d.ts

@@ -1,3 +1 @@
-declare function run(): void;
-
-export { run };
+export { run } from './run.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from './run.js';

package/dist/run.d.ts

@@ -0,0 +1 @@
+export declare function run(): void;

package/dist/run.js

@@ -0,0 +1,5 @@
+import { runMain } from 'citty';
+import { main } from './commands/main.js';
+export function run() {
+    runMain(main);
+}

package/dist/shared/args.d.ts

@@ -0,0 +1,35 @@
+export declare const eruditPathArg: {
+    eruditPath: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+};
+export declare const projectPathArg: {
+    projectPath: {
+        type: "positional";
+        description: string;
+        required: false;
+        default: string;
+    };
+};
+export declare const contentTargetsArg: {
+    target: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+};
+export declare const nitroPresetArg: {
+    preset: {
+        type: "string";
+        required: false;
+        description: string;
+    };
+};
+export declare function resolveArgPaths(projectPath: string, eruditPath: string): {
+    projectPath: string;
+    eruditPath: string;
+};

package/dist/shared/args.js

@@ -0,0 +1,52 @@
+import { consola } from 'consola';
+import chalk from 'chalk';
+import { resolvePath } from './path.js';
+export const eruditPathArg = {
+    eruditPath: {
+        type: 'string',
+        description: 'Custom Erudit Nuxt Layer location',
+        required: false,
+        default: 'erudit', // Let `nuxi` find erudit in project dependencies
+    },
+};
+export const projectPathArg = {
+    projectPath: {
+        type: 'positional',
+        description: 'Erudit project location',
+        required: false,
+        default: '.',
+    },
+};
+export const contentTargetsArg = {
+    target: {
+        type: 'string',
+        description: 'Content targets to process',
+        required: false,
+        default: '',
+    },
+};
+export const nitroPresetArg = {
+    preset: {
+        type: 'string',
+        required: false,
+        description: '(Nuxt Build Flag) Nitro preset to use for building',
+    },
+};
+export function resolveArgPaths(projectPath, eruditPath) {
+    consola.start('Resolving project path...');
+    projectPath = resolvePath(projectPath);
+    consola.success('Resolved project path:', chalk.greenBright(projectPath));
+    consola.start('Resolving Erudit Nuxt Layer path...');
+    if (eruditPath === 'erudit') {
+        consola.success(`'nuxi' will find Erudit in your dependencies!`);
+    }
+    else {
+        eruditPath = resolvePath(eruditPath);
+        consola.warn('Custom Erudit Nuxt Layer path will be used: ' +
+            chalk.yellowBright(eruditPath));
+    }
+    return {
+        projectPath,
+        eruditPath,
+    };
+}

package/dist/shared/log.d.ts

@@ -0,0 +1 @@
+export declare function logCommand(command: string): void;

package/dist/shared/log.js

@@ -0,0 +1,6 @@
+import chalk from 'chalk';
+import { consola } from 'consola';
+export function logCommand(command) {
+    consola.info(`Running command: ${chalk.cyanBright(command)}`);
+    console.log();
+}

package/dist/shared/nuxt.d.ts

@@ -0,0 +1,3 @@
+type NuxtCommand = 'dev' | 'build' | 'generate' | 'prepare';
+export declare function spawnNuxt(command: NuxtCommand, projectPath: string, restParams?: string): Promise<void>;
+export {};

package/dist/shared/nuxt.js

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+export async function spawnNuxt(command, projectPath, restParams) {
+    return new Promise((resolve) => {
+        const onClose = (exitCode) => {
+            if (exitCode === 0) {
+                console.log('Nuxt process exited successfully!');
+                return resolve();
+            }
+            if (exitCode === 1) {
+                console.error('Nuxt process exited with an error!');
+                return resolve();
+            }
+            if (exitCode === 1337) {
+                console.warn('Nuxt full restart is requested!');
+                _spawnNuxt();
+                return;
+            }
+            if (command === 'dev') {
+                console.error(`Nuxt process exited with an error code ${exitCode} in development mode!\nRespawning...`);
+                _spawnNuxt();
+                return;
+            }
+        };
+        const _spawnNuxt = () => {
+            const mode = (() => {
+                switch (command) {
+                    case 'dev':
+                    case 'prepare':
+                        return 'dev';
+                    case 'build':
+                        return 'write';
+                    case 'generate':
+                        return 'static';
+                }
+            })();
+            const nuxtProcess = spawn(`nuxt ${command} ${projectPath}/.erudit/nuxt ${restParams || ''}`, {
+                shell: true,
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    ERUDIT_PROJECT_DIR: projectPath,
+                    ERUDIT_COMMAND: command,
+                    ERUDIT_MODE: mode,
+                },
+            });
+            nuxtProcess.on('close', onClose);
+        };
+        _spawnNuxt();
+    });
+}

package/dist/shared/path.d.ts

@@ -0,0 +1 @@
+export declare function resolvePath(path: string): string;

package/dist/shared/path.js

@@ -0,0 +1,13 @@
+import { existsSync, lstatSync } from 'node:fs';
+import chalk from 'chalk';
+import { resolve, isAbsolute } from 'node:path';
+export function resolvePath(path) {
+    path = path.replace(/\\/g, '/');
+    path = path.endsWith('/') ? path.slice(0, -1) : path;
+    if (!isAbsolute(path)) {
+        path = resolve(process.cwd(), path).replace(/\\/g, '/');
+    }
+    if (existsSync(path) && !lstatSync(path).isDirectory())
+        throw new Error(`Path "${chalk.yellowBright(path)}" is not a directory!`);
+    return path;
+}

package/dist/shared/prepare.d.ts

@@ -0,0 +1,7 @@
+interface PrepareData {
+    projectPath: string;
+    eruditPath: string;
+    contentTargets?: string | string[];
+}
+export declare function prepare({ projectPath, eruditPath, contentTargets, }: PrepareData): Promise<void>;
+export {};

package/dist/shared/prepare.js

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { consola } from 'consola';
+export async function prepare({ projectPath, eruditPath, contentTargets, }) {
+    const eruditBuildDir = `${projectPath}/.erudit`;
+    const distDir = `${projectPath}/.output`;
+    consola.start('Cleaning up...');
+    if (existsSync(distDir))
+        rmSync(distDir, { recursive: true });
+    if (existsSync(eruditBuildDir))
+        rmSync(eruditBuildDir, { recursive: true });
+    consola.success('Cleaned up!');
+    consola.start('Generating Erudit build files...');
+    mkdirSync(eruditBuildDir, { recursive: true });
+    mkdirSync(eruditBuildDir + '/nuxt', { recursive: true });
+    writeFileSync(`${eruditBuildDir}/nuxt/nuxt.config.ts`, `
+        export default {
+            compatibilityDate: '2025-07-20',
+            extends: ['${eruditPath}'],
+        }
+        `);
+    ['app', 'server', 'shared', 'node'].forEach((name) => {
+        writeFileSync(`${eruditBuildDir}/tsconfig.nuxt.${name}.json`, JSON.stringify({ extends: [`./nuxt/.nuxt/tsconfig.${name}.json`] }, null, 4));
+    });
+    mkdirSync(`${eruditBuildDir}/types`, { recursive: true });
+    writeFileSync(`${eruditBuildDir}/tsconfig.erudit.json`, JSON.stringify({
+        compilerOptions: {
+            paths: {
+                '#project/*': [`${projectPath}/*`],
+                '#content/*': [`${projectPath}/content/*`],
+            },
+            verbatimModuleSyntax: true,
+            forceConsistentCasingInFileNames: true,
+            strict: true,
+            noEmit: true,
+            skipLibCheck: true,
+            target: 'ESNext',
+            module: 'ESNext',
+            moduleResolution: 'Bundler',
+            allowJs: true,
+            resolveJsonModule: true,
+            allowSyntheticDefaultImports: true,
+            jsx: 'react-jsx',
+            jsxImportSource: '@jsprose/core',
+            types: ['@jsprose/core/types', '@erudit-js/prose/types'],
+            lib: ['ESNext'],
+        },
+        include: [`${projectPath}/**/*`, `${eruditBuildDir}/**/*`],
+        exclude: [
+            `${eruditBuildDir}/nuxt/**/*`,
+            `${projectPath}/**/docs.ts`,
+        ],
+    }, null, 4));
+    if (!existsSync(`${projectPath}/tsconfig.json`)) {
+        writeFileSync(`${projectPath}/tsconfig.json`, JSON.stringify({
+            files: [],
+            references: [
+                {
+                    path: `./.erudit/tsconfig.erudit.json`,
+                },
+                {
+                    path: `./.erudit/tsconfig.nuxt.app.json`,
+                },
+                {
+                    path: `./.erudit/tsconfig.nuxt.server.json`,
+                },
+                {
+                    path: `./.erudit/tsconfig.nuxt.shared.json`,
+                },
+                {
+                    path: `./.erudit/tsconfig.nuxt.node.json`,
+                },
+            ],
+        }, null, 4));
+    }
+    await prepareContentTargets(eruditBuildDir, contentTargets);
+    writeFileSync(`${eruditBuildDir}/__AUTOGENERATED__`, `This directory is autogenerated by Erudit CLI.\nAll changes will be lost on next launch!`);
+    consola.success('Erudit build files ready!');
+}
+async function prepareContentTargets(buildDir, targets) {
+    if (typeof targets === 'undefined' || targets === '') {
+        return;
+    }
+    if (typeof targets === 'string') {
+        targets = [targets];
+    }
+    if (Array.isArray(targets)) {
+        writeFileSync(`${buildDir}/targets.json`, JSON.stringify(targets, null, 4));
+        consola.success(`Saved ${targets.length} content targets!`);
+        return;
+    }
+    throw new Error(`Failed to resolve content targets: "${targets}"!`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@erudit-js/cli",
-    "version": "3.0.0-dev.8",
+    "version": "4.0.0-dev.1",
     "type": "module",
     "description": "📟 Command Line Interface for Erudit",
     "license": "MIT",
@@ -9,31 +9,32 @@
         "url": "git+https://github.com/erudit-js/erudit.git",
         "directory": "packages/cli"
     },
+    "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "exports": {
-        ".": "./dist/index.mjs",
-        "./cli": "./bin/erudit-cli.mjs"
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./cli": "./bin/erudit-cli.js"
     },
     "bin": {
-        "erudit-cli": "bin/erudit-cli.mjs",
-        "erudit": "bin/erudit-cli.mjs"
+        "erudit-cli": "bin/erudit-cli.js",
+        "erudit": "bin/erudit-cli.js"
     },
     "scripts": {
-        "dev": "bun unbuild --stub",
-        "build": "bun run prepack",
-        "prepack": "bun unbuild"
+        "build": "rm -rf dist && bun tsc --project ./tsconfig.src.json && bun run postBuild.ts",
+        "test": "bun vitest run",
+        "prepack": "bun run build"
     },
     "files": [
         "bin",
         "dist"
     ],
     "dependencies": {
-        "@erudit-js/cog": "3.0.0-dev.8",
-        "chalk": "^5.4.1",
+        "@erudit-js/core": "4.0.0-dev.1",
+        "chalk": "^5.6.2",
         "citty": "^0.1.6",
-        "consola": "^3.4.0"
-    },
-    "devDependencies": {
-        "unbuild": "^3.3.1"
+        "consola": "^3.4.2"
     }
 }

package/bin/erudit-cli.mjs

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-import { run } from '../dist/index.mjs';
-
-run();

package/dist/index.d.mts

@@ -1,3 +0,0 @@
-declare function run(): void;
-
-export { run };

package/dist/index.mjs

@@ -1,398 +0,0 @@
-import { defineCommand, runMain } from 'citty';
-import { brandColorLogotype } from '@erudit-js/cog/utils/brandNode';
-import { consola } from 'consola';
-import chalk from 'chalk';
-import { existsSync, lstatSync, readdirSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { resolvePaths } from '@erudit-js/cog/kit';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { spawn } from 'node:child_process';
-
-const version = "3.0.0-dev.8";
-
-function resolvePath(path) {
-  path = resolvePaths(path);
-  path = path.endsWith("/") ? path.slice(0, -1) : path;
-  if (existsSync(path) && !lstatSync(path).isDirectory())
-    throw new Error(
-      `Path "${chalk.yellowBright(path)}" is not a directory!`
-    );
-  return path;
-}
-
-const init = defineCommand({
-  meta: {
-    name: "Init",
-    description: "Creates a new Erudit project at specified path"
-  },
-  args: {
-    path: {
-      type: "positional",
-      description: "Path for the new Erudit project",
-      required: true,
-      valueHint: chalk.gray(
-        `"${chalk.greenBright(".")}" OR "${chalk.greenBright("path/to/project")}"`
-      )
-    }
-  },
-  async run({ args }) {
-    consola.start("Resolving project path...");
-    const projectPath = resolvePath(args.path);
-    if (projectPath === void 0) return;
-    if (existsSync(projectPath) && readdirSync(projectPath).length > 0)
-      throw new Error(
-        `Directory "${chalk.yellowBright(projectPath)}" is not empty!`
-      );
-    consola.success(
-      "Resolved project path:",
-      chalk.greenBright(projectPath)
-    );
-    consola.start("Creating project directory...");
-    try {
-      try {
-        rmSync(projectPath, { recursive: true });
-      } catch (error) {
-        if (error?.code !== "ENOENT") {
-          throw error;
-        }
-      }
-      mkdirSync(projectPath, { recursive: true });
-    } catch (error) {
-      throw new Error(
-        `Failed to prepare project directory "${chalk.yellowBright(projectPath)}"!
-
-${error}`
-      );
-    }
-    consola.success("Project directory created!");
-    consola.start("Creating project files...");
-    consola.success("Project files created!");
-  }
-});
-
-function logCommand(command) {
-  consola.info(`Running command: ${chalk.cyanBright(command)}`);
-  console.log();
-}
-
-async function alias2Relative(rootDir) {
-  rootDir = resolvePaths(rootDir);
-  if (!existsSync(rootDir)) {
-    return;
-  }
-  const ALIASES_RESOLVED_FILE = path.join(rootDir, "ALIASES_RESOLVED");
-  if (existsSync(ALIASES_RESOLVED_FILE)) {
-    console.log("Aliases already resolved. Skipping...");
-    return;
-  }
-  const replaceMap = {
-    "@erudit": "./",
-    "@module": "./module",
-    "@server": "./server/plugin",
-    "@shared": "./shared",
-    "@app": "./app"
-  };
-  const allFiles = await findAllFiles(rootDir);
-  for (const filePath of allFiles) {
-    await processFile(filePath, rootDir, replaceMap);
-  }
-  await fs.writeFile(ALIASES_RESOLVED_FILE, (/* @__PURE__ */ new Date()).toISOString());
-  console.log("All aliases resolved successfully");
-}
-async function findAllFiles(dir) {
-  const results = [];
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (![".git", "dist", "build"].includes(entry.name)) {
-          results.push(...await findAllFiles(fullPath));
-        }
-      } else if (entry.isFile() && /\.(js|ts|vue)$/.test(entry.name)) {
-        results.push(fullPath);
-      }
-    }
-  } catch (error) {
-    console.error(`Error reading directory ${dir}:`, error);
-  }
-  return results;
-}
-async function processFile(filePath, rootDir, replaceMap) {
-  try {
-    let content = await fs.readFile(filePath, "utf8");
-    let modified = false;
-    for (const [alias, targetBasePath] of Object.entries(replaceMap)) {
-      const staticAliasPattern = new RegExp(
-        `(import|from)\\s+(['"])${alias}/([^'"]+)(['"])`,
-        "g"
-      );
-      const dynamicAliasPattern = new RegExp(
-        `(import\\s*\\()\\s*(['"])${alias}/([^'"]+)(['"])\\s*\\)`,
-        "g"
-      );
-      const calculateRelativePath = (importPath) => {
-        const currentFileDir = path.dirname(filePath);
-        const targetAbsoluteDir = path.join(
-          rootDir,
-          targetBasePath.replace(/^\.\//, "")
-        );
-        const targetAbsolutePath = path.join(
-          targetAbsoluteDir,
-          importPath
-        );
-        let relativePath = path.relative(
-          currentFileDir,
-          targetAbsolutePath
-        );
-        if (!relativePath.startsWith(".")) {
-          relativePath = "./" + relativePath;
-        }
-        return relativePath.replace(/\\/g, "/");
-      };
-      content = content.replace(
-        staticAliasPattern,
-        (match, statement, openQuote, importPath, closeQuote) => {
-          const relativePath = calculateRelativePath(importPath);
-          modified = true;
-          return `${statement} ${openQuote}${relativePath}${closeQuote}`;
-        }
-      );
-      content = content.replace(
-        dynamicAliasPattern,
-        (match, importStatement, openQuote, importPath, closeQuote) => {
-          const relativePath = calculateRelativePath(importPath);
-          modified = true;
-          return `${importStatement}${openQuote}${relativePath}${closeQuote})`;
-        }
-      );
-    }
-    if (modified) {
-      await fs.writeFile(filePath, content, "utf8");
-      console.log(`Updated aliases in: ${filePath}`);
-    }
-  } catch (error) {
-    console.error(`Error processing file ${filePath}:`, error);
-  }
-}
-
-async function prepare$1(projectPath, eruditPath) {
-  const eruditBuildDir = `${projectPath}/.erudit`;
-  const distDir = `${projectPath}/dist`;
-  const nodeModulesErudit = `${projectPath}/node_modules/erudit`;
-  await alias2Relative(nodeModulesErudit);
-  consola.start("Cleaning up...");
-  if (existsSync(distDir)) rmSync(distDir, { recursive: true });
-  if (existsSync(eruditBuildDir)) rmSync(eruditBuildDir, { recursive: true });
-  consola.success("Cleaned up!");
-  consola.start("Generating Erudit build files...");
-  mkdirSync(eruditBuildDir, { recursive: true });
-  mkdirSync(eruditBuildDir + "/nuxt", { recursive: true });
-  writeFileSync(
-    `${eruditBuildDir}/nuxt/nuxt.config.ts`,
-    `
-        export default {
-            compatibilityDate: '2025-01-01',
-            extends: ['${eruditPath}'],
-            future: {
-                compatibilityVersion: 4,
-            },
-        }
-    `
-  );
-  writeFileSync(
-    `${eruditBuildDir}/tsconfig.json`,
-    JSON.stringify(
-      {
-        extends: "./nuxt/.nuxt/tsconfig.json"
-      },
-      null,
-      4
-    )
-  );
-  consola.success("Erudit build files ready!");
-}
-
-async function spawnNuxt(command, projectPath) {
-  return new Promise((resolve) => {
-    const onClose = (exitCode) => {
-      if (exitCode === 1337) _spawnNuxt();
-      else if (exitCode !== 0)
-        throw new Error(`Nuxt exited with code ${exitCode}!`);
-      else resolve();
-    };
-    const _spawnNuxt = () => {
-      const nuxtProcess = spawn(
-        `nuxt ${command} ${projectPath}/.erudit/nuxt`,
-        {
-          shell: true,
-          stdio: "inherit",
-          env: {
-            ...process.env,
-            ERUDIT_PROJECT_DIR: projectPath
-          }
-        }
-      );
-      nuxtProcess.on("close", onClose);
-    };
-    _spawnNuxt();
-  });
-}
-
-const eruditPathArg = {
-  eruditPath: {
-    type: "string",
-    description: "Custom Erudit Nuxt Layer location",
-    required: false,
-    default: "erudit"
-    // Let `nuxi` find erudit in project dependencies
-  }
-};
-const projectPathArg = {
-  projectPath: {
-    type: "positional",
-    description: "Erudit project location",
-    required: false,
-    default: "."
-  }
-};
-function resolveArgPaths(projectPath, eruditPath) {
-  consola.start("Resolving project path...");
-  projectPath = resolvePath(projectPath);
-  consola.success("Resolved project path:", chalk.greenBright(projectPath));
-  consola.start("Resolving Erudit Nuxt Layer path...");
-  if (eruditPath === "erudit") {
-    consola.success(`'nuxi' will find Erudit in your dependencies!`);
-  } else {
-    eruditPath = resolvePath(eruditPath);
-    consola.warn(
-      "Custom Erudit Nuxt Layer path will be used: " + chalk.yellowBright(eruditPath)
-    );
-  }
-  return {
-    projectPath,
-    eruditPath
-  };
-}
-
-const prepare = defineCommand({
-  meta: {
-    name: "Prepare",
-    description: "Creates a .erudit directory in your project and generates build files"
-  },
-  args: {
-    ...projectPathArg,
-    ...eruditPathArg
-  },
-  async run({ args }) {
-    logCommand("prepare");
-    const { projectPath, eruditPath } = resolveArgPaths(
-      args.projectPath,
-      args.eruditPath
-    );
-    await prepare$1(projectPath, eruditPath);
-    consola.start("Generating Nuxt build files...");
-    await spawnNuxt("prepare", projectPath);
-    consola.success("Nuxt is prepared!");
-  }
-});
-
-const dev = defineCommand({
-  meta: {
-    name: "Dev",
-    description: "Runs Erudit project in development mode"
-  },
-  args: {
-    ...projectPathArg,
-    ...eruditPathArg
-  },
-  async run({ args }) {
-    logCommand("dev");
-    const { projectPath, eruditPath } = resolveArgPaths(
-      args.projectPath,
-      args.eruditPath
-    );
-    await prepare$1(projectPath, eruditPath);
-    consola.start("Starting Nuxt dev...");
-    await spawnNuxt("dev", projectPath);
-  }
-});
-
-const build = defineCommand({
-  meta: {
-    name: "Build",
-    description: "Generates fully static Erudit site"
-  },
-  args: {
-    ...projectPathArg,
-    ...eruditPathArg
-  },
-  async run({ args }) {
-    logCommand("build");
-    const { projectPath, eruditPath } = resolveArgPaths(
-      args.projectPath,
-      args.eruditPath
-    );
-    await prepare$1(projectPath, eruditPath);
-    consola.start("Starting Nuxt build...");
-    await spawnNuxt("generate", projectPath);
-  }
-});
-
-const preview = defineCommand({
-  meta: {
-    name: "Preview",
-    description: "Preview created static Erudit site"
-  },
-  args: {
-    project: {
-      type: "positional",
-      description: "Project path",
-      required: false,
-      default: "."
-    }
-  },
-  async run({ args }) {
-    consola.start("Resolving project path...");
-    const projectPath = resolvePath(args.project);
-    consola.success(
-      "Resolved project path:",
-      chalk.greenBright(projectPath)
-    );
-    const distPath = `${projectPath}/dist`;
-    if (!existsSync(distPath))
-      throw new Error(
-        `No 'dist' folder found! Did you run 'erudit build'?`
-      );
-    spawn("npx http-server . -p 3000", {
-      shell: true,
-      stdio: "inherit",
-      env: process.env,
-      cwd: distPath
-    });
-  }
-});
-
-const main = defineCommand({
-  meta: {
-    name: "Erudit CLI",
-    description: "Command Line Interface for Erudit!",
-    version
-  },
-  subCommands: {
-    init,
-    prepare,
-    dev,
-    build,
-    preview
-  },
-  setup() {
-    console.log(brandColorLogotype);
-  }
-});
-
-function run() {
-  runMain(main);
-}
-
-export { run };