create-vatts-app 1.0.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 itsmuzin
+
+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/dist/createApp/cli.d.ts

@@ -0,0 +1,5 @@
+import type { CreateAppOptions } from "./types";
+export declare function parseArgs(argv: string[]): CreateAppOptions;
+export declare function promptForMissingOptions(opts: CreateAppOptions): Promise<Required<Omit<CreateAppOptions, "appName">> & {
+    appName: string;
+}>;

package/dist/createApp/cli.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.promptForMissingOptions = promptForMissingOptions;
+const console_1 = __importDefault(require("vatts/console"));
+function normalizeAliasPrefix(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "@/";
+    // Allow users to type "@" or "@/" or "@/*". We normalize to prefix form ("@/").
+    if (trimmed.endsWith("/*"))
+        return trimmed.slice(0, -1); // "@/*" -> "@/"
+    if (trimmed.endsWith("/"))
+        return trimmed;
+    return `${trimmed}/`;
+}
+function readArgValue(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1)
+        return undefined;
+    const next = args[idx + 1];
+    if (!next || next.startsWith("-"))
+        return undefined;
+    return next;
+}
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const appName = args.find((a) => a.length > 0 && !a.startsWith("-"));
+    // flags
+    const tailwindFlag = args.includes("--tailwind") || args.includes("-t");
+    const noInstallFlag = args.includes("--no-install");
+    const installFlag = args.includes("--install");
+    const noExamplesFlag = args.includes("--no-examples");
+    const examplesFlag = args.includes("--examples");
+    const noAliasFlag = args.includes("--no-alias");
+    const aliasValue = readArgValue(args, "--alias");
+    return {
+        appName,
+        tailwind: tailwindFlag ? true : undefined,
+        // default examples = true (prompt still decides)
+        examples: noExamplesFlag ? false : examplesFlag ? true : undefined,
+        install: noInstallFlag ? false : installFlag ? true : undefined,
+        moduleAlias: noAliasFlag ? false : aliasValue ? true : undefined,
+        alias: aliasValue ? normalizeAliasPrefix(aliasValue) : undefined,
+    };
+}
+async function promptForMissingOptions(opts) {
+    const appName = opts.appName ?? (await console_1.default.ask("What is the name of your app?", "my-vatts-app"));
+    let tailwind = opts.tailwind;
+    if (tailwind === undefined) {
+        tailwind = await console_1.default.confirm("Do you want to include Tailwind CSS?", true);
+    }
+    let examples = opts.examples;
+    if (examples === undefined) {
+        examples = await console_1.default.confirm("Do you want to include example routes?", true);
+    }
+    let install = opts.install;
+    if (install === undefined) {
+        install = await console_1.default.confirm("Do you want to install dependencies?", true);
+    }
+    let moduleAlias = opts.moduleAlias;
+    if (moduleAlias === undefined) {
+        moduleAlias = await console_1.default.confirm("Do you want to set a module alias?", true);
+    }
+    let alias = opts.alias;
+    if (moduleAlias) {
+        if (alias === undefined) {
+            alias = await console_1.default.ask("Which alias do you want to set?", "@/");
+        }
+        alias = normalizeAliasPrefix(alias);
+    }
+    else {
+        // keep a stable value even when disabled
+        alias = "@/";
+    }
+    return {
+        appName,
+        tailwind,
+        examples,
+        install,
+        moduleAlias,
+        alias,
+    };
+}

package/dist/createApp/createApp.d.ts

@@ -0,0 +1,3 @@
+import type { CreateAppOptions } from "./types";
+export declare function createAppFromArgv(argv: string[]): Promise<void>;
+export declare function createApp(options: CreateAppOptions): Promise<void>;

package/dist/createApp/createApp.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppFromArgv = createAppFromArgv;
+exports.createApp = createApp;
+const cli_1 = require("./cli");
+const steps_1 = require("./steps");
+const path = __importStar(require("node:path"));
+const validate_1 = require("./validate");
+function resolveOwnPackageJson() {
+    const pkgPath = path.resolve(__dirname, "..", "..", "package.json");
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(pkgPath);
+}
+async function createAppFromArgv(argv) {
+    const opts = (0, cli_1.parseArgs)(argv);
+    return createApp(opts);
+}
+async function createApp(options) {
+    const resolved = await (0, cli_1.promptForMissingOptions)(options);
+    const safeName = (0, validate_1.validateAppName)(resolved.appName);
+    const rootDir = safeName;
+    // Fail fast to avoid overwriting anything.
+    (0, validate_1.assertTargetDirIsSafeEmpty)(rootDir);
+    const ownPkg = resolveOwnPackageJson();
+    const ctx = {
+        appName: safeName,
+        rootDir,
+        willTailwind: resolved.tailwind,
+        willRouteExample: resolved.examples,
+        willInstallDependencies: resolved.install,
+        willUseModuleAlias: resolved.moduleAlias,
+        moduleAlias: resolved.alias,
+        vattsVersion: ownPkg.version,
+        packageJson: {},
+    };
+    console.clear();
+    await (0, steps_1.stepCreateProjectDirAndPackageJson)(ctx);
+    await (0, steps_1.stepCreateProjectStructure)(ctx);
+    await (0, steps_1.stepWriteVattsConfig)(ctx);
+    await (0, steps_1.stepWriteTsConfig)(ctx);
+    await (0, steps_1.stepSetupTailwind)(ctx);
+    await (0, steps_1.stepCreateExampleRoutes)(ctx);
+    await (0, steps_1.stepInstallDependencies)(ctx);
+    (0, steps_1.printSummary)(ctx);
+}

package/dist/createApp/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureDir(dirPath: string): void;
+export declare function writeFile(targetPath: string, content: string): void;
+export declare function writeJson(targetPath: string, data: unknown): void;
+export declare function exists(targetPath: string): boolean;

package/dist/createApp/fs.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.writeFile = writeFile;
+exports.writeJson = writeJson;
+exports.exists = exists;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+function writeFile(targetPath, content) {
+    ensureDir(path.dirname(targetPath));
+    fs.writeFileSync(targetPath, content);
+}
+function writeJson(targetPath, data) {
+    writeFile(targetPath, JSON.stringify(data, null, 2));
+}
+function exists(targetPath) {
+    return fs.existsSync(targetPath);
+}

package/dist/createApp/index.d.ts

@@ -0,0 +1 @@
+export * from "./createApp";

package/dist/createApp/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createApp"), exports);

package/dist/createApp/install.d.ts

@@ -0,0 +1 @@
+export declare function npmInstall(cwd: string): Promise<void>;

package/dist/createApp/install.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.npmInstall = npmInstall;
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+function trySpawn(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, { cwd, stdio: "inherit" });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}`));
+        });
+    });
+}
+async function npmInstall(cwd) {
+    // Strategy (Windows-safe):
+    // 1) Try npm.cmd from PATH
+    // 2) Fallback: run npm-cli.js with Node (process.execPath) at the same Node installation
+    // 3) Try npm from PATH (non-windows / alternative)
+    const args = ["install"];
+    // 1) npm.cmd
+    if (process.platform === "win32") {
+        try {
+            return await trySpawn("npm.cmd", args, cwd);
+        }
+        catch {
+            // ignore and fallback
+        }
+        // 2) npm-cli.js via node
+        // Typical location: <nodeDir>/node_modules/npm/bin/npm-cli.js
+        const nodeDir = path.dirname(process.execPath);
+        const npmCli = path.join(nodeDir, "node_modules", "npm", "bin", "npm-cli.js");
+        if (fs.existsSync(npmCli)) {
+            return await trySpawn(process.execPath, [npmCli, ...args], cwd);
+        }
+    }
+    // 3) npm
+    return await trySpawn("npm", args, cwd);
+}

package/dist/createApp/packageJson.d.ts

@@ -0,0 +1,2 @@
+import type { CreateAppContext } from "./types";
+export declare function buildPackageJson(ctx: Pick<CreateAppContext, "appName" | "vattsVersion" | "willTailwind">): Promise<any>;

package/dist/createApp/packageJson.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPackageJson = buildPackageJson;
+const console_1 = __importDefault(require("vatts/console"));
+async function buildPackageJson(ctx) {
+    async function verifyVersion() {
+        // node fetch
+        try {
+            const response = await fetch('https://registry.npmjs.org/vatts/latest');
+            const data = await response.json();
+            return data.version;
+        }
+        catch (error) {
+            console_1.default.error('Could not check for the latest Vatts.js version:', error);
+            return ctx.vattsVersion; // Retorna a versão atual em caso de erro
+        }
+    }
+    const version = await verifyVersion();
+    const packageJson = {
+        name: ctx.appName,
+        version: "0.1.0",
+        description: "Basic application for Vatts.js framework",
+        scripts: {
+            start: "vatts start",
+            dev: "vatts dev",
+        },
+        dependencies: {
+            vatts: `${version}`,
+            react: "^19.2.3",
+            "react-dom": "^19.2.3",
+            "ts-node": "^10.9.2",
+        },
+        devDependencies: {
+            "@types/react": "^19.2.8",
+            typescript: "^5.9.3",
+        },
+    };
+    if (ctx.willTailwind) {
+        packageJson.dependencies = {
+            ...packageJson.dependencies,
+            tailwindcss: "^4.1.18",
+            "@tailwindcss/postcss": "^4.1.18",
+            postcss: "^8.5.6",
+            autoprefixer: "^10.4.23",
+        };
+    }
+    return packageJson;
+}

package/dist/createApp/steps.d.ts

@@ -0,0 +1,9 @@
+import type { CreateAppContext } from "./types";
+export declare function stepCreateProjectDirAndPackageJson(ctx: CreateAppContext): Promise<void>;
+export declare function stepCreateProjectStructure(ctx: CreateAppContext): Promise<void>;
+export declare function stepWriteVattsConfig(ctx: CreateAppContext): Promise<void>;
+export declare function stepWriteTsConfig(ctx: CreateAppContext): Promise<void>;
+export declare function stepSetupTailwind(ctx: CreateAppContext): Promise<void>;
+export declare function stepCreateExampleRoutes(ctx: CreateAppContext): Promise<void>;
+export declare function stepInstallDependencies(ctx: CreateAppContext): Promise<void>;
+export declare function printSummary(ctx: CreateAppContext): void;

package/dist/createApp/steps.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepCreateProjectDirAndPackageJson = stepCreateProjectDirAndPackageJson;
+exports.stepCreateProjectStructure = stepCreateProjectStructure;
+exports.stepWriteVattsConfig = stepWriteVattsConfig;
+exports.stepWriteTsConfig = stepWriteTsConfig;
+exports.stepSetupTailwind = stepSetupTailwind;
+exports.stepCreateExampleRoutes = stepCreateExampleRoutes;
+exports.stepInstallDependencies = stepInstallDependencies;
+exports.printSummary = printSummary;
+const console_1 = __importStar(require("vatts/console"));
+const path = __importStar(require("node:path"));
+const fs_1 = require("./fs");
+const templates_1 = require("./templates");
+const packageJson_1 = require("./packageJson");
+const install_1 = require("./install");
+async function stepCreateProjectDirAndPackageJson(ctx) {
+    const dynamic = console_1.default.dynamicLine("Creating your Vatts.js app...");
+    (0, fs_1.ensureDir)(ctx.rootDir);
+    ctx.packageJson = await (0, packageJson_1.buildPackageJson)({
+        appName: ctx.appName,
+        vattsVersion: ctx.vattsVersion,
+        willTailwind: ctx.willTailwind,
+    });
+    (0, fs_1.writeJson)(path.join(ctx.rootDir, "package.json"), ctx.packageJson);
+    dynamic.end("Created project directory and package.json");
+}
+async function stepCreateProjectStructure(ctx) {
+    const dynamic = console_1.default.dynamicLine("Creating project structure...");
+    (0, fs_1.ensureDir)(path.join(ctx.rootDir, "src", "backend", "routes"));
+    (0, fs_1.ensureDir)(path.join(ctx.rootDir, "src", "web", "routes"));
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "src", "web", "globals.css"), (0, templates_1.globalsCssTemplate)(ctx.willTailwind));
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "src", "web", "layout.tsx"), (0, templates_1.layoutTsxTemplate)());
+    dynamic.end("Created project structure");
+}
+async function stepWriteVattsConfig(ctx) {
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "vatts.config.ts"), (0, templates_1.vattsConfigTemplate)());
+}
+async function stepWriteTsConfig(ctx) {
+    const dynamic = console_1.default.dynamicLine("Initializing TypeScript configuration...");
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "tsconfig.json"), (0, templates_1.tsconfigTemplate)(ctx.willUseModuleAlias ? { moduleAlias: ctx.moduleAlias } : { moduleAlias: false }));
+    dynamic.end("TypeScript configuration initialized.");
+}
+async function stepSetupTailwind(ctx) {
+    if (!ctx.willTailwind)
+        return;
+    const dynamic = console_1.default.dynamicLine("Setting up Tailwind CSS...");
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "postcss.config.js"), (0, templates_1.postcssConfigTemplate)());
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "tailwind.config.js"), (0, templates_1.tailwindConfigTemplate)());
+    dynamic.end("Tailwind CSS setup complete.");
+}
+async function stepCreateExampleRoutes(ctx) {
+    if (!ctx.willRouteExample)
+        return;
+    const dynamic = console_1.default.dynamicLine("Creating example routes...");
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "src", "web", "routes", "index.tsx"), (0, templates_1.webIndexRouteTemplate)(ctx.willTailwind));
+    (0, fs_1.writeFile)(path.join(ctx.rootDir, "src", "backend", "routes", "Example.ts"), (0, templates_1.backendExampleRouteTemplate)());
+    dynamic.end("Example routes created.");
+}
+async function stepInstallDependencies(ctx) {
+    if (!ctx.willInstallDependencies)
+        return;
+    const dynamic = console_1.default.dynamicLine("Installing dependencies...");
+    console.log(`\nInstalling dependencies:\n${ctx.packageJson.dependencies
+        ? Object.keys(ctx.packageJson.dependencies)
+            .map((dep) => `  - ${console_1.Colors.FgCyan}${dep}${console_1.Colors.Reset}`)
+            .join("\n")
+        : ""}\n\nInstalling devDependencies:\n${ctx.packageJson.devDependencies
+        ? Object.keys(ctx.packageJson.devDependencies)
+            .map((dep) => `  - ${console_1.Colors.FgCyan}${dep}${console_1.Colors.Reset}`)
+            .join("\n")
+        : ""}\n`);
+    const spinnerFrames = ["|", "/", "-", "\\"];
+    let frameIndex = 0;
+    const spinner = setInterval(() => {
+        dynamic.update(`${console_1.Colors.FgGreen}${spinnerFrames[frameIndex]}${console_1.Colors.Reset} Installing...`);
+        frameIndex = (frameIndex + 1) % spinnerFrames.length;
+    }, 100);
+    try {
+        await (0, install_1.npmInstall)(ctx.rootDir);
+    }
+    finally {
+        clearInterval(spinner);
+    }
+    dynamic.end("Dependencies installed.");
+}
+function printSummary(ctx) {
+    console.clear();
+    const now = new Date();
+    const time = now.toLocaleTimeString("pt-BR", { hour12: false });
+    const timer = ` ${console_1.Colors.FgGray}${time}${console_1.Colors.Reset}  `;
+    const label = console_1.Colors.FgGray;
+    const cmd = console_1.Colors.Bright + console_1.Colors.FgCyan;
+    const ok = console_1.Colors.FgGreen;
+    const dim = console_1.Colors.Dim;
+    const bright = console_1.Colors.Bright;
+    const nodeVersion = process.version;
+    const platform = process.platform;
+    console.log("");
+    console.log(`${timer}${bright}${console_1.Colors.FgCyan}Vatts.js${console_1.Colors.Reset} ${dim}v${ctx.vattsVersion}${console_1.Colors.Reset}`);
+    console.log(`${timer}${dim}────────────────────────────────────────${console_1.Colors.Reset}`);
+    console.log(`${timer}${ok}✔${console_1.Colors.Reset}  ${bright}Project ${console_1.Colors.FgWhite}${ctx.appName}${console_1.Colors.Reset}${bright} created successfully.${console_1.Colors.Reset}`);
+    console.log("");
+    console.log(`${timer}${label}Environment:${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}  • Runtime:${console_1.Colors.Reset} ${console_1.Colors.Bright + console_1.Colors.FgGreen}Node.js${console_1.Colors.Reset} ${dim}${nodeVersion}${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}  • Platform:${console_1.Colors.Reset} ${cmd}${platform}${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}  • Framework:${console_1.Colors.Reset} ${cmd}Vatts.js${console_1.Colors.Reset} ${dim}v${ctx.vattsVersion}${console_1.Colors.Reset}`);
+    console.log("");
+    console.log(`${timer}${label}Next steps:${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}  1.${console_1.Colors.Reset} ${cmd}cd ${ctx.appName}${console_1.Colors.Reset}`);
+    let step = 2;
+    if (!ctx.willInstallDependencies) {
+        console.log(`${timer}${label}  ${step++}.${console_1.Colors.Reset} ${cmd}npm install${console_1.Colors.Reset}`);
+    }
+    console.log(`${timer}${label}  ${step++}.${console_1.Colors.Reset} ${cmd}vatts dev${console_1.Colors.Reset}${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}     or${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}     ${cmd}npm run dev${console_1.Colors.Reset}`);
+    console.log("");
+    console.log(`${timer}${label}Production:${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}  • Start:${console_1.Colors.Reset} ${cmd}vatts start${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}    or${console_1.Colors.Reset}`);
+    console.log(`${timer}${label}    ${cmd}npm run start${console_1.Colors.Reset}`);
+    console.log("");
+    console.log(`${timer}${dim}Website:${console_1.Colors.Reset} ${console_1.Colors.FgCyan}https://vatts.mfraz.ovh${console_1.Colors.Reset}`);
+    console.log("");
+    console.log();
+}

package/dist/createApp/templates.d.ts

@@ -0,0 +1,10 @@
+export declare function globalsCssTemplate(willTailwind: boolean): "@import \"tailwindcss\";\n" | "body {\nbackground-color: #030712; \n}";
+export declare function layoutTsxTemplate(): string;
+export declare function vattsConfigTemplate(): string;
+export declare function tsconfigTemplate(opts?: {
+    moduleAlias?: string | false;
+}): string;
+export declare function postcssConfigTemplate(): string;
+export declare function tailwindConfigTemplate(): string;
+export declare function webIndexRouteTemplate(willTailwind: boolean): string;
+export declare function backendExampleRouteTemplate(): string;

package/dist/createApp/templates.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalsCssTemplate = globalsCssTemplate;
+exports.layoutTsxTemplate = layoutTsxTemplate;
+exports.vattsConfigTemplate = vattsConfigTemplate;
+exports.tsconfigTemplate = tsconfigTemplate;
+exports.postcssConfigTemplate = postcssConfigTemplate;
+exports.tailwindConfigTemplate = tailwindConfigTemplate;
+exports.webIndexRouteTemplate = webIndexRouteTemplate;
+exports.backendExampleRouteTemplate = backendExampleRouteTemplate;
+function globalsCssTemplate(willTailwind) {
+    // even without tailwind, leave empty file to avoid import errors
+    return willTailwind ? `@import "tailwindcss";\n` : `body {
+background-color: #030712; 
+}`;
+}
+function layoutTsxTemplate() {
+    // keeping same content/behavior as original generator
+    return `import React from 'react';
+import {Metadata} from "vatts/react"
+import './globals.css';
+
+interface LayoutProps {
+    children: React.ReactNode;
+}
+
+export const metadata: Metadata = {
+    title: "Vatts JS | The Fast and Simple Web Framework for React",
+    description: "The fastest and simplest web framework for React! Start building high-performance web applications today with Vatts JS.",
+    keywords: ["Vatts JS", "web framework", "React", "JavaScript", "TypeScript", "web development", "fast", "simple", "SSR", "frontend"],
+    author: "Vatts JS Team",
+};
+
+export default function Layout({ children }: LayoutProps) {
+    return (
+        <>{children}</>
+    );
+}
+`;
+}
+function vattsConfigTemplate() {
+    return `import type { VattsConfigFunction } from 'vatts';
+
+const hightConfig: VattsConfigFunction = (phase, { defaultConfig }) => {
+    return defaultConfig;
+};
+
+export default hightConfig;`;
+}
+function tsconfigTemplate(opts) {
+    const aliasPrefix = opts?.moduleAlias;
+    const willAlias = typeof aliasPrefix === "string" && aliasPrefix.length > 0;
+    // convert "@/" => "@/*" and strip trailing "/" for prefix like "@"
+    const normalizedPrefix = willAlias ? (aliasPrefix.endsWith("/") ? aliasPrefix : `${aliasPrefix}/`) : "@/";
+    const aliasKey = `${normalizedPrefix}*`; // "@/*"
+    const aliasBlock = willAlias
+        ? `,
+    "baseUrl": ".",
+    "paths": {
+      "${aliasKey}": ["src/*"]
+    }`
+        : "";
+    return `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "moduleResolution": "nodenext",
+    "types": ["vatts/global"]${aliasBlock}
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+`;
+}
+function postcssConfigTemplate() {
+    return `const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+    autoprefixer: {},
+  },
+};
+
+module.exports = config;
+`;
+}
+function tailwindConfigTemplate() {
+    return `/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./src/**/*.{js,ts,jsx,tsx}",
+    "./src/web/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}`;
+}
+function webIndexRouteTemplate(willTailwind) {
+    let base = `import React from 'react'; 
+import {RouteConfig} from "vatts/react";`;
+    if (willTailwind) {
+        base += `
+function Welcome() {
+  return (
+    <div className="flex min-h-screen flex-col items-center justify-center bg-gray-950 p-4 text-center">
+      <div className="group relative">
+        <div className="absolute -inset-1 rounded-lg bg-gradient-to-r from-purple-600 to-cyan-400 opacity-25 blur transition duration-500 group-hover:opacity-50"></div>
+        <div className="relative rounded-lg bg-gray-900 px-8 py-6 ring-1 ring-gray-800">
+          <h1 className="mb-2 text-4xl font-bold tracking-tight text-white sm:text-5xl">
+            Hello <span className="text-transparent bg-clip-text bg-gradient-to-r from-purple-400 to-cyan-400">World</span>
+          </h1>
+          
+          <p className="text-sm font-medium text-gray-400">
+            Running with <span className="text-gray-200">Vatts.js</span>
+          </p>
+        </div>
+      </div>
+    </div>
+  );
+}
+`;
+    }
+    else {
+        base += `
+function Welcome() {
+  const [isHovered, setIsHovered] = React.useState(false);
+
+  // Definição dos estilos
+  const styles: { [key: string]: React.CSSProperties } = {
+    container: {
+      display: 'flex',
+      minHeight: '100vh',
+      flexDirection: 'column',
+      alignItems: 'center',
+      justifyContent: 'center',
+      backgroundColor: '#030712', // gray-950
+      padding: '1rem',
+      textAlign: 'center',
+      fontFamily: 'sans-serif', // Padrão para garantir consistência
+    },
+    groupWrapper: {
+      position: 'relative',
+    },
+    gradientBlur: {
+      position: 'absolute',
+      top: '-4px', // -inset-1 (aprox 0.25rem)
+      right: '-4px',
+      bottom: '-4px',
+      left: '-4px',
+      borderRadius: '0.5rem',
+      background: 'linear-gradient(to right, #9333ea, #22d3ee)', // purple-600 to cyan-400
+      filter: 'blur(8px)', // blur (padrao do tailwind é 8px ou 4px dependendo da versão, 8px fica bom aqui)
+      transition: 'opacity 500ms ease',
+      opacity: isHovered ? 0.5 : 0.25, // Controle via useState
+    },
+    card: {
+      position: 'relative',
+      borderRadius: '0.5rem',
+      backgroundColor: '#111827', // gray-900
+      padding: '1.5rem 2rem', // px-8 py-6
+      border: '1px solid #1f2937', // simulando ring-1 ring-gray-800
+      color: 'white',
+    },
+    title: {
+      marginBottom: '0.5rem',
+      fontSize: '2.25rem', // text-4xl
+      fontWeight: 'bold',
+      letterSpacing: '-0.025em', // tracking-tight
+      color: 'white',
+      lineHeight: 1,
+    },
+    gradientText: {
+      color: 'transparent',
+      backgroundClip: 'text',
+      WebkitBackgroundClip: 'text',
+      backgroundImage: 'linear-gradient(to right, #c084fc, #22d3ee)', // purple-400 to cyan-400
+    },
+    subtitle: {
+      fontSize: '0.875rem', // text-sm
+      fontWeight: 500,
+      color: '#9ca3af', // gray-400
+      margin: 0,
+    },
+    subtitleHighlight: {
+      color: '#e5e7eb', // gray-200
+    },
+  };
+
+  return (
+      <div style={styles.container}>
+        <div
+            style={styles.groupWrapper}
+            onMouseEnter={() => setIsHovered(true)}
+            onMouseLeave={() => setIsHovered(false)}
+        >
+          <div style={styles.gradientBlur}></div>
+
+          <div style={styles.card}>
+            <h1 style={styles.title}>
+              Hello <span style={styles.gradientText}>World</span>
+            </h1>
+
+            <p style={styles.subtitle}>
+              Running with <span style={styles.subtitleHighlight}>Vatts.js</span>
+            </p>
+          </div>
+        </div>
+      </div>
+  );
+}`;
+    }
+    base += `
+
+export const config: RouteConfig = {
+    pattern: '/',
+    component: Welcome,
+    generateMetadata: () => ({
+        title: 'Vatts.js | Home'
+    })
+};
+
+export default config;
+`;
+    return base;
+}
+function backendExampleRouteTemplate() {
+    return `import {BackendRouteConfig, VattsRequest, VattsResponse} from "vatts"
+
+const ExampleRoute: BackendRouteConfig = {
+    pattern: '/api/example',
+    GET(request: VattsRequest, params) {
+        return VattsResponse.json({
+            message: 'Welcome to the Example API!'
+        })
+    },
+    POST: async (request: VattsRequest, params) => {
+        const data = await request.json();
+        return VattsResponse.json({
+            message: 'POST request received at Example API!',
+            body: data
+        })
+    }
+};
+
+export default ExampleRoute;`;
+}

package/dist/createApp/types.d.ts

@@ -0,0 +1,24 @@
+export type CreateAppOptions = {
+    /** If omitted, we prompt */
+    appName?: string;
+    tailwind?: boolean;
+    examples?: boolean;
+    install?: boolean;
+    /** If omitted, we prompt (default: true) */
+    moduleAlias?: boolean;
+    /** Alias prefix to use when moduleAlias=true (default: "@/") */
+    alias?: string;
+};
+export type CreateAppContext = {
+    appName: string;
+    rootDir: string;
+    willTailwind: boolean;
+    willRouteExample: boolean;
+    willInstallDependencies: boolean;
+    willUseModuleAlias: boolean;
+    /** Normalized alias prefix (ex: "@/") */
+    moduleAlias: string;
+    /** computed */
+    vattsVersion: string;
+    packageJson: Record<string, any>;
+};

package/dist/createApp/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/createApp/validate.d.ts

@@ -0,0 +1,2 @@
+export declare function validateAppName(appName: string): string;
+export declare function assertTargetDirIsSafeEmpty(rootDir: string): void;

package/dist/createApp/validate.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAppName = validateAppName;
+exports.assertTargetDirIsSafeEmpty = assertTargetDirIsSafeEmpty;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const WINDOWS_RESERVED_NAMES = new Set([
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9",
+]);
+function validateAppName(appName) {
+    const name = appName.trim();
+    if (!name) {
+        throw new Error("App name cannot be empty.");
+    }
+    // We scaffold into a folder with this name, so keep it filesystem-safe.
+    if (name.includes(path.sep) || name.includes("/") || name.includes("\\")) {
+        throw new Error("App name must be a folder name, not a path.");
+    }
+    // Windows forbidden chars in file/dir names.
+    if (/[<>:"/\\|?*]/.test(name)) {
+        throw new Error("App name contains invalid filename characters.");
+    }
+    if (name.length > 214) {
+        throw new Error("App name is too long.");
+    }
+    // Avoid '.' and '..'
+    if (name === "." || name === "..") {
+        throw new Error("App name cannot be '.' or '..'.");
+    }
+    // Windows device names (case-insensitive), also invalid with extensions.
+    const upper = name.toUpperCase();
+    const base = upper.split(".")[0];
+    if (WINDOWS_RESERVED_NAMES.has(base)) {
+        throw new Error(`App name '${name}' is reserved on Windows.`);
+    }
+    return name;
+}
+function assertTargetDirIsSafeEmpty(rootDir) {
+    // If the directory doesn't exist, it's safe.
+    if (!fs.existsSync(rootDir))
+        return;
+    const stat = fs.statSync(rootDir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Target path '${rootDir}' already exists and isn't a directory.`);
+    }
+    // Must be empty to avoid overwriting user's files.
+    const entries = fs.readdirSync(rootDir);
+    if (entries.length > 0) {
+        throw new Error(`Target directory '${rootDir}' already exists and isn't empty.`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,18 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const console_1 = __importDefault(require("vatts/console"));
+const createApp_1 = require("./createApp");
+async function main() {
+    try {
+        await (0, createApp_1.createAppFromArgv)(process.argv);
+    }
+    catch (error) {
+        console_1.default.error("An error occurred:", error);
+        process.exit(1);
+    }
+}
+main();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "create-vatts-app",
+  "version": "1.0.0",
+  "description": "CLI tool to create a new Vatts.js application",
+  "main": "dist/index.js",
+  "bin": {
+    "create-vatts-app": "dist/index.js"
+  },
+  "keywords": [
+    "vattsjs",
+    "vatts",
+    "framework",
+    "web",
+    "typescript",
+    "react"
+  ],
+  "files": [
+    "dist"
+  ],
+  "author": "itsmuzin",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "rimraf": "^5.0.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "ts-node": "^10.9.2",
+    "vatts": "1.0.1"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "version:major": "pnpm version major --no-git-tag-version",
+    "version:minor": "pnpm version minor --no-git-tag-version",
+    "version:patch": "pnpm version patch --no-git-tag-version"
+  }
+}