stackloom-cli 1.0.0

package/src/commands/init.js

@@ -0,0 +1,350 @@
+#!/usr/bin/env node
+
+import inquirer from "inquirer";
+import path from "path";
+import fs from "fs-extra";
+import os from "os";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import ora from "ora";
+import { execSync } from "child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+
+const TEMPLATE_REPO = "dellzetter-lang/starter-kit-mern";
+const DEFAULT_BRANCH = "main";
+const GITHUB_TAR_URL = `https://github.com/${TEMPLATE_REPO}/archive/refs/heads/${DEFAULT_BRANCH}.tar.gz`;
+
+const PRESET_VARIANTS = [
+  "saas",
+  "clinic",
+  "studio",
+  "operations",
+  "commerce",
+  "custom",
+];
+
+const DESIGN_THEMES = [
+  "executiveBlue",
+  "clinicSoft",
+  "studioElevated",
+  "operationsDense",
+  "commerceWarm",
+];
+
+const DESIGN_LAYOUTS = [
+  "hybridSaas",
+  "sidebarWorkspace",
+  "topbarPortal",
+  "rightRailStudio",
+];
+
+const DATA_TEMPLATES = ["dashboard", "denseOps", "editorial", "commerce"];
+
+export default async function initCmd(projectName, options) {
+  const spinner = ora({ discardStdin: false });
+
+  // Resolve project name and directory
+  let resolvedProjectName = projectName;
+  let parentDir = options.target ? path.resolve(options.target) : process.cwd();
+
+  // 1. Ask for Project Name if not provided
+  if (!resolvedProjectName) {
+    const { name } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Project name:",
+        default: "my-loom-app",
+        validate: (input) =>
+          /^[a-z0-9-_]+$/i.test(input) ||
+          "Use only letters, numbers, dashes, underscores",
+      },
+    ]);
+    resolvedProjectName = name;
+  }
+
+  const outDir = path.join(parentDir, resolvedProjectName);
+
+  // 2. Check for directory existence
+  if (fs.existsSync(outDir)) {
+    if (options.force) {
+      await fs.remove(outDir);
+    } else {
+      const files = fs.readdirSync(outDir).filter((f) => f !== "node_modules");
+      if (files.length > 0) {
+        const { confirm } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: `Directory ${resolvedProjectName} is not empty. Overwrite?`,
+            default: false,
+          },
+        ]);
+        if (!confirm) {
+          console.log(chalk.gray("✖ Cancelled."));
+          process.exit(0);
+        }
+        await fs.remove(outDir);
+      }
+    }
+  }
+  await fs.ensureDir(outDir);
+
+  // 3. Smart Interactive Configuration
+  // We only ask for options that weren't provided as flags
+  const config = { ...options };
+
+  const questions = [];
+
+  if (!config.preset) {
+    questions.push({
+      type: "list",
+      name: "preset",
+      message: "Choose a preset variant:",
+      choices: PRESET_VARIANTS,
+      default: "saas",
+    });
+  }
+
+  if (!config.theme) {
+    questions.push({
+      type: "list",
+      name: "theme",
+      message: "Design theme:",
+      choices: DESIGN_THEMES,
+      default: (answers) => {
+        const p = config.preset || answers.preset;
+        const map = {
+          saas: "operationsDense",
+          clinic: "clinicSoft",
+          studio: "studioElevated",
+          operations: "operationsDense",
+          commerce: "commerceWarm",
+        };
+        return map[p] || "executiveBlue";
+      },
+    });
+  }
+
+  if (!config.layout) {
+    questions.push({
+      type: "list",
+      name: "layout",
+      message: "Layout shell:",
+      choices: DESIGN_LAYOUTS,
+      default: (answers) => {
+        const p = config.preset || answers.preset;
+        const map = {
+          saas: "topbarPortal",
+          clinic: "sidebarWorkspace",
+          studio: "rightRailStudio",
+          operations: "sidebarWorkspace",
+          commerce: "topbarPortal",
+        };
+        return map[p] || "hybridSaas";
+      },
+    });
+  }
+
+  if (!config.architecture) {
+    questions.push({
+      type: "list",
+      name: "architecture",
+      message: "Architecture level:",
+      choices: [
+        { name: "Lightweight (Minimalist)", value: "lightweight" },
+        { name: "Moderate (Standard MERN)", value: "moderate" },
+        { name: "Advanced (Enterprise Ready)", value: "advanced" },
+      ],
+      default: "moderate",
+    });
+  }
+
+  if (config.install === undefined) {
+    questions.push({
+      type: "confirm",
+      name: "installDeps",
+      message: "Install dependencies automatically?",
+      default: true,
+    });
+  }
+
+  const interactiveAnswers =
+    questions.length > 0 ? await inquirer.prompt(questions) : {};
+  const finalConfig = { ...config, ...interactiveAnswers };
+
+  // Set defaults for brand/tagline if not provided
+  const presetDefaults = {
+    saas: { brand: "MERN Starter", tagline: "Secure app foundation" },
+    clinic: { brand: "CareDesk", tagline: "Clinic operations kit" },
+    studio: { brand: "StudioBoard", tagline: "Creative production hub" },
+    operations: { brand: "OpsGrid", tagline: "Internal operations console" },
+    commerce: { brand: "MarketPilot", tagline: "Commerce admin starter" },
+    custom: { brand: resolvedProjectName, tagline: "Build something great" },
+  };
+
+  const selectedPreset = finalConfig.preset || "saas";
+  finalConfig.brandName =
+    finalConfig.brandName || presetDefaults[selectedPreset].brand;
+  finalConfig.tagline =
+    finalConfig.tagline || presetDefaults[selectedPreset].tagline;
+
+  // 4. Scaffolding Process
+  spinner.start("Downloading template...");
+  const tempDir = path.join(os.tmpdir(), `loom-${Date.now()}`);
+  await fs.ensureDir(tempDir);
+
+  try {
+    await downloadTemplate(tempDir);
+    spinner.succeed("Template downloaded");
+  } catch (err) {
+    spinner.fail("Failed to download template");
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+
+  spinner.start("Extracting and customizing...");
+  await fs.copy(tempDir, outDir);
+  await fs.remove(tempDir);
+
+  await applyPresetCustomization(outDir, finalConfig);
+  await syncProjectDependencies(outDir);
+
+  // Ensure sanitize.js
+  const sanitizePath = path.join(outDir, "frontend/src/utils/sanitize.js");
+  if (!fs.existsSync(sanitizePath)) {
+    await fs.ensureDir(path.dirname(sanitizePath));
+    await fs.writeFile(sanitizePath, sanitizeUtilContent);
+  }
+  spinner.succeed("Project customized");
+
+  // 5. Install Dependencies
+  if (finalConfig.installDeps || finalConfig.install) {
+    console.log(chalk.cyan("\n━> Installing dependencies with pnpm..."));
+    try {
+      execSync("pnpm install --no-frozen-lockfile", {
+        cwd: outDir,
+        stdio: "inherit",
+        env: { ...process.env, CI: "true" },
+      });
+      console.log(chalk.green("✓ Dependencies installed\n"));
+    } catch (err) {
+      console.log(
+        chalk.yellow(
+          "⚠ Installation failed. You can run 'pnpm install' manually.\n",
+        ),
+      );
+    }
+  }
+
+   // 6. Setup .env
+   const backendEnvPath = path.join(outDir, "backend", ".env");
+   const backendEnvExamplePath = path.join(outDir, "backend", ".env.example");
+   if (!fs.existsSync(backendEnvPath) && fs.existsSync(backendEnvExamplePath)) {
+     await fs.copy(backendEnvExamplePath, backendEnvPath);
+   }
+
+   const frontendEnvPath = path.join(outDir, "frontend", ".env");
+   const frontendEnvExamplePath = path.join(outDir, "frontend", ".env.example");
+   if (!fs.existsSync(frontendEnvPath) && fs.existsSync(frontendEnvExamplePath)) {
+     await fs.copy(frontendEnvExamplePath, frontendEnvPath);
+   }
+
+  console.log(chalk.green.bold("✨ Project created successfully!"));
+  console.log(chalk.white(`\n  cd ${resolvedProjectName}`));
+  console.log(chalk.white(`  pnpm dev\n`));
+}
+
+// ─── Helpers ────────────────────────────────────────────
+
+async function downloadTemplate(destDir) {
+  const { createGunzip } = await import("zlib");
+  const { pipeline } = await import("stream");
+  const https = await import("https");
+  const { extract } = await import("tar");
+
+  return new Promise((resolve, reject) => {
+    https
+      .get(GITHUB_TAR_URL, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          https
+            .get(res.headers.location, (res2) => {
+              pipeline(
+                res2.pipe(createGunzip()),
+                extract({ cwd: destDir, strip: 1 }),
+                (err) => {
+                  if (err) reject(err);
+                  else resolve();
+                },
+              );
+            })
+            .on("error", reject);
+          return;
+        }
+        if (res.statusCode !== 200)
+          return reject(new Error(`HTTP ${res.statusCode}`));
+        pipeline(
+          res.pipe(createGunzip()),
+          extract({ cwd: destDir, strip: 1 }),
+          (err) => {
+            if (err) reject(err);
+            else resolve();
+          },
+        );
+      })
+      .on("error", reject);
+  });
+}
+
+async function applyPresetCustomization(projectRoot, config) {
+  const presetPath = path.join(
+    projectRoot,
+    "frontend/src/config/app-preset.js",
+  );
+  if (!(await fs.pathExists(presetPath))) return;
+
+  let code = await fs.readFile(presetPath, "utf-8");
+  const presetVal =
+    config.preset === "custom"
+      ? `{ ...baseContent, brand: { name: "${config.brandName}", tagline: "${config.tagline}" }, layout: designLayouts.${config.layout}, theme: designThemes.${config.theme} }`
+      : `presetVariants.${config.preset || "saas"}`;
+
+  code = code.replace(
+    /export const appPreset = .+;/,
+    `export const appPreset = ${presetVal};`,
+  );
+  await fs.writeFile(presetPath, code, "utf-8");
+}
+
+async function syncProjectDependencies(outDir) {
+  const frontendPkgPath = path.join(outDir, "frontend/package.json");
+  if (await fs.pathExists(frontendPkgPath)) {
+    const pkg = await fs.readJSON(frontendPkgPath);
+    const required = {
+      "lucide-react": "^1.8.0",
+      clsx: "^2.1.1",
+      "tailwind-merge": "^3.5.0",
+      "class-variance-authority": "^0.7.1",
+      sonner: "^2.0.7",
+      "@radix-ui/react-dialog": "^1.1.2",
+      "@radix-ui/react-slot": "^1.2.4",
+    };
+    let changed = false;
+    for (const [name, version] of Object.entries(required)) {
+      if (!pkg.dependencies[name]) {
+        pkg.dependencies[name] = version;
+        changed = true;
+      }
+    }
+    if (changed) await fs.writeJSON(frontendPkgPath, pkg, { spaces: 2 });
+  }
+}
+
+ const sanitizeUtilContent = `export function sanitizeText(v) { return typeof v === 'string' ? v.replace(/<[^>]*>?/gm, "").trim() : v; }
+ export function sanitizeEmail(v) { return typeof v === 'string' ? v.toLowerCase().trim() : v; }
+ export function sanitizeUrl(v) { return typeof v === 'string' ? v.trim() : v; }
+ export function sanitizePhone(v) { return typeof v === 'string' ? v.replace(/[^+0-9]/g, '').trim() : v; }
+ export function sanitizeNumber(v) { const n = parseFloat(v); return isNaN(n) ? 0 : n; }
+ export function sanitizeBoolean(v) { return typeof v === 'boolean' ? v : (typeof v === 'string' ? v.toLowerCase() === 'true' : !!v); }
+ `;

package/src/commands/make/resource.js

@@ -0,0 +1,298 @@
+#!/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';
+import { ResourceDefinition, parseFieldSpec } from '../../core/resource-definition.js';
+import { Generator } from '../../core/generator.js';
+
+export default async function makeResourceCmd(name, options) {
+  console.warn(
+    chalk.yellow(
+      "⚠  'make:resource' is superseded by 'loom generate resource'\n" +
+        "   (engine-backed: transactional render→inject→validate→commit). This command still works.",
+    ),
+  );
+  const spinner = ora();
+  const projectRoot = process.cwd();
+
+  // Determine resource definition
+  let resourceDef;
+
+  if (options.file) {
+    // Load from definition file
+    const defPath = path.resolve(projectRoot, options.file);
+    if (!(await fs.pathExists(defPath))) {
+      console.error(chalk.red(`✖  Resource definition file not found: ${defPath}`));
+      process.exit(1);
+    }
+    const mod = await import(defPath);
+    const def = mod.default || mod;
+    // Validate
+    resourceDef = new ResourceDefinition(def);
+  } else if (options.fields) {
+    // Build from CLI arguments
+    const fields = options.fields.split(';').map(spec => {
+      const parsed = parseFieldSpec(spec);
+      if (!parsed) {
+        throw new Error(`Failed to parse field spec: "${spec}"`);
+      }
+      return parsed;
+    });
+
+    resourceDef = new ResourceDefinition({
+      name: name,
+      fields,
+      relations: options.relations ? parseRelations(options.relations) : {},
+      features: parseFeatures(options),
+      ui: { listView: options.ui || 'table' },
+      permissions: parsePermissions(options.permissions),
+    });
+  } else if (options.interactive) {
+    // Interactive mode: ask user
+    resourceDef = await interactiveResourceWizard(name);
+  } else {
+    console.error(chalk.red('✖  You must provide either --fields, --file, or --interactive'));
+    console.log(chalk.gray('   Examples:'));
+    console.log(chalk.gray(`   loom make:resource Product --fields "name:str,price:num"`));
+    console.log(chalk.gray(`   loom make:resource User --file .loom/resources/user.resource.js`));
+    process.exit(1);
+  }
+
+  // Validate name consistency
+  if (name && resourceDef.name !== name) {
+    console.warn(chalk.yellow(`⚠  Resource name "${resourceDef.name}" differs from command arg "${name}". Using definition file name.`));
+  }
+
+  // Show preview if dry-run
+  if (options.dryRun) {
+    await showPreview(projectRoot, resourceDef, options);
+    return;
+  }
+
+  // Confirm if interactive and files would be overwritten
+  if (!options.force && !options.nonInteractive) {
+    const conflicts = await detectConflicts(projectRoot, resourceDef);
+    if (conflicts.length > 0) {
+      console.log(chalk.yellow('⚠  The following files would be overwritten:'));
+      conflicts.forEach(f => console.log(chalk.gray(`   ${f}`)));
+      const { confirm } = await inquirer.prompt([
+        { type: 'confirm', name: 'confirm', message: 'Continue?', default: false }
+      ]);
+      if (!confirm) {
+        console.log(chalk.gray('✖  cancelled.'));
+        process.exit(0);
+      }
+    }
+  }
+
+  // Generate
+  spinner.start(`Generating resource: ${resourceDef.name}`);
+  
+  try {
+    const generator = new Generator({
+      projectRoot,
+      architecture: options.arch || 'moderate',
+      dryRun: false,
+      verbose: options.verbose,
+      force: options.force,
+      withFrontend: options.noFrontend ? false : true,
+      withTests: options.withTests || false,
+    });
+
+    const result = await generator.generateFromDefinition(resourceDef);
+    
+    spinner.succeed(`Generated ${resourceDef.name} (${result.files.length} files)`);
+
+    // Show summary
+    console.log('');
+    console.log(chalk.green('── Summary ──'));
+    result.files.forEach(f => {
+      const icon = f.action === 'CREATE' ? '+' : f.action === 'UPDATE' ? '~' : '⊘';
+      const color = f.action === 'CREATE' ? chalk.green : f.action === 'UPDATE' ? chalk.yellow : chalk.gray;
+      console.log(color(`${icon} ${f.output}`));
+    });
+    
+    if (result.issues.length) {
+      console.log('');
+      console.log(chalk.yellow('Issues:'));
+      result.issues.forEach(i => {
+        const prefix = i.type === 'error' ? '✖' : '⚠';
+        const color = i.type === 'error' ? chalk.red : chalk.yellow;
+        console.log(color(`  ${prefix} ${i.message}`));
+      });
+    }
+
+    console.log('');
+    console.log(chalk.gray('Next steps:'));
+    console.log(chalk.gray(`  cd ${projectRoot}`));
+    console.log(chalk.gray('  pnpm dev'));
+    console.log('');
+  } catch (err) {
+    spinner.fail('Generation failed');
+    console.error(chalk.red(err.message));
+    if (options.debug) {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Helper Functions
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseRelations(str) {
+  // Format: "Post:hasMany,Comment:hasMany:through=PostComment"
+  // Not fully implemented in v0.2.0 Phase 1 — skip for now
+  return { belongsTo: [], hasMany: [] };
+}
+
+function parseFeatures(options) {
+  const features = {};
+  if (options.softDelete) features.softDelete = true;
+  if (options.auditLog) features.auditLog = true;
+  if (options.auth) features.auth = options.auth;
+  if (options.search) features.search = options.search;
+  return features;
+}
+
+function parsePermissions(str) {
+  // Format: "create:admin,manager read:all update:admin,self delete:admin"
+  if (!str) return {};
+  // Simplified parsing
+  const perms = {};
+  str.split(' ').forEach(segment => {
+    const [action, roles] = segment.split(':');
+    if (action && roles) {
+      perms[action] = roles.split(',');
+    }
+  });
+  return perms;
+}
+
+async function detectConflicts(projectRoot, resourceDef) {
+  const conflicts = [];
+  const commonFiles = [
+    `backend/src/modules/${resourceDef.kebabName}/models/${resourceDef.name}.js`,
+    `backend/src/modules/${resourceDef.kebabName}/routes/${resourceDef.name}.routes.js`,
+    `frontend/src/pages/admin/${resourceDef.kebabName}/ListPage.jsx`,
+  ];
+  
+  for (const file of commonFiles) {
+    const fullPath = path.join(projectRoot, file);
+    if (await fs.pathExists(fullPath)) {
+      conflicts.push(file);
+    }
+  }
+  return conflicts;
+}
+
+async function showPreview(projectRoot, resourceDef, options) {
+  console.log('');
+  console.log(chalk.cyan.bold(`═══ PREVIEW: ${resourceDef.name} ═══`));
+  console.log('');
+  
+  const generator = new Generator({
+    projectRoot,
+    architecture: options.arch || 'moderate',
+    dryRun: true,
+    verbose: false,
+  });
+
+  try {
+    const result = await generator.generateFromDefinition(resourceDef);
+    
+    // Group by action
+    const creates = result.files.filter(f => f.action === 'CREATE');
+    const updates = result.files.filter(f => f.action === 'UPDATE');
+    const skips = result.files.filter(f => f.action === 'SKIP');
+
+    if (creates.length) {
+      console.log(chalk.green('CREATE:'));
+      creates.forEach(f => console.log(chalk.gray(`  ${f.output}`)));
+    }
+    if (updates.length) {
+      console.log(chalk.yellow('UPDATE:'));
+      updates.forEach(f => console.log(chalk.gray(`  ${f.output}`)));
+    }
+    if (skips.length) {
+      console.log(chalk.gray('SKIP (already exist):'));
+      skips.forEach(f => console.log(chalk.gray(`  ${f.output}`)));
+    }
+
+    console.log('');
+    console.log(chalk.white(`Total: ${creates.length} new, ${updates.length} updates, ${skips.length} skipped`));
+    console.log(chalk.gray('(Use --verbose to see estimated time saved)'));
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red('Preview error:'), err.message);
+    if (options.debug) console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+async function interactiveResourceWizard(name) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'resourceName',
+      message: 'Resource name (PascalCase):',
+      default: name ? name.charAt(0).toUpperCase() + name.slice(1) : 'MyResource',
+      validate: (v) => /^[A-Z][a-zA-Z0-9]*$/.test(v) || 'Must be PascalCase',
+    },
+    {
+      type: 'input',
+      name: 'fields',
+      message: 'Fields (semicolon-separated, e.g., "name:str,email:email,age:num")',
+      default: 'name:str',
+    },
+    {
+      type: 'list',
+      name: 'arch',
+      message: 'Architecture:',
+      choices: [
+        { name: 'Lightweight — inline controllers, minimal files', value: 'lightweight' },
+        { name: 'Moderate — full separation (model/service/controller)', value: 'moderate' },
+        { name: 'Advanced — plus tests, DTOs, domain logic', value: 'advanced' },
+      ],
+      default: 'moderate',
+    },
+    {
+      type: 'confirm',
+      name: 'withFrontend',
+      message: 'Generate frontend pages and components?',
+      default: true,
+    },
+    {
+      type: 'confirm',
+      name: 'withTests',
+      message: 'Generate test files?',
+      default: false,
+    },
+    {
+      type: 'confirm',
+      name: 'softDelete',
+      message: 'Enable soft delete?',
+      default: false,
+    },
+  ]);
+
+  const fields = answers.fields.split(';').map(spec => {
+    const parsed = parseFieldSpec(spec);
+    if (!parsed) throw new Error(`Invalid field spec: ${spec}`);
+    return parsed;
+  });
+
+  return new ResourceDefinition({
+    name: answers.resourceName,
+    fields,
+    features: {
+      softDelete: answers.softDelete,
+      auditLog: true,
+    },
+    ui: { listView: 'table' },
+  });
+}

package/src/commands/preset.js

@@ -0,0 +1,57 @@
+#!/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';
+
+const PRESETS = ['saas', 'clinic', 'studio', 'operations', 'commerce'];
+
+/**
+ * Preset Command — applies a predefined configuration preset
+ */
+export default async function presetCmd(presetName) {
+  const spinner = ora();
+  const projectRoot = process.cwd();
+
+  const presetPath = path.join(projectRoot, 'frontend/src/config/app-preset.js');
+  if (!(await fs.pathExists(presetPath))) {
+    console.log(chalk.red('✖ Not a MERN Starter Kit project (missing app-preset.js).'));
+    return;
+  }
+
+  let selectedPreset = presetName;
+
+  if (!selectedPreset || !PRESETS.includes(selectedPreset)) {
+    const { choice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'choice',
+        message: 'Select a preset to apply:',
+        choices: PRESETS,
+      },
+    ]);
+    selectedPreset = choice;
+  }
+
+  spinner.start(`Applying ${selectedPreset} preset...`);
+
+  try {
+    let presetCode = await fs.readFile(presetPath, 'utf-8');
+    
+    // Replace the export line
+    presetCode = presetCode.replace(
+      /export const appPreset = .+;/,
+      `export const appPreset = presetVariants.${selectedPreset};`
+    );
+
+    await fs.writeFile(presetPath, presetCode, 'utf-8');
+    spinner.succeed(`Preset "${selectedPreset}" applied successfully.`);
+    
+    console.log(chalk.gray('\nNote: This changed your UI configuration. Run `pnpm dev` to see changes.'));
+  } catch (err) {
+    spinner.fail('Failed to apply preset');
+    console.error(chalk.red(err.message));
+  }
+}