stackloom-cli 1.0.0

package/src/commands/remove.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+
+export default async function removeCmd(resourceType, name, options) {
+  const spinner = ora();
+  const projectRoot = process.cwd();
+
+  // Validate we're in a MERN Starter project
+  if (!fs.existsSync(path.join(projectRoot, 'frontend/src/App.jsx'))) {
+    console.log(chalk.red('✖  Not a MERN Starter Kit project.'));
+    process.exit(1);
+  }
+
+  const type = resourceType.toLowerCase();
+  const confirmed = options.force || await confirmRemove(type, name);
+
+  if (!confirmed) {
+    console.log(chalk.gray('✖  Cancelled.'));
+    process.exit(0);
+  }
+
+  switch (type) {
+    case 'page':
+      await removePage(projectRoot, name, options, spinner);
+      break;
+    case 'module':
+      await removeModule(projectRoot, name, options, spinner);
+      break;
+    default:
+      console.log(chalk.red(`✖  Unknown resource type: ${type}. Use "page" or "module".`));
+      process.exit(1);
+  }
+}
+
+async function confirmRemove(type, name) {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `Remove ${type} "${name}"? This will delete files and clean up references.`,
+      default: false,
+    },
+  ]);
+  return confirm;
+}
+
+async function removePage(projectRoot, pageName, options, spinner) {
+  const pageNameCap = pageName.charAt(0).toUpperCase() + pageName.slice(1);
+  const pageDir = path.join(projectRoot, 'frontend/src/pages', pageName);
+  const pageFile = path.join(pageDir, `${pageNameCap}Page.jsx`);
+
+  // Delete page directory
+  if (fs.existsSync(pageDir)) {
+    await fs.remove(pageDir);
+    spinner.succeed(`Removed page directory: ${pageDir}`);
+  } else {
+    spinner.warn(`Page directory not found: ${pageDir}`);
+  }
+
+  // Remove lazy import from AppRouter.jsx
+  const routerPath = path.join(projectRoot, 'frontend/src/routes/AppRouter.jsx');
+  if (fs.existsSync(routerPath)) {
+    let routerCode = await fs.readFile(routerPath, 'utf-8');
+    const importLine = `const ${pageNameCap}Page = lazy(() => import("@/pages/${pageName}/${pageNameCap}Page"));`;
+
+    if (routerCode.includes(importLine)) {
+      routerCode = routerCode.replace(importLine + '\n', '');
+      // Also remove empty line left behind
+      routerCode = routerCode.replace(/^\s*$\n/m, '');
+      await fs.writeFile(routerPath, routerCode);
+      spinner.succeed('Removed lazy import from AppRouter.jsx');
+    } else {
+      spinner.warn(`Lazy import not found in AppRouter.jsx — skipping`);
+    }
+
+   // Remove route block from AppRouter.jsx
+   // Strategy: find comment line, then skip all lines until we hit a line that is just '/>' (self-closing tag terminator)
+   const commentLine = `/* ${pageNameCap} */`;
+   const lines = routerCode.split('\n');
+   const filtered = [];
+   let skipping = false;
+
+   for (let i = 0; i < lines.length; i++) {
+     const line = lines[i];
+
+     if (!skipping && line.includes(commentLine)) {
+       skipping = true;
+       continue;
+     }
+
+     if (skipping) {
+       // When we encounter a line whose trimmed content is exactly '/>', the route block is closed
+       if (line.trim() === '/>') {
+         skipping = false;
+       }
+       // Skip this line (part of route block)
+       continue;
+     }
+
+     filtered.push(line);
+   }
+
+   const newRouterCode = filtered.join('\n');
+   if (newRouterCode !== routerCode) {
+     await fs.writeFile(routerPath, newRouterCode);
+     spinner.succeed('Removed route from AppRouter.jsx');
+   } else {
+     spinner.warn('Route block not found in AppRouter.jsx — skipping');
+   }
+  } else {
+    spinner.warn('AppRouter.jsx not found — cannot clean imports/routes');
+  }
+
+  // Remove navigation entry from app-preset.js
+  const presetPath = path.join(projectRoot, 'frontend/src/config/app-preset.js');
+  if (fs.existsSync(presetPath)) {
+    let presetCode = await fs.readFile(presetPath, 'utf-8');
+    const navEntryRegex = new RegExp(`\\{\\s*label:\\s*"${pageNameCap}",\\s*href:\\s*"[^"]*",\\s*icon:\\s*"[^"]*"\\s*\\},?\\s*\\n?`);
+    const before = presetCode;
+    presetCode = presetCode.replace(navEntryRegex, '');
+
+    if (presetCode !== before) {
+      // Clean up trailing comma left behind from navigation array
+      presetCode = presetCode.replace(/,\s*\n\s*]/, '\n    ]');
+      await fs.writeFile(presetPath, presetCode);
+      spinner.succeed('Removed navigation entry from app-preset.js');
+    } else {
+      spinner.warn('Navigation entry not found in app-preset.js — skipping');
+    }
+  } else {
+    spinner.warn('app-preset.js not found — cannot remove navigation entry');
+  }
+}
+
+async function removeModule(projectRoot, moduleName, options, spinner) {
+  const modDir = path.join(projectRoot, 'backend/src/modules', moduleName);
+
+  // Delete module directory
+  if (fs.existsSync(modDir)) {
+    await fs.remove(modDir);
+    spinner.succeed(`Removed module directory: ${modDir}`);
+  } else {
+    spinner.warn(`Module directory not found: ${modDir}`);
+  }
+
+  // Unmount route from backend/src/routes/index.js
+  const routesIndexPath = path.join(projectRoot, 'backend/src/routes/index.js');
+  if (fs.existsSync(routesIndexPath)) {
+    let routesCode = await fs.readFile(routesIndexPath, 'utf-8');
+    const mountLine = `router.use("/${moduleName}", require("../modules/${moduleName}/${moduleName}.routes"));`;
+
+    if (routesCode.includes(mountLine)) {
+      // Remove the line and any adjacent blank lines
+      const lines = routesCode.split('\n');
+      const filtered = lines.filter((line) => !line.trim().startsWith(`router.use("/${moduleName}"`));
+      const cleaned = filtered.join('\n').replace(/\n{3,}/g, '\n\n'); // collapse excessive blank lines
+      await fs.writeFile(routesIndexPath, cleaned);
+      spinner.succeed(`Unmounted /${moduleName} route from backend/src/routes/index.js`);
+    } else {
+      spinner.warn(`Mount line not found in routes/index.js — skipping`);
+    }
+  } else {
+    spinner.warn('backend/src/routes/index.js not found — cannot unmount route');
+  }
+}

package/src/commands/rename.js

@@ -0,0 +1,54 @@
+/**
+ * `loom rename <new-name>` — rebrand the CLI tool itself.
+ *
+ * Updates branding.json (the runtime source of truth) and package.json's `bin`
+ * key so the binary is exposed under the new name after the next install/link.
+ * One command, no manual find-and-replace.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { branding, brandingPath, saveBrandingTo } from "../branding/index.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_PATH = path.join(__dirname, "..", "..", "package.json");
+
+/** A valid CLI/bin command name: lowercase, digits, hyphens, starts with a letter. */
+const VALID_NAME = /^[a-z][a-z0-9-]*$/;
+
+export default async function rename(newName, options = {}) {
+  if (!newName || !VALID_NAME.test(newName)) {
+    console.error(
+      `Invalid CLI name "${newName ?? ""}". Use lowercase letters, digits and hyphens, starting with a letter.`,
+    );
+    process.exit(1);
+  }
+
+  const oldBin = branding.binName;
+  if (newName === oldBin) {
+    console.log(`CLI is already named "${newName}". Nothing to do.`);
+    return;
+  }
+
+  const displayName = options.displayName || newName.toUpperCase();
+  const description = options.description || branding.description;
+
+  // 1. Re-point package.json's bin key, preserving the existing target script.
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(PKG_PATH, "utf-8"));
+  } catch (err) {
+    console.error(`Could not read ${PKG_PATH}: ${err.message}`);
+    process.exit(1);
+  }
+  const binTarget =
+    (pkg.bin && (pkg.bin[oldBin] || Object.values(pkg.bin)[0])) || "./bin/cli.js";
+  pkg.bin = { [newName]: binTarget };
+  writeFileSync(PKG_PATH, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
+
+  // 2. Persist the new identity to branding.json.
+  saveBrandingTo(brandingPath, { binName: newName, displayName, description }, branding);
+
+  console.log(`Renamed CLI: ${oldBin} → ${newName}  (display name "${displayName}")`);
+  console.log(`Re-link the binary with 'pnpm install' (or 'npm link') to use '${newName}'.`);
+}

package/src/commands/rollback.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { StateTracker } from '../core/state-tracker.js';
+
+/**
+ * Rollback Command — undoes the last generation action
+ */
+export default async function rollbackCmd(options) {
+  const spinner = ora();
+  const projectRoot = process.cwd();
+  const tracker = new StateTracker(projectRoot);
+
+  const lastEvent = await tracker.getLastEvent();
+
+  if (!lastEvent) {
+    console.log(chalk.yellow('⚠ No generation history found to rollback.'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\nReverting last action: ${lastEvent.action} ${lastEvent.resource || ''}`));
+  console.log(chalk.gray(`Timestamp: ${lastEvent.timestamp}`));
+  console.log(chalk.gray(`Files affected: ${lastEvent.files.length}`));
+
+  if (!options.force) {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Are you sure you want to revert these changes? Files created will be deleted, and updates may be lost.',
+        default: false,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.gray('✖ Rollback cancelled.'));
+      return;
+    }
+  }
+
+  spinner.start('Rolling back changes...');
+
+  try {
+    let revertedCount = 0;
+    for (const file of lastEvent.files) {
+      const fullPath = path.join(projectRoot, file.path);
+      
+      if (file.action === 'CREATE') {
+        if (await fs.pathExists(fullPath)) {
+          await fs.remove(fullPath);
+          revertedCount++;
+          if (options.verbose) console.log(chalk.gray(`  - Deleted ${file.path}`));
+        }
+      } else if (file.action === 'UPDATE') {
+        // For updates, we can't easily revert without backups
+        // In a real production CLI, we'd have .loom/backups/
+        spinner.warn(`Cannot fully revert update to ${file.path} without backup. Please check manually.`);
+      }
+    }
+
+    // Clean up empty directories
+    await cleanupEmptyDirs(projectRoot, lastEvent.files.map(f => f.path));
+
+    await tracker.removeEvent(lastEvent.id);
+    spinner.succeed(`Rollback complete. ${revertedCount} files removed.`);
+  } catch (err) {
+    spinner.fail('Rollback failed');
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+}
+
+async function cleanupEmptyDirs(projectRoot, filePaths) {
+  const dirs = [...new Set(filePaths.map(fp => path.dirname(path.join(projectRoot, fp))))];
+  // Sort by depth (deepest first)
+  dirs.sort((a, b) => b.length - a.length);
+
+  for (const dir of dirs) {
+    if (await fs.pathExists(dir)) {
+      const files = await fs.readdir(dir);
+      if (files.length === 0) {
+        await fs.remove(dir);
+      }
+    }
+  }
+}

package/src/commands/wizard.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Import generators directly (they are plain async functions)
+import { default as pageGenerator } from './generate/page.js';
+import { default as moduleGenerator } from './generate/module.js';
+import { default as themeGenerator } from './generate/theme.js';
+import { default as deployGenerator } from './generate/deploy.js';
+import { default as removeCommand } from './remove.js';
+
+export default async function wizardCmd(options) {
+  const spinner = ora({ discardStdin: false });
+  const projectRoot = process.cwd();
+
+  // Verify we're in a MERN Starter project
+  if (!fs.existsSync(path.join(projectRoot, 'frontend/src/App.jsx'))) {
+    console.log(chalk.red('✖  Not a MERN Starter Kit project. Run this inside your project directory.'));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan('\n🚀 MERN Starter Kit Wizard'));
+  console.log(chalk.gray('Interactive guide to extend your project.\n'));
+
+  const steps = [];
+
+  while (true) {
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: '➕ Add a backend module', value: 'add_module' },
+          { name: '➕ Add a frontend page', value: 'add_page' },
+          { name: '🎨 Import a shadcn theme', value: 'add_theme' },
+          { name: '📦 Generate deploy configs', value: 'add_deploy' },
+          { name: '🗑️  Remove something', value: 'remove' },
+          { name: '✅ Done — exit wizard', value: 'done' },
+        ],
+      },
+    ]);
+
+    if (action === 'done') break;
+
+    if (action === 'add_module') {
+      const { moduleName } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'moduleName',
+          message: 'Module name (e.g., products, invoices, appointments):',
+          validate: (input) => /^[a-z0-9-_]+$/i.test(input) || 'Use only letters, numbers, dashes, underscores',
+        },
+      ]);
+      steps.push({ type: 'generate', subtype: 'module', name: moduleName });
+    }
+
+    if (action === 'add_page') {
+      const { pageName, route, icon, addNav } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'pageName',
+          message: 'Page name (e.g., settings, reports, team):',
+          validate: (input) => /^[a-z0-9-_]+$/i.test(input) || 'Use only letters, numbers, dashes, underscores',
+        },
+        {
+          type: 'input',
+          name: 'route',
+          message: 'Route path (leave blank for /<page>):',
+        },
+        {
+          type: 'input',
+          name: 'icon',
+          message: 'Lucide icon name (e.g., layout, settings, users):',
+          default: 'layout',
+        },
+        {
+          type: 'confirm',
+          name: 'addNav',
+          message: 'Add to navigation?',
+          default: true,
+        },
+      ]);
+      steps.push({
+        type: 'generate',
+        subtype: 'page',
+        name: pageName,
+        options: {
+          route: route || `/${pageName}`,
+          icon,
+          noNav: !addNav,
+          force: false,
+        },
+      });
+    }
+
+    if (action === 'add_theme') {
+      const { method } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'method',
+          message: 'How would you like to provide the theme CSS?',
+          choices: [
+            { name: 'From a file', value: 'file' },
+            { name: 'Paste CSS directly', value: 'paste' },
+          ],
+        },
+      ]);
+
+      let filePath, pasteContent;
+      if (method === 'file') {
+        const res = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'filePath',
+            message: 'Path to CSS file (must contain :root and .dark):',
+          },
+        ]);
+        filePath = res.filePath;
+      } else {
+        const res = await inquirer.prompt([
+          {
+            type: 'editor',
+            name: 'pasteContent',
+            message: 'Paste your CSS variables (Ctrl+D to finish):',
+          },
+        ]);
+        pasteContent = res.pasteContent;
+      }
+
+      steps.push({
+        type: 'generate',
+        subtype: 'theme',
+        options: {
+          file: filePath,
+          paste: pasteContent,
+          fallback: 'executiveBlue',
+          appearance: 'quiet',
+        },
+      });
+      console.log(chalk.green('✓ Will import shadcn theme'));
+    }
+
+    if (action === 'add_deploy') {
+      const { targets } = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'targets',
+          message: 'Select deployment targets:',
+          choices: [
+            { name: '🐳 Docker (Dockerfile + docker-compose)', value: 'docker' },
+            { name: '▲ Vercel (vercel.json)', value: 'vercel' },
+            { name: '🚂 Railway (railway.yaml)', value: 'railway' },
+          ],
+        },
+      ]);
+      if (targets.length) {
+        steps.push({
+          type: 'generate',
+          subtype: 'deploy',
+          options: {
+            target: targets.join(','),
+            force: false,
+          },
+        });
+        console.log(chalk.green(`✓ Will generate: ${targets.join(', ')}`));
+      }
+    }
+
+    if (action === 'remove') {
+      const { resourceType, resourceName } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'resourceType',
+          message: 'Remove what type?',
+          choices: ['page', 'module'],
+        },
+        {
+          type: 'input',
+          name: 'resourceName',
+          message: 'Name of the resource to remove:',
+        },
+      ]);
+      steps.push({
+        type: 'remove',
+        resourceType,
+        name: resourceName,
+      });
+      console.log(chalk.yellow(`⚠ Will remove ${resourceType}: ${resourceName}`));
+    }
+  }
+
+  if (steps.length === 0) {
+    console.log(chalk.gray('No actions selected. Bye!'));
+    process.exit(0);
+  }
+
+  // Summary + confirmation
+  console.log(chalk.cyan('\n📋 Summary of actions:'));
+  for (const step of steps) {
+    if (step.type === 'generate') {
+      const labelMap = {
+        module: 'Backend module',
+        page: 'Frontend page',
+        theme: 'Shadcn theme',
+        deploy: 'Deploy configs',
+      };
+      const label = labelMap[step.subtype] || step.subtype;
+      let detail = '';
+      if (step.subtype === 'page' && step.options) {
+        detail = ` → ${step.options.route}`;
+      }
+      if (step.subtype === 'deploy' && step.options) {
+        detail = ` → ${step.options.target}`;
+      }
+      console.log(chalk.white(`  • Generate ${label}: "${step.name}"${detail}`));
+    } else if (step.type === 'remove') {
+      console.log(chalk.yellow(`  • Remove ${step.resourceType} "${step.name}"`));
+    }
+  }
+
+  const skipConfirm = options.skipConfirm;
+  let confirmed = skipConfirm;
+  if (!skipConfirm) {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Proceed?',
+        default: true,
+      },
+    ]);
+    confirmed = confirm;
+  }
+
+  if (!confirmed) {
+    console.log(chalk.gray('✖  Cancelled.'));
+    process.exit(0);
+  }
+
+  // Execute steps sequentially
+  console.log('');
+  const originalCwd = process.cwd();
+
+  for (const step of steps) {
+    if (step.type === 'generate') {
+      spinner.start(`Generating ${step.subtype}: ${step.name || ''}`);
+
+      try {
+        process.chdir(projectRoot); // Ensure correct cwd for generators
+
+        switch (step.subtype) {
+          case 'module': {
+            // moduleGenerator(name, options)
+            await moduleGenerator(step.name, { force: false });
+            break;
+          }
+          case 'page': {
+            // pageGenerator(name, options)
+            await pageGenerator(step.name, step.options);
+            break;
+          }
+          case 'deploy': {
+            // deployGenerator(options)
+            await deployGenerator(step.options);
+            break;
+          }
+          case 'theme': {
+            // themeGenerator(options)
+            await themeGenerator(step.options);
+            break;
+          }
+        }
+
+        spinner.succeed(`${step.subtype.charAt(0).toUpperCase() + step.subtype.slice(1)} "${step.name}" generated`);
+        process.chdir(originalCwd);
+      } catch (err) {
+        process.chdir(originalCwd);
+        spinner.fail(`Failed to generate ${step.subtype} "${step.name || ''}": ${err.message}`);
+      }
+    }
+
+    if (step.type === 'remove') {
+      spinner.start(`Removing ${step.resourceType}: ${step.name}`);
+      try {
+        await removeCommand(step.resourceType, step.name, { force: false });
+        spinner.succeed(`${step.resourceType} "${step.name}" removed`);
+      } catch (err) {
+        spinner.fail(`Failed to remove ${step.resourceType} "${step.name}": ${err.message}`);
+      }
+    }
+  }
+
+  console.log(chalk.green.bold('\n✨ Wizard complete!\n'));
+}

package/src/core/__tests__/generator.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { Generator } from '../generator.js';
+import { ResourceDefinition } from '../resource-definition.js';
+
+describe('Generator', () => {
+  let tempDir;
+
+  beforeEach(async () => {
+    tempDir = path.join(os.tmpdir(), `loom-test-${Math.random().toString(36).slice(2)}`);
+    await fs.ensureDir(tempDir);
+    // Create a mock project structure
+    await fs.ensureDir(path.join(tempDir, 'backend', 'src', 'modules'));
+    await fs.writeJSON(path.join(tempDir, 'backend', 'package.json'), { name: 'backend' });
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  it('should validate project root', async () => {
+    const gen = new Generator({ projectRoot: os.tmpdir() });
+    await expect(gen.validateProject()).rejects.toThrow(/Not a MERN Starter Kit backend/);
+  });
+
+  it('should build context correctly', async () => {
+    const res = new ResourceDefinition({ name: 'Product' });
+    const gen = new Generator({ projectRoot: tempDir });
+    gen.resource = res;
+    const context = await gen.buildContext();
+    
+    expect(context.resource.name).toBe('Product');
+    expect(context.project.backendDir).toBe('backend');
+    expect(context.utils.pascal('test')).toBe('Test');
+  });
+
+  it('should generate files (backend)', async () => {
+    const res = new ResourceDefinition({ 
+      name: 'Product',
+      fields: [{ name: 'name', type: 'string' }]
+    });
+    const gen = new Generator({ projectRoot: tempDir, verbose: true });
+    
+    const result = await gen.generateFromDefinition(res);
+    
+    expect(result.files.length).toBeGreaterThan(0);
+    const modelFile = path.join(tempDir, 'backend/src/modules/product/models/Product.js');
+    expect(await fs.pathExists(modelFile)).toBe(true);
+    
+    const content = await fs.readFile(modelFile, 'utf-8');
+    expect(content).toContain('ProductSchema');
+    expect(content).toContain('AUTO-GENERATED');
+  });
+
+  it('should respect dry-run mode', async () => {
+    const res = new ResourceDefinition({ name: 'Product' });
+    const gen = new Generator({ projectRoot: tempDir, dryRun: true });
+    
+    const result = await gen.generateFromDefinition(res);
+    
+    const modelFile = path.join(tempDir, 'backend/src/modules/product/models/Product.js');
+    expect(await fs.pathExists(modelFile)).toBe(false);
+    expect(result.files.find(f => f.action === 'CREATE')).toBeTruthy();
+  });
+});