create-rasti 0.0.1

package/src/apply/index.js

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { applyBase } from './base.js';
+import { applySsr } from './ssr.js';
+import { applyStatic } from './static.js';
+import { applyTailwind } from './tailwind.js';
+import { applyCssfun } from './cssfun.js';
+import { applyIcons } from './icons.js';
+import { applyRouter } from './router.js';
+import { applyFeaturesInclude } from './featuresInclude.js';
+import { getBaseContext } from './description.js';
+import { copyTemplateFile } from '../utils/template.js';
+import { createSpinner, log } from '../utils/logger.js';
+
+const RASTI_AGENTS_MD_URL = 'https://raw.githubusercontent.com/8tentaculos/rasti/master/docs/AGENTS.md';
+
+/**
+ * Fetch Rasti AGENTS.md and write to project root as AGENTS-RASTI.md.
+ * @param {string} targetDir - Project root directory
+ */
+async function fetchRastiAgentsMd(targetDir) {
+    const res = await fetch(RASTI_AGENTS_MD_URL);
+    if (!res.ok) throw new Error(`Failed to fetch AGENTS-RASTI.md: ${res.status}`);
+    const text = await res.text();
+    await fs.writeFile(path.join(targetDir, 'AGENTS-RASTI.md'), text, 'utf-8');
+}
+
+/**
+ * Apply a project plan by copying templates and applying features.
+ * @param {object} plan - Project plan object
+ */
+export async function applyPlan(plan) {
+    const targetDir = path.resolve(process.cwd(), plan.name);
+    const spinner = createSpinner();
+
+    const ctx = {
+        plan,
+        targetDir,
+        spinner
+    };
+
+    try {
+        spinner.start('Creating project...');
+
+        if (plan.base === 'ssr' || plan.base === 'static') {
+            await applySsr(ctx);
+            if (plan.base === 'static') {
+                await applyStatic(ctx);
+            }
+        } else {
+            await applyBase(ctx);
+        }
+
+        spinner.stop('Project created');
+
+        if (plan.features.tailwind) {
+            spinner.start('Adding Tailwind CSS...');
+            await applyTailwind(ctx);
+            spinner.stop('Tailwind CSS added');
+        }
+
+        if (plan.features.cssfun) {
+            spinner.start('Adding CSSFUN...');
+            await applyCssfun(ctx);
+            spinner.stop('CSSFUN added');
+        }
+
+        if (plan.features.router) {
+            spinner.start('Adding micro-router...');
+            await applyRouter(ctx);
+            spinner.stop('micro-router added');
+        }
+
+        if (plan.features.icons) {
+            const iconLabel = plan.features.icons.join(', ');
+            spinner.start(`Adding rasti-icons (${iconLabel})...`);
+            await applyIcons(ctx);
+            spinner.stop('rasti-icons added');
+        }
+
+        spinner.start('Writing features list...');
+        await applyFeaturesInclude(ctx);
+        spinner.stop('Features list written');
+
+        spinner.start('Writing AGENTS.md...');
+        const agentsContext = {
+            ...getBaseContext(plan),
+            SSR : (plan.base === 'ssr' || plan.base === 'static') ? 'true' : '',
+            STATIC : plan.base === 'static' ? 'true' : '',
+            TAILWIND : plan.features.tailwind ? 'true' : '',
+            CSSFUN : plan.features.cssfun   ? 'true' : '',
+            ROUTER : plan.features.router   ? 'true' : '',
+            ICONS : plan.features.icons    ? 'true' : '',
+        };
+        await copyTemplateFile('AGENTS.md', path.join(ctx.targetDir, 'AGENTS.md'), agentsContext);
+        spinner.stop('AGENTS.md written');
+
+        spinner.start('Adding Rasti AGENTS.md...');
+        try {
+            await fetchRastiAgentsMd(ctx.targetDir);
+            spinner.stop('Rasti AGENTS.md added');
+        } catch {
+            spinner.stop('Could not fetch Rasti AGENTS.md (offline?) — skipped');
+        }
+
+        logSummary(plan);
+
+    } catch (error) {
+        spinner.stop('Failed');
+        throw error;
+    }
+}
+
+/**
+ * Log a summary of what was created.
+ * @param {object} plan - Project plan object
+ */
+function logSummary(plan) {
+    const features = [];
+
+    if (plan.features.tailwind) features.push('Tailwind CSS');
+    if (plan.features.cssfun) features.push('CSSFUN');
+    if (plan.features.icons) {
+        features.push(`rasti-icons (${plan.features.icons.join(', ')})`);
+    }
+    if (plan.features.router) features.push('micro-router');
+
+    const featureList = features.length > 0
+        ? `\n  Features: ${features.join(', ')}`
+        : '';
+
+    const templateLabel = plan.base === 'static' ? 'Static (SSR + static build)' : plan.base.toUpperCase();
+    log.info(`Project: ${plan.name}\n  Template: ${templateLabel}${featureList}`);
+}

package/src/apply/router.js

@@ -0,0 +1,50 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { copyTemplateFile, copyStyledTemplate, copyExtraFile } from '../utils/template.js';
+import { addDependencies } from '../utils/pkg.js';
+import { getBaseContext } from './description.js';
+import { VERSIONS } from '../versions.js';
+
+/**
+ * Build the template context for router-related files.
+ * @param {object} plan - Project plan
+ * @returns {object} Template placeholder values
+ */
+function getRouterContext(plan) {
+    const routeAbout = plan.base === 'static' ? '/about/' : '/about';
+    return {
+        ...getBaseContext(plan),
+        ROUTE_ABOUT : routeAbout,
+        CSSFUN : plan.features.cssfun ? 'true' : '',
+        TAILWIND : plan.features.tailwind ? 'true' : '',
+        ROUTER : 'true'
+    };
+}
+
+export async function applyRouter(ctx) {
+    const { plan, targetDir } = ctx;
+    const context = getRouterContext(plan);
+
+    await addDependencies(targetDir, { dependencies : { 'path-to-regexp' : VERSIONS.pathToRegexp } });
+
+    await copyExtraFile('micro-router/src/index.js', path.join(targetDir, 'src', 'lib', 'router.js'));
+
+    await copyTemplateFile('_extras/router/router-setup.js', path.join(targetDir, 'src', 'router-setup.js'), context);
+
+    const componentsDir = path.join(targetDir, 'src', 'components');
+    await fs.mkdir(componentsDir, { recursive : true });
+    await copyStyledTemplate('_extras/router/components/About.js', path.join(componentsDir, 'About.js'), context, plan);
+
+    if (!plan.features.cssfun) {
+        const stylePath = path.join(targetDir, 'src', 'style.css');
+        try {
+            let css = await fs.readFile(stylePath, 'utf-8');
+            if (!css.includes('.nav')) {
+                css += '\n.nav { display: flex; gap: 1rem; }\n';
+                await fs.writeFile(stylePath, css, 'utf-8');
+            }
+        } catch {
+            // no style.css (e.g. tailwind replaces it)
+        }
+    }
+}

package/src/apply/ssr.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { copyTemplateDir, copyTemplateFile, copyStyledTemplate, copyExtraFile } from '../utils/template.js';
+import { updatePackageName } from '../utils/pkg.js';
+import { getBaseContext } from './description.js';
+
+/**
+ * Apply the SSR base template.
+ * @param {object} ctx - Context object with plan and targetDir
+ */
+export async function applySsr(ctx) {
+    const { plan, targetDir } = ctx;
+    const routeAbout = plan.base === 'static' ? '/about/' : '/about';
+    const context = {
+        ...getBaseContext(plan),
+        CSSFUN : plan.features.cssfun ? 'true' : '',
+        TAILWIND : plan.features.tailwind ? 'true' : '',
+        ROUTER : plan.features.router ? 'true' : '',
+        ROUTE_ABOUT : routeAbout
+    };
+
+    await copyTemplateDir('ssr', targetDir, context);
+    await copyStyledTemplate('_base/App.js', path.join(targetDir, 'src', 'App.js'), context, plan);
+    await copyStyledTemplate('_base/components/Button.js', path.join(targetDir, 'src', 'components', 'Button.js'), context, plan);
+    await copyStyledTemplate('_base/components/Home.js', path.join(targetDir, 'src', 'components', 'Home.js'), context, plan);
+    await copyStyledTemplate('_base/components/Header.js', path.join(targetDir, 'src', 'components', 'Header.js'), context, plan);
+    await copyTemplateFile('_base/style.css', path.join(targetDir, 'src', 'style.css'), context);
+    await copyExtraFile('cn/src/index.js', path.join(targetDir, 'src', 'lib', 'cn.js'));
+    await updatePackageName(targetDir, plan.name);
+}

package/src/apply/static.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import { copyTemplateFile } from '../utils/template.js';
+import { mergeScripts } from '../utils/pkg.js';
+
+/**
+ * Build STATIC_ROUTES placeholder value for static.config.js.
+ * @param {object} plan - Project plan
+ * @returns {string} Lines for the array (e.g. "  '/',\n  '/about/',\n")
+ */
+function getStaticRoutes(plan) {
+    if (plan.features.router) {
+        return '    \'/\',\n    \'/about/\',\n';
+    }
+    return '    \'/\',\n';
+}
+
+/**
+ * Apply static overlay: static.config.js, build script, package.json scripts.
+ * @param {object} ctx - Context with plan and targetDir
+ */
+export async function applyStatic(ctx) {
+    const { plan, targetDir } = ctx;
+
+    const staticRoutes = getStaticRoutes(plan);
+    await copyTemplateFile(
+        'static/static.config.js',
+        path.join(targetDir, 'static.config.js'),
+        { STATIC_ROUTES : staticRoutes }
+    );
+
+    await copyTemplateFile(
+        'static/scripts/build-static.js',
+        path.join(targetDir, 'scripts', 'build-static.js'),
+        {}
+    );
+    await copyTemplateFile(
+        'static/scripts/serve-static.js',
+        path.join(targetDir, 'scripts', 'serve-static.js'),
+        {}
+    );
+
+    await mergeScripts(targetDir, {
+        'build:static' : 'npm run build && node scripts/build-static.js',
+        'preview:static' : 'node scripts/serve-static.js'
+    });
+}

package/src/apply/tailwind.js

@@ -0,0 +1,33 @@
+import path from 'node:path';
+import { copyTemplateFile } from '../utils/template.js';
+import { addDependencies } from '../utils/pkg.js';
+import { VERSIONS } from '../versions.js';
+
+/**
+ * Apply Tailwind CSS to the project.
+ * @param {object} ctx - Context object with plan and targetDir
+ */
+export async function applyTailwind(ctx) {
+    const { targetDir } = ctx;
+
+    await addDependencies(targetDir, {
+        devDependencies : {
+            '@tailwindcss/vite' : VERSIONS.tailwindVite,
+            'tailwindcss' : VERSIONS.tailwindcss
+        }
+    });
+
+    // Copy Tailwind style.css (overwrites base style.css)
+    await copyTemplateFile(
+        '_features/tailwind/style.css',
+        path.join(targetDir, 'src', 'style.css'),
+        {}
+    );
+
+    // Copy Tailwind vite.config.js (overwrites base vite.config.js)
+    await copyTemplateFile(
+        '_features/tailwind/vite.config.js',
+        path.join(targetDir, 'vite.config.js'),
+        {}
+    );
+}

package/src/args.js

@@ -0,0 +1,55 @@
+import { DEFAULT_PRESET } from '../extras/rasti-icons/src/presets.js';
+
+/**
+ * Parse command line arguments without external dependencies.
+ * Supports flags (--flag) and positional arguments.
+ * @param {string[]} argv - Command line arguments (process.argv.slice(2))
+ * @returns {object} Parsed arguments object
+ */
+export function parseArgs(argv) {
+    const args = {
+        name : null,
+        ssr : false,
+        static : false,
+        tailwind : false,
+        cssfun : false,
+        icons : null,
+        router : false,
+        help : false
+    };
+
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+
+        if (arg === '--help' || arg === '-h') {
+            args.help = true;
+        } else if (arg === '--ssr') {
+            args.ssr = true;
+        } else if (arg === '--static') {
+            args.static = true;
+        } else if (arg === '--tailwind') {
+            args.tailwind = true;
+        } else if (arg === '--cssfun') {
+            args.cssfun = true;
+        } else if (arg === '--icons') {
+            if (!args.icons) args.icons = [];
+            const next = argv[i + 1];
+            if (next && !next.startsWith('-')) {
+                const parts = next.split(',').map(s => s.trim()).filter(Boolean);
+                args.icons.push(...parts);
+                i++;
+            } else {
+                args.icons.push(DEFAULT_PRESET);
+            }
+        } else if (arg === '--router') {
+            args.router = true;
+        } else if (!arg.startsWith('-')) {
+            // Positional argument - project name
+            if (!args.name) {
+                args.name = arg;
+            }
+        }
+    }
+
+    return args;
+}

package/src/cli.js

@@ -0,0 +1,91 @@
+import { parseArgs } from './args.js';
+import { runPrompts } from './prompts.js';
+import { createPlan } from './plan.js';
+import { validatePlan } from './validate.js';
+import { applyPlan } from './apply/index.js';
+import { log, intro, outro } from './utils/logger.js';
+import { DEFAULT_PRESET, PRESET_IDS } from '../extras/rasti-icons/src/presets.js';
+
+/**
+ * Main entry point for the CLI.
+ * Handles both flag-based and interactive modes.
+ * @param {string[]} argv - Command line arguments
+ */
+export async function run(argv) {
+    try {
+        intro();
+
+        const args = parseArgs(argv);
+
+        if (args.help) {
+            showHelp();
+            return;
+        }
+
+        const needsPrompts = !args.name;
+
+        let options;
+        if (needsPrompts) {
+            options = await runPrompts(args);
+            if (!options) return; // User cancelled
+        } else {
+            options = args;
+        }
+
+        const plan = createPlan(options);
+        const validation = validatePlan(plan);
+
+        if (!validation.valid) {
+            log.error(validation.error);
+            process.exit(1);
+        }
+
+        await applyPlan(plan);
+
+        outro(plan.name, plan.packageManager);
+    } catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}
+
+/**
+ * Show help message.
+ */
+function showHelp() {
+    const presetList = PRESET_IDS.join(', ');
+
+    console.log(`
+create-rasti - Create Rasti + Vite projects
+
+Usage:
+  npm create rasti [project-name] [options]
+
+Options:
+  --ssr        Use SSR template instead of SPA
+  --static     Use Static template (SSR + pre-rendered static build)
+  --tailwind   Add Tailwind CSS
+  --cssfun     Add CSSFUN (CSS-in-JS with light and dark themes)
+  --icons [sets]     Add rasti-icons (preset ids: ${DEFAULT_PRESET} (default), ${presetList}).
+                     Repeat flag or use comma-separated list. Multiple sets are written under src/icons/<preset>/ each;
+                     a single set uses src/icons/ directly.
+  --router     Add micro-router (universal router, two pages and links)
+  --help       Show this help message
+
+Examples:
+  npm create rasti                     # Interactive mode
+  npm create rasti my-app              # Create SPA project
+  npm create rasti my-app --ssr        # Create SSR project
+  npm create rasti my-app --static     # Create static site (SSR + static build)
+  npm create rasti my-app --tailwind   # Create SPA with Tailwind
+  npm create rasti my-app --icons                       # SPA with ${DEFAULT_PRESET} in src/icons
+  npm create rasti my-app --icons heroicons-outline     # SPA with heroicons-outline in src/icons
+  npm create rasti my-app --icons akar-icons            # SPA with akar-icons in src/icons
+  npm create rasti my-app --icons feathericon           # SPA with feathericon in src/icons
+  npm create rasti my-app --icons pixelarticons         # SPA with pixelarticons in src/icons
+  npm create rasti my-app --icons heroicons-solid,heroicons-outline  # Multiple sets in subfolders under src/icons
+  npm create rasti my-app --router     # SPA with two pages and universal router
+
+Note: --tailwind and --cssfun are mutually exclusive.
+`);
+}

package/src/plan.js

@@ -0,0 +1,33 @@
+import { detectPackageManager } from './utils/exec.js';
+
+/**
+ * Normalize icons option to false or a deduped preset id array.
+ * @param {string|string[]|false|null|undefined} icons
+ * @returns {false|string[]}
+ */
+function normalizeIconSets(icons) {
+    if (icons == null || icons === false) return false;
+    const arr = Array.isArray(icons) ? icons : [icons];
+    const deduped = [...new Set(arr)];
+    return deduped.length ? deduped : false;
+}
+
+/**
+ * Create a project plan from user options.
+ * @param {object} options - User options from args or prompts
+ * @returns {object} Project plan object
+ */
+export function createPlan(options) {
+    const base = options.static ? 'static' : (options.ssr ? 'ssr' : 'spa');
+    return {
+        name : options.name,
+        base,
+        features : {
+            tailwind : options.tailwind || false,
+            cssfun : options.cssfun || false,
+            icons : normalizeIconSets(options.icons),
+            router : options.router || false
+        },
+        packageManager : detectPackageManager()
+    };
+}

package/src/prompts.js

@@ -0,0 +1,116 @@
+import * as p from '@clack/prompts';
+import { DEFAULT_PRESET, PRESET_OPTIONS } from '../extras/rasti-icons/src/presets.js';
+
+/**
+ * Run interactive prompts to gather project options.
+ * @param {object} defaults - Default values from command line args
+ * @returns {Promise<object|null>} Options object or null if cancelled
+ */
+export async function runPrompts(defaults = {}) {
+    const options = { ...defaults };
+
+    // Project name
+    const name = await p.text({
+        message : 'Project name',
+        placeholder : 'my-rasti-app',
+        validate : (value) => {
+            if (!value) return 'Project name is required';
+            if (!/^[a-z0-9-_]+$/i.test(value)) {
+                return 'Project name can only contain letters, numbers, dashes and underscores';
+            }
+        }
+    });
+
+    if (p.isCancel(name)) {
+        p.cancel('Operation cancelled.');
+        return null;
+    }
+
+    options.name = name;
+
+    // Template base
+    const base = await p.select({
+        message : 'Select template',
+        options : [
+            { value : 'spa', label : 'SPA', hint : 'Single Page Application' },
+            { value : 'ssr', label : 'SSR', hint : 'Server-Side Rendering' },
+            { value : 'static', label : 'Static', hint : 'Pre-rendered static site (SSR + static build)' }
+        ],
+        initialValue : defaults.static ? 'static' : (defaults.ssr ? 'ssr' : 'spa')
+    });
+
+    if (p.isCancel(base)) {
+        p.cancel('Operation cancelled.');
+        return null;
+    }
+
+    options.ssr = base === 'ssr' || base === 'static';
+    options.static = base === 'static';
+
+    // Styling option
+    const styling = await p.select({
+        message : 'Select styling',
+        options : [
+            { value : 'none', label : 'None', hint : 'Plain CSS' },
+            { value : 'tailwind', label : 'Tailwind CSS', hint : 'Utility-first CSS' },
+            { value : 'cssfun', label : 'CSSFUN', hint : 'CSS-in-JS with light and dark themes' }
+        ],
+        initialValue : defaults.tailwind ? 'tailwind' : defaults.cssfun ? 'cssfun' : 'none'
+    });
+
+    if (p.isCancel(styling)) {
+        p.cancel('Operation cancelled.');
+        return null;
+    }
+
+    options.tailwind = styling === 'tailwind';
+    options.cssfun = styling === 'cssfun';
+
+    // Router
+    const router = await p.confirm({
+        message : 'Add micro-router?',
+        initialValue : defaults.router || false
+    });
+
+    if (p.isCancel(router)) {
+        p.cancel('Operation cancelled.');
+        return null;
+    }
+
+    options.router = router;
+
+    // Icons
+    const addIcons = await p.confirm({
+        message : 'Add icon components?',
+        initialValue : !!defaults.icons
+    });
+
+    if (p.isCancel(addIcons)) {
+        p.cancel('Operation cancelled.');
+        return null;
+    }
+
+    if (addIcons) {
+        const initialIconSets = Array.isArray(defaults.icons)
+            ? defaults.icons
+            : (defaults.icons ? [defaults.icons] : [DEFAULT_PRESET]);
+
+        const iconsets = await p.multiselect({
+            message : 'Which icon sets?',
+            options : PRESET_OPTIONS,
+            initialValues : initialIconSets,
+            required : true
+        });
+
+        if (p.isCancel(iconsets)) {
+            p.cancel('Operation cancelled.');
+            return null;
+        }
+
+        options.icons = iconsets;
+    } else {
+        options.icons = null;
+    }
+
+    return options;
+}

package/src/utils/copy.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * Write content to a file, creating directories if needed.
+ * @param {string} filePath - Path to the file
+ * @param {string} content - Content to write
+ */
+export async function writeFile(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive : true });
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+
+/**
+ * Read content from a file.
+ * @param {string} filePath - Path to the file
+ * @returns {Promise<string>} File content
+ */
+export async function readFile(filePath) {
+    return fs.readFile(filePath, 'utf-8');
+}