stackloom-cli 1.0.0

package/src/commands/generate/test-scaffold.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Generate test scaffolding for modules
+ */
+export async function generateModuleTests(moduleName, testsDir) {
+  const pascalName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+  
+  return `const request = require('supertest');
+const { ${pascalName}Model } = require('../${moduleName}/${moduleName}.model');
+const app = require('../../app');
+
+describe('${pascalName} Module API', () => {
+  let test${pascalName}Id;
+
+  beforeAll(async () => {
+    // Setup test database connection
+    await connectToTestDatabase();
+  });
+
+  afterAll(async () => {
+    // Cleanup test database
+    await ${pascalName}Model.deleteMany({});
+    await disconnectFromTestDatabase();
+  });
+
+  describe('POST /api/${moduleName} - Create', () => {
+    it('should create a new ${moduleName}', async () => {
+      const new${pascalName} = {
+        name: 'Test ${pascalName}',
+        // Add required fields based on schema
+      };
+
+      const response = await request(app)
+        .post('/api/${moduleName}')
+        .send(new${pascalName})
+        .expect(201);
+
+      expect(response.body).toHaveProperty('data');
+      expect(response.body.data).toHaveProperty('_id');
+      expect(response.body.data.name).toBe(new${pascalName}.name);
+      
+      test${pascalName}Id = response.body.data._id;
+    });
+
+    it('should return 400 for invalid data', async () => {
+      await request(app)
+        .post('/api/${moduleName}')
+        .send({}) // Empty body
+        .expect(400);
+    });
+  });
+
+  describe('GET /api/${moduleName} - List', () => {
+    it('should list all ${moduleName}s', async () => {
+      const response = await request(app)
+        .get('/api/${moduleName}')
+        .expect(200);
+
+      expect(response.body).toHaveProperty('data');
+      expect(Array.isArray(response.body.data)).toBe(true);
+    });
+
+    it('should support pagination', async () => {
+      const response = await request(app)
+        .get('/api/${moduleName}?page=1&limit=10')
+        .expect(200);
+
+      expect(response.body).toHaveProperty('data');
+    });
+  });
+
+  describe('GET /api/${moduleName}/:id - Get One', () => {
+    it('should get a single ${moduleName}', async () => {
+      const response = await request(app)
+        .get(\`/api/${moduleName}/\${test${pascalName}Id}\`)
+        .expect(200);
+
+      expect(response.body.data._id).toBe(test${pascalName}Id);
+    });
+
+    it('should return 404 for non-existent ${moduleName}', async () => {
+      await request(app)
+        .get('/api/${moduleName}/507f1f77bcf86cd799439011')
+        .expect(404);
+    });
+  });
+
+  describe('PUT /api/${moduleName}/:id - Update', () => {
+    it('should update a ${moduleName}', async () => {
+      const updatedData = {
+        name: 'Updated ${pascalName} Name',
+      };
+
+      const response = await request(app)
+        .put(\`/api/${moduleName}/\${test${pascalName}Id}\`)
+        .send(updatedData)
+        .expect(200);
+
+      expect(response.body.data.name).toBe(updatedData.name);
+    });
+
+    it('should return 404 for updating non-existent ${moduleName}', async () => {
+      await request(app)
+        .put('/api/${moduleName}/507f1f77bcf86cd799439011')
+        .send({ name: 'Updated' })
+        .expect(404);
+    });
+  });
+
+  describe('DELETE /api/${moduleName}/:id - Delete', () => {
+    it('should delete a ${moduleName}', async () => {
+      await request(app)
+        .delete(\`/api/${moduleName}/\${test${pascalName}Id}\`)
+        .expect(200);
+
+      // Verify deletion
+      await request(app)
+        .get(\`/api/${moduleName}/\${test${pascalName}Id}\`)
+        .expect(404);
+    });
+
+    it('should return 404 when deleting non-existent ${moduleName}', async () => {
+      await request(app)
+        .delete('/api/${moduleName}/507f1f77bcf86cd799439011')
+        .expect(404);
+    });
+  });
+
+  describe('Validation Tests', () => {
+    it('should validate required fields', async () => {
+      const response = await request(app)
+        .post('/api/${moduleName}')
+        .send({})
+        .expect(400);
+
+      expect(response.body).toHaveProperty('error');
+    });
+
+    it('should validate field types', async () => {
+      const response = await request(app)
+        .post('/api/${moduleName}')
+        .send({ name: 12345 }) // Wrong type
+        .expect(400);
+
+      expect(response.body).toHaveProperty('error');
+    });
+  });
+});
+`;
+}
+
+export async function generateFrontendTests(componentName) {
+  return `import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { BrowserRouter } from 'react-router-dom';
+import { ${componentName}Page } from './${componentName}Page';
+import '@testing-library/jest-dom';
+
+jest.mock('@/hooks/useAuth', () => ({
+  useAuth: () => ({
+    user: { name: 'Test User', email: 'test@example.com' },
+  }),
+}));
+
+describe('${componentName}Page', () => {
+  const renderComponent = () => {
+    return render(
+      <BrowserRouter>
+        <${componentName}Page />
+      </BrowserRouter>
+    );
+  };
+
+  it('should render the page title', () => {
+    renderComponent();
+    expect(screen.getByText('${componentName}')).toBeInTheDocument();
+  });
+
+  it('should display user name', () => {
+    renderComponent();
+    expect(screen.getByText(/Test User/i)).toBeInTheDocument();
+  });
+
+  describe('Page structure', () => {
+    it('should have main sections', () => {
+      renderComponent();
+      expect(screen.getByRole('main')).toBeInTheDocument();
+    });
+  });
+});
+`;
+}
+
+export async function generateApiTests(moduleName) {
+  const pascalName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+  
+  return `import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import request from 'supertest';
+import app from '../../app';
+import { ${pascalName}Model } from '../../src/modules/${moduleName}/${moduleName}.model';
+
+describe('${pascalName} API Integration Tests', () => {
+  let testId;
+
+  beforeAll(async () => {
+    // Clear collection before tests
+    await ${pascalName}Model.deleteMany({});
+  });
+
+  afterAll(async () => {
+    await ${pascalName}Model.deleteMany({});
+  });
+
+  describe('CRUD Operations', () => {
+    it('should create a ${moduleName}', async () => {
+      const response = await request(app)
+        .post('/api/${moduleName}')
+        .send({
+          name: 'Integration Test ${pascalName}',
+        })
+        .expect('Content-Type', /json/)
+        .expect(201);
+
+      expect(response.body.data).toBeDefined();
+      expect(response.body.data.name).toBe('Integration Test ${pascalName}');
+      testId = response.body.data._id;
+    });
+
+    it('should retrieve all ${moduleName}s', async () => {
+      const response = await request(app)
+        .get('/api/${moduleName}')
+        .expect(200);
+
+      expect(Array.isArray(response.body.data)).toBe(true);
+      expect(response.body.data.length).toBeGreaterThan(0);
+    });
+
+    it('should retrieve a single ${moduleName}', async () => {
+      const response = await request(app)
+        .get(\`/api/${moduleName}/\${testId}\`)
+        .expect(200);
+
+      expect(response.body.data._id).toBe(testId);
+    });
+
+    it('should update a ${moduleName}', async () => {
+      const response = await request(app)
+        .put(\`/api/${moduleName}/\${testId}\`)
+        .send({ name: 'Updated Name' })
+        .expect(200);
+
+      expect(response.body.data.name).toBe('Updated Name');
+    });
+
+    it('should delete a ${moduleName}', async () => {
+      await request(app)
+        .delete(\`/api/${moduleName}/\${testId}\`)
+        .expect(200);
+
+      // Verify it's gone
+      await request(app)
+        .get(\`/api/${moduleName}/\${testId}\`)
+        .expect(404);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should return 404 for non-existent ${moduleName}', async () => {
+      await request(app)
+        .get('/api/${moduleName}/507f1f77bcf86cd799439011')
+        .expect(404);
+    });
+  });
+});
+`;
+}

package/src/commands/generate/theme.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+import process from 'process';
+
+export default async function generateThemeCmd(options) {
+  const spinner = ora();
+  const projectRoot = process.cwd();
+
+  // Validate project
+  if (!fs.existsSync(path.join(projectRoot, 'frontend/src/config/app-preset.js'))) {
+    console.log(chalk.red('✖  Not a MERN Starter Kit project (missing app-preset.js).'));
+    process.exit(1);
+  }
+
+  let cssContent = '';
+
+  if (options.file) {
+    const filePath = path.resolve(projectRoot, options.file);
+    if (!fs.existsSync(filePath)) {
+      console.log(chalk.red(`✖  File not found: ${filePath}`));
+      process.exit(1);
+    }
+    cssContent = await fs.readFile(filePath, 'utf-8');
+  } else if (options.paste) {
+    cssContent = options.paste;
+  } else {
+    console.log(chalk.yellow('⚠  No CSS provided. Use --file path/to/theme.css or --paste "css string".'));
+    process.exit(1);
+  }
+
+  // Basic validation
+  if (!cssContent.includes(':root') && !cssContent.includes('.dark')) {
+    console.log(chalk.yellow('⚠  CSS does not contain :root or .dark blocks.'));
+  }
+
+  // Persist the raw CSS in the project for reference (non-destructive, new file)
+  const cssOutPath = path.join(projectRoot, 'frontend/src/config/imported-shadcn-theme.css');
+  await fs.writeFile(cssOutPath, cssContent);
+  spinner.succeed(`CSS saved to ${cssOutPath}`);
+
+  // Print the code snippet to paste into app-preset.js
+  const fallbackTheme = options.fallback || 'designTokens.calmBlue';
+  const appearance = options.appearance || 'appearanceRecipes.elevated';
+
+  console.log('');
+  console.log(chalk.green('✓  Theme CSS saved. Add this to your app-preset.js:'));
+  console.log('');
+  console.log(chalk.white(`import { installShadcnDesignPreset } from "@/lib/shadcn-theme";
+import { ${fallbackTheme} } from "./design-themes";
+import { ${appearance} } from "./design-themes";
+
+export const appPreset = {
+  ...presetVariants.saas, // or your chosen base
+  theme: installShadcnDesignPreset(\`${cssContent.replace(/`/g, '\\`')}\`, {
+    fallbackTheme: ${fallbackTheme},
+    appearance: ${appearance},
+  }),
+  // optional: override other fields (brand, navigation, landing)
+};`));
+  console.log('');
+  console.log(chalk.gray('Alternatively, use designThemes object directly with parsed cssVars.'));
+  console.log('');
+}

package/src/commands/generate-resource.js

@@ -0,0 +1,133 @@
+/**
+ * `loom generate resource|module|page <name>` — the unified, engine-backed
+ * generation command.
+ *
+ * Replaces the divergent code paths (string-template page generator vs the EJS
+ * generator) with one flow: blueprint + recipe → transactional pipeline. It
+ * decides *nothing* about what files exist or where they go — the recipe and
+ * blueprint do — it only wires the pieces and reports.
+ */
+import path from "node:path";
+import { ResourceDefinition, parseFieldSpec } from "../core/resource-definition.js";
+import { TemplateLoader } from "../core/template-loader.js";
+import { blueprintLoader } from "../blueprint/index.js";
+import { recipeLoader } from "../recipes/index.js";
+import { createGenerationPipeline } from "../engine/index.js";
+import { reporterFromOptions } from "../services/index.js";
+import { validateGenerateOptions, validateResourceDefinition } from "../schemas/index.js";
+
+const NAMING = {
+  pascal: (s) => s.charAt(0).toUpperCase() + s.slice(1),
+  camel: (s) => s.charAt(0).toLowerCase() + s.slice(1),
+  kebab: (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase(),
+};
+
+/** Build a validated ResourceDefinition from --fields / --file / a bare name. */
+async function resolveResource(name, options) {
+  let raw;
+  if (options.file) {
+    const mod = await import(path.resolve(process.cwd(), options.file));
+    raw = mod.default || mod;
+  } else {
+    const fields = options.fields
+      ? options.fields
+          .split(";")
+          .map((spec) => parseFieldSpec(spec.trim()))
+          .filter(Boolean)
+      : [];
+    raw = { name: NAMING.pascal(name), fields };
+  }
+
+  // Schema-validate before construction — typed errors, not a thrown stack trace.
+  const validated = validateResourceDefinition(raw);
+  if (!validated.success) {
+    throw new Error(`Invalid resource definition:\n  - ${validated.issues.join("\n  - ")}`);
+  }
+  return new ResourceDefinition(validated.data);
+}
+
+/**
+ * @param {string} type - recipe name: "resource" | "module" | "page"
+ * @param {string} name - resource name
+ * @param {object} options - merged command + global options
+ */
+export default async function generateResource(type, name, options = {}) {
+  const reporter = reporterFromOptions(options);
+  const projectRoot = process.cwd();
+
+  try {
+    if (!name) throw new Error(`A name is required: loom generate ${type} <Name>`);
+
+    const optionCheck = validateGenerateOptions(options);
+    if (!optionCheck.success) {
+      throw new Error(`Invalid options:\n  - ${optionCheck.issues.join("\n  - ")}`);
+    }
+
+    const resource = await resolveResource(name, options);
+    const blueprint = await blueprintLoader.load(projectRoot);
+    const recipe = await recipeLoader.load(options.recipe || type, blueprint);
+
+    reporter.step(`Generating ${recipe.name} "${resource.name}" (${blueprint.architecture.name})`);
+
+    // The recipe's `when` evaluation context: params + derived flags.
+    const recipeContext = {
+      withFrontend: options.frontend !== false,
+      withTests: Boolean(options.withTests),
+      architecture: options.arch || "moderate",
+      formMode: options.formMode || "page",
+      usesTypeScript: blueprint.usesTypeScript(projectRoot),
+    };
+    for (const field of resource.fields) recipeContext[`hasField:${field.name}`] = true;
+
+    // Template-path tokens ({kebab}, {Name}) used by recipe `out`/`template`.
+    const vars = { kebab: resource.kebabName, Name: resource.pascalName };
+
+    // EJS rendering bridged to the engine's injected-renderer contract.
+    const templates = new TemplateLoader();
+    templates.projectRoot = projectRoot;
+    const templateContext = {
+      resource,
+      blueprint,
+      options: recipeContext,
+      project: { root: projectRoot, usesTypeScript: recipeContext.usesTypeScript },
+      utils: NAMING,
+    };
+    const renderer = (templatePath) => templates.render(templatePath, templateContext, projectRoot);
+
+    const pipeline = createGenerationPipeline({ renderer });
+    const ctx = await pipeline.run({
+      projectRoot,
+      recipe,
+      blueprint,
+      recipeContext,
+      vars,
+      templateContext,
+      dryRun: Boolean(options.dryRun),
+    });
+
+    const { files, dryRun } = ctx.result;
+    for (const file of files) {
+      reporter.event("file", { action: file.action, path: file.relPath });
+      reporter.info(`${file.action === "create" ? "+" : "~"} ${file.relPath}`);
+    }
+    reporter.result({
+      recipe: recipe.name,
+      resource: resource.name,
+      dryRun,
+      files,
+      injections: ctx.injections || [],
+    });
+    reporter.success(
+      dryRun
+        ? `Dry run — ${files.length} file(s) would change`
+        : `Generated ${resource.name} — ${files.length} file(s)`,
+    );
+  } catch (err) {
+    reporter.error(err.message);
+    reporter.result({ error: err.message });
+    reporter.flush();
+    process.exitCode = err.name === "BlueprintLoadError" || err.name === "RecipeLoadError" ? 1 : 2;
+    return;
+  }
+  reporter.flush();
+}

package/src/commands/index.js

@@ -0,0 +1,9 @@
+export { default as initCmd } from "./init.js";
+export { default as generatePageCmd } from "./generate/page.js";
+export { default as generateModuleCmd } from "./generate/module.js";
+export { default as presetCmd } from "./preset.js";
+export { default as finalizeCmd } from "./finalize.js";
+export { default as rollbackCmd } from "./rollback.js";
+export { default as doctorCmd } from "./doctor.js";
+export { default as cleanupCmd } from "./cleanup.js";
+export { getConfigPaths } from "./generate/page.js";