@gravito/scaffold 1.0.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,3269 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseGenerator: () => BaseGenerator,
+  CleanArchitectureGenerator: () => CleanArchitectureGenerator,
+  DddGenerator: () => DddGenerator,
+  EnterpriseMvcGenerator: () => EnterpriseMvcGenerator,
+  Scaffold: () => Scaffold,
+  StubGenerator: () => StubGenerator
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/generators/BaseGenerator.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/generators/StubGenerator.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_handlebars = __toESM(require("handlebars"), 1);
+var StubGenerator = class {
+  config;
+  handlebars;
+  constructor(config) {
+    this.config = config;
+    this.handlebars = import_handlebars.default.create();
+    this.registerBuiltinHelpers();
+    if (config.helpers) {
+      for (const [name, helper] of Object.entries(config.helpers)) {
+        this.handlebars.registerHelper(name, helper);
+      }
+    }
+  }
+  /**
+   * Register built-in Handlebars helpers.
+   */
+  registerBuiltinHelpers() {
+    this.handlebars.registerHelper("capitalize", (str) => {
+      if (!str) {
+        return "";
+      }
+      return str.charAt(0).toUpperCase() + str.slice(1);
+    });
+    this.handlebars.registerHelper("lowercase", (str) => {
+      return str?.toLowerCase() ?? "";
+    });
+    this.handlebars.registerHelper("uppercase", (str) => {
+      return str?.toUpperCase() ?? "";
+    });
+    this.handlebars.registerHelper("camelCase", (str) => {
+      if (!str) {
+        return "";
+      }
+      return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toLowerCase());
+    });
+    this.handlebars.registerHelper("pascalCase", (str) => {
+      if (!str) {
+        return "";
+      }
+      return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toUpperCase());
+    });
+    this.handlebars.registerHelper("snakeCase", (str) => {
+      if (!str) {
+        return "";
+      }
+      return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").replace(/[-\s]+/g, "_");
+    });
+    this.handlebars.registerHelper("kebabCase", (str) => {
+      if (!str) {
+        return "";
+      }
+      return str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "").replace(/[_\s]+/g, "-");
+    });
+    this.handlebars.registerHelper("pluralize", (str) => {
+      if (!str) {
+        return "";
+      }
+      if (str.endsWith("y")) {
+        return `${str.slice(0, -1)}ies`;
+      }
+      if (str.endsWith("s") || str.endsWith("x") || str.endsWith("ch") || str.endsWith("sh")) {
+        return `${str}es`;
+      }
+      return `${str}s`;
+    });
+    this.handlebars.registerHelper("date", (format) => {
+      const now = /* @__PURE__ */ new Date();
+      if (format === "iso") {
+        return now.toISOString();
+      }
+      if (format === "year") {
+        return now.getFullYear().toString();
+      }
+      return now.toISOString().split("T")[0];
+    });
+    this.handlebars.registerHelper("eq", (a, b) => a === b);
+    this.handlebars.registerHelper("neq", (a, b) => a !== b);
+  }
+  /**
+   * Generate a file from a stub template.
+   *
+   * @param stubName - Name of the stub file (relative to stubsDir)
+   * @param outputPath - Output path (relative to outputDir)
+   * @param variables - Template variables
+   * @returns Path to the generated file
+   */
+  async generate(stubName, outputPath, variables = {}) {
+    const stubPath = import_node_path.default.resolve(this.config.stubsDir, stubName);
+    const template = await import_promises.default.readFile(stubPath, "utf-8");
+    const compiled = this.handlebars.compile(template);
+    const content = compiled({
+      ...this.config.defaultVariables,
+      ...variables
+    });
+    const fullOutputPath = import_node_path.default.resolve(this.config.outputDir, outputPath);
+    await import_promises.default.mkdir(import_node_path.default.dirname(fullOutputPath), { recursive: true });
+    await import_promises.default.writeFile(fullOutputPath, content, "utf-8");
+    return fullOutputPath;
+  }
+  /**
+   * Generate multiple files from a stub template.
+   *
+   * @param stubName - Name of the stub file
+   * @param outputs - Array of [outputPath, variables] tuples
+   * @returns Array of generated file paths
+   */
+  async generateMany(stubName, outputs) {
+    const results = [];
+    for (const [outputPath, variables] of outputs) {
+      const result = await this.generate(stubName, outputPath, variables);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Render a template string directly.
+   *
+   * @param template - Template string
+   * @param variables - Template variables
+   * @returns Rendered content
+   */
+  render(template, variables = {}) {
+    const compiled = this.handlebars.compile(template);
+    return compiled({
+      ...this.config.defaultVariables,
+      ...variables
+    });
+  }
+  /**
+   * Register a custom Handlebars helper.
+   *
+   * @param name - Helper name
+   * @param helper - Helper function
+   */
+  registerHelper(name, helper) {
+    this.handlebars.registerHelper(name, helper);
+  }
+  /**
+   * Register a Handlebars partial.
+   *
+   * @param name - Partial name
+   * @param partial - Partial template string
+   */
+  registerPartial(name, partial) {
+    this.handlebars.registerPartial(name, partial);
+  }
+};
+
+// src/generators/BaseGenerator.ts
+var BaseGenerator = class {
+  config;
+  stubGenerator;
+  filesCreated = [];
+  constructor(config) {
+    this.config = config;
+    this.stubGenerator = new StubGenerator({
+      stubsDir: config.templatesDir,
+      outputDir: ""
+      // Set per-generation
+    });
+  }
+  /**
+   * Generate the project scaffold.
+   *
+   * @param context - Generator context
+   * @returns Array of created file paths
+   */
+  async generate(context) {
+    this.filesCreated = [];
+    const structure = this.getDirectoryStructure(context);
+    await this.createStructure(context.targetDir, structure, context);
+    await this.generateCommonFiles(context);
+    return this.filesCreated;
+  }
+  /**
+   * Create directory structure recursively.
+   */
+  async createStructure(basePath, nodes, context) {
+    for (const node of nodes) {
+      const fullPath = import_node_path2.default.resolve(basePath, node.name);
+      if (node.type === "directory") {
+        await import_promises2.default.mkdir(fullPath, { recursive: true });
+        this.log(`\u{1F4C1} Created directory: ${node.name}`);
+        if (node.children) {
+          await this.createStructure(fullPath, node.children, context);
+        }
+      } else {
+        await import_promises2.default.mkdir(import_node_path2.default.dirname(fullPath), { recursive: true });
+        if (node.template) {
+          const templatePath = import_node_path2.default.resolve(this.config.templatesDir, node.template);
+          try {
+            const template = await import_promises2.default.readFile(templatePath, "utf-8");
+            const content = this.stubGenerator.render(template, context);
+            await import_promises2.default.writeFile(fullPath, content, "utf-8");
+          } catch {
+            await import_promises2.default.writeFile(fullPath, node.content ?? "", "utf-8");
+          }
+        } else if (node.content) {
+          await import_promises2.default.writeFile(fullPath, node.content, "utf-8");
+        } else {
+          await import_promises2.default.writeFile(fullPath, "", "utf-8");
+        }
+        this.filesCreated.push(fullPath);
+        this.log(`\u{1F4C4} Created file: ${node.name}`);
+      }
+    }
+  }
+  /**
+   * Generate common files (package.json, .env, etc.)
+   */
+  async generateCommonFiles(context) {
+    await this.writeFile(context.targetDir, "package.json", this.generatePackageJson(context));
+    await this.writeFile(context.targetDir, ".env.example", this.generateEnvExample(context));
+    await this.writeFile(context.targetDir, ".env", this.generateEnvExample(context));
+    await this.writeFile(context.targetDir, ".gitignore", this.generateGitignore());
+    await this.writeFile(context.targetDir, "tsconfig.json", this.generateTsConfig());
+    await this.writeFile(
+      context.targetDir,
+      "ARCHITECTURE.md",
+      this.generateArchitectureDoc(context)
+    );
+  }
+  /**
+   * Write a file and track it.
+   */
+  async writeFile(basePath, relativePath, content) {
+    const fullPath = import_node_path2.default.resolve(basePath, relativePath);
+    await import_promises2.default.mkdir(import_node_path2.default.dirname(fullPath), { recursive: true });
+    await import_promises2.default.writeFile(fullPath, content, "utf-8");
+    this.filesCreated.push(fullPath);
+    this.log(`\u{1F4C4} Created file: ${relativePath}`);
+  }
+  /**
+   * Generate package.json content.
+   */
+  generatePackageJson(context) {
+    const pkg = {
+      name: context.nameKebabCase,
+      version: "0.1.0",
+      type: "module",
+      scripts: {
+        dev: "bun run --watch src/bootstrap.ts",
+        build: "bun build ./src/bootstrap.ts --outdir ./dist --target bun",
+        start: "bun run dist/bootstrap.js",
+        test: "bun test",
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        "gravito-core": "^1.0.0-beta.5"
+      },
+      devDependencies: {
+        "@types/bun": "latest",
+        typescript: "^5.0.0"
+      }
+    };
+    return JSON.stringify(pkg, null, 2);
+  }
+  /**
+   * Generate .env.example content.
+   */
+  generateEnvExample(context) {
+    return `# Application
+APP_NAME="${context.name}"
+APP_ENV=development
+APP_KEY=
+APP_DEBUG=true
+APP_URL=http://localhost:3000
+
+# Server
+PORT=3000
+
+# Database
+DB_CONNECTION=sqlite
+DB_DATABASE=database/database.sqlite
+
+# Cache
+CACHE_DRIVER=memory
+
+# Logging
+LOG_LEVEL=debug
+`;
+  }
+  /**
+   * Generate .gitignore content.
+   */
+  generateGitignore() {
+    return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# System
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Database
+*.sqlite
+*.sqlite-journal
+
+# Coverage
+coverage/
+`;
+  }
+  /**
+   * Generate tsconfig.json content.
+   */
+  generateTsConfig() {
+    const config = {
+      compilerOptions: {
+        target: "ESNext",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        esModuleInterop: true,
+        strict: true,
+        skipLibCheck: true,
+        declaration: true,
+        outDir: "./dist",
+        rootDir: "./src",
+        baseUrl: ".",
+        paths: {
+          "@/*": ["./src/*"]
+        }
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"]
+    };
+    return JSON.stringify(config, null, 2);
+  }
+  /**
+   * Log a message if verbose mode is enabled.
+   */
+  log(message) {
+    if (this.config.verbose) {
+      console.log(message);
+    }
+  }
+  /**
+   * Create generator context from options.
+   */
+  static createContext(name, targetDir, architecture, packageManager = "bun", extra = {}) {
+    const now = /* @__PURE__ */ new Date();
+    const pascalCase = name.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toUpperCase());
+    const camelCase = pascalCase.replace(/^./, (c) => c.toLowerCase());
+    const snakeCase = name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").replace(/[-\s]+/g, "_");
+    const kebabCase = name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "").replace(/[_\s]+/g, "-");
+    return {
+      name,
+      namePascalCase: pascalCase,
+      nameCamelCase: camelCase,
+      nameSnakeCase: snakeCase,
+      nameKebabCase: kebabCase,
+      targetDir,
+      architecture,
+      packageManager,
+      year: now.getFullYear().toString(),
+      date: now.toISOString().split("T")[0] ?? now.toISOString().slice(0, 10),
+      ...extra
+    };
+  }
+};
+
+// src/generators/CleanArchitectureGenerator.ts
+var CleanArchitectureGenerator = class extends BaseGenerator {
+  get architectureType() {
+    return "clean";
+  }
+  get displayName() {
+    return "Clean Architecture";
+  }
+  get description() {
+    return "Uncle Bob's Clean Architecture with strict dependency rules and pure domain layer";
+  }
+  getDirectoryStructure(context) {
+    return [
+      {
+        type: "directory",
+        name: "config",
+        children: [
+          { type: "file", name: "app.ts", content: this.generateAppConfig(context) },
+          { type: "file", name: "database.ts", content: this.generateDatabaseConfig() },
+          { type: "file", name: "auth.ts", content: this.generateAuthConfig() },
+          { type: "file", name: "cache.ts", content: this.generateCacheConfig() },
+          { type: "file", name: "logging.ts", content: this.generateLoggingConfig() }
+        ]
+      },
+      {
+        type: "directory",
+        name: "src",
+        children: [
+          // Domain Layer (innermost - no dependencies)
+          {
+            type: "directory",
+            name: "Domain",
+            children: [
+              {
+                type: "directory",
+                name: "Entities",
+                children: [
+                  { type: "file", name: "Entity.ts", content: this.generateBaseEntity() },
+                  { type: "file", name: "User.ts", content: this.generateUserEntity() }
+                ]
+              },
+              {
+                type: "directory",
+                name: "ValueObjects",
+                children: [
+                  { type: "file", name: "ValueObject.ts", content: this.generateBaseValueObject() },
+                  { type: "file", name: "Email.ts", content: this.generateEmailValueObject() }
+                ]
+              },
+              {
+                type: "directory",
+                name: "Interfaces",
+                children: [
+                  {
+                    type: "file",
+                    name: "IUserRepository.ts",
+                    content: this.generateUserRepositoryInterface()
+                  }
+                ]
+              },
+              {
+                type: "directory",
+                name: "Exceptions",
+                children: [
+                  {
+                    type: "file",
+                    name: "DomainException.ts",
+                    content: this.generateDomainException()
+                  }
+                ]
+              }
+            ]
+          },
+          // Application Layer (use cases)
+          {
+            type: "directory",
+            name: "Application",
+            children: [
+              {
+                type: "directory",
+                name: "UseCases",
+                children: [
+                  {
+                    type: "directory",
+                    name: "User",
+                    children: [
+                      {
+                        type: "file",
+                        name: "CreateUser.ts",
+                        content: this.generateCreateUserUseCase()
+                      },
+                      { type: "file", name: "GetUser.ts", content: this.generateGetUserUseCase() }
+                    ]
+                  }
+                ]
+              },
+              {
+                type: "directory",
+                name: "DTOs",
+                children: [{ type: "file", name: "UserDTO.ts", content: this.generateUserDTO() }]
+              },
+              {
+                type: "directory",
+                name: "Interfaces",
+                children: [
+                  {
+                    type: "file",
+                    name: "IMailService.ts",
+                    content: this.generateMailServiceInterface()
+                  }
+                ]
+              }
+            ]
+          },
+          // Infrastructure Layer (external implementations)
+          {
+            type: "directory",
+            name: "Infrastructure",
+            children: [
+              {
+                type: "directory",
+                name: "Persistence",
+                children: [
+                  {
+                    type: "directory",
+                    name: "Repositories",
+                    children: [
+                      {
+                        type: "file",
+                        name: "UserRepository.ts",
+                        content: this.generateUserRepository()
+                      }
+                    ]
+                  },
+                  {
+                    type: "directory",
+                    name: "Migrations",
+                    children: [{ type: "file", name: ".gitkeep", content: "" }]
+                  }
+                ]
+              },
+              {
+                type: "directory",
+                name: "ExternalServices",
+                children: [
+                  { type: "file", name: "MailService.ts", content: this.generateMailService() }
+                ]
+              },
+              {
+                type: "directory",
+                name: "Providers",
+                children: [
+                  {
+                    type: "file",
+                    name: "AppServiceProvider.ts",
+                    content: this.generateAppServiceProvider(context)
+                  },
+                  {
+                    type: "file",
+                    name: "RepositoryServiceProvider.ts",
+                    content: this.generateRepositoryServiceProvider()
+                  }
+                ]
+              }
+            ]
+          },
+          // Interface Layer (controllers, presenters)
+          {
+            type: "directory",
+            name: "Interface",
+            children: [
+              {
+                type: "directory",
+                name: "Http",
+                children: [
+                  {
+                    type: "directory",
+                    name: "Controllers",
+                    children: [
+                      {
+                        type: "file",
+                        name: "UserController.ts",
+                        content: this.generateUserController()
+                      }
+                    ]
+                  },
+                  {
+                    type: "directory",
+                    name: "Middleware",
+                    children: [{ type: "file", name: ".gitkeep", content: "" }]
+                  },
+                  {
+                    type: "directory",
+                    name: "Routes",
+                    children: [{ type: "file", name: "api.ts", content: this.generateApiRoutes() }]
+                  }
+                ]
+              },
+              {
+                type: "directory",
+                name: "Presenters",
+                children: [
+                  { type: "file", name: "UserPresenter.ts", content: this.generateUserPresenter() }
+                ]
+              }
+            ]
+          },
+          { type: "file", name: "bootstrap.ts", content: this.generateBootstrap(context) }
+        ]
+      },
+      {
+        type: "directory",
+        name: "tests",
+        children: [
+          {
+            type: "directory",
+            name: "Unit",
+            children: [
+              {
+                type: "directory",
+                name: "Domain",
+                children: [{ type: "file", name: ".gitkeep", content: "" }]
+              },
+              {
+                type: "directory",
+                name: "Application",
+                children: [{ type: "file", name: ".gitkeep", content: "" }]
+              }
+            ]
+          },
+          {
+            type: "directory",
+            name: "Integration",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          }
+        ]
+      }
+    ];
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Config Generators (similar to MVC but simplified)
+  // ─────────────────────────────────────────────────────────────
+  generateAppConfig(context) {
+    return `export default {
+  name: process.env.APP_NAME ?? '${context.name}',
+  env: process.env.APP_ENV ?? 'development',
+  debug: process.env.APP_DEBUG === 'true',
+  url: process.env.APP_URL ?? 'http://localhost:3000',
+  key: process.env.APP_KEY,
+}
+`;
+  }
+  generateDatabaseConfig() {
+    return `export default {
+  default: process.env.DB_CONNECTION ?? 'sqlite',
+  connections: {
+    sqlite: {
+      driver: 'sqlite',
+      database: process.env.DB_DATABASE ?? 'database/database.sqlite',
+    },
+  },
+}
+`;
+  }
+  generateAuthConfig() {
+    return `export default {
+  defaults: { guard: 'web' },
+  guards: {
+    web: { driver: 'session', provider: 'users' },
+    api: { driver: 'token', provider: 'users' },
+  },
+}
+`;
+  }
+  generateCacheConfig() {
+    return `export default {
+  default: process.env.CACHE_DRIVER ?? 'memory',
+  stores: {
+    memory: { driver: 'memory' },
+  },
+}
+`;
+  }
+  generateLoggingConfig() {
+    return `export default {
+  default: process.env.LOG_CHANNEL ?? 'console',
+  channels: {
+    console: { driver: 'console', level: process.env.LOG_LEVEL ?? 'debug' },
+  },
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Domain Layer
+  // ─────────────────────────────────────────────────────────────
+  generateBaseEntity() {
+    return `/**
+ * Base Entity
+ *
+ * All domain entities extend this base class.
+ * Entities have identity and lifecycle.
+ *
+ * IMPORTANT: This layer must have NO external dependencies.
+ */
+
+export abstract class Entity<T> {
+  protected readonly _id: T
+
+  constructor(id: T) {
+    this._id = id
+  }
+
+  get id(): T {
+    return this._id
+  }
+
+  equals(other: Entity<T>): boolean {
+    if (other === null || other === undefined) {
+      return false
+    }
+    if (!(other instanceof Entity)) {
+      return false
+    }
+    return this._id === other._id
+  }
+}
+`;
+  }
+  generateUserEntity() {
+    return `/**
+ * User Entity
+ *
+ * Core domain entity representing a user.
+ * Contains business logic related to users.
+ */
+
+import { Entity } from './Entity'
+import { Email } from '../ValueObjects/Email'
+
+export interface UserProps {
+  name: string
+  email: Email
+  createdAt: Date
+  updatedAt?: Date
+}
+
+export class User extends Entity<string> {
+  private props: UserProps
+
+  private constructor(id: string, props: UserProps) {
+    super(id)
+    this.props = props
+  }
+
+  static create(id: string, name: string, email: string): User {
+    return new User(id, {
+      name,
+      email: Email.create(email),
+      createdAt: new Date(),
+    })
+  }
+
+  static reconstitute(id: string, props: UserProps): User {
+    return new User(id, props)
+  }
+
+  get name(): string {
+    return this.props.name
+  }
+
+  get email(): Email {
+    return this.props.email
+  }
+
+  get createdAt(): Date {
+    return this.props.createdAt
+  }
+
+  updateName(name: string): void {
+    if (!name || name.trim().length === 0) {
+      throw new Error('Name cannot be empty')
+    }
+    this.props.name = name.trim()
+    this.props.updatedAt = new Date()
+  }
+}
+`;
+  }
+  generateBaseValueObject() {
+    return `/**
+ * Base Value Object
+ *
+ * Value objects are immutable and compared by value.
+ * They have no identity of their own.
+ */
+
+export abstract class ValueObject<T> {
+  protected readonly props: T
+
+  constructor(props: T) {
+    this.props = Object.freeze(props)
+  }
+
+  equals(other: ValueObject<T>): boolean {
+    if (other === null || other === undefined) {
+      return false
+    }
+    return JSON.stringify(this.props) === JSON.stringify(other.props)
+  }
+}
+`;
+  }
+  generateEmailValueObject() {
+    return `/**
+ * Email Value Object
+ *
+ * Encapsulates email validation and comparison.
+ */
+
+import { ValueObject } from './ValueObject'
+
+interface EmailProps {
+  value: string
+}
+
+export class Email extends ValueObject<EmailProps> {
+  private constructor(props: EmailProps) {
+    super(props)
+  }
+
+  static create(email: string): Email {
+    if (!Email.isValid(email)) {
+      throw new Error(\`Invalid email: \${email}\`)
+    }
+    return new Email({ value: email.toLowerCase().trim() })
+  }
+
+  static isValid(email: string): boolean {
+    const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/
+    return emailRegex.test(email)
+  }
+
+  get value(): string {
+    return this.props.value
+  }
+
+  toString(): string {
+    return this.value
+  }
+}
+`;
+  }
+  generateUserRepositoryInterface() {
+    return `/**
+ * User Repository Interface
+ *
+ * Defines the contract for user persistence.
+ * Implementations are in Infrastructure layer.
+ */
+
+import type { User } from '../Entities/User'
+
+export interface IUserRepository {
+  findById(id: string): Promise<User | null>
+  findByEmail(email: string): Promise<User | null>
+  save(user: User): Promise<void>
+  delete(id: string): Promise<void>
+  findAll(): Promise<User[]>
+}
+`;
+  }
+  generateDomainException() {
+    return `/**
+ * Domain Exception
+ *
+ * Base exception for domain-level errors.
+ */
+
+export class DomainException extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'DomainException'
+  }
+}
+
+export class EntityNotFoundException extends DomainException {
+  constructor(entity: string, id: string) {
+    super(\`\${entity} with id \${id} not found\`)
+    this.name = 'EntityNotFoundException'
+  }
+}
+
+export class InvalidValueException extends DomainException {
+  constructor(message: string) {
+    super(message)
+    this.name = 'InvalidValueException'
+  }
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Application Layer
+  // ─────────────────────────────────────────────────────────────
+  generateCreateUserUseCase() {
+    return `/**
+ * Create User Use Case
+ *
+ * Application service for creating new users.
+ */
+
+import { User } from '../../../Domain/Entities/User'
+import type { IUserRepository } from '../../../Domain/Interfaces/IUserRepository'
+import type { UserDTO } from '../../DTOs/UserDTO'
+
+export interface CreateUserInput {
+  name: string
+  email: string
+}
+
+export interface CreateUserOutput {
+  user: UserDTO
+}
+
+export class CreateUserUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  async execute(input: CreateUserInput): Promise<CreateUserOutput> {
+    // Check if email already exists
+    const existing = await this.userRepository.findByEmail(input.email)
+    if (existing) {
+      throw new Error('User with this email already exists')
+    }
+
+    // Create user entity
+    const user = User.create(
+      crypto.randomUUID(),
+      input.name,
+      input.email
+    )
+
+    // Persist
+    await this.userRepository.save(user)
+
+    // Return DTO
+    return {
+      user: {
+        id: user.id,
+        name: user.name,
+        email: user.email.value,
+        createdAt: user.createdAt.toISOString(),
+      },
+    }
+  }
+}
+`;
+  }
+  generateGetUserUseCase() {
+    return `/**
+ * Get User Use Case
+ */
+
+import type { IUserRepository } from '../../../Domain/Interfaces/IUserRepository'
+import { EntityNotFoundException } from '../../../Domain/Exceptions/DomainException'
+import type { UserDTO } from '../../DTOs/UserDTO'
+
+export interface GetUserInput {
+  id: string
+}
+
+export interface GetUserOutput {
+  user: UserDTO
+}
+
+export class GetUserUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  async execute(input: GetUserInput): Promise<GetUserOutput> {
+    const user = await this.userRepository.findById(input.id)
+
+    if (!user) {
+      throw new EntityNotFoundException('User', input.id)
+    }
+
+    return {
+      user: {
+        id: user.id,
+        name: user.name,
+        email: user.email.value,
+        createdAt: user.createdAt.toISOString(),
+      },
+    }
+  }
+}
+`;
+  }
+  generateUserDTO() {
+    return `/**
+ * User Data Transfer Object
+ *
+ * Used for transferring user data across boundaries.
+ */
+
+export interface UserDTO {
+  id: string
+  name: string
+  email: string
+  createdAt: string
+  updatedAt?: string
+}
+
+export interface CreateUserDTO {
+  name: string
+  email: string
+}
+
+export interface UpdateUserDTO {
+  name?: string
+  email?: string
+}
+`;
+  }
+  generateMailServiceInterface() {
+    return `/**
+ * Mail Service Interface
+ *
+ * Contract for email sending functionality.
+ */
+
+export interface MailMessage {
+  to: string
+  subject: string
+  body: string
+  html?: string
+}
+
+export interface IMailService {
+  send(message: MailMessage): Promise<void>
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Infrastructure Layer
+  // ─────────────────────────────────────────────────────────────
+  generateUserRepository() {
+    return `/**
+ * User Repository Implementation
+ *
+ * Concrete implementation of IUserRepository.
+ */
+
+import type { User } from '../../../Domain/Entities/User'
+import type { IUserRepository } from '../../../Domain/Interfaces/IUserRepository'
+
+// In-memory store for demo purposes
+const users = new Map<string, User>()
+
+export class UserRepository implements IUserRepository {
+  async findById(id: string): Promise<User | null> {
+    return users.get(id) ?? null
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    for (const user of users.values()) {
+      if (user.email.value === email) {
+        return user
+      }
+    }
+    return null
+  }
+
+  async save(user: User): Promise<void> {
+    users.set(user.id, user)
+  }
+
+  async delete(id: string): Promise<void> {
+    users.delete(id)
+  }
+
+  async findAll(): Promise<User[]> {
+    return Array.from(users.values())
+  }
+}
+`;
+  }
+  generateMailService() {
+    return `/**
+ * Mail Service Implementation
+ */
+
+import type { IMailService, MailMessage } from '../../Application/Interfaces/IMailService'
+
+export class MailService implements IMailService {
+  async send(message: MailMessage): Promise<void> {
+    // TODO: Implement actual email sending
+    console.log(\`[Mail] Sending to \${message.to}: \${message.subject}\`)
+  }
+}
+`;
+  }
+  generateAppServiceProvider(context) {
+    return `/**
+ * App Service Provider
+ */
+
+import { ServiceProvider, type Container, type PlanetCore } from 'gravito-core'
+
+export class AppServiceProvider extends ServiceProvider {
+  register(_container: Container): void {
+    // Register application services
+  }
+
+  boot(_core: PlanetCore): void {
+    console.log('${context.name} (Clean Architecture) booted!')
+  }
+}
+`;
+  }
+  generateRepositoryServiceProvider() {
+    return `/**
+ * Repository Service Provider
+ *
+ * Binds repository interfaces to implementations.
+ */
+
+import { ServiceProvider, type Container } from 'gravito-core'
+import { UserRepository } from '../Persistence/Repositories/UserRepository'
+import { MailService } from '../ExternalServices/MailService'
+
+export class RepositoryServiceProvider extends ServiceProvider {
+  register(container: Container): void {
+    // Bind repositories
+    container.singleton('userRepository', () => new UserRepository())
+
+    // Bind external services
+    container.singleton('mailService', () => new MailService())
+  }
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Interface Layer
+  // ─────────────────────────────────────────────────────────────
+  generateUserController() {
+    return `/**
+ * User Controller
+ */
+
+import type { GravitoContext } from 'gravito-core'
+import { CreateUserUseCase } from '../../../Application/UseCases/User/CreateUser'
+import { GetUserUseCase } from '../../../Application/UseCases/User/GetUser'
+import { UserRepository } from '../../../Infrastructure/Persistence/Repositories/UserRepository'
+
+const userRepository = new UserRepository()
+
+export class UserController {
+  async create(c: GravitoContext) {
+    const body = await c.req.json() as { name: string; email: string }
+    const useCase = new CreateUserUseCase(userRepository)
+
+    const result = await useCase.execute({
+      name: body.name,
+      email: body.email,
+    })
+
+    return c.json({ success: true, data: result.user }, 201)
+  }
+
+  async show(c: GravitoContext) {
+    const id = c.req.param('id') ?? ''
+    const useCase = new GetUserUseCase(userRepository)
+
+    const result = await useCase.execute({ id })
+
+    return c.json({ success: true, data: result.user })
+  }
+}
+`;
+  }
+  generateApiRoutes() {
+    return `/**
+ * API Routes
+ */
+
+import { UserController } from '../Controllers/UserController'
+
+export function registerApiRoutes(router: any): void {
+  const users = new UserController()
+
+  router.post('/api/users', (c: any) => users.create(c))
+  router.get('/api/users/:id', (c: any) => users.show(c))
+}
+`;
+  }
+  generateUserPresenter() {
+    return `/**
+ * User Presenter
+ *
+ * Formats user data for different output formats.
+ */
+
+import type { UserDTO } from '../../Application/DTOs/UserDTO'
+
+export class UserPresenter {
+  static toJson(user: UserDTO): object {
+    return {
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      created_at: user.createdAt,
+    }
+  }
+
+  static toList(users: UserDTO[]): object {
+    return {
+      data: users.map((u) => this.toJson(u)),
+      total: users.length,
+    }
+  }
+}
+`;
+  }
+  generateBootstrap(context) {
+    return `/**
+ * Application Bootstrap
+ */
+
+import { PlanetCore } from 'gravito-core'
+import { AppServiceProvider } from './Infrastructure/Providers/AppServiceProvider'
+import { RepositoryServiceProvider } from './Infrastructure/Providers/RepositoryServiceProvider'
+import { registerApiRoutes } from './Interface/Http/Routes/api'
+
+const core = new PlanetCore({
+  config: { APP_NAME: '${context.name}' },
+})
+
+core.register(new RepositoryServiceProvider())
+core.register(new AppServiceProvider())
+
+await core.bootstrap()
+
+// Register routes
+registerApiRoutes(core.router)
+
+export default core.liftoff()
+`;
+  }
+  generateArchitectureDoc(context) {
+    return `# ${context.name} - Clean Architecture Guide
+
+## Overview
+
+This project follows **Clean Architecture** (by Robert C. Martin).
+The key principle is the **Dependency Rule**: dependencies point inward.
+
+## Layer Structure
+
+\`\`\`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502                    Interface Layer                      \u2502
+\u2502              (Controllers, Presenters)                  \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502                 Infrastructure Layer                    \u2502
+\u2502          (Repositories, External Services)              \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502                  Application Layer                      \u2502
+\u2502                (Use Cases, DTOs)                        \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502                    Domain Layer                         \u2502
+\u2502        (Entities, Value Objects, Interfaces)            \u2502
+\u2502                   \u2B50 PURE \u2B50                             \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\`\`\`
+
+## Dependency Rule
+
+> Inner layers know nothing about outer layers.
+
+- **Domain**: No dependencies (pure TypeScript only)
+- **Application**: Depends only on Domain
+- **Infrastructure**: Implements Domain interfaces
+- **Interface**: Calls Application use cases
+
+## Directory Structure
+
+\`\`\`
+src/
+\u251C\u2500\u2500 Domain/                 # Enterprise Business Rules
+\u2502   \u251C\u2500\u2500 Entities/          # Business objects with identity
+\u2502   \u251C\u2500\u2500 ValueObjects/      # Immutable value types
+\u2502   \u251C\u2500\u2500 Interfaces/        # Repository contracts
+\u2502   \u2514\u2500\u2500 Exceptions/        # Domain errors
+\u251C\u2500\u2500 Application/           # Application Business Rules
+\u2502   \u251C\u2500\u2500 UseCases/          # Business operations
+\u2502   \u251C\u2500\u2500 DTOs/              # Data transfer objects
+\u2502   \u2514\u2500\u2500 Interfaces/        # Service contracts
+\u251C\u2500\u2500 Infrastructure/        # Frameworks & Drivers
+\u2502   \u251C\u2500\u2500 Persistence/       # Database implementations
+\u2502   \u251C\u2500\u2500 ExternalServices/  # Third-party integrations
+\u2502   \u2514\u2500\u2500 Providers/         # Service providers
+\u2514\u2500\u2500 Interface/             # Interface Adapters
+    \u251C\u2500\u2500 Http/              # HTTP controllers & routes
+    \u2514\u2500\u2500 Presenters/        # Output formatters
+\`\`\`
+
+## Key Benefits
+
+1. **Testable**: Domain and Use Cases can be tested without frameworks
+2. **Independent**: Business logic is framework-agnostic
+3. **Maintainable**: Changes in outer layers don't affect inner layers
+4. **Flexible**: Easy to swap databases or frameworks
+
+Created with \u2764\uFE0F using Gravito Framework
+`;
+  }
+};
+
+// src/generators/DddGenerator.ts
+var DddGenerator = class extends BaseGenerator {
+  get architectureType() {
+    return "ddd";
+  }
+  get displayName() {
+    return "Domain-Driven Design (DDD)";
+  }
+  get description() {
+    return "Full DDD with Bounded Contexts, Aggregates, and Event-Driven patterns";
+  }
+  getDirectoryStructure(context) {
+    return [
+      {
+        type: "directory",
+        name: "config",
+        children: [
+          { type: "file", name: "app.ts", content: this.generateAppConfig(context) },
+          { type: "file", name: "database.ts", content: this.generateDatabaseConfig() },
+          { type: "file", name: "modules.ts", content: this.generateModulesConfig() },
+          { type: "file", name: "cache.ts", content: this.generateCacheConfig() },
+          { type: "file", name: "logging.ts", content: this.generateLoggingConfig() }
+        ]
+      },
+      {
+        type: "directory",
+        name: "src",
+        children: [
+          // Bootstrap - Application startup and configuration
+          this.generateBootstrapDirectory(context),
+          // Shared - Cross-module shared components
+          this.generateShared(),
+          // Modules - Bounded Contexts
+          {
+            type: "directory",
+            name: "Modules",
+            children: [
+              this.generateModule("Ordering", context),
+              this.generateModule("Catalog", context)
+            ]
+          },
+          { type: "file", name: "main.ts", content: this.generateMainEntry(context) }
+        ]
+      },
+      {
+        type: "directory",
+        name: "tests",
+        children: [
+          {
+            type: "directory",
+            name: "Modules",
+            children: [
+              {
+                type: "directory",
+                name: "Ordering",
+                children: [
+                  {
+                    type: "directory",
+                    name: "Unit",
+                    children: [{ type: "file", name: ".gitkeep", content: "" }]
+                  },
+                  {
+                    type: "directory",
+                    name: "Integration",
+                    children: [{ type: "file", name: ".gitkeep", content: "" }]
+                  }
+                ]
+              },
+              {
+                type: "directory",
+                name: "Catalog",
+                children: [
+                  {
+                    type: "directory",
+                    name: "Unit",
+                    children: [{ type: "file", name: ".gitkeep", content: "" }]
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            type: "directory",
+            name: "Shared",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          }
+        ]
+      }
+    ];
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Bootstrap Directory
+  // ─────────────────────────────────────────────────────────────
+  generateBootstrapDirectory(context) {
+    return {
+      type: "directory",
+      name: "Bootstrap",
+      children: [
+        { type: "file", name: "app.ts", content: this.generateBootstrapApp(context) },
+        { type: "file", name: "providers.ts", content: this.generateProvidersRegistry(context) },
+        { type: "file", name: "events.ts", content: this.generateEventsRegistry() },
+        { type: "file", name: "routes.ts", content: this.generateRoutesRegistry(context) }
+      ]
+    };
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Shared Directory (replaces SharedKernel with user's structure)
+  // ─────────────────────────────────────────────────────────────
+  generateShared() {
+    return {
+      type: "directory",
+      name: "Shared",
+      children: [
+        {
+          type: "directory",
+          name: "Domain",
+          children: [
+            {
+              type: "directory",
+              name: "ValueObjects",
+              children: [
+                { type: "file", name: "Id.ts", content: this.generateIdValueObject() },
+                { type: "file", name: "Money.ts", content: this.generateMoneyValueObject() },
+                { type: "file", name: "Email.ts", content: this.generateEmailValueObject() }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Events",
+              children: [
+                { type: "file", name: "DomainEvent.ts", content: this.generateDomainEvent() }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Primitives",
+              children: [
+                { type: "file", name: "AggregateRoot.ts", content: this.generateAggregateRoot() },
+                { type: "file", name: "Entity.ts", content: this.generateEntity() },
+                { type: "file", name: "ValueObject.ts", content: this.generateValueObject() }
+              ]
+            }
+          ]
+        },
+        {
+          type: "directory",
+          name: "Infrastructure",
+          children: [
+            {
+              type: "directory",
+              name: "EventBus",
+              children: [
+                {
+                  type: "file",
+                  name: "EventDispatcher.ts",
+                  content: this.generateEventDispatcher()
+                }
+              ]
+            }
+          ]
+        },
+        {
+          type: "directory",
+          name: "Exceptions",
+          children: [
+            { type: "file", name: "Handler.ts", content: this.generateExceptionHandler() }
+          ]
+        }
+      ]
+    };
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Module Generator (replaces Bounded Context)
+  // ─────────────────────────────────────────────────────────────
+  generateModule(name, context) {
+    return {
+      type: "directory",
+      name,
+      children: [
+        // Domain Layer
+        {
+          type: "directory",
+          name: "Domain",
+          children: [
+            {
+              type: "directory",
+              name: "Aggregates",
+              children: [
+                {
+                  type: "directory",
+                  name,
+                  children: [
+                    { type: "file", name: `${name}.ts`, content: this.generateAggregate(name) },
+                    {
+                      type: "file",
+                      name: `${name}Status.ts`,
+                      content: this.generateAggregateStatus(name)
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Events",
+              children: [
+                {
+                  type: "file",
+                  name: `${name}Created.ts`,
+                  content: this.generateCreatedEvent(name)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Repositories",
+              children: [
+                {
+                  type: "file",
+                  name: `I${name}Repository.ts`,
+                  content: this.generateRepositoryInterface(name)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Services",
+              children: [{ type: "file", name: ".gitkeep", content: "" }]
+            }
+          ]
+        },
+        // Application Layer
+        {
+          type: "directory",
+          name: "Application",
+          children: [
+            {
+              type: "directory",
+              name: "Commands",
+              children: [
+                {
+                  type: "directory",
+                  name: `Create${name}`,
+                  children: [
+                    {
+                      type: "file",
+                      name: `Create${name}Command.ts`,
+                      content: this.generateCommand(name)
+                    },
+                    {
+                      type: "file",
+                      name: `Create${name}Handler.ts`,
+                      content: this.generateCommandHandler(name)
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Queries",
+              children: [
+                {
+                  type: "directory",
+                  name: `Get${name}ById`,
+                  children: [
+                    {
+                      type: "file",
+                      name: `Get${name}ByIdQuery.ts`,
+                      content: this.generateQuery(name)
+                    },
+                    {
+                      type: "file",
+                      name: `Get${name}ByIdHandler.ts`,
+                      content: this.generateQueryHandler(name)
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "DTOs",
+              children: [{ type: "file", name: `${name}DTO.ts`, content: this.generateDTO(name) }]
+            }
+          ]
+        },
+        // Infrastructure Layer
+        {
+          type: "directory",
+          name: "Infrastructure",
+          children: [
+            {
+              type: "directory",
+              name: "Persistence",
+              children: [
+                {
+                  type: "file",
+                  name: `${name}Repository.ts`,
+                  content: this.generateRepository(name)
+                }
+              ]
+            },
+            {
+              type: "directory",
+              name: "Providers",
+              children: [
+                {
+                  type: "file",
+                  name: `${name}ServiceProvider.ts`,
+                  content: this.generateModuleServiceProvider(name, context)
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    };
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Bootstrap File Generators
+  // ─────────────────────────────────────────────────────────────
+  generateBootstrapApp(context) {
+    return `/**
+ * Application Bootstrap
+ *
+ * Central configuration and initialization of the application.
+ */
+
+import { PlanetCore } from 'gravito-core'
+import { registerProviders } from './providers'
+import { registerRoutes } from './routes'
+
+export async function createApp(): Promise<PlanetCore> {
+    const core = new PlanetCore({
+        config: {
+            APP_NAME: '${context.name}',
+        },
+    })
+
+    // Register all service providers
+    await registerProviders(core)
+
+    // Bootstrap the application
+    await core.bootstrap()
+
+    // Register routes
+    registerRoutes(core.router)
+
+    return core
+}
+`;
+  }
+  generateProvidersRegistry(_context) {
+    return `/**
+ * Service Providers Registry
+ *
+ * Register all module service providers here.
+ */
+
+import type { PlanetCore } from 'gravito-core'
+import { OrderingServiceProvider } from '../Modules/Ordering/Infrastructure/Providers/OrderingServiceProvider'
+import { CatalogServiceProvider } from '../Modules/Catalog/Infrastructure/Providers/CatalogServiceProvider'
+
+export async function registerProviders(core: PlanetCore): Promise<void> {
+    // Register module providers
+    core.register(new OrderingServiceProvider())
+    core.register(new CatalogServiceProvider())
+
+    // Add more providers as needed
+}
+`;
+  }
+  generateEventsRegistry() {
+    return `/**
+ * Domain Events Registry
+ *
+ * Register all domain event handlers here.
+ */
+
+import { EventDispatcher } from '../Shared/Infrastructure/EventBus/EventDispatcher'
+
+export function registerEvents(dispatcher: EventDispatcher): void {
+    // Register event handlers
+    // dispatcher.subscribe('ordering.created', async (event) => { ... })
+}
+`;
+  }
+  generateRoutesRegistry(_context) {
+    return `/**
+ * Routes Registry
+ *
+ * Register all module routes here.
+ */
+
+export function registerRoutes(router: any): void {
+    // Health check
+    router.get('/health', (c: any) => c.json({ status: 'healthy' }))
+
+    // Ordering module
+    router.get('/api/orders', (c: any) => c.json({ message: 'Order list' }))
+    router.post('/api/orders', (c: any) => c.json({ message: 'Order created' }, 201))
+
+    // Catalog module
+    router.get('/api/products', (c: any) => c.json({ message: 'Product list' }))
+}
+`;
+  }
+  generateMainEntry(_context) {
+    return `/**
+ * Application Entry Point
+ *
+ * Start the HTTP server.
+ */
+
+import { createApp } from './Bootstrap/app'
+
+const app = await createApp()
+
+export default app.liftoff()
+`;
+  }
+  generateModulesConfig() {
+    return `/**
+ * Modules Configuration
+ *
+ * Define module boundaries and their dependencies.
+ */
+
+export default {
+    modules: {
+        ordering: {
+            name: 'Ordering',
+            description: 'Order management module',
+            prefix: '/api/orders',
+        },
+        catalog: {
+            name: 'Catalog',
+            description: 'Product catalog module',
+            prefix: '/api/products',
+        },
+    },
+
+    // Module dependencies
+    dependencies: {
+        ordering: ['catalog'], // Ordering depends on Catalog
+    },
+}
+`;
+  }
+  generateModuleServiceProvider(name, _context) {
+    return `/**
+ * ${name} Service Provider
+ */
+
+import { ServiceProvider, type Container, type PlanetCore } from 'gravito-core'
+import { ${name}Repository } from '../Persistence/${name}Repository'
+
+export class ${name}ServiceProvider extends ServiceProvider {
+    register(container: Container): void {
+        container.singleton('${name.toLowerCase()}Repository', () => new ${name}Repository())
+    }
+
+    boot(_core: PlanetCore): void {
+        console.log('[${name}] Module loaded')
+    }
+}
+`;
+  }
+  /**
+   * Override package.json for DDD architecture (uses main.ts instead of bootstrap.ts)
+   */
+  generatePackageJson(context) {
+    const pkg = {
+      name: context.nameKebabCase,
+      version: "0.1.0",
+      type: "module",
+      scripts: {
+        dev: "bun run --watch src/main.ts",
+        build: "bun build ./src/main.ts --outdir ./dist --target bun",
+        start: "bun run dist/main.js",
+        test: "bun test",
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        "gravito-core": "^1.0.0-beta.5"
+      },
+      devDependencies: {
+        "@types/bun": "latest",
+        typescript: "^5.0.0"
+      }
+    };
+    return JSON.stringify(pkg, null, 2);
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Config Generators
+  // ─────────────────────────────────────────────────────────────
+  generateAppConfig(context) {
+    return `export default {
+  name: process.env.APP_NAME ?? '${context.name}',
+  env: process.env.APP_ENV ?? 'development',
+  debug: process.env.APP_DEBUG === 'true',
+  url: process.env.APP_URL ?? 'http://localhost:3000',
+}
+`;
+  }
+  generateDatabaseConfig() {
+    return `export default {
+  default: process.env.DB_CONNECTION ?? 'sqlite',
+  connections: {
+    sqlite: { driver: 'sqlite', database: 'database/database.sqlite' },
+  },
+}
+`;
+  }
+  generateCacheConfig() {
+    return `export default {
+  default: process.env.CACHE_DRIVER ?? 'memory',
+  stores: { memory: { driver: 'memory' } },
+}
+`;
+  }
+  generateLoggingConfig() {
+    return `export default {
+  default: 'console',
+  channels: { console: { driver: 'console', level: 'debug' } },
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Shared Kernel Files
+  // ─────────────────────────────────────────────────────────────
+  generateIdValueObject() {
+    return `/**
+ * ID Value Object
+ *
+ * Shared identifier across all contexts.
+ */
+
+export class Id {
+  private readonly _value: string
+
+  private constructor(value: string) {
+    this._value = value
+  }
+
+  static create(): Id {
+    return new Id(crypto.randomUUID())
+  }
+
+  static from(value: string): Id {
+    if (!value) throw new Error('Id cannot be empty')
+    return new Id(value)
+  }
+
+  get value(): string {
+    return this._value
+  }
+
+  equals(other: Id): boolean {
+    return this._value === other._value
+  }
+
+  toString(): string {
+    return this._value
+  }
+}
+`;
+  }
+  generateMoneyValueObject() {
+    return `/**
+ * Money Value Object
+ */
+
+export class Money {
+  constructor(
+    public readonly amount: number,
+    public readonly currency: string = 'USD'
+  ) {
+    if (amount < 0) throw new Error('Amount cannot be negative')
+  }
+
+  add(other: Money): Money {
+    this.assertSameCurrency(other)
+    return new Money(this.amount + other.amount, this.currency)
+  }
+
+  subtract(other: Money): Money {
+    this.assertSameCurrency(other)
+    return new Money(this.amount - other.amount, this.currency)
+  }
+
+  private assertSameCurrency(other: Money): void {
+    if (this.currency !== other.currency) {
+      throw new Error('Cannot operate on different currencies')
+    }
+  }
+
+  equals(other: Money): boolean {
+    return this.amount === other.amount && this.currency === other.currency
+  }
+}
+`;
+  }
+  generateEmailValueObject() {
+    return `/**
+ * Email Value Object
+ */
+
+export class Email {
+  private readonly _value: string
+
+  private constructor(value: string) {
+    this._value = value.toLowerCase().trim()
+  }
+
+  static create(email: string): Email {
+    if (!Email.isValid(email)) {
+      throw new Error(\`Invalid email: \${email}\`)
+    }
+    return new Email(email)
+  }
+
+  static isValid(email: string): boolean {
+    return /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(email)
+  }
+
+  get value(): string {
+    return this._value
+  }
+}
+`;
+  }
+  generateDomainEvent() {
+    return `/**
+ * Domain Event Base
+ */
+
+export abstract class DomainEvent {
+  readonly occurredOn: Date
+  readonly eventId: string
+
+  constructor() {
+    this.occurredOn = new Date()
+    this.eventId = crypto.randomUUID()
+  }
+
+  abstract get eventName(): string
+  abstract get aggregateId(): string
+}
+`;
+  }
+  generateAggregateRoot() {
+    return `/**
+ * Aggregate Root Base
+ */
+
+import type { DomainEvent } from '../Events/DomainEvent'
+import type { Id } from '../ValueObjects/Id'
+
+export abstract class AggregateRoot<T extends Id = Id> {
+  private _domainEvents: DomainEvent[] = []
+
+  protected constructor(protected readonly _id: T) {}
+
+  get id(): T {
+    return this._id
+  }
+
+  get domainEvents(): DomainEvent[] {
+    return [...this._domainEvents]
+  }
+
+  protected addDomainEvent(event: DomainEvent): void {
+    this._domainEvents.push(event)
+  }
+
+  clearDomainEvents(): DomainEvent[] {
+    const events = [...this._domainEvents]
+    this._domainEvents = []
+    return events
+  }
+}
+`;
+  }
+  generateEntity() {
+    return `/**
+ * Entity Base
+ */
+
+import type { Id } from '../ValueObjects/Id'
+
+export abstract class Entity<T extends Id = Id> {
+  protected constructor(protected readonly _id: T) {}
+
+  get id(): T {
+    return this._id
+  }
+
+  equals(other: Entity<T>): boolean {
+    return this._id.equals(other._id)
+  }
+}
+`;
+  }
+  generateValueObject() {
+    return `/**
+ * Value Object Base
+ */
+
+export abstract class ValueObject<T> {
+  protected readonly props: T
+
+  constructor(props: T) {
+    this.props = Object.freeze(props)
+  }
+
+  equals(other: ValueObject<T>): boolean {
+    return JSON.stringify(this.props) === JSON.stringify(other.props)
+  }
+}
+`;
+  }
+  generateEventDispatcher() {
+    return `/**
+ * Event Dispatcher
+ */
+
+import type { DomainEvent } from '../../Domain/Events/DomainEvent'
+
+type EventHandler = (event: DomainEvent) => void | Promise<void>
+
+export class EventDispatcher {
+  private handlers: Map<string, EventHandler[]> = new Map()
+
+  subscribe(eventName: string, handler: EventHandler): void {
+    const handlers = this.handlers.get(eventName) ?? []
+    handlers.push(handler)
+    this.handlers.set(eventName, handlers)
+  }
+
+  async dispatch(event: DomainEvent): Promise<void> {
+    const handlers = this.handlers.get(event.eventName) ?? []
+    for (const handler of handlers) {
+      await handler(event)
+    }
+  }
+
+  async dispatchAll(events: DomainEvent[]): Promise<void> {
+    for (const event of events) {
+      await this.dispatch(event)
+    }
+  }
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Bounded Context Templates
+  // ─────────────────────────────────────────────────────────────
+  generateAggregate(name) {
+    return `/**
+ * ${name} Aggregate Root
+ */
+
+import { AggregateRoot } from '../../../../../Shared/Domain/Primitives/AggregateRoot'
+import { Id } from '../../../../../Shared/Domain/ValueObjects/Id'
+import { ${name}Created } from '../../Events/${name}Created'
+import { ${name}Status } from './${name}Status'
+
+export interface ${name}Props {
+  // Add properties here
+  status: ${name}Status
+  createdAt: Date
+}
+
+export class ${name} extends AggregateRoot {
+  private props: ${name}Props
+
+  private constructor(id: Id, props: ${name}Props) {
+    super(id)
+    this.props = props
+  }
+
+  static create(id: Id): ${name} {
+    const aggregate = new ${name}(id, {
+      status: ${name}Status.PENDING,
+      createdAt: new Date(),
+    })
+
+    aggregate.addDomainEvent(new ${name}Created(id.value))
+
+    return aggregate
+  }
+
+  get status(): ${name}Status {
+    return this.props.status
+  }
+
+  // Add domain methods here
+}
+`;
+  }
+  generateAggregateStatus(name) {
+    return `/**
+ * ${name} Status
+ */
+
+export enum ${name}Status {
+  PENDING = 'pending',
+  ACTIVE = 'active',
+  COMPLETED = 'completed',
+  CANCELLED = 'cancelled',
+}
+`;
+  }
+  generateCreatedEvent(name) {
+    return `/**
+ * ${name} Created Event
+ */
+
+import { DomainEvent } from '../../../../Shared/Domain/Events/DomainEvent'
+
+export class ${name}Created extends DomainEvent {
+  constructor(public readonly ${name.toLowerCase()}Id: string) {
+    super()
+  }
+
+  get eventName(): string {
+    return '${name.toLowerCase()}.created'
+  }
+
+  get aggregateId(): string {
+    return this.${name.toLowerCase()}Id
+  }
+}
+`;
+  }
+  generateRepositoryInterface(name) {
+    return `/**
+ * ${name} Repository Interface
+ */
+
+import type { ${name} } from '../Aggregates/${name}/${name}'
+
+export interface I${name}Repository {
+  findById(id: string): Promise<${name} | null>
+  save(aggregate: ${name}): Promise<void>
+  delete(id: string): Promise<void>
+}
+`;
+  }
+  generateCommand(name) {
+    return `/**
+ * Create ${name} Command
+ */
+
+export class Create${name}Command {
+  constructor(
+    // Add command properties
+    public readonly id?: string
+  ) {}
+}
+`;
+  }
+  generateCommandHandler(name) {
+    return `/**
+ * Create ${name} Handler
+ */
+
+import type { I${name}Repository } from '../../../Domain/Repositories/I${name}Repository'
+import { ${name} } from '../../../Domain/Aggregates/${name}/${name}'
+import { Id } from '../../../../../Shared/Domain/ValueObjects/Id'
+import type { Create${name}Command } from './Create${name}Command'
+
+export class Create${name}Handler {
+  constructor(private repository: I${name}Repository) {}
+
+  async handle(command: Create${name}Command): Promise<string> {
+    const id = command.id ? Id.from(command.id) : Id.create()
+    const aggregate = ${name}.create(id)
+
+    await this.repository.save(aggregate)
+
+    return id.value
+  }
+}
+`;
+  }
+  generateQuery(name) {
+    return `/**
+ * Get ${name} By Id Query
+ */
+
+export class Get${name}ByIdQuery {
+  constructor(public readonly id: string) {}
+}
+`;
+  }
+  generateQueryHandler(name) {
+    return `/**
+ * Get ${name} By Id Handler
+ */
+
+import type { I${name}Repository } from '../../../Domain/Repositories/I${name}Repository'
+import type { ${name}DTO } from '../../DTOs/${name}DTO'
+import type { Get${name}ByIdQuery } from './Get${name}ByIdQuery'
+
+export class Get${name}ByIdHandler {
+  constructor(private repository: I${name}Repository) {}
+
+  async handle(query: Get${name}ByIdQuery): Promise<${name}DTO | null> {
+    const aggregate = await this.repository.findById(query.id)
+    if (!aggregate) return null
+
+    return {
+      id: aggregate.id.value,
+      status: aggregate.status,
+    }
+  }
+}
+`;
+  }
+  generateDTO(name) {
+    return `/**
+ * ${name} DTO
+ */
+
+import type { ${name}Status } from '../../Domain/Aggregates/${name}/${name}Status'
+
+export interface ${name}DTO {
+  id: string
+  status: ${name}Status
+  // Add more fields
+}
+`;
+  }
+  generateRepository(name) {
+    return `/**
+ * ${name} Repository Implementation
+ */
+
+import type { ${name} } from '../../Domain/Aggregates/${name}/${name}'
+import type { I${name}Repository } from '../../Domain/Repositories/I${name}Repository'
+
+const store = new Map<string, ${name}>()
+
+export class ${name}Repository implements I${name}Repository {
+  async findById(id: string): Promise<${name} | null> {
+    return store.get(id) ?? null
+  }
+
+  async save(aggregate: ${name}): Promise<void> {
+    store.set(aggregate.id.value, aggregate)
+  }
+
+  async delete(id: string): Promise<void> {
+    store.delete(id)
+  }
+}
+`;
+  }
+  generateExceptionHandler() {
+    return `/**
+ * Exception Handler
+ */
+
+export function report(error: unknown): void {
+  console.error('[Exception]', error)
+}
+`;
+  }
+  generateArchitectureDoc(context) {
+    return `# ${context.name} - DDD Architecture Guide
+
+## Overview
+
+This project follows **Domain-Driven Design (DDD)** with strategic and tactical patterns.
+
+## Bounded Contexts
+
+\`\`\`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510     \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502    Ordering     \u2502\u2500\u2500\u2500\u2500\u25B6\u2502     Catalog     \u2502
+\u2502  (Core Domain)  \u2502     \u2502 (Supporting)    \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518     \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+        \u2502
+        \u25BC
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  SharedKernel   \u2502
+\u2502 (Shared Types)  \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\`\`\`
+
+## Context Structure
+
+Each bounded context follows this structure:
+
+\`\`\`
+Context/
+\u251C\u2500\u2500 Domain/              # Core business logic
+\u2502   \u251C\u2500\u2500 Aggregates/     # Aggregate roots + entities
+\u2502   \u251C\u2500\u2500 Events/         # Domain events
+\u2502   \u251C\u2500\u2500 Repositories/   # Repository interfaces
+\u2502   \u2514\u2500\u2500 Services/       # Domain services
+\u251C\u2500\u2500 Application/        # Use cases
+\u2502   \u251C\u2500\u2500 Commands/       # Write operations
+\u2502   \u251C\u2500\u2500 Queries/        # Read operations
+\u2502   \u251C\u2500\u2500 EventHandlers/  # Event reactions
+\u2502   \u2514\u2500\u2500 DTOs/           # Data transfer objects
+\u251C\u2500\u2500 Infrastructure/     # External concerns
+\u2502   \u251C\u2500\u2500 Persistence/    # Repository implementations
+\u2502   \u2514\u2500\u2500 Providers/      # DI configuration
+\u2514\u2500\u2500 UserInterface/      # Entry points
+    \u251C\u2500\u2500 Http/           # REST controllers
+    \u2514\u2500\u2500 Cli/            # CLI commands
+\`\`\`
+
+## SharedKernel
+
+Contains types shared across contexts:
+- **ValueObjects**: Id, Money, Email
+- **Primitives**: AggregateRoot, Entity, ValueObject
+- **Events**: DomainEvent base class
+- **EventBus**: Event dispatcher
+
+## Key Patterns
+
+1. **Aggregates**: Consistency boundaries
+2. **Domain Events**: Inter-context communication
+3. **CQRS**: Separate read/write models
+4. **Repository Pattern**: Persistence abstraction
+
+Created with \u2764\uFE0F using Gravito Framework
+`;
+  }
+};
+
+// src/generators/EnterpriseMvcGenerator.ts
+var EnterpriseMvcGenerator = class extends BaseGenerator {
+  get architectureType() {
+    return "enterprise-mvc";
+  }
+  get displayName() {
+    return "Enterprise MVC";
+  }
+  get description() {
+    return "Laravel-inspired MVC with Services and Repositories for enterprise applications";
+  }
+  getDirectoryStructure(context) {
+    return [
+      {
+        type: "directory",
+        name: "config",
+        children: [
+          { type: "file", name: "app.ts", content: this.generateAppConfig(context) },
+          { type: "file", name: "database.ts", content: this.generateDatabaseConfig() },
+          { type: "file", name: "auth.ts", content: this.generateAuthConfig() },
+          { type: "file", name: "cache.ts", content: this.generateCacheConfig() },
+          { type: "file", name: "logging.ts", content: this.generateLoggingConfig() }
+        ]
+      },
+      {
+        type: "directory",
+        name: "src",
+        children: [
+          {
+            type: "directory",
+            name: "Http",
+            children: [
+              { type: "file", name: "Kernel.ts", content: this.generateHttpKernel() },
+              {
+                type: "directory",
+                name: "Controllers",
+                children: [
+                  { type: "file", name: "Controller.ts", content: this.generateBaseController() },
+                  {
+                    type: "file",
+                    name: "HomeController.ts",
+                    content: this.generateHomeController(context)
+                  }
+                ]
+              },
+              {
+                type: "directory",
+                name: "Middleware",
+                children: [
+                  { type: "file", name: "Authenticate.ts", content: this.generateAuthMiddleware() }
+                ]
+              }
+            ]
+          },
+          {
+            type: "directory",
+            name: "Services",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          },
+          {
+            type: "directory",
+            name: "Repositories",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          },
+          {
+            type: "directory",
+            name: "Models",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          },
+          {
+            type: "directory",
+            name: "Resources",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          },
+          {
+            type: "directory",
+            name: "Providers",
+            children: [
+              {
+                type: "file",
+                name: "AppServiceProvider.ts",
+                content: this.generateAppServiceProvider(context)
+              },
+              {
+                type: "file",
+                name: "RouteServiceProvider.ts",
+                content: this.generateRouteServiceProvider(context)
+              }
+            ]
+          },
+          {
+            type: "directory",
+            name: "Exceptions",
+            children: [
+              { type: "file", name: "Handler.ts", content: this.generateExceptionHandler() }
+            ]
+          },
+          { type: "file", name: "bootstrap.ts", content: this.generateBootstrap(context) },
+          { type: "file", name: "routes.ts", content: this.generateRoutes(context) }
+        ]
+      },
+      {
+        type: "directory",
+        name: "tests",
+        children: [
+          {
+            type: "directory",
+            name: "Unit",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          },
+          {
+            type: "directory",
+            name: "Feature",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          }
+        ]
+      },
+      {
+        type: "directory",
+        name: "database",
+        children: [
+          {
+            type: "directory",
+            name: "migrations",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          },
+          {
+            type: "directory",
+            name: "seeders",
+            children: [{ type: "file", name: ".gitkeep", content: "" }]
+          }
+        ]
+      }
+    ];
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Config Generators
+  // ─────────────────────────────────────────────────────────────
+  generateAppConfig(context) {
+    return `/**
+ * Application Configuration
+ */
+export default {
+  /**
+   * Application name
+   */
+  name: process.env.APP_NAME ?? '${context.name}',
+
+  /**
+   * Application environment
+   */
+  env: process.env.APP_ENV ?? 'development',
+
+  /**
+   * Debug mode
+   */
+  debug: process.env.APP_DEBUG === 'true',
+
+  /**
+   * Application URL
+   */
+  url: process.env.APP_URL ?? 'http://localhost:3000',
+
+  /**
+   * Timezone
+   */
+  timezone: 'UTC',
+
+  /**
+   * Locale
+   */
+  locale: 'en',
+
+  /**
+   * Fallback locale
+   */
+  fallbackLocale: 'en',
+
+  /**
+   * Encryption key
+   */
+  key: process.env.APP_KEY,
+
+  /**
+   * Service providers to register
+   */
+  providers: [
+    // Framework providers
+    // 'RouteServiceProvider',
+
+    // Application providers
+    // 'AppServiceProvider',
+  ],
+}
+`;
+  }
+  generateDatabaseConfig() {
+    return `/**
+ * Database Configuration
+ */
+export default {
+  /**
+   * Default connection
+   */
+  default: process.env.DB_CONNECTION ?? 'sqlite',
+
+  /**
+   * Database connections
+   */
+  connections: {
+    sqlite: {
+      driver: 'sqlite',
+      database: process.env.DB_DATABASE ?? 'database/database.sqlite',
+    },
+
+    mysql: {
+      driver: 'mysql',
+      host: process.env.DB_HOST ?? 'localhost',
+      port: Number(process.env.DB_PORT ?? 3306),
+      database: process.env.DB_DATABASE ?? 'forge',
+      username: process.env.DB_USERNAME ?? 'forge',
+      password: process.env.DB_PASSWORD ?? '',
+    },
+
+    postgres: {
+      driver: 'postgres',
+      host: process.env.DB_HOST ?? 'localhost',
+      port: Number(process.env.DB_PORT ?? 5432),
+      database: process.env.DB_DATABASE ?? 'forge',
+      username: process.env.DB_USERNAME ?? 'forge',
+      password: process.env.DB_PASSWORD ?? '',
+    },
+  },
+
+  /**
+   * Migration settings
+   */
+  migrations: {
+    table: 'migrations',
+    path: 'database/migrations',
+  },
+}
+`;
+  }
+  generateAuthConfig() {
+    return `/**
+ * Authentication Configuration
+ */
+export default {
+  /**
+   * Default guard
+   */
+  defaults: {
+    guard: 'web',
+  },
+
+  /**
+   * Authentication guards
+   */
+  guards: {
+    web: {
+      driver: 'session',
+      provider: 'users',
+    },
+
+    api: {
+      driver: 'token',
+      provider: 'users',
+    },
+  },
+
+  /**
+   * User providers
+   */
+  providers: {
+    users: {
+      driver: 'database',
+      table: 'users',
+    },
+  },
+}
+`;
+  }
+  generateCacheConfig() {
+    return `/**
+ * Cache Configuration
+ */
+export default {
+  /**
+   * Default cache driver
+   */
+  default: process.env.CACHE_DRIVER ?? 'memory',
+
+  /**
+   * Cache stores
+   */
+  stores: {
+    memory: {
+      driver: 'memory',
+    },
+
+    file: {
+      driver: 'file',
+      path: 'storage/cache',
+    },
+
+    redis: {
+      driver: 'redis',
+      host: process.env.REDIS_HOST ?? 'localhost',
+      port: Number(process.env.REDIS_PORT ?? 6379),
+      password: process.env.REDIS_PASSWORD ?? null,
+      database: Number(process.env.REDIS_CACHE_DB ?? 0),
+    },
+  },
+
+  /**
+   * Cache key prefix
+   */
+  prefix: 'app_cache_',
+}
+`;
+  }
+  generateLoggingConfig() {
+    return `/**
+ * Logging Configuration
+ */
+export default {
+  /**
+   * Default log channel
+   */
+  default: process.env.LOG_CHANNEL ?? 'console',
+
+  /**
+   * Log channels
+   */
+  channels: {
+    console: {
+      driver: 'console',
+      level: process.env.LOG_LEVEL ?? 'debug',
+    },
+
+    file: {
+      driver: 'file',
+      path: 'storage/logs/app.log',
+      level: process.env.LOG_LEVEL ?? 'debug',
+    },
+  },
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Core File Generators
+  // ─────────────────────────────────────────────────────────────
+  generateHttpKernel() {
+    return `/**
+ * HTTP Kernel
+ *
+ * The HTTP kernel is the central point for managing HTTP middleware.
+ * Global middleware runs on every request, while route middleware
+ * can be assigned to specific routes.
+ */
+
+import type { GravitoMiddleware } from 'gravito-core'
+
+/**
+ * Global middleware stack.
+ * These middleware are run during every request.
+ */
+export const globalMiddleware: GravitoMiddleware[] = [
+  // Add global middleware here
+]
+
+/**
+ * Route middleware groups.
+ * These can be assigned to routes using the middleware name.
+ */
+export const middlewareGroups: Record<string, GravitoMiddleware[]> = {
+  web: [
+    // Session middleware
+    // CSRF middleware
+  ],
+  api: [
+    // Rate limiting
+    // API authentication
+  ],
+}
+
+/**
+ * Route middleware aliases.
+ * Convenient names for middleware that can be assigned to routes.
+ */
+export const routeMiddleware: Record<string, GravitoMiddleware> = {
+  // auth: AuthenticateMiddleware,
+  // guest: RedirectIfAuthenticated,
+  // throttle: ThrottleRequests,
+}
+
+/**
+ * Middleware priority.
+ * Determines the order in which middleware are executed.
+ */
+export const middlewarePriority: string[] = [
+  // StartSession
+  // ShareErrorsFromSession
+  // AuthenticateSession
+  // SubstituteBindings
+  // Authorize
+]
+`;
+  }
+  generateBaseController() {
+    return `/**
+ * Base Controller
+ *
+ * All controllers should extend this base class.
+ * Provides common functionality and helper methods.
+ */
+
+export abstract class Controller {
+  /**
+   * Create a success response.
+   */
+  protected success<T>(data: T, message = 'Success') {
+    return {
+      success: true,
+      message,
+      data,
+    }
+  }
+
+  /**
+   * Create an error response.
+   */
+  protected error(message: string, code = 'ERROR', details?: unknown) {
+    return {
+      success: false,
+      error: {
+        code,
+        message,
+        details,
+      },
+    }
+  }
+}
+`;
+  }
+  generateHomeController(context) {
+    return `/**
+ * Home Controller
+ */
+
+import type { GravitoContext } from 'gravito-core'
+import { Controller } from './Controller'
+
+export class HomeController extends Controller {
+  /**
+   * Display the home page.
+   */
+  async index(c: GravitoContext) {
+    return c.json(this.success({
+      name: '${context.name}',
+      message: 'Welcome to your new Gravito application!',
+      architecture: 'Enterprise MVC',
+    }))
+  }
+
+  /**
+   * Health check endpoint.
+   */
+  async health(c: GravitoContext) {
+    return c.json({
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+    })
+  }
+}
+`;
+  }
+  generateAuthMiddleware() {
+    return `/**
+ * Authenticate Middleware
+ *
+ * Protects routes that require authentication.
+ */
+
+import type { GravitoContext, GravitoNext } from 'gravito-core'
+
+export async function Authenticate(c: GravitoContext, next: GravitoNext) {
+  // TODO: Implement authentication check
+  // const session = c.get('session')
+  // if (!session?.user) {
+  //   return c.json({ error: 'Authentication required' }, 401)
+  // }
+
+  await next()
+}
+`;
+  }
+  generateAppServiceProvider(context) {
+    return `/**
+ * App Service Provider
+ *
+ * This is the main application service provider.
+ * Register and bootstrap application services here.
+ */
+
+import { ServiceProvider, type Container, type PlanetCore } from 'gravito-core'
+
+export class AppServiceProvider extends ServiceProvider {
+  /**
+   * Register any application services.
+   */
+  register(container: Container): void {
+    // Register services
+    // container.singleton('myService', () => new MyService())
+  }
+
+  /**
+   * Bootstrap any application services.
+   */
+  boot(core: PlanetCore): void {
+    // Bootstrap services
+    console.log('${context.name} application booted!')
+  }
+}
+`;
+  }
+  generateRouteServiceProvider(_context) {
+    return `/**
+ * Route Service Provider
+ *
+ * Configures and registers application routes.
+ */
+
+import { ServiceProvider, type Container, type PlanetCore } from 'gravito-core'
+import { registerRoutes } from '../routes'
+
+export class RouteServiceProvider extends ServiceProvider {
+  /**
+   * Register any application services.
+   */
+  register(_container: Container): void {
+    // Routes are registered in boot
+  }
+
+  /**
+   * Bootstrap any application services.
+   */
+  boot(core: PlanetCore): void {
+    registerRoutes(core.router)
+  }
+}
+`;
+  }
+  generateExceptionHandler() {
+    return `/**
+ * Exception Handler
+ *
+ * Handles all exceptions thrown by the application.
+ * Customize error responses and logging here.
+ */
+
+import type { ErrorHandlerContext } from 'gravito-core'
+
+/**
+ * Report an exception (logging, monitoring, etc.)
+ */
+export function report(error: unknown, context: ErrorHandlerContext): void {
+  // Log to external service (Sentry, etc.)
+  if (!context.isProduction) {
+    console.error('[Exception Handler]', error)
+  }
+}
+
+/**
+ * Determine if the exception should be reported.
+ */
+export function shouldReport(error: unknown): boolean {
+  // Don't report 4xx errors
+  if (error instanceof Error && 'status' in error) {
+    const status = (error as any).status
+    if (status >= 400 && status < 500) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * A list of exception types that should not be reported.
+ */
+export const dontReport: string[] = [
+  'ValidationException',
+  'NotFoundException',
+]
+`;
+  }
+  generateBootstrap(context) {
+    return `/**
+ * Application Bootstrap
+ *
+ * This is the entry point for your application.
+ * It initializes the core and registers all providers.
+ */
+
+import { PlanetCore } from 'gravito-core'
+import { AppServiceProvider } from './Providers/AppServiceProvider'
+import { RouteServiceProvider } from './Providers/RouteServiceProvider'
+
+// Load environment variables
+// Bun automatically loads .env
+
+// Create application core
+const core = new PlanetCore({
+  config: {
+    APP_NAME: '${context.name}',
+  },
+})
+
+// Register service providers
+core.register(new AppServiceProvider())
+core.register(new RouteServiceProvider())
+
+// Bootstrap the application
+await core.bootstrap()
+
+// Export for Bun.serve()
+export default core.liftoff()
+`;
+  }
+  generateRoutes(_context) {
+    return `/**
+ * Application Routes
+ *
+ * Define your application routes here.
+ */
+
+import { HomeController } from './Http/Controllers/HomeController'
+
+export function registerRoutes(router: any): void {
+  const home = new HomeController()
+
+  // API Routes
+  router.get('/api', (c: any) => home.index(c))
+  router.get('/api/health', (c: any) => home.health(c))
+
+  // Web Routes
+  router.get('/', (c: any) => home.index(c))
+}
+`;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Architecture Documentation
+  // ─────────────────────────────────────────────────────────────
+  generateArchitectureDoc(context) {
+    return `# ${context.name} - Architecture Guide
+
+## Overview
+
+This project uses **Enterprise MVC Architecture**, inspired by Laravel's conventions.
+It provides a clear separation of concerns while remaining pragmatic and easy to understand.
+
+## Directory Structure
+
+\`\`\`
+${context.name}/
+\u251C\u2500\u2500 config/                 # Configuration files
+\u2502   \u251C\u2500\u2500 app.ts             # Application settings
+\u2502   \u251C\u2500\u2500 database.ts        # Database connections
+\u2502   \u251C\u2500\u2500 auth.ts            # Authentication settings
+\u2502   \u251C\u2500\u2500 cache.ts           # Cache configuration
+\u2502   \u2514\u2500\u2500 logging.ts         # Logging channels
+\u251C\u2500\u2500 src/
+\u2502   \u251C\u2500\u2500 Http/
+\u2502   \u2502   \u251C\u2500\u2500 Kernel.ts      # HTTP middleware management
+\u2502   \u2502   \u251C\u2500\u2500 Controllers/   # HTTP request handlers
+\u2502   \u2502   \u2514\u2500\u2500 Middleware/    # Request/Response interceptors
+\u2502   \u251C\u2500\u2500 Services/          # Business logic layer
+\u2502   \u251C\u2500\u2500 Repositories/      # Data access layer
+\u2502   \u251C\u2500\u2500 Models/            # Data models/entities
+\u2502   \u251C\u2500\u2500 Resources/         # API response transformers
+\u2502   \u251C\u2500\u2500 Providers/         # Service providers
+\u2502   \u251C\u2500\u2500 Exceptions/        # Custom exceptions
+\u2502   \u251C\u2500\u2500 bootstrap.ts       # Application entry point
+\u2502   \u2514\u2500\u2500 routes.ts          # Route definitions
+\u251C\u2500\u2500 tests/
+\u2502   \u251C\u2500\u2500 Unit/              # Unit tests
+\u2502   \u2514\u2500\u2500 Feature/           # Integration tests
+\u2514\u2500\u2500 database/
+    \u251C\u2500\u2500 migrations/        # Database migrations
+    \u2514\u2500\u2500 seeders/           # Database seeders
+\`\`\`
+
+## Request Flow
+
+\`\`\`
+Request
+   \u2502
+   \u25BC
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  Http/Kernel    \u2502 \u2500\u2500\u25B6 Global Middleware
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+         \u2502
+         \u25BC
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502    Router       \u2502 \u2500\u2500\u25B6 Route Matching
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+         \u2502
+         \u25BC
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  Controller     \u2502 \u2500\u2500\u25B6 Request Handling
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+         \u2502
+         \u25BC
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502    Service      \u2502 \u2500\u2500\u25B6 Business Logic
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+         \u2502
+         \u25BC
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  Repository     \u2502 \u2500\u2500\u25B6 Data Access
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+         \u2502
+         \u25BC
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502   Resource      \u2502 \u2500\u2500\u25B6 Response Transform
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+         \u2502
+         \u25BC
+     Response
+\`\`\`
+
+## Layer Responsibilities
+
+### Controllers
+- Handle HTTP requests and responses
+- Validate input (or delegate to Form Requests)
+- Call services for business logic
+- Return transformed responses
+
+### Services
+- Contain business logic
+- Orchestrate multiple repositories
+- Enforce business rules
+- Should be framework-agnostic
+
+### Repositories
+- Abstract data access
+- Handle database queries
+- Return domain objects
+
+### Resources
+- Transform models for API responses
+- Control what data is exposed
+- Handle nested relationships
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+bun install
+
+# Run development server
+bun run dev
+
+# Run tests
+bun test
+\`\`\`
+
+## Configuration
+
+All configuration is in the \`config/\` directory.
+Environment-specific values should use environment variables.
+
+## Service Providers
+
+Service providers are the central place to configure your application.
+They are registered in \`src/bootstrap.ts\`:
+
+\`\`\`typescript
+core.register(new AppServiceProvider())
+core.register(new RouteServiceProvider())
+\`\`\`
+
+Created with \u2764\uFE0F using Gravito Framework
+`;
+  }
+};
+
+// src/Scaffold.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var Scaffold = class {
+  templatesDir;
+  verbose;
+  constructor(options = {}) {
+    this.templatesDir = options.templatesDir ?? import_node_path3.default.resolve(__dirname, "../templates");
+    this.verbose = options.verbose ?? false;
+  }
+  /**
+   * Get all available architecture types.
+   */
+  getArchitectureTypes() {
+    return [
+      {
+        type: "enterprise-mvc",
+        name: "Enterprise MVC",
+        description: "Laravel-inspired MVC with Services and Repositories"
+      },
+      {
+        type: "clean",
+        name: "Clean Architecture",
+        description: "Uncle Bob's Clean Architecture with strict dependency rules"
+      },
+      {
+        type: "ddd",
+        name: "Domain-Driven Design",
+        description: "Full DDD with Bounded Contexts and CQRS"
+      }
+    ];
+  }
+  /**
+   * Create a new project scaffold.
+   */
+  async create(options) {
+    const generator = this.createGenerator(options.architecture);
+    const context = BaseGenerator.createContext(
+      options.name,
+      options.targetDir,
+      options.architecture,
+      options.packageManager ?? "bun",
+      options.context ?? {}
+    );
+    try {
+      const filesCreated = await generator.generate(context);
+      return {
+        success: true,
+        targetDir: options.targetDir,
+        filesCreated
+      };
+    } catch (error) {
+      return {
+        success: false,
+        targetDir: options.targetDir,
+        filesCreated: [],
+        errors: [error instanceof Error ? error.message : String(error)]
+      };
+    }
+  }
+  /**
+   * Create a generator for the specified architecture.
+   */
+  createGenerator(type) {
+    const config = {
+      templatesDir: this.templatesDir,
+      verbose: this.verbose
+    };
+    switch (type) {
+      case "enterprise-mvc":
+        return new EnterpriseMvcGenerator(config);
+      case "clean":
+        return new CleanArchitectureGenerator(config);
+      case "ddd":
+        return new DddGenerator(config);
+      default:
+        throw new Error(`Unknown architecture type: ${type}`);
+    }
+  }
+  /**
+   * Generate a single module (for DDD bounded context).
+   */
+  async generateModule(_targetDir, _moduleName, _options = {}) {
+    throw new Error("Module generation not yet implemented");
+  }
+  /**
+   * Generate a service provider.
+   */
+  async generateProvider(_targetDir, _providerName) {
+    throw new Error("Provider generation not yet implemented");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseGenerator,
+  CleanArchitectureGenerator,
+  DddGenerator,
+  EnterpriseMvcGenerator,
+  Scaffold,
+  StubGenerator
+});