create-meridian-app 0.1.0

package/dist/chunk-7IUTX6RW.js

@@ -0,0 +1,468 @@
+// src/commands/new.ts
+import path2 from "path";
+import { existsSync as existsSync2 } from "fs";
+import ora from "ora";
+import chalk from "chalk";
+import prompts from "prompts";
+import { execa } from "execa";
+
+// src/templates/index.ts
+function renderPackageJson(vars) {
+  return JSON.stringify(
+    {
+      name: vars.name,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "meridian dev",
+        build: "meridian build",
+        start: "node --import tsx/esm src/main.ts",
+        "db:migrate": "meridian db:migrate",
+        "db:generate": "meridian db:generate"
+      },
+      dependencies: {
+        "@meridianjs/framework": "latest",
+        "@meridianjs/framework-utils": "latest",
+        "@meridianjs/types": "latest",
+        "@meridianjs/event-bus-local": "latest",
+        "@meridianjs/user": "latest",
+        "@meridianjs/workspace": "latest",
+        "@meridianjs/auth": "latest",
+        "@meridianjs/project": "latest",
+        "@meridianjs/issue": "latest",
+        "dotenv": "^16.0.0"
+      },
+      devDependencies: {
+        "create-meridian-app": "latest",
+        typescript: "^5.4.0",
+        tsx: "^4.0.0",
+        "@types/node": "^22.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function renderTsConfig() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        lib: ["ES2022"],
+        outDir: "dist",
+        rootDir: "src",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        resolveJsonModule: true,
+        declaration: true,
+        declarationMap: true,
+        sourceMap: true
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"]
+    },
+    null,
+    2
+  );
+}
+function renderMeridianConfig(vars) {
+  return `import { defineConfig } from "@meridianjs/framework"
+import dotenv from "dotenv"
+dotenv.config()
+
+export default defineConfig({
+  projectConfig: {
+    databaseUrl: process.env.DATABASE_URL ?? "${vars.databaseUrl}",
+    httpPort: Number(process.env.PORT) || ${vars.httpPort},
+    jwtSecret: process.env.JWT_SECRET ?? "changeme-replace-in-production",
+  },
+  modules: [
+    { resolve: "@meridianjs/event-bus-local" },
+    { resolve: "@meridianjs/user" },
+    { resolve: "@meridianjs/workspace" },
+    { resolve: "@meridianjs/auth" },
+    { resolve: "@meridianjs/project" },
+    { resolve: "@meridianjs/issue" },
+  ],
+})
+`;
+}
+function renderMainTs() {
+  return `import { bootstrap } from "@meridianjs/framework"
+import { fileURLToPath } from "node:url"
+import path from "node:path"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const rootDir = path.resolve(__dirname, "..")
+
+const app = await bootstrap({ rootDir })
+await app.start()
+
+process.on("SIGTERM", async () => {
+  await app.stop()
+  process.exit(0)
+})
+
+process.on("SIGINT", async () => {
+  await app.stop()
+  process.exit(0)
+})
+`;
+}
+function renderMiddlewares() {
+  return `import { authenticateJWT } from "@meridianjs/auth"
+
+export default {
+  routes: [
+    { matcher: "/admin", middlewares: [authenticateJWT] },
+  ],
+}
+`;
+}
+function renderHelloRoute() {
+  return `import type { Request, Response } from "express"
+
+export const GET = async (_req: Request, res: Response) => {
+  res.json({ message: "Hello from Meridian!", timestamp: new Date().toISOString() })
+}
+`;
+}
+function renderGitIgnore() {
+  return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+
+# Editor
+.vscode/
+.idea/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+`;
+}
+function renderEnvExample(vars) {
+  return `# Copy this file to .env and fill in your values
+DATABASE_URL=${vars.databaseUrl}
+PORT=${vars.httpPort}
+JWT_SECRET=changeme-replace-in-production
+`;
+}
+function renderReadme(vars) {
+  return `# ${vars.name}
+
+A Meridian application.
+
+## Getting started
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Set up your database
+cp .env.example .env
+# Edit .env with your database URL
+
+# Sync database schema
+npm run db:migrate
+
+# Start the development server
+npm run dev
+\`\`\`
+
+## Commands
+
+| Command | Description |
+|---|---|
+| \`npm run dev\` | Start development server with hot reload |
+| \`npm run build\` | Type-check the project |
+| \`npm run db:migrate\` | Synchronize the database schema |
+| \`npm run db:generate <name>\` | Generate a new migration file |
+
+## Project structure
+
+\`\`\`
+src/
+  main.ts              Entry point
+  api/
+    middlewares.ts     Route-level middleware configuration
+    admin/             File-based API routes
+  modules/             Custom domain modules
+  workflows/           DAG workflows with compensation
+  subscribers/         Event subscribers
+  jobs/                Scheduled background jobs
+  links/               Cross-module link definitions
+\`\`\`
+
+## Extending Meridian
+
+See the [Meridian documentation](https://github.com/meridian/meridian) for guides on:
+- Creating custom modules
+- Building workflows
+- Writing event subscribers
+- Scheduling background jobs
+- Building plugins
+`;
+}
+function renderModuleIndex(name, pascalName) {
+  return `import { Module } from "@meridianjs/framework-utils"
+import { ${pascalName}ModuleService } from "./service.js"
+import { ${pascalName} } from "./models/${name}.js"
+import defaultLoader from "./loaders/default.js"
+
+export default Module("${name}ModuleService", {
+  service: ${pascalName}ModuleService,
+  models: [${pascalName}],
+  loaders: [defaultLoader],
+  linkable: {
+    ${name}: { tableName: "${name}", primaryKey: "id" },
+  },
+})
+`;
+}
+function renderModuleLoader(name, pascalName) {
+  return `import { createModuleOrm, createRepository, dmlToEntitySchema } from "@meridianjs/framework-utils"
+import type { LoaderOptions } from "@meridianjs/types"
+import { ${pascalName} } from "../models/${name}.js"
+
+const ${pascalName}Schema = dmlToEntitySchema(${pascalName})
+
+export default async function defaultLoader({ container }: LoaderOptions): Promise<void> {
+  const config = container.resolve("config") as any
+  const orm = await createModuleOrm(
+    [${pascalName}Schema],
+    config.projectConfig.databaseUrl
+  )
+  const em = orm.em.fork()
+  container.register({
+    ${name}Repository: createRepository(em, "${name}"),
+    ${name}Orm: orm,
+  })
+}
+`;
+}
+function renderModuleModel(name, pascalName) {
+  return `import { model } from "@meridianjs/framework-utils"
+
+export const ${pascalName} = model("${name}", {
+  id: model.id(),
+  name: model.text(),
+  created_at: model.dateTime(),
+  updated_at: model.dateTime(),
+})
+`;
+}
+function renderModuleService(name, pascalName) {
+  return `import { MeridianService } from "@meridianjs/framework-utils"
+import type { MeridianContainer } from "@meridianjs/types"
+import { ${pascalName} } from "./models/${name}.js"
+
+export class ${pascalName}ModuleService extends MeridianService({ ${pascalName} }) {
+  constructor(container: MeridianContainer) {
+    super(container)
+  }
+
+  // Add custom service methods here
+}
+`;
+}
+function renderWorkflow(name, pascalName) {
+  const camelName = pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
+  return `import { createStep, createWorkflow, WorkflowResponse } from "@meridianjs/workflow-engine"
+import type { MeridianContainer } from "@meridianjs/types"
+
+interface ${pascalName}WorkflowInput {
+  // Define your input shape here
+}
+
+const ${camelName}Step = createStep(
+  "${name}-step",
+  async (input: ${pascalName}WorkflowInput, { container }: { container: MeridianContainer }) => {
+    // Forward logic: implement your step here
+    return { result: null }
+  },
+  async (_input: ${pascalName}WorkflowInput, _context: { container: MeridianContainer }) => {
+    // Compensation logic: runs if a later step fails
+  }
+)
+
+export const ${camelName}Workflow = createWorkflow(
+  "${name}",
+  (input: ${pascalName}WorkflowInput) => {
+    const result = ${camelName}Step(input)
+    return new WorkflowResponse(result)
+  }
+)
+`;
+}
+
+// src/utils.ts
+import path from "path";
+import fs from "fs/promises";
+import { existsSync } from "fs";
+function toPascalCase(str) {
+  return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function toKebabCase(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+async function writeFile(filePath, content) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function mkdir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function mkdirWithKeep(dirPath) {
+  await mkdir(dirPath);
+  await writeFile(path.join(dirPath, ".gitkeep"), "");
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(path.join(dir, "meridian.config.ts"))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// src/commands/new.ts
+async function runNew(projectName) {
+  console.log();
+  console.log(chalk.bold("  Create Meridian App"));
+  console.log();
+  let name = projectName;
+  if (!name) {
+    const res = await prompts(
+      {
+        type: "text",
+        name: "name",
+        message: "Project name",
+        initial: "my-meridian-app",
+        validate: (v) => /^[a-z0-9-_]+$/.test(v) || "Use lowercase letters, numbers, hyphens, and underscores only"
+      },
+      { onCancel: () => process.exit(0) }
+    );
+    name = res.name;
+  }
+  const targetDir = path2.resolve(process.cwd(), name);
+  if (existsSync2(targetDir)) {
+    const { overwrite } = await prompts(
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `Directory "${name}" already exists. Continue anyway?`,
+        initial: false
+      },
+      { onCancel: () => process.exit(0) }
+    );
+    if (!overwrite) {
+      console.log(chalk.yellow("  Cancelled."));
+      process.exit(0);
+    }
+  }
+  const answers = await prompts(
+    [
+      {
+        type: "text",
+        name: "databaseUrl",
+        message: "Database URL",
+        initial: `postgresql://postgres:postgres@localhost:5432/${name}`
+      },
+      {
+        type: "number",
+        name: "httpPort",
+        message: "HTTP port",
+        initial: 9e3
+      },
+      {
+        type: "confirm",
+        name: "installDeps",
+        message: "Install dependencies now?",
+        initial: true
+      }
+    ],
+    { onCancel: () => process.exit(0) }
+  );
+  const vars = {
+    name,
+    databaseUrl: answers.databaseUrl,
+    httpPort: answers.httpPort
+  };
+  const spinner = ora("Scaffolding project...").start();
+  try {
+    await writeFile(path2.join(targetDir, "package.json"), renderPackageJson(vars));
+    await writeFile(path2.join(targetDir, "tsconfig.json"), renderTsConfig());
+    await writeFile(path2.join(targetDir, "meridian.config.ts"), renderMeridianConfig(vars));
+    await writeFile(path2.join(targetDir, ".gitignore"), renderGitIgnore());
+    await writeFile(path2.join(targetDir, ".env.example"), renderEnvExample(vars));
+    await writeFile(path2.join(targetDir, "README.md"), renderReadme(vars));
+    await writeFile(path2.join(targetDir, "src", "main.ts"), renderMainTs());
+    await writeFile(path2.join(targetDir, "src", "api", "middlewares.ts"), renderMiddlewares());
+    await writeFile(
+      path2.join(targetDir, "src", "api", "admin", "hello", "route.ts"),
+      renderHelloRoute()
+    );
+    await mkdirWithKeep(path2.join(targetDir, "src", "modules"));
+    await mkdirWithKeep(path2.join(targetDir, "src", "workflows"));
+    await mkdirWithKeep(path2.join(targetDir, "src", "subscribers"));
+    await mkdirWithKeep(path2.join(targetDir, "src", "jobs"));
+    await mkdirWithKeep(path2.join(targetDir, "src", "links"));
+    spinner.succeed("Scaffolded project files");
+  } catch (err) {
+    spinner.fail("Failed to scaffold project files");
+    throw err;
+  }
+  if (answers.installDeps) {
+    const installSpinner = ora("Installing dependencies...").start();
+    try {
+      await execa("npm", ["install"], { cwd: targetDir, stdio: "pipe" });
+      installSpinner.succeed("Dependencies installed");
+    } catch (err) {
+      installSpinner.warn("npm install failed \u2014 run it manually");
+    }
+  }
+  console.log();
+  console.log(chalk.green("  \u2713 Project created!"));
+  console.log();
+  console.log(`  ${chalk.dim("cd")} ${chalk.cyan(name)}`);
+  if (!answers.installDeps) {
+    console.log(`  ${chalk.dim("npm install")}`);
+  }
+  console.log(`  ${chalk.dim("cp")} .env.example .env ${chalk.dim("# fill in your DATABASE_URL")}`);
+  console.log(`  ${chalk.cyan("npm run db:migrate")}`);
+  console.log(`  ${chalk.cyan("npm run dev")}`);
+  console.log();
+}
+
+export {
+  renderModuleIndex,
+  renderModuleLoader,
+  renderModuleModel,
+  renderModuleService,
+  renderWorkflow,
+  toPascalCase,
+  toKebabCase,
+  writeFile,
+  findProjectRoot,
+  runNew
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+import {
+  findProjectRoot,
+  renderModuleIndex,
+  renderModuleLoader,
+  renderModuleModel,
+  renderModuleService,
+  renderWorkflow,
+  runNew,
+  toKebabCase,
+  toPascalCase,
+  writeFile
+} from "./chunk-7IUTX6RW.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/dev.ts
+import path from "path";
+import { existsSync } from "fs";
+import chalk from "chalk";
+import { execa } from "execa";
+async function runDev() {
+  const rootDir = findProjectRoot();
+  if (!rootDir) {
+    console.error(chalk.red("  \u2716 Could not find meridian.config.ts. Are you inside a Meridian project?"));
+    process.exit(1);
+  }
+  const mainTs = path.join(rootDir, "src", "main.ts");
+  if (!existsSync(mainTs)) {
+    console.error(chalk.red(`  \u2716 Entry point not found: ${mainTs}`));
+    process.exit(1);
+  }
+  console.log(chalk.dim(`  \u2192 Starting dev server from ${rootDir}`));
+  console.log();
+  const result = await execa(
+    "node",
+    ["--import", "tsx/esm", mainTs],
+    {
+      cwd: rootDir,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NODE_ENV: process.env.NODE_ENV ?? "development",
+        FORCE_COLOR: "1"
+      }
+    }
+  ).catch((err) => {
+    if (err.signal === "SIGINT" || err.signal === "SIGTERM") {
+      process.exit(0);
+    }
+    throw err;
+  });
+  process.exit(result.exitCode ?? 0);
+}
+
+// src/commands/build.ts
+import chalk2 from "chalk";
+import { execa as execa2 } from "execa";
+async function runBuild() {
+  const rootDir = findProjectRoot();
+  if (!rootDir) {
+    console.error(chalk2.red("  \u2716 Could not find meridian.config.ts. Are you inside a Meridian project?"));
+    process.exit(1);
+  }
+  console.log(chalk2.dim("  \u2192 Type-checking project..."));
+  console.log();
+  const result = await execa2("npx", ["tsc", "--noEmit"], {
+    cwd: rootDir,
+    stdio: "inherit"
+  }).catch((err) => err);
+  if (result.exitCode !== 0) {
+    console.log();
+    console.error(chalk2.red("  \u2716 Type check failed"));
+    process.exit(result.exitCode ?? 1);
+  }
+  console.log();
+  console.log(chalk2.green("  \u2713 Type check passed"));
+}
+
+// src/commands/db-migrate.ts
+import path2 from "path";
+import chalk3 from "chalk";
+import ora from "ora";
+import { execa as execa3 } from "execa";
+async function runDbMigrate() {
+  const rootDir = findProjectRoot();
+  if (!rootDir) {
+    console.error(chalk3.red("  \u2716 Could not find meridian.config.ts. Are you inside a Meridian project?"));
+    process.exit(1);
+  }
+  const spinner = ora("Synchronizing database schema...").start();
+  const script = `
+import { bootstrap } from "@meridianjs/framework"
+import { fileURLToPath } from "node:url"
+import path from "node:path"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const app = await bootstrap({ rootDir: ${JSON.stringify(rootDir)} })
+// Schema sync already ran during module loading above.
+// Don't start the HTTP server \u2014 just close all connections.
+await app.stop()
+process.exit(0)
+`;
+  const scriptPath = path2.join(rootDir, ".meridian-migrate-tmp.mjs");
+  const { writeFile: writeFile2, unlink } = await import("fs/promises");
+  await writeFile2(scriptPath, script, "utf-8");
+  try {
+    await execa3("node", ["--import", "tsx/esm", scriptPath], {
+      cwd: rootDir,
+      stdio: "pipe",
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    spinner.succeed("Database schema synchronized");
+  } catch (err) {
+    spinner.fail("Schema migration failed");
+    console.error();
+    if (err.stderr) console.error(chalk3.red(err.stderr));
+    if (err.stdout) console.error(err.stdout);
+    process.exit(1);
+  } finally {
+    await unlink(scriptPath).catch(() => null);
+  }
+}
+
+// src/commands/db-generate.ts
+import path3 from "path";
+import fs from "fs/promises";
+import chalk4 from "chalk";
+async function runDbGenerate(migrationName) {
+  const rootDir = findProjectRoot();
+  if (!rootDir) {
+    console.error(chalk4.red("  \u2716 Could not find meridian.config.ts. Are you inside a Meridian project?"));
+    process.exit(1);
+  }
+  if (!migrationName) {
+    console.error(chalk4.red("  \u2716 Migration name is required. Usage: meridian db:generate <name>"));
+    process.exit(1);
+  }
+  const safeName = migrationName.toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+  const fileName = `${timestamp}_${safeName}.ts`;
+  const migrationsDir = path3.join(rootDir, "src", "migrations");
+  await fs.mkdir(migrationsDir, { recursive: true });
+  const content = `/**
+ * Migration: ${safeName}
+ * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+ *
+ * This file is a placeholder. Meridian uses MikroORM's updateSchema() by default.
+ * For custom migration SQL, implement the up() and down() methods below and
+ * run them via a custom script calling \`em.getMigrator().up()\`.
+ */
+
+export async function up(): Promise<void> {
+  // Write your migration SQL here
+}
+
+export async function down(): Promise<void> {
+  // Write your rollback SQL here
+}
+`;
+  const filePath = path3.join(migrationsDir, fileName);
+  await fs.writeFile(filePath, content, "utf-8");
+  console.log(chalk4.green(`  \u2713 Created migration: src/migrations/${fileName}`));
+  console.log();
+  console.log(chalk4.dim("  Note: Meridian auto-syncs schema on startup via updateSchema()."));
+  console.log(chalk4.dim("  Use this file for custom DDL that requires manual control."));
+}
+
+// src/commands/generate/module.ts
+import path4 from "path";
+import { existsSync as existsSync2 } from "fs";
+import chalk5 from "chalk";
+async function generateModule(name) {
+  const rootDir = findProjectRoot();
+  if (!rootDir) {
+    console.error(chalk5.red("  \u2716 Could not find meridian.config.ts. Are you inside a Meridian project?"));
+    process.exit(1);
+  }
+  if (!name) {
+    console.error(chalk5.red("  \u2716 Module name is required. Usage: meridian generate module <name>"));
+    process.exit(1);
+  }
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(kebab);
+  const moduleDir = path4.join(rootDir, "src", "modules", kebab);
+  if (existsSync2(moduleDir)) {
+    console.error(chalk5.red(`  \u2716 Module directory already exists: src/modules/${kebab}`));
+    process.exit(1);
+  }
+  await writeFile(path4.join(moduleDir, "index.ts"), renderModuleIndex(kebab, pascal));
+  await writeFile(path4.join(moduleDir, `models/${kebab}.ts`), renderModuleModel(kebab, pascal));
+  await writeFile(path4.join(moduleDir, `loaders/default.ts`), renderModuleLoader(kebab, pascal));
+  await writeFile(path4.join(moduleDir, "service.ts"), renderModuleService(kebab, pascal));
+  console.log(chalk5.green(`  \u2713 Generated module: src/modules/${kebab}/`));
+  console.log();
+  console.log("  Files created:");
+  console.log(chalk5.dim(`    src/modules/${kebab}/index.ts`));
+  console.log(chalk5.dim(`    src/modules/${kebab}/models/${kebab}.ts`));
+  console.log(chalk5.dim(`    src/modules/${kebab}/loaders/default.ts`));
+  console.log(chalk5.dim(`    src/modules/${kebab}/service.ts`));
+  console.log();
+  console.log("  Next steps:");
+  console.log(chalk5.dim(`    1. Add the module to your meridian.config.ts:`));
+  console.log(chalk5.dim(`       { resolve: "./src/modules/${kebab}" }`));
+  console.log(chalk5.dim(`    2. Run \`npm run db:migrate\` to sync the schema`));
+}
+
+// src/commands/generate/workflow.ts
+import path5 from "path";
+import { existsSync as existsSync3 } from "fs";
+import chalk6 from "chalk";
+async function generateWorkflow(name) {
+  const rootDir = findProjectRoot();
+  if (!rootDir) {
+    console.error(chalk6.red("  \u2716 Could not find meridian.config.ts. Are you inside a Meridian project?"));
+    process.exit(1);
+  }
+  if (!name) {
+    console.error(chalk6.red("  \u2716 Workflow name is required. Usage: meridian generate workflow <name>"));
+    process.exit(1);
+  }
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(kebab);
+  const filePath = path5.join(rootDir, "src", "workflows", `${kebab}.ts`);
+  if (existsSync3(filePath)) {
+    console.error(chalk6.red(`  \u2716 Workflow already exists: src/workflows/${kebab}.ts`));
+    process.exit(1);
+  }
+  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  await writeFile(filePath, renderWorkflow(kebab, pascal));
+  console.log(chalk6.green(`  \u2713 Generated workflow: src/workflows/${kebab}.ts`));
+  console.log();
+  console.log("  Usage:");
+  console.log(chalk6.dim(`    import { ${camel}Workflow } from "./workflows/${kebab}.js"`));
+  console.log(chalk6.dim(`    const { result } = await ${camel}Workflow(req.scope).run({ input: {...} })`));
+}
+
+// src/commands/generate/plugin.ts
+import path6 from "path";
+import { existsSync as existsSync4 } from "fs";
+import chalk7 from "chalk";
+function renderPluginIndex(_name, pascalName) {
+  return `import { fileURLToPath } from "node:url"
+import path from "node:path"
+import type { PluginRegistrationContext } from "@meridianjs/types"
+
+/**
+ * The compiled directory of this plugin.
+ * The Meridian plugin-loader uses this to auto-scan api/, subscribers/, jobs/.
+ */
+export const pluginRoot: string = path.dirname(fileURLToPath(import.meta.url))
+
+/**
+ * Called during bootstrap before route/subscriber auto-scan.
+ * Use ctx.addModule() to register domain modules.
+ */
+export default async function register(_ctx: PluginRegistrationContext): Promise<void> {
+  // Example: register a custom module
+  // await ctx.addModule({ resolve: My${pascalName}Module })
+}
+`;
+}
+function renderPluginRoute(name) {
+  return `import type { Response } from "express"
+
+/**
+ * GET /admin/${name}
+ * Example plugin admin route.
+ */
+export const GET = async (req: any, res: Response) => {
+  res.json({ plugin: "${name}", status: "active" })
+}
+`;
+}
+async function generatePlugin(name) {
+  const rootDir = findProjectRoot();
+  if (!rootDir) {
+    console.error(chalk7.red("  \u2716 Could not find meridian.config.ts. Are you inside a Meridian project?"));
+    process.exit(1);
+  }
+  if (!name) {
+    console.error(chalk7.red("  \u2716 Plugin name is required. Usage: meridian generate plugin <name>"));
+    process.exit(1);
+  }
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(kebab);
+  const pluginDir = path6.join(rootDir, "src", "plugins", kebab);
+  if (existsSync4(pluginDir)) {
+    console.error(chalk7.red(`  \u2716 Plugin directory already exists: src/plugins/${kebab}`));
+    process.exit(1);
+  }
+  await writeFile(path6.join(pluginDir, "index.ts"), renderPluginIndex(kebab, pascal));
+  await writeFile(
+    path6.join(pluginDir, "api", "admin", kebab, "route.ts"),
+    renderPluginRoute(kebab)
+  );
+  console.log(chalk7.green(`  \u2713 Generated plugin: src/plugins/${kebab}/`));
+  console.log();
+  console.log("  Files created:");
+  console.log(chalk7.dim(`    src/plugins/${kebab}/index.ts`));
+  console.log(chalk7.dim(`    src/plugins/${kebab}/api/admin/${kebab}/route.ts`));
+  console.log();
+  console.log("  Next steps:");
+  console.log(chalk7.dim(`    1. Add the plugin to your meridian.config.ts:`));
+  console.log(chalk7.dim(`       plugins: [{ resolve: "./src/plugins/${kebab}" }]`));
+  console.log(chalk7.dim(`    2. Start the dev server: \`npm run dev\``));
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("meridian").description("Meridian project management framework CLI").version("0.1.0");
+program.command("new [project-name]").description("Create a new Meridian project").action((projectName) => {
+  runNew(projectName).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+program.command("dev").description("Start the development server").action(() => {
+  runDev().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+program.command("build").description("Type-check the project").action(() => {
+  runBuild().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+program.command("db:migrate").description("Synchronize the database schema (runs updateSchema on all modules)").action(() => {
+  runDbMigrate().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+program.command("db:generate <name>").description("Generate a new migration file").action((name) => {
+  runDbGenerate(name).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+var generateCmd = program.command("generate").alias("g").description("Generate boilerplate files");
+generateCmd.command("module <name>").description("Scaffold a new module in src/modules/").action((name) => {
+  generateModule(name).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+generateCmd.command("workflow <name>").description("Scaffold a new workflow in src/workflows/").action((name) => {
+  generateWorkflow(name).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+generateCmd.command("plugin <name>").description("Scaffold a local plugin in src/plugins/").action((name) => {
+  generatePlugin(name).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+program.parse(process.argv);

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  runNew
+} from "./chunk-7IUTX6RW.js";
+
+// src/index.ts
+var projectName = process.argv[2];
+var name = projectName && !projectName.startsWith("-") ? projectName : void 0;
+runNew(name).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "create-meridian-app",
+  "version": "0.1.0",
+  "description": "Create a new Meridian project or manage an existing one",
+  "main": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "bin": {
+    "create-meridian-app": "./dist/index.js",
+    "meridian": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ora": "^8.1.1",
+    "chalk": "^5.3.0",
+    "prompts": "^2.4.2",
+    "execa": "^9.5.2"
+  },
+  "devDependencies": {
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.5",
+    "tsx": "4.21.0",
+    "typescript": "*"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}