muscle-config 1.0.0

package/dist/features/css.feature.js

@@ -0,0 +1,107 @@
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { spinner } from "../utils/spinner.js";
+import { logger } from "../utils/logger.js";
+import { generateCssReset, generateCssVariables, generateCssTypography, generateCssIndex, generateCssIndexWithImports, generateCssThemeToggle, } from "../generators/css-plain.generator.js";
+import { saveSnapshot, restoreSnapshots, rollbackFeature, } from "../utils/rollback.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function cssFeature(config) {
+    return {
+        name: "css",
+        async run(projectPath) {
+            try {
+                if (config.mode === "skip") {
+                    logger.info("Skipping CSS configuration — using Vite default.");
+                    return;
+                }
+                /**
+                 * STEP 1
+                 * Detect TypeScript or JavaScript
+                 */
+                const tsConfigPath = path.join(projectPath, "vite.config.ts");
+                let isTypeScript = false;
+                try {
+                    await fs.access(tsConfigPath);
+                    isTypeScript = true;
+                }
+                catch { }
+                /**
+                 * STEP 2
+                 * Generate CSS files — separate files or single file mode
+                 */
+                if (config.separateFiles) {
+                    spinner.start("Generating CSS files...");
+                    const stylesDir = path.join(projectPath, "src/styles");
+                    await fs.mkdir(stylesDir, { recursive: true });
+                    if (config.reset) {
+                        await fs.writeFile(path.join(stylesDir, "reset.css"), generateCssReset());
+                    }
+                    await fs.writeFile(path.join(stylesDir, "variables.css"), generateCssVariables(config));
+                    await fs.writeFile(path.join(stylesDir, "typography.css"), generateCssTypography(config));
+                    spinner.succeed("CSS files generated!");
+                    /**
+                     * STEP 3 (separate files)
+                     * Overwrite src/index.css with @import statements pointing to styles/
+                     */
+                    spinner.start("Updating main CSS entry...");
+                    const mainCssPath = path.join(projectPath, "src/index.css");
+                    await saveSnapshot(mainCssPath);
+                    await fs.writeFile(mainCssPath, generateCssIndexWithImports(config));
+                    spinner.succeed("Main CSS entry updated!");
+                }
+                else {
+                    /**
+                     * STEP 2 (single file)
+                     * Overwrite src/index.css with all generated styles inline
+                     */
+                    spinner.start("Generating CSS styles...");
+                    const mainCssPath = path.join(projectPath, "src/index.css");
+                    await saveSnapshot(mainCssPath);
+                    await fs.writeFile(mainCssPath, generateCssIndex(config));
+                    spinner.succeed("CSS styles generated!");
+                }
+                /**
+                 * STEP 4
+                 * Generate ThemeToggle component if class dark mode + toggle selected
+                 */
+                if (config.darkModeToggle) {
+                    spinner.start("Creating ThemeToggle component...");
+                    const componentDir = path.join(projectPath, "src/components");
+                    await fs.mkdir(componentDir, { recursive: true });
+                    const toggleFile = path.join(componentDir, isTypeScript ? "ThemeToggle.tsx" : "ThemeToggle.jsx");
+                    await fs.writeFile(toggleFile, generateCssThemeToggle(isTypeScript));
+                    spinner.succeed("ThemeToggle component created!");
+                }
+                /**
+                 * STEP 5
+                 * Copy demo App template if user selected it
+                 */
+                if (config.demo) {
+                    spinner.start("Copying CSS demo template...");
+                    const templateDir = path.join(__dirname, "../templates/react/css");
+                    const appTemplatePath = path.join(templateDir, isTypeScript ? "App.tsx" : "App.jsx");
+                    const appTargetPath = path.join(projectPath, isTypeScript ? "src/App.tsx" : "src/App.jsx");
+                    await fs.copyFile(appTemplatePath, appTargetPath);
+                    spinner.succeed("Demo template copied!");
+                }
+                /**
+                 * FINAL SUCCESS MESSAGE
+                 */
+                logger.success("CSS setup complete!");
+            }
+            catch (error) {
+                spinner.fail("Failed to setup CSS.");
+                await restoreSnapshots();
+                await rollbackFeature([
+                    path.join(projectPath, "src/styles"),
+                    path.join(projectPath, "src/components/ThemeToggle.tsx"),
+                    path.join(projectPath, "src/components/ThemeToggle.jsx"),
+                    path.join(projectPath, "src/App.tsx"),
+                    path.join(projectPath, "src/App.jsx"),
+                ]);
+                throw error;
+            }
+        },
+    };
+}

package/dist/features/feature.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/features/git.feature.js

@@ -0,0 +1,52 @@
+import { execa } from "execa";
+import { spinner } from "../utils/spinner.js";
+import { logger } from "../utils/logger.js";
+import { rollbackFeature } from "../utils/rollback.js";
+import path from "path";
+export function gitFeature(config) {
+    return {
+        name: "git",
+        async run(projectPath) {
+            try {
+                if (!config.init) {
+                    logger.info("Skipping Git initialization.");
+                    return;
+                }
+                /**
+                 * STEP 1
+                 * Initialize a new Git repository in the project folder
+                 */
+                spinner.start("Initializing Git repository...");
+                await execa("git", ["init"], { cwd: projectPath });
+                spinner.succeed("Git repository initialized!");
+                if (!config.initialCommit)
+                    return;
+                /**
+                 * STEP 2
+                 * Stage all generated files
+                 */
+                spinner.start("Staging files...");
+                await execa("git", ["add", "."], { cwd: projectPath });
+                spinner.succeed("Files staged!");
+                /**
+                 * STEP 3
+                 * Create the initial commit with a hardcoded conventional message
+                 */
+                spinner.start("Creating initial commit...");
+                await execa("git", ["commit", "-m", "chore: initial commit"], {
+                    cwd: projectPath,
+                });
+                spinner.succeed("Initial commit created!");
+                /**
+                 * FINAL SUCCESS MESSAGE
+                 */
+                logger.success("Git setup complete!");
+            }
+            catch (error) {
+                spinner.fail("Failed to setup Git.");
+                await rollbackFeature([path.join(projectPath, ".git")]);
+                throw error;
+            }
+        },
+    };
+}

package/dist/features/mui.feature.js

@@ -0,0 +1,138 @@
+import { execa } from "execa";
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { spinner } from "../utils/spinner.js";
+import { logger } from "../utils/logger.js";
+import { generateMuiTheme, generateMuiThemeToggle, generateThemeContextProvider, generateAppMuiThemeProvider, generateMuiMain, generateMuiIndexCss, } from "../generators/mui.generator.js";
+import { restoreSnapshots, rollbackFeature, saveSnapshot, } from "../utils/rollback.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function muiFeature(config) {
+    return {
+        name: "mui",
+        async run(projectPath) {
+            try {
+                /**
+                 * STEP 1
+                 * Detect TypeScript or JavaScript
+                 */
+                const tsConfigPath = path.join(projectPath, "vite.config.ts");
+                let isTypeScript = false;
+                try {
+                    await fs.access(tsConfigPath);
+                    isTypeScript = true;
+                }
+                catch { }
+                /**
+                 * STEP 2
+                 * Install MUI core + emotion peer deps
+                 */
+                spinner.start("Installing MUI...");
+                await execa("npm", ["install", "@mui/material", "@emotion/react", "@emotion/styled"], { cwd: projectPath });
+                spinner.succeed("MUI installed!");
+                /**
+                 * STEP 3
+                 * Install MUI Icons if selected or needed for ThemeToggle
+                 */
+                if (config.icons || config.darkModeToggle) {
+                    spinner.start("Installing MUI Icons...");
+                    await execa("npm", ["install", "@mui/icons-material"], {
+                        cwd: projectPath,
+                    });
+                    spinner.succeed("MUI Icons installed!");
+                }
+                /**
+                 * STEP 4
+                 * Generate src/themes/theme.ts or theme.js
+                 */
+                spinner.start("Generating MUI theme...");
+                const themesDir = path.join(projectPath, "src/themes");
+                await fs.mkdir(themesDir, { recursive: true });
+                const themeFile = path.join(themesDir, isTypeScript ? "theme.ts" : "theme.js");
+                await fs.writeFile(themeFile, generateMuiTheme(config, isTypeScript));
+                spinner.succeed("MUI theme generated!");
+                /**
+                 * STEP 5
+                 * Apply font to src/index.css if a font was selected
+                 */
+                if (config.font !== "none") {
+                    spinner.start("Applying font...");
+                    const indexCssPath = path.join(projectPath, "src/index.css");
+                    await saveSnapshot(indexCssPath);
+                    await fs.writeFile(indexCssPath, generateMuiIndexCss(config));
+                    spinner.succeed("Font applied!");
+                }
+                /**
+                 * STEP 6
+                 * Generate src/context/ThemeContextProvider
+                 */
+                spinner.start("Generating ThemeContextProvider...");
+                const contextDir = path.join(projectPath, "src/context");
+                await fs.mkdir(contextDir, { recursive: true });
+                const contextFile = path.join(contextDir, isTypeScript
+                    ? "ThemeContextProvider.tsx"
+                    : "ThemeContextProvider.jsx");
+                await fs.writeFile(contextFile, generateThemeContextProvider(config, isTypeScript));
+                spinner.succeed("ThemeContextProvider generated!");
+                /**
+                 * STEP 7
+                 * Generate src/themes/AppMuiThemeProvider
+                 */
+                spinner.start("Generating AppMuiThemeProvider...");
+                const providerFile = path.join(themesDir, isTypeScript ? "AppMuiThemeProvider.tsx" : "AppMuiThemeProvider.jsx");
+                await fs.writeFile(providerFile, generateAppMuiThemeProvider(isTypeScript));
+                spinner.succeed("AppMuiThemeProvider generated!");
+                /**
+                 * STEP 8
+                 * Generate ThemeToggle component if dark mode toggle selected
+                 */
+                if (config.darkModeToggle) {
+                    spinner.start("Creating ThemeToggle component...");
+                    const componentDir = path.join(projectPath, "src/components");
+                    await fs.mkdir(componentDir, { recursive: true });
+                    const toggleFile = path.join(componentDir, isTypeScript ? "ThemeToggle.tsx" : "ThemeToggle.jsx");
+                    await fs.writeFile(toggleFile, generateMuiThemeToggle());
+                    spinner.succeed("ThemeToggle component created!");
+                }
+                /**
+                 * STEP 9
+                 * Overwrite main.tsx / main.jsx with provider composition
+                 */
+                spinner.start("Configuring main entry point...");
+                const mainFile = path.join(projectPath, isTypeScript ? "src/main.tsx" : "src/main.jsx");
+                await saveSnapshot(mainFile);
+                await fs.writeFile(mainFile, generateMuiMain(isTypeScript));
+                spinner.succeed("Main entry point configured!");
+                /**
+                 * STEP 10
+                 * Copy demo App template if user selected it
+                 */
+                if (config.demo) {
+                    spinner.start("Copying MUI demo template...");
+                    const templateDir = path.join(__dirname, "../templates/react/mui");
+                    const appTemplatePath = path.join(templateDir, isTypeScript ? "App.tsx" : "App.jsx");
+                    const appTargetPath = path.join(projectPath, isTypeScript ? "src/App.tsx" : "src/App.jsx");
+                    await fs.copyFile(appTemplatePath, appTargetPath);
+                    spinner.succeed("Demo template copied!");
+                }
+                /**
+                 * FINAL SUCCESS MESSAGE
+                 */
+                logger.success("MUI added successfully!");
+            }
+            catch (error) {
+                spinner.fail("Failed to setup MUI.");
+                await restoreSnapshots();
+                await rollbackFeature([
+                    path.join(projectPath, "src/themes"),
+                    path.join(projectPath, "src/context"),
+                    path.join(projectPath, "src/components/ThemeToggle.tsx"),
+                    path.join(projectPath, "src/components/ThemeToggle.jsx"),
+                    path.join(projectPath, "src/App.tsx"),
+                    path.join(projectPath, "src/App.jsx"),
+                ]);
+                throw error;
+            }
+        },
+    };
+}

package/dist/features/prettier.feature.js

@@ -0,0 +1,73 @@
+import fs from "fs/promises";
+import path from "path";
+import { spinner } from "../utils/spinner.js";
+import { logger } from "../utils/logger.js";
+import { installPackages } from "../utils/install.js";
+import { rollbackFeature } from "../utils/rollback.js";
+export function prettierFeature(config) {
+    return {
+        name: "prettier",
+        async run(projectPath) {
+            try {
+                if (!config.enabled) {
+                    logger.info("Skipping Prettier setup.");
+                    return;
+                }
+                /**
+                 * STEP 1
+                 * Install Prettier
+                 */
+                spinner.start("Installing Prettier...");
+                await installPackages(["prettier"], projectPath, true);
+                spinner.succeed("Prettier installed!");
+                /**
+                 * STEP 2
+                 * Build the Prettier config object from user choices
+                 */
+                const prettierConfig = {
+                    singleQuote: config.singleQuote,
+                    semi: config.semi,
+                    tabWidth: config.tabWidth,
+                };
+                /**
+                 * STEP 3
+                 * Check if .prettierrc already exists (Tailwind plugin case)
+                 * If yes — read it and merge, preserving the plugins array
+                 * If no  — create fresh
+                 */
+                const prettierrcPath = path.join(projectPath, ".prettierrc");
+                let existingConfig = {};
+                try {
+                    const raw = await fs.readFile(prettierrcPath, "utf-8");
+                    existingConfig = JSON.parse(raw);
+                }
+                catch {
+                    // file doesn't exist — start fresh
+                }
+                const merged = { ...prettierConfig, ...existingConfig };
+                spinner.start("Writing .prettierrc...");
+                await fs.writeFile(prettierrcPath, JSON.stringify(merged, null, 2));
+                spinner.succeed(".prettierrc written!");
+                /**
+                 * STEP 4
+                 * Create .prettierignore
+                 */
+                spinner.start("Creating .prettierignore...");
+                await fs.writeFile(path.join(projectPath, ".prettierignore"), ["node_modules", "dist", "build", ""].join("\n"));
+                spinner.succeed(".prettierignore created!");
+                /**
+                 * FINAL SUCCESS MESSAGE
+                 */
+                logger.success("Prettier setup complete!");
+            }
+            catch (error) {
+                spinner.fail("Failed to setup Prettier.");
+                await rollbackFeature([
+                    path.join(projectPath, ".prettierrc"),
+                    path.join(projectPath, ".prettierignore"),
+                ]);
+                throw error;
+            }
+        },
+    };
+}

package/dist/features/tailwind.feature.js

@@ -0,0 +1,116 @@
+import { execa } from "execa";
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { spinner } from "../utils/spinner.js";
+import { logger } from "../utils/logger.js";
+import { generateIndexCss } from "../generators/css.generator.js";
+import { generateThemeToggle } from "../generators/toggle.generator.js";
+import { generateTailwindConfig } from "../generators/tailwind.config.generator.js";
+import { restoreSnapshots, rollbackFeature, saveSnapshot, } from "../utils/rollback.js";
+import { installPackages } from "../utils/install.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function tailwindFeature(config) {
+    return {
+        name: "tailwind",
+        async run(projectPath) {
+            try {
+                /**
+                 * STEP 1
+                 * Install Tailwind v4 and the Vite plugin
+                 */
+                spinner.start("Installing Tailwind v4...");
+                await execa("npm", ["install", "tailwindcss", "@tailwindcss/vite", "--legacy-peer-deps"], { cwd: projectPath });
+                spinner.succeed("Tailwind installed!");
+                /**
+                 * STEP 2
+                 * Detect TypeScript or JavaScript
+                 */
+                const tsConfigPath = path.join(projectPath, "vite.config.ts");
+                const jsConfigPath = path.join(projectPath, "vite.config.js");
+                let viteConfigPath;
+                let isTypeScript = false;
+                try {
+                    await fs.access(tsConfigPath);
+                    viteConfigPath = tsConfigPath;
+                    isTypeScript = true;
+                }
+                catch {
+                    try {
+                        await fs.access(jsConfigPath);
+                        viteConfigPath = jsConfigPath;
+                    }
+                    catch {
+                        throw new Error("Could not find vite.config.ts or vite.config.js");
+                    }
+                }
+                /**
+                 * STEP 3
+                 * Copy the Vite config template that includes the Tailwind plugin
+                 */
+                spinner.start("Configuring Vite...");
+                const templateDir = path.join(__dirname, "../templates/react/tailwind-v4");
+                const viteTemplatePath = path.join(templateDir, isTypeScript ? "vite.config.ts" : "vite.config.js");
+                await fs.copyFile(viteTemplatePath, viteConfigPath);
+                spinner.succeed("Vite configured!");
+                /**
+                 * STEP 4
+                 * Generate tailwind.config based on user choices
+                 */
+                spinner.start("Generating Tailwind config...");
+                const tailwindConfigPath = path.join(projectPath, isTypeScript ? "tailwind.config.ts" : "tailwind.config.js");
+                await fs.writeFile(tailwindConfigPath, generateTailwindConfig(config));
+                spinner.succeed("Tailwind config generated!");
+                /**
+                 * STEP 5
+                 * Generate src/index.css with font, colors, and dark mode setup
+                 */
+                spinner.start("Generating Tailwind styles...");
+                const cssPath = path.join(projectPath, "src/index.css");
+                await saveSnapshot(cssPath);
+                await fs.writeFile(cssPath, generateIndexCss(config));
+                spinner.succeed("Tailwind styles generated!");
+                /**
+                 * STEP 6
+                 * Generate ThemeToggle component if user selected dark mode toggle
+                 */
+                if (config.darkModeToggle) {
+                    spinner.start("Creating ThemeToggle component...");
+                    const componentDir = path.join(projectPath, "src/components");
+                    await fs.mkdir(componentDir, { recursive: true });
+                    const toggleFile = path.join(componentDir, isTypeScript ? "ThemeToggle.tsx" : "ThemeToggle.jsx");
+                    await fs.writeFile(toggleFile, generateThemeToggle(isTypeScript));
+                    spinner.succeed("ThemeToggle component created!");
+                }
+                /**
+                 * STEP 7
+                 * Install Prettier + Tailwind class sorting plugin if selected
+                 */
+                if (config.prettierTailwind) {
+                    spinner.start("Installing Prettier + Tailwind plugin...");
+                    await installPackages(["prettier", "prettier-plugin-tailwindcss"], projectPath, true);
+                    spinner.succeed("Prettier installed!");
+                    spinner.start("Creating .prettierrc...");
+                    await fs.writeFile(path.join(projectPath, ".prettierrc"), JSON.stringify({ plugins: ["prettier-plugin-tailwindcss"] }, null, 2));
+                    spinner.succeed(".prettierrc created!");
+                }
+                /**
+                 * FINAL SUCCESS MESSAGE
+                 */
+                logger.success("Tailwind v4 added successfully!");
+            }
+            catch (error) {
+                spinner.fail("Failed to setup Tailwind.");
+                await restoreSnapshots();
+                await rollbackFeature([
+                    path.join(projectPath, "tailwind.config.ts"),
+                    path.join(projectPath, "tailwind.config.js"),
+                    path.join(projectPath, "src/components/ThemeToggle.tsx"),
+                    path.join(projectPath, "src/components/ThemeToggle.jsx"),
+                    path.join(projectPath, ".prettierrc"),
+                ]);
+                throw error;
+            }
+        },
+    };
+}

package/dist/generators/architecture.generator.js

@@ -0,0 +1,75 @@
+import fs from "fs/promises";
+import path from "path";
+// ─── Helpers ───
+async function createFolder(folderPath) {
+    await fs.mkdir(folderPath, { recursive: true });
+}
+async function createGitkeep(folderPath) {
+    await fs.writeFile(path.join(folderPath, ".gitkeep"), "");
+}
+async function createIndexFile(folderPath, isTypeScript) {
+    const filename = isTypeScript ? "index.ts" : "index.js";
+    await fs.writeFile(path.join(folderPath, filename), "export {};\n");
+}
+async function folderExists(folderPath) {
+    try {
+        await fs.access(folderPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Main generator ───
+export async function generateArchitecture(config, projectPath, isTypeScript) {
+    if (config.style === "skip")
+        return;
+    const srcPath = path.join(projectPath, "src");
+    if (config.style === "feature-based") {
+        // Create src/features/ folder
+        const featuresDir = path.join(srcPath, "features");
+        await createFolder(featuresDir);
+        // Create each feature with its selected folders
+        for (const feature of config.features) {
+            const featureDir = path.join(featuresDir, feature);
+            await createFolder(featureDir);
+            for (const folder of config.featureFolders) {
+                const folderPath = path.join(featureDir, folder);
+                await createFolder(folderPath);
+                if (config.indexFiles.includes(folder)) {
+                    await createIndexFile(folderPath, isTypeScript);
+                }
+                else {
+                    await createGitkeep(folderPath);
+                }
+            }
+        }
+        // Create shared folders in src/ — skip if already exists
+        for (const folder of config.sharedFolders) {
+            const folderPath = path.join(srcPath, folder);
+            if (await folderExists(folderPath))
+                continue;
+            await createFolder(folderPath);
+            if (config.indexFiles.includes(folder)) {
+                await createIndexFile(folderPath, isTypeScript);
+            }
+            else {
+                await createGitkeep(folderPath);
+            }
+        }
+    }
+    if (config.style === "layered") {
+        for (const folder of config.sharedFolders) {
+            const folderPath = path.join(srcPath, folder);
+            if (await folderExists(folderPath))
+                continue;
+            await createFolder(folderPath);
+            if (config.indexFiles.includes(folder)) {
+                await createIndexFile(folderPath, isTypeScript);
+            }
+            else {
+                await createGitkeep(folderPath);
+            }
+        }
+    }
+}