@maestro-js/init 1.0.0-alpha.10

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/bin.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import {
+  buildProjectTree,
+  scaffold
+} from "./chunk-P4YULL3I.js";
+
+// src/bin.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { access } from "fs/promises";
+import { fileURLToPath } from "url";
+var name = process.argv[2];
+if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
+  console.error("Project name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens.");
+  process.exit(1);
+}
+var targetDir = path.join(process.cwd(), name);
+if (await fileExists(targetDir)) {
+  console.error(`Directory "${name}" already exists.`);
+  process.exit(1);
+}
+var tokens = {
+  name,
+  Name: toPascalCase(name),
+  name_snake: name.replace(/-/g, "_"),
+  ENCRYPTION_KEY: crypto.randomBytes(32).toString("base64"),
+  HASH_KEY: crypto.randomBytes(32).toString("base64"),
+  DB_PORT: String(deriveDbPort(name))
+};
+var tree = buildProjectTree(name);
+var created = await scaffold(tree, targetDir, tokens);
+console.log(`
+Created ${created.length} files in ./${name}/
+`);
+installSkills(targetDir);
+console.log("Next steps:");
+console.log(`  cd ${name}`);
+console.log("  pnpm install");
+console.log("  maestro db:make-container");
+console.log("  maestro db:migrate");
+console.log(`  cd ${name}-web && pnpm dev`);
+function toPascalCase(str) {
+  return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function deriveDbPort(name2) {
+  let hash = 0;
+  for (const char of name2) hash = hash * 31 + char.charCodeAt(0) & 65535;
+  return 3307 + hash % 100;
+}
+function installSkills(targetDir2) {
+  const skillSources = [
+    { cmd: `npx --yes @maestro-js/agent-skills@${getCurrentVersion()}`, label: "maestro" },
+    { cmd: "npx skills add https://react-aria.adobe.com --all -a claude-code", label: "react-aria" },
+    { cmd: "npx skills add anthropics/skills --skill skill-creator -a claude-code -y", label: "skill-creator" },
+    { cmd: "npx skills add mattpocock/skills --skill grill-me -a claude-code -y", label: "grill-me" },
+    { cmd: "playwright-cli install --skills", label: "playwright-cli" }
+  ];
+  for (const { cmd, label } of skillSources) {
+    try {
+      execSync(cmd, { cwd: targetDir2, stdio: "inherit" });
+    } catch {
+      console.warn(`Warning: Failed to install ${label} skills.`);
+    }
+  }
+}
+async function fileExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCurrentVersion() {
+  const dir = path.dirname(fileURLToPath(import.meta.url));
+  const raw = fs.readFileSync(path.join(dir, "../package.json"), "utf-8");
+  const pkg = JSON.parse(raw);
+  return pkg.version;
+}

package/dist/chunk-P4YULL3I.js

@@ -0,0 +1,1275 @@
+#!/usr/bin/env node
+
+// src/templates/root.ts
+function rootPackageJson(name) {
+  return JSON.stringify(
+    {
+      type: "module",
+      private: true,
+      scripts: {
+        "fks-cascade": "maestro config:run --config services -- node ./scripts/foreign-key-delete-behavior.ts cascade",
+        "fks-restrict": "maestro config:run --config services -- node ./scripts/foreign-key-delete-behavior.ts restrict"
+      },
+      dependencies: {
+        "@maestro-js/config": "latest",
+        [`@${name}/services`]: "workspace:*"
+      },
+      devDependencies: {
+        "@maestro-js/cli": "latest",
+        "@maestro-js/db-migrate": "latest",
+        "@maestro-js/db": "latest",
+        "@types/node": "^22.19.11",
+        tsx: "^4.21.0"
+      }
+    },
+    null,
+    2
+  );
+}
+var rootTsconfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "es2022",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noUncheckedIndexedAccess": true
+  },
+  "exclude": ["node_modules"],
+  "include": ["./src", "./packages/*/src", "./packages/*/tests", "./scripts"]
+}
+`;
+var rootEnv = `DB_HOST=localhost
+DB_PORT={{DB_PORT}}
+DB_USER=root
+DB_PASSWORD=root
+DB_DATABASE={{name}}
+
+ENCRYPTION_KEY={{ENCRYPTION_KEY}}
+HASH_KEY={{HASH_KEY}}
+
+MAIL_FROM=noreply@{{name}}.app
+BASE_URL=http://localhost:3000
+`;
+var rootGitignore = `node_modules
+dist
+.env
+.env.*
+!.env.example
+!.env.encrypted
+!.env.*.encrypted
+.react-router
+.DS_Store
+build
+.e2e-mail/
+cdk.out
+`;
+function pnpmWorkspace(name) {
+  return `packages:
+  - packages/*
+  - ${name}-web
+  - queue-processor
+  - infrastructure
+  - scripts
+`;
+}
+
+// src/templates/config.ts
+var servicesConfig = `export default async function (env: Record<string, string | undefined>) {
+  return {
+    DB_HOST: env.DB_HOST ?? 'localhost',
+    DB_PORT: env.DB_PORT ?? '3306',
+    DB_USER: env.DB_USER ?? '{{name}}',
+    DB_PASSWORD: env.DB_PASSWORD ?? '',
+    DB_DATABASE: env.DB_DATABASE ?? '{{name}}',
+    REDIS_URL: env.REDIS_URL ?? 'localhost',
+    REDIS_PORT: env.REDIS_PORT ?? '6379',
+    ENCRYPTION_KEY: env.ENCRYPTION_KEY,
+    HASH_KEY: env.HASH_KEY,
+    MAIL_FROM: env.MAIL_FROM ?? 'noreply@{{name}}.app',
+    BASE_URL: env.BASE_URL ?? 'http://localhost:3000',
+    ENV_NAME: env.ENV_NAME ?? 'local',
+    AWS_REGION: env.AWS_REGION ?? 'us-east-1'
+  }
+}
+`;
+var webConfig = `import getServicesConfig from './services.ts'
+
+export default async function (env: Record<string, string | undefined>) {
+  const servicesConfig = await getServicesConfig(env)
+
+  return {
+    ...servicesConfig,
+    PORT: env.PORT ?? '3000',
+    SESSION_COOKIE_NAME: '{{name_snake}}_session',
+    SESSION_COOKIE_SECURE: servicesConfig.ENV_NAME !== 'local' ? 'true' : 'false'
+  }
+}
+`;
+var queueProcessorConfig = `import getServicesConfig from './services.ts'
+
+export default async function (env: Record<string, string | undefined>) {
+  const servicesConfig = await getServicesConfig(env)
+
+  return {
+    ...servicesConfig,
+    QUEUE_CONCURRENCY: env.QUEUE_CONCURRENCY ?? '1',
+    QUEUE_POLL_INTERVAL: env.QUEUE_POLL_INTERVAL ?? '5000'
+  }
+}
+`;
+var dbMigrateConfig = `export default async function (env: Record<string, string | undefined>) {
+  return {
+    DB_HOST: env.DB_HOST ?? 'localhost',
+    DB_PORT: env.DB_PORT ?? '3306',
+    DB_USER: env.DB_USER ?? '{{name}}',
+    DB_PASSWORD: env.DB_PASSWORD ?? '',
+    DB_DATABASE: env.DB_DATABASE ?? '{{name}}'
+  }
+}
+`;
+
+// src/templates/schemas.ts
+function schemasPackageJson(name) {
+  return JSON.stringify(
+    {
+      name: `@${name}/schemas`,
+      private: true,
+      type: "module",
+      exports: { ".": "./src/index.ts" },
+      scripts: { typecheck: "tsc --noEmit" },
+      dependencies: {
+        "iso-fns": "npm:iso-fns@2.0.0-alpha.26",
+        zod: "^4.3.0",
+        "@maestro-js/iso-zod": "latest"
+      },
+      devDependencies: {}
+    },
+    null,
+    2
+  );
+}
+var schemasIndex = `// Export your Zod schemas here
+// Example: export { UserSchemas } from './user/index.ts'
+`;
+
+// src/templates/services.ts
+function servicesPackageJson(name) {
+  return JSON.stringify(
+    {
+      name: `@${name}/services`,
+      private: true,
+      type: "module",
+      exports: { ".": "./src/index.ts" },
+      scripts: {
+        test: `maestro config:run --config services --root $PWD/../.. -- node ./run-tests.ts`,
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        [`@${name}/schemas`]: "workspace:*",
+        "@aws-sdk/client-ses": "^3.1004.0",
+        "@maestro-js/auth": "latest",
+        "@maestro-js/cache": "latest",
+        "@maestro-js/config": "latest",
+        "@maestro-js/crypt": "latest",
+        "@maestro-js/custom-errors": "latest",
+        "@maestro-js/db": "latest",
+        "@maestro-js/exceptions": "latest",
+        "@maestro-js/hash": "latest",
+        "@maestro-js/helpers": "latest",
+        "@maestro-js/iso-zod": "latest",
+        "@maestro-js/log": "latest",
+        "@maestro-js/mail": "latest",
+        "@maestro-js/password": "latest",
+        "@maestro-js/permissions": "latest",
+        "@maestro-js/queue": "latest",
+        "@maestro-js/rate-limiting": "latest",
+        "@maestro-js/recurring-jobs": "latest",
+        "@maestro-js/session": "latest",
+        "iso-fns": "npm:iso-fns@2.0.0-alpha.26",
+        zod: "^4.3.0"
+      },
+      devDependencies: {
+        "@maestro-js/cli": "latest",
+        "@types/node": "^22.0.0",
+        "beartest-js": "^8.0.2"
+      }
+    },
+    null,
+    2
+  );
+}
+var servicesTsconfig = `{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "es2022",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true
+  },
+  "include": ["./src"]
+}
+`;
+var maestroTs = `import fs from 'node:fs'
+import path from 'node:path'
+import { Db } from '@maestro-js/db'
+import { Cache } from '@maestro-js/cache'
+import { Hash } from '@maestro-js/hash'
+import { Crypt } from '@maestro-js/crypt'
+import { Session } from '@maestro-js/session'
+import { RateLimiting } from '@maestro-js/rate-limiting'
+import { Queue } from '@maestro-js/queue'
+import { RecurringJobs } from '@maestro-js/recurring-jobs'
+import { Mail } from '@maestro-js/mail'
+import { Log } from '@maestro-js/log'
+import { SESClient, SendRawEmailCommand, type SendRawEmailCommandInput } from '@aws-sdk/client-ses'
+
+Db.Provider.register(
+  'default',
+  Db.Provider.create({
+    driver: Db.drivers.mysql({
+      user: process.env.DB_USER!,
+      password: process.env.DB_PASSWORD!,
+      host: process.env.DB_HOST!,
+      database: process.env.DB_DATABASE!,
+      port: Number(process.env.DB_PORT!)
+    })
+  })
+)
+
+Cache.Provider.register(
+  'default',
+  Cache.Provider.create({
+    driver:
+      process.env.ENV_NAME === 'local'
+        ? Cache.drivers.mockRedis({})
+        : Cache.drivers.redis({ url: process.env.REDIS_URL!, port: Number(process.env.REDIS_PORT!) })
+  })
+)
+
+Hash.Provider.register(
+  'default',
+  Hash.Provider.create(Hash.drivers.sha256({ key: process.env.HASH_KEY!, previousKeys: [] }))
+)
+Hash.Provider.register('bcrypt', Hash.Provider.create(Hash.drivers.bcrypt({ rounds: 12 })))
+
+Crypt.Provider.register(
+  'default',
+  Crypt.Provider.create({
+    key: process.env.ENCRYPTION_KEY!,
+    previousKeys: []
+  })
+)
+
+Session.Provider.register(
+  'default',
+  Session.Provider.create({
+    driver: Session.drivers.store({
+      store: Cache,
+      crypt: Crypt,
+      cookie: {
+        name: '{{name_snake}}_session',
+        secure: process.env.ENV_NAME !== 'local',
+        httpOnly: true,
+        sameSite: 'Lax',
+        maxAge: 30 * 24 * 60 * 60
+      }
+    })
+  })
+)
+
+RateLimiting.Provider.register('default', RateLimiting.Provider.create(Cache))
+
+Queue.Provider.register(
+  'default',
+  Queue.Provider.create({
+    driver: Queue.drivers.db({
+      db: Db,
+      databaseTable: 'queueMessages'
+    }),
+    logger: Log
+  })
+)
+
+RecurringJobs.Provider.register(
+  'default',
+  RecurringJobs.Provider.create({
+    driver: RecurringJobs.drivers.db({
+      db: Db,
+      databaseTable: 'recurringJobs'
+    }),
+    logger: Log
+  })
+)
+
+if (process.env.ENV_NAME === 'local') {
+  const e2eMailDir = path.resolve(process.cwd(), '.e2e-mail')
+  fs.mkdirSync(e2eMailDir, { recursive: true })
+  Mail.Provider.register(
+    'default',
+    Mail.Provider.create({
+      driver: Mail.drivers.stub({
+        logger: {
+          info(envelope: Mail.Envelope) {
+            fs.writeFileSync(path.join(e2eMailDir, 'latest.json'), JSON.stringify(envelope, null, 2))
+          }
+        } as any
+      }),
+      name: 'default',
+      globalFrom: process.env.MAIL_FROM!,
+      logger: Log,
+      queue: Queue
+    })
+  )
+} else {
+  const sesClient = new SESClient({ region: process.env.AWS_REGION! })
+  Mail.Provider.register(
+    'default',
+    Mail.Provider.create({
+      driver: Mail.drivers.ses({
+        send(command: { input: SendRawEmailCommandInput }) {
+          return sesClient.send(new SendRawEmailCommand(command.input))
+        },
+        configurationSetName: '{{name}}'
+      }),
+      name: 'default',
+      globalFrom: process.env.MAIL_FROM!,
+      logger: Log,
+      queue: Queue
+    })
+  )
+}
+
+Log.addTransport(Log.transports.console())
+
+// TODO: Register Auth.Provider with your credentials type
+// TODO: Register Password.Provider if using password auth
+// TODO: Register Permissions.Provider with your action map
+
+declare module '@maestro-js/hash' {
+  namespace Hash {
+    namespace Provider {
+      interface Keys {
+        default: true
+        bcrypt: true
+      }
+    }
+  }
+}
+`;
+var servicesIndex = `import './maestro.ts'
+export { Db } from '@maestro-js/db'
+export { Cache } from '@maestro-js/cache'
+export { Hash } from '@maestro-js/hash'
+export { Crypt } from '@maestro-js/crypt'
+// TODO: export { Auth } from '@maestro-js/auth'
+// TODO: export { Password } from '@maestro-js/password'
+export { Helpers } from '@maestro-js/helpers'
+export { Session } from '@maestro-js/session'
+export { RateLimiting } from '@maestro-js/rate-limiting'
+export { Queue } from '@maestro-js/queue'
+export { RecurringJobs } from '@maestro-js/recurring-jobs'
+export { Mail } from '@maestro-js/mail'
+export { Log } from '@maestro-js/log'
+// TODO: export { Permissions } from '@maestro-js/permissions'
+export { CustomErrors } from '@maestro-js/custom-errors'
+`;
+
+// src/templates/web.ts
+function webPackageJson(name) {
+  return JSON.stringify(
+    {
+      name: `@${name}/${name}-web`,
+      private: true,
+      type: "module",
+      scripts: {
+        dev: `NODE_OPTIONS='--import ./instrument.server.mjs' maestro config:run --config ${name}-web --root $PWD/.. -- react-router dev`,
+        "dev-test": "IS_TESTING=true pnpm dev",
+        build: "react-router build",
+        start: `NODE_ENV=production NODE_OPTIONS='--import ./instrument.server.mjs' maestro config:run --config ${name}-web --root $PWD/.. -- react-router-serve ./build/server/index.js`,
+        typecheck: "react-router typegen && tsc --noEmit",
+        "test:e2e": `maestro config:run --config ${name}-web --root $PWD/.. -- playwright test`,
+        format: "prettier --write app/"
+      },
+      dependencies: {
+        [`@${name}/schemas`]: "workspace:*",
+        [`@${name}/services`]: "workspace:*",
+        "@maestro-js/custom-errors": "latest",
+        "@maestro-js/log": "latest",
+        "@maestro-js/form": "latest",
+        "@react-router/node": "^7.9.0",
+        "@react-router/serve": "^7.9.0",
+        "@sentry/react-router": "^9",
+        isbot: "^5",
+        "iso-fns": "npm:iso-fns@2.0.0-alpha.26",
+        react: "^19.0.0",
+        "react-aria-components": "^1.15.1",
+        "react-dom": "^19.0.0",
+        "react-router": "^7.9.0",
+        "tailwind-merge": "^3.5.0",
+        "vite-env-only": "^3.0.3",
+        zod: "^4.0.0"
+      },
+      devDependencies: {
+        "@maestro-js/cli": "latest",
+        "@maestro-js/react-router-file-routes": "latest",
+        "@playwright/test": "^1.52.0",
+        "@react-router/dev": "^7.9.0",
+        "@tailwindcss/vite": "^4.2.0",
+        "@types/node": "^22.19.11",
+        "@types/react": "^19.0.0",
+        "@types/react-dom": "^19.0.0",
+        tailwindcss: "^4.2.1",
+        typescript: "^5.7.0",
+        vite: "^8.0.0",
+        "vite-plugin-icons-spritesheet": "^3.0.1",
+        "vite-tsconfig-paths": "^6.1.1"
+      }
+    },
+    null,
+    2
+  );
+}
+var webTsconfig = `{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "types": ["vite/client"],
+    "rootDirs": [".", ".react-router/types"],
+    "paths": {
+      "~/*": ["./app/*"]
+    }
+  },
+  "include": [
+    "app",
+    "tests",
+    "vite.config.ts",
+    "react-router.config.ts",
+    ".react-router",
+    "./environment.d.ts",
+    "playwright.config.ts"
+  ]
+}
+`;
+var viteConfig = `import { reactRouter } from '@react-router/dev/vite'
+import { sentryReactRouter } from '@sentry/react-router'
+import tailwindcss from '@tailwindcss/vite'
+import { defineConfig } from 'vite'
+import { iconsSpritesheet } from 'vite-plugin-icons-spritesheet'
+import tsconfigPaths from 'vite-tsconfig-paths'
+import { envOnlyMacros } from 'vite-env-only'
+
+export default defineConfig((config) => ({
+  plugins: [
+    iconsSpritesheet({
+      inputDir: 'icons',
+      outputDir: 'app/icons',
+      fileName: 'sprite.svg',
+      withTypes: true,
+      typesOutputFile: 'app/icons/types.ts',
+      iconNameTransformer: (name) => name,
+      formatter: 'prettier'
+    }),
+    envOnlyMacros(),
+    tsconfigPaths(),
+    tailwindcss(),
+    reactRouter(),
+    sentryReactRouter(
+      {
+        org: process.env.SENTRY_ORG,
+        project: process.env.SENTRY_PROJECT,
+        authToken: process.env.SENTRY_AUTH_TOKEN
+      },
+      config
+    )
+  ],
+  server: {
+    port: 3000,
+    strictPort: true
+  }
+}))
+`;
+var reactRouterConfig = `import type { Config } from '@react-router/dev/config'
+import { sentryOnBuildEnd } from '@sentry/react-router'
+
+export default {
+  ssr: true,
+  future: {
+    v8_middleware: true
+  },
+  async buildEnd({ viteConfig, reactRouterConfig, buildManifest }) {
+    await sentryOnBuildEnd({ viteConfig, reactRouterConfig, buildManifest })
+  }
+} satisfies Config
+`;
+var instrumentServerMjs = `import * as Sentry from '@sentry/react-router'
+import { Log } from '@maestro-js/log'
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  tracesSampleRate: 1.0,
+  sendDefaultPii: false
+})
+
+Log.addTransport(
+  Log.transports.sentry({
+    sentry: Sentry,
+    filter: { level: ['error', 'emergency'] },
+    getCaptureContext(message) {
+      return {
+        tags: { channel: message.channel ?? 'default' },
+        extra: {},
+        level: message.level === 'emergency' ? 'fatal' : message.level
+      }
+    }
+  })
+)
+
+Log.addTransport(
+  Log.transports.sentryBreadcrumbs({
+    sentry: Sentry,
+    filter: { level: ['info', 'warn'] }
+  })
+)
+`;
+var environmentDts = `declare module '*.svg' {
+  const href: string
+  export default href
+}
+
+interface ImportMetaEnv {
+  VITE_SENTRY_DSN: string
+}
+`;
+
+// src/templates/web-app.ts
+var entryServerTsx = `import * as Sentry from '@sentry/react-router'
+import { createReadableStreamFromReadable } from '@react-router/node'
+import { renderToPipeableStream } from 'react-dom/server'
+import { ServerRouter } from 'react-router'
+import '~/services.server'
+
+export default Sentry.createSentryHandleRequest({
+  ServerRouter,
+  renderToPipeableStream,
+  createReadableStreamFromReadable
+})
+
+export const handleError = Sentry.createSentryHandleError({ logErrors: true })
+`;
+var entryClientTsx = `import * as Sentry from '@sentry/react-router'
+import { startTransition, StrictMode } from 'react'
+import { hydrateRoot } from 'react-dom/client'
+import { HydratedRouter } from 'react-router/dom'
+
+Sentry.init({
+  dsn: import.meta.env.VITE_SENTRY_DSN,
+  integrations: [Sentry.reactRouterTracingIntegration(), Sentry.replayIntegration()],
+  tracesSampleRate: 1.0,
+  replaysSessionSampleRate: 0.1,
+  replaysOnErrorSampleRate: 1.0
+})
+
+startTransition(() => {
+  hydrateRoot(
+    document,
+    <StrictMode>
+      <HydratedRouter />
+    </StrictMode>
+  )
+})
+`;
+var rootTsx = `import * as Sentry from '@sentry/react-router'
+import { HeadlessForm } from '@maestro-js/form'
+import {
+  Links,
+  Meta,
+  Outlet,
+  Scripts,
+  ScrollRestoration,
+  useLoaderData,
+  useRouteLoaderData,
+  isRouteErrorResponse,
+  useRouteError,
+  Link,
+  useActionData,
+  useFetchers
+} from 'react-router'
+import type { LoaderFunctionArgs, MiddlewareFunction } from 'react-router'
+import { getRequestContext, requestContextMiddleware } from '~/features/request-context.server'
+import { csrfMiddleware } from '~/features/csrf-middleware.server'
+import { customErrorStatusCodeMiddleware } from '~/features/custom-error-status-code-middleware.server'
+import { securityHeadersMiddleware } from '~/features/security-headers-middleware.server'
+import { getSessionToast } from '~/features/redirect-with-toast.server'
+import './app.css'
+
+export const middleware: MiddlewareFunction<Response>[] = [
+  customErrorStatusCodeMiddleware,
+  requestContextMiddleware,
+  csrfMiddleware,
+  securityHeadersMiddleware
+]
+
+export async function loader({ context }: LoaderFunctionArgs) {
+  const requestContext = getRequestContext(context)
+
+  return {
+    csrfToken: requestContext.session.getCsrfToken(),
+    toast: getSessionToast(requestContext.session)
+  }
+}
+
+function Document({ children }: { children: React.ReactNode }) {
+  const loaderData = useRouteLoaderData<typeof loader>('root')
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <Meta />
+        <Links />
+      </head>
+      <body className="h-full bg-white text-neutral-900 antialiased">
+        {children}
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  )
+}
+
+export default function Root() {
+  const { csrfToken, toast } = useLoaderData<typeof loader>()
+
+  return (
+    <Document>
+      <HeadlessForm.GlobalProvider useServerErrors={useServerErrors} csrfToken={csrfToken}>
+        <Outlet />
+      </HeadlessForm.GlobalProvider>
+    </Document>
+  )
+}
+
+export function ErrorBoundary() {
+  const error = useRouteError()
+
+  if (isRouteErrorResponse(error)) {
+    const { status } = error
+
+    let title = 'Something went wrong'
+    let description = 'An unexpected error occurred.'
+
+    if (status === 404) {
+      title = 'Page not found'
+      description = 'The page you were looking for could not be found.'
+    } else if (status === 401) {
+      title = 'Unauthorized'
+      description = 'You need to be logged in to access this page.'
+    } else if (status === 403) {
+      title = 'Forbidden'
+      description = "You don't have permission to access this resource."
+    } else if (status === 429) {
+      title = 'Too many requests'
+      description = 'Please slow down and try again in a moment.'
+    }
+
+    return (
+      <Document>
+        <div className="flex min-h-screen items-center justify-center bg-neutral-50 px-4">
+          <div className="text-center">
+            <p className="text-5xl font-bold text-neutral-300">{status}</p>
+            <h1 className="mt-4 text-xl font-semibold text-neutral-900">{title}</h1>
+            <p className="mt-2 text-sm text-neutral-600">{description}</p>
+            <Link to="/" className="mt-6 inline-block typography-link">
+              Go home
+            </Link>
+          </div>
+        </div>
+      </Document>
+    )
+  }
+
+  if (error instanceof Error) {
+    Sentry.captureException(error)
+  }
+
+  return (
+    <Document>
+      <div className="flex min-h-screen items-center justify-center bg-neutral-50 px-4">
+        <div className="text-center">
+          <p className="text-5xl font-bold text-neutral-300">500</p>
+          <h1 className="mt-4 text-xl font-semibold text-neutral-900">Something went wrong</h1>
+          <p className="mt-2 text-sm text-neutral-600">An unexpected error occurred. Please try again later.</p>
+          <Link to="/" className="mt-6 inline-block typography-link">
+            Go home
+          </Link>
+        </div>
+      </div>
+    </Document>
+  )
+}
+
+function useServerErrors(formId: string | undefined) {
+  const actionData = useActionData<any>()
+  const fetchers = useFetchers()
+
+  const serverError =
+    actionData && typeof actionData === 'object' && 'formSubmissionError' in actionData
+      ? actionData['formSubmissionError']
+      : null
+  if (formId && serverError?.formId === formId) {
+    return serverError.issues
+  }
+
+  const fetcherMatch =
+    fetchers
+      .map((fetcher) => {
+        const fetcherData = fetcher.data
+        const serverError =
+          fetcherData && typeof fetcherData === 'object' && 'formSubmissionError' in fetcherData
+            ? fetcherData['formSubmissionError']
+            : null
+        if (formId && serverError?.formId === formId) {
+          return serverError.issues
+        }
+        return null
+      })
+      .filter(Boolean)[0] ?? null
+  return fetcherMatch
+}
+`;
+var routesTs = `import { type RouteConfig } from '@react-router/dev/routes'
+import { ReactRouterFileRoutes } from '@maestro-js/react-router-file-routes'
+
+export default ReactRouterFileRoutes.getRoutes('routes') satisfies RouteConfig
+`;
+var servicesServerTs = `export * from '@{{name}}/services'
+`;
+var appCss = `@import 'tailwindcss';
+
+@theme {
+  --color-primary-50: var(--color-blue-50);
+  --color-primary-100: var(--color-blue-100);
+  --color-primary-200: var(--color-blue-200);
+  --color-primary-300: var(--color-blue-300);
+  --color-primary-400: var(--color-blue-400);
+  --color-primary-500: var(--color-blue-500);
+  --color-primary-600: var(--color-blue-600);
+  --color-primary-700: var(--color-blue-700);
+  --color-primary-800: var(--color-blue-800);
+  --color-primary-900: var(--color-blue-900);
+  --color-primary-950: var(--color-blue-950);
+
+  --color-positive-50: var(--color-emerald-50);
+  --color-positive-100: var(--color-emerald-100);
+  --color-positive-200: var(--color-emerald-200);
+  --color-positive-300: var(--color-emerald-300);
+  --color-positive-400: var(--color-emerald-400);
+  --color-positive-500: var(--color-emerald-500);
+  --color-positive-600: var(--color-emerald-600);
+  --color-positive-700: var(--color-emerald-700);
+  --color-positive-800: var(--color-emerald-800);
+  --color-positive-900: var(--color-emerald-900);
+  --color-positive-950: var(--color-emerald-950);
+
+  --color-negative-50: var(--color-red-50);
+  --color-negative-100: var(--color-red-100);
+  --color-negative-200: var(--color-red-200);
+  --color-negative-300: var(--color-red-300);
+  --color-negative-400: var(--color-red-400);
+  --color-negative-500: var(--color-red-500);
+  --color-negative-600: var(--color-red-600);
+  --color-negative-700: var(--color-red-700);
+  --color-negative-800: var(--color-red-800);
+  --color-negative-900: var(--color-red-900);
+  --color-negative-950: var(--color-red-950);
+
+  --color-neutral-50: var(--color-gray-50);
+  --color-neutral-100: var(--color-gray-100);
+  --color-neutral-200: var(--color-gray-200);
+  --color-neutral-300: var(--color-gray-300);
+  --color-neutral-400: var(--color-gray-400);
+  --color-neutral-500: var(--color-gray-500);
+  --color-neutral-600: var(--color-gray-600);
+  --color-neutral-700: var(--color-gray-700);
+  --color-neutral-800: var(--color-gray-800);
+  --color-neutral-900: var(--color-gray-900);
+  --color-neutral-950: var(--color-gray-950);
+
+  --font-sans: ui-sans-serif, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+}
+
+/* Base styles */
+html {
+  @apply h-full antialiased;
+}
+
+body {
+  @apply h-full bg-white text-neutral-900 font-sans text-sm leading-relaxed;
+}
+
+/* Interactive element base states */
+button,
+[role='button'] {
+  @apply cursor-pointer;
+}
+
+a,
+button,
+[role='button'],
+input,
+select,
+textarea {
+  @apply outline-none focus-visible:ring-2 focus-visible:ring-primary-500/40 focus-visible:ring-offset-1 rounded-sm;
+}
+
+/* Typography utilities */
+.typography-h1 {
+  @apply text-2xl font-semibold tracking-tight text-balance text-neutral-900;
+}
+
+.typography-h2 {
+  @apply text-base font-semibold text-neutral-900;
+}
+
+.typography-h3 {
+  @apply text-sm font-semibold text-neutral-900;
+}
+
+.typography-link {
+  @apply text-sm font-medium text-blue-600 hover:text-blue-500;
+}
+
+.typography-button {
+  @apply text-sm font-medium;
+}
+`;
+var indexRoute = `export default function Index() {
+  return (
+    <div className="flex min-h-screen items-center justify-center">
+      <div className="text-center">
+        <h1 className="typography-h1">Welcome to {{Name}}</h1>
+        <p className="mt-2 text-sm text-neutral-600">Your Maestro project is ready.</p>
+      </div>
+    </div>
+  )
+}
+`;
+
+// src/templates/web-features.ts
+var requestContextServer = `import { Session } from '~/services.server'
+import { createContext, RouterContextProvider, type MiddlewareFunction } from 'react-router'
+import { randomUUID } from 'node:crypto'
+import assert from 'node:assert'
+
+interface RequestContext {
+  requestId: string
+  session: Session
+  // TODO: Add profile field once Auth is configured
+  // profile: YourProfileType | null
+}
+
+const requestContext = createContext<RequestContext | null>(null)
+
+export const requestContextMiddleware: MiddlewareFunction<Response> = async ({ request, context }, next) => {
+  const requestId = randomUUID()
+  const cookieHeader = request.headers.get('Cookie')
+  const session = await Session.getSession(cookieHeader)
+
+  // TODO: Add auth once Auth.Provider is configured
+  // const authResult = await Auth.authenticate({ session, cookieHeader, deviceContext })
+  // const profile = authResult.id ? await YourService.GetProfileById({ id: authResult.id }) : null
+
+  context.set(requestContext, { requestId, session })
+
+  const response = await next()
+
+  // TODO: Append auth cookie once Auth is configured
+  // if (authResult.cookie) {
+  //   response.headers.append('Set-Cookie', authResult.cookie)
+  // }
+  response.headers.append('Set-Cookie', await session.commit())
+
+  return response
+}
+
+export function getRequestContext(context: Readonly<RouterContextProvider>) {
+  const request = context.get(requestContext)
+  assert.ok(request)
+  return request
+}
+`;
+var csrfMiddlewareServer = `import type { MiddlewareFunction } from 'react-router'
+import { getRequestContext } from './request-context.server'
+
+export const csrfMiddleware: MiddlewareFunction<Response> = async ({ request, context }, next) => {
+  const mutatingMethods = ['POST', 'PUT', 'DELETE']
+  if (mutatingMethods.includes(request.method)) {
+    const cloned = request.clone()
+    const formDataForMiddleware = await cloned.formData()
+    const clientCsrfToken = formDataForMiddleware.get('__csrfToken')
+    const requestContext = getRequestContext(context)
+    const sessionCsrfToken = requestContext.session.getCsrfToken()
+    if (clientCsrfToken !== sessionCsrfToken) {
+      throw new Response('Invalid CSRF token', { status: 403 })
+    }
+  }
+  return next()
+}
+`;
+var securityHeadersMiddlewareServer = `import type { MiddlewareFunction } from 'react-router'
+
+export const securityHeadersMiddleware: MiddlewareFunction<Response> = async (_args, next) => {
+  const response = await next()
+  response.headers.set('Strict-Transport-Security', 'max-age=31536000; includeSubDomains')
+  response.headers.set('X-Content-Type-Options', 'nosniff')
+  response.headers.set('X-Frame-Options', 'DENY')
+  response.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin')
+  return response
+}
+`;
+var customErrorStatusCodeMiddlewareServer = `import * as Sentry from '@sentry/react-router'
+import { type MiddlewareFunction } from 'react-router'
+import { CustomErrors, Log } from '~/services.server'
+
+const log = Log.channel('http')
+
+export const customErrorStatusCodeMiddleware: MiddlewareFunction<Response> = async ({ request }, next) => {
+  try {
+    return await next()
+  } catch (e) {
+    if (e instanceof Response) throw e
+
+    const statusCode = CustomErrors.getHttpStatusCode(e)
+    if (statusCode) {
+      if (statusCode >= 500) {
+        log.error('Server error', {
+          status: statusCode,
+          url: request.url,
+          error: e instanceof Error ? e.message : String(e)
+        })
+      } else {
+        log.warn('Client error', { status: statusCode, url: request.url, error: e instanceof Error ? e.name : String(e) })
+      }
+      throw new Response(null, { status: statusCode })
+    } else {
+      Sentry.captureException(e)
+      log.error('Unhandled error', { url: request.url, error: e instanceof Error ? (e.stack ?? e.message) : String(e) })
+      throw e
+    }
+  }
+}
+`;
+var redirectWithToastServer = `import { redirect } from 'react-router'
+import type { Session } from '~/services.server'
+
+type Toast = { type: 'success' | 'error' | 'info'; message: string }
+
+const TOAST_SESSION_KEY = '_toast'
+
+export function redirectWithToast(url: string, toast: Toast, session: Session) {
+  session.flash(TOAST_SESSION_KEY, toast)
+  return redirect(url)
+}
+
+export function getSessionToast(session: Session): Toast | null {
+  return (session.get(TOAST_SESSION_KEY) as Toast) ?? null
+}
+`;
+
+// src/templates/queue-processor.ts
+function queueProcessorPackageJson(name) {
+  return JSON.stringify(
+    {
+      name: `@${name}/queue-processor`,
+      private: true,
+      type: "module",
+      scripts: {
+        start: "maestro config:run --config queue-processor -- tsx src/index.ts"
+      },
+      dependencies: {
+        "@maestro-js/config": "latest",
+        [`@${name}/services`]: "workspace:*"
+      },
+      devDependencies: {
+        "@maestro-js/cli": "latest",
+        "@types/node": "^22.19.11",
+        tsx: "^4.21.0"
+      }
+    },
+    null,
+    2
+  );
+}
+var queueProcessorTsconfig = `{
+  "extends": "../tsconfig.json",
+  "include": ["src"]
+}
+`;
+var queueProcessorIndex = `import { Queue, RecurringJobs, Log } from '@{{name}}/services'
+import './recurring-jobs.ts'
+
+const log = Log.channel('queue-processor')
+
+const concurrency = Number(process.env.QUEUE_CONCURRENCY ?? '1')
+const sleepSeconds = Number(process.env.QUEUE_POLL_INTERVAL ?? '5000') / 1000
+
+log.info({ event: 'queueProcessorStarting', concurrency, sleepSeconds })
+
+const queueHandle = Queue.work({ concurrency, sleepSeconds })
+const recurringJobsHandle = RecurringJobs.work()
+
+process.on('SIGTERM', () => {
+  log.info({ event: 'queueProcessorStopping', reason: 'SIGTERM' })
+  queueHandle.abort('SIGTERM')
+  recurringJobsHandle.abort()
+})
+
+process.on('SIGINT', () => {
+  log.info({ event: 'queueProcessorStopping', reason: 'SIGINT' })
+  queueHandle.abort('SIGINT')
+  recurringJobsHandle.abort()
+})
+
+queueHandle.then(() => {
+  log.info({ event: 'queueProcessorStopped' })
+  process.exit(0)
+})
+`;
+var recurringJobsTs = `// import { RecurringJobs, Log } from '@{{name}}/services'
+
+// Define recurring jobs here
+// Example:
+// RecurringJobs.create({
+//   name: 'my-recurring-job',
+//   cron: '0 3 * * *',
+//   async handle() {
+//     // ...
+//     return {}
+//   }
+// })
+`;
+
+// src/templates/infrastructure.ts
+var dbMigrationsSqlsGitkeep = "";
+
+// src/templates/scripts.ts
+var foreignKeyDeleteBehavior = `import { Db } from '@maestro-js/db'
+
+Db.Provider.register(
+  'default',
+  Db.Provider.create({
+    driver: Db.drivers.mysql({
+      user: process.env.DB_USER!,
+      password: process.env.DB_PASSWORD!,
+      host: process.env.DB_HOST!,
+      database: process.env.DB_DATABASE!,
+      port: Number(process.env.DB_PORT!)
+    })
+  })
+)
+
+// TODO: Add foreign key entries as you create migrations
+// Map constraint names to their ON DELETE behavior when using cascade mode
+const FKS: Record<string, string> = {
+  // Example: fk_posts_userId: 'CASCADE'
+}
+
+type ForeignKey = {
+  TABLE_NAME: string
+  COLUMN_NAME: string
+  REFERENCED_TABLE_NAME: string
+  REFERENCED_COLUMN_NAME: string
+  CONSTRAINT_NAME: string
+}
+
+const foreignKeys = await Db.select<ForeignKey>(
+  \`SELECT
+    TABLE_NAME,
+    COLUMN_NAME,
+    REFERENCED_TABLE_NAME,
+    REFERENCED_COLUMN_NAME,
+    CONSTRAINT_NAME
+  FROM information_schema.KEY_COLUMN_USAGE
+  WHERE TABLE_SCHEMA = ?
+    AND REFERENCED_TABLE_NAME IS NOT NULL
+  ORDER BY TABLE_NAME, COLUMN_NAME\`,
+  [process.env.DB_DATABASE!]
+)
+
+const dbFkNames = new Set(foreignKeys.map((fk) => fk.CONSTRAINT_NAME))
+const localFkNames = new Set(Object.keys(FKS))
+
+const missingFromLocal = [...dbFkNames].filter((name) => !localFkNames.has(name))
+const extraInLocal = [...localFkNames].filter((name) => !dbFkNames.has(name))
+
+if (missingFromLocal.length > 0) {
+  console.error('Foreign keys in database but missing from FKS:', missingFromLocal)
+}
+if (extraInLocal.length > 0) {
+  console.error('Foreign keys in FKS but not in database:', extraInLocal)
+}
+if (missingFromLocal.length > 0 || extraInLocal.length > 0) {
+  process.exit(1)
+}
+
+console.log('FKS matches database foreign keys')
+
+async function applyOnDeleteRestrict() {
+  for (const constraintName of Object.keys(FKS)) {
+    const fk = foreignKeys.find((f) => f.CONSTRAINT_NAME === constraintName)!
+    await Db.statement(\`ALTER TABLE \${fk.TABLE_NAME} DROP FOREIGN KEY \${constraintName}\`)
+    await Db.statement(
+      \`ALTER TABLE \${fk.TABLE_NAME}
+        ADD CONSTRAINT \${constraintName}
+        FOREIGN KEY (\${fk.COLUMN_NAME})
+        REFERENCES \${fk.REFERENCED_TABLE_NAME}(\${fk.REFERENCED_COLUMN_NAME})
+        ON DELETE RESTRICT\`
+    )
+    console.log(\`\${constraintName}: ON DELETE RESTRICT applied\`)
+  }
+}
+
+async function applyOnDeleteCascade() {
+  for (const [constraintName, behavior] of Object.entries(FKS)) {
+    const fk = foreignKeys.find((f) => f.CONSTRAINT_NAME === constraintName)!
+    await Db.statement(\`ALTER TABLE \${fk.TABLE_NAME} DROP FOREIGN KEY \${constraintName}\`)
+    await Db.statement(
+      \`ALTER TABLE \${fk.TABLE_NAME}
+        ADD CONSTRAINT \${constraintName}
+        FOREIGN KEY (\${fk.COLUMN_NAME})
+        REFERENCES \${fk.REFERENCED_TABLE_NAME}(\${fk.REFERENCED_COLUMN_NAME})
+        ON DELETE \${behavior}\`
+    )
+    console.log(\`\${constraintName}: ON DELETE \${behavior} applied\`)
+  }
+}
+
+const action = process.argv[2]
+
+if (action === 'cascade') {
+  await applyOnDeleteCascade()
+} else if (action === 'restrict') {
+  await applyOnDeleteRestrict()
+} else {
+  console.error('Usage: foreign-key-delete-behavior <cascade|restrict>')
+  process.exit(1)
+}
+
+process.exit(0)
+`;
+
+// src/scaffold.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join, dirname } from "path";
+async function scaffold(tree, basePath, tokens) {
+  const created = [];
+  await writeTree(tree, basePath, tokens, created);
+  return created;
+}
+async function writeTree(tree, dir, tokens, created) {
+  for (const [name, value] of Object.entries(tree)) {
+    const fullPath = join(dir, name);
+    if (typeof value === "string") {
+      await mkdir(dirname(fullPath), { recursive: true });
+      const content = tokens ? replaceTokens(value, tokens) : value;
+      await writeFile(fullPath, content);
+      created.push(fullPath);
+    } else {
+      await writeTree(value, fullPath, tokens, created);
+    }
+  }
+}
+function replaceTokens(content, tokens) {
+  return content.replace(/\{\{(\w+)\}\}/g, (match, key) => tokens[key] ?? match);
+}
+
+// src/index.ts
+function buildProjectTree(name) {
+  return {
+    "package.json": rootPackageJson(name),
+    "pnpm-workspace.yaml": pnpmWorkspace(name),
+    "tsconfig.json": rootTsconfig,
+    ".env": rootEnv,
+    ".gitignore": rootGitignore,
+    config: {
+      "services.ts": servicesConfig,
+      [`${name}-web.ts`]: webConfig,
+      "queue-processor.ts": queueProcessorConfig,
+      "db-migrate.ts": dbMigrateConfig
+    },
+    packages: {
+      schemas: {
+        "package.json": schemasPackageJson(name),
+        src: {
+          "index.ts": schemasIndex
+        }
+      },
+      services: {
+        "package.json": servicesPackageJson(name),
+        "tsconfig.json": servicesTsconfig,
+        src: {
+          "maestro.ts": maestroTs,
+          "index.ts": servicesIndex
+        }
+      }
+    },
+    [`${name}-web`]: {
+      "package.json": webPackageJson(name),
+      "tsconfig.json": webTsconfig,
+      "vite.config.ts": viteConfig,
+      "react-router.config.ts": reactRouterConfig,
+      "instrument.server.mjs": instrumentServerMjs,
+      "environment.d.ts": environmentDts,
+      icons: {
+        ".gitkeep": ""
+      },
+      app: {
+        "entry.server.tsx": entryServerTsx,
+        "entry.client.tsx": entryClientTsx,
+        "root.tsx": rootTsx,
+        "routes.ts": routesTs,
+        "services.server.ts": servicesServerTs,
+        "app.css": appCss,
+        routes: {
+          "index.tsx": indexRoute
+        },
+        features: {
+          "request-context.server.ts": requestContextServer,
+          "csrf-middleware.server.ts": csrfMiddlewareServer,
+          "security-headers-middleware.server.ts": securityHeadersMiddlewareServer,
+          "custom-error-status-code-middleware.server.ts": customErrorStatusCodeMiddlewareServer,
+          "redirect-with-toast.server.ts": redirectWithToastServer
+        }
+      }
+    },
+    "queue-processor": {
+      "package.json": queueProcessorPackageJson(name),
+      "tsconfig.json": queueProcessorTsconfig,
+      src: {
+        "index.ts": queueProcessorIndex,
+        "recurring-jobs.ts": recurringJobsTs
+      }
+    },
+    infrastructure: {
+      "db-migrations": {
+        sqls: {
+          ".gitkeep": dbMigrationsSqlsGitkeep
+        }
+      }
+    },
+    scripts: {
+      "foreign-key-delete-behavior.ts": foreignKeyDeleteBehavior
+    }
+  };
+}
+
+export {
+  scaffold,
+  buildProjectTree
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+type Tree = {
+    [name: string]: string | Tree;
+};
+type Tokens = Record<string, string>;
+declare function scaffold(tree: Tree, basePath: string, tokens?: Tokens): Promise<string[]>;
+
+declare function buildProjectTree(name: string): Tree;
+
+export { type Tokens, type Tree, buildProjectTree, scaffold };

package/dist/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  buildProjectTree,
+  scaffold
+} from "./chunk-P4YULL3I.js";
+export {
+  buildProjectTree,
+  scaffold
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@maestro-js/init",
+  "description": "Project scaffolding for the Maestro framework. Generates a complete monorepo with config, schemas, services, web app, queue processor, and infrastructure.",
+  "type": "module",
+  "bin": {
+    "maestro-init": "./dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.11"
+  },
+  "version": "1.0.0-alpha.10",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "repository": "https://github.com/Marcato-Partners/maestro-js",
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write src/",
+    "lint": "prettier --check src/"
+  }
+}