@alfredmouelle/create-stack 0.1.1 → 0.2.0

package/lib/capabilities.mjs

@@ -0,0 +1,375 @@
+// Swappable capabilities (storage, cache, jobs, logger, analytics, error-tracking).
+// Generalizes mailer.mjs: vendor a capability's core + chosen adapter into the fork,
+// generate a composition root reading typed env, and return dep/env deltas.
+// Manifest (capability.json) is the source of truth for files/deps/env; this registry
+// adds only what a manifest can't carry — the env → constructor-arg mapping.
+
+import { readdirSync, statSync } from 'node:fs'
+import { STACK_ROOT } from './paths.mjs'
+import { copy, exists, join, read, readJSON, write } from './util.mjs'
+
+const PKG = (cap) => join(STACK_ROOT, 'packages', cap)
+
+/**
+ * Per-capability wiring. `dir` = vendored destination, `entry` = exported accessor
+ * stem, `portType` = the interface returned. Each adapter maps constructor args to
+ * env keys: [argName, ENV_KEY, required?]. A required arg is narrowed via required().
+ */
+const CAPS = {
+  storage: {
+    label: 'Storage',
+    dir: 'src/server/storage',
+    entry: 'storage',
+    portType: 'StoragePort',
+    defaultAdapter: 's3',
+    adapters: {
+      s3: {
+        fn: 's3Adapter',
+        args: [
+          ['bucket', 'S3_BUCKET', true],
+          ['region', 'S3_REGION', true],
+          ['accessKeyId', 'AWS_ACCESS_KEY_ID', false],
+          ['secretAccessKey', 'AWS_SECRET_ACCESS_KEY', false],
+        ],
+      },
+      r2: {
+        fn: 'r2Adapter',
+        args: [
+          ['bucket', 'R2_BUCKET', true],
+          ['accountId', 'R2_ACCOUNT_ID', true],
+          ['accessKeyId', 'R2_ACCESS_KEY_ID', false],
+          ['secretAccessKey', 'R2_SECRET_ACCESS_KEY', false],
+        ],
+      },
+      gcs: {
+        fn: 'gcsAdapter',
+        args: [
+          ['bucket', 'GCS_BUCKET', true],
+          ['projectId', 'GOOGLE_CLOUD_PROJECT', false],
+        ],
+      },
+      local: { fn: 'localAdapter', args: [['baseDir', 'STORAGE_LOCAL_DIR', true]] },
+    },
+  },
+
+  cache: {
+    label: 'Cache',
+    dir: 'src/server/cache',
+    entry: 'cache',
+    portType: 'CachePort',
+    defaultAdapter: 'redis',
+    adapters: {
+      redis: { fn: 'redisAdapter', args: [['url', 'REDIS_URL', false]] },
+      memory: { fn: 'memoryAdapter', args: [] },
+    },
+  },
+
+  logger: {
+    label: 'Logger',
+    dir: 'src/server/logger',
+    entry: 'logger',
+    portType: 'Logger',
+    defaultAdapter: 'pino',
+    adapters: {
+      pino: { fn: 'pinoAdapter', args: [] },
+      console: { fn: 'consoleAdapter', args: [] },
+    },
+  },
+
+  analytics: {
+    label: 'Analytics',
+    dir: 'src/server/analytics',
+    entry: 'analytics',
+    portType: 'AnalyticsPort',
+    defaultAdapter: 'posthog',
+    adapters: {
+      posthog: {
+        fn: 'posthogAdapter',
+        args: [
+          ['apiKey', 'POSTHOG_API_KEY', true],
+          ['host', 'POSTHOG_HOST', false],
+        ],
+      },
+      plausible: {
+        fn: 'plausibleAdapter',
+        args: [
+          ['domain', 'PLAUSIBLE_DOMAIN', true],
+          ['apiHost', 'PLAUSIBLE_API_HOST', false],
+        ],
+      },
+      noop: { fn: 'noopAdapter', args: [] },
+    },
+  },
+
+  'error-tracking': {
+    label: 'Error tracking',
+    dir: 'src/server/error-tracking',
+    entry: 'errorTracking',
+    portType: 'ErrorTrackingPort',
+    defaultAdapter: 'sentry',
+    adapters: {
+      sentry: {
+        fn: 'sentryAdapter',
+        args: [
+          ['dsn', 'SENTRY_DSN', true],
+          ['environment', 'SENTRY_ENVIRONMENT', false],
+        ],
+      },
+      console: { fn: 'consoleAdapter', args: [] },
+    },
+  },
+
+  jobs: {
+    label: 'Background jobs',
+    dir: 'src/server/jobs',
+    entry: 'jobs',
+    kind: 'jobs', // bespoke: concrete adapter (serving) + HTTP surface
+    defaultAdapter: 'inngest',
+    adapters: {
+      inngest: { fn: 'inngestAdapter' },
+      trigger: { fn: 'triggerDevAdapter' },
+      memory: { fn: 'memoryAdapter' },
+    },
+  },
+}
+
+export const CAPABILITIES = Object.keys(CAPS)
+
+/** Prompt options for the capability multiselect. */
+export const capabilityChoices = () =>
+  CAPABILITIES.map((name) => ({
+    value: name,
+    label: CAPS[name].label,
+    hint: Object.keys(CAPS[name].adapters).join(' / '),
+  }))
+
+/** Adapter options + default for one capability (drives the per-capability select). */
+export const adapterChoices = (cap) => ({
+  defaultAdapter: CAPS[cap].defaultAdapter,
+  options: Object.keys(CAPS[cap].adapters).map((value) => ({ value, label: value })),
+})
+
+/** Resolve a possibly-empty flag value to a valid adapter, or throw. */
+export function resolveAdapter(cap, value) {
+  const spec = CAPS[cap]
+  if (!spec) throw new Error(`Unknown capability: ${cap}`)
+  if (value === true || value == null || value === '') return spec.defaultAdapter
+  if (!spec.adapters[value]) {
+    throw new Error(
+      `Unknown ${cap} adapter: ${value} (have ${Object.keys(spec.adapters).join(', ')})`,
+    )
+  }
+  return value
+}
+
+const REQUIRED_HELPER = `
+function required(value: string | undefined, name: string): string {
+  if (!value) throw new Error(\`\${name} is required\`)
+  return value
+}
+`
+
+/** Object-literal body mapping constructor args to env (required ones narrowed). */
+const ctorArgs = (args) =>
+  args
+    .map(([name, key, req]) =>
+      req ? `      ${name}: required(env.${key}, '${key}'),` : `      ${name}: env.${key},`,
+    )
+    .join('\n')
+
+/** Lazy-singleton composition root: boots without env, constructs on first use. */
+function standardRoot({ entry, portType, adapterKey, fn, args }) {
+  const getter = `get${entry[0].toUpperCase()}${entry.slice(1)}`
+  const hasRequired = args.some((a) => a[2])
+  const ctor = args.length ? `${fn}({\n${ctorArgs(args)}\n    })` : `${fn}()`
+  const envImport = args.length ? "import { env } from '~/env'\n" : ''
+  return `${envImport}import { ${fn} } from './adapters/${adapterKey}/index'
+import type { ${portType} } from './core/port'
+${hasRequired ? REQUIRED_HELPER : ''}
+let instance: ${portType} | null = null
+export function ${getter}(): ${portType} {
+  if (!instance) {
+    instance = ${ctor}
+  }
+  return instance
+}
+`
+}
+
+/** Slug usable as an Inngest app id (no slashes, lowercase). */
+const slug = (name) =>
+  name
+    .split('/')
+    .pop()
+    .replace(/[^a-z0-9]+/gi, '-')
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase() || 'app'
+
+/** Jobs needs the concrete adapter object (for serving), so it exports an eager const. */
+function jobsRoot(adapterKey, projectName) {
+  if (adapterKey === 'inngest') {
+    return `import { env } from '~/env'
+import { inngestAdapter } from './adapters/inngest/index'
+
+// Composition root — register jobs with jobs.defineJob(), trigger with jobs.trigger().
+export const jobs = inngestAdapter({
+  id: '${slug(projectName)}',
+  eventKey: env.INNGEST_EVENT_KEY,
+})
+`
+  }
+  if (adapterKey === 'trigger') {
+    return `import { env } from '~/env'
+import { triggerDevAdapter } from './adapters/trigger/index'
+
+// Composition root — register jobs with jobs.defineJob(), trigger with jobs.trigger().
+export const jobs = triggerDevAdapter({
+  secretKey: env.TRIGGER_SECRET_KEY,
+})
+`
+  }
+  return `import { memoryAdapter } from './adapters/memory/index'
+
+// In-process composition root (dev/tests) — runs handlers inline on trigger().
+export const jobs = memoryAdapter()
+`
+}
+
+const JOBS_SERVE = `import { serve } from 'inngest/edge'
+import { env } from '~/env'
+import { inngestServeHandler } from './adapters/inngest/index'
+import { jobs } from './index'
+
+// Web-standard FetchHandler serving the registered functions; mounted by the route shim.
+export const handler = inngestServeHandler(jobs, serve, {
+  signingKey: env.INNGEST_SIGNING_KEY,
+})
+`
+
+const NEXT_INNGEST_ROUTE = `import { handler } from '~/server/jobs/serve'
+
+export { handler as GET, handler as POST, handler as PUT }
+`
+
+const TANSTACK_INNGEST_ROUTE = `import { createFileRoute } from '@tanstack/react-router'
+import type {} from '@tanstack/react-start'
+import { handler } from '~/server/jobs/serve'
+
+export const Route = createFileRoute('/api/inngest')({
+  server: {
+    handlers: {
+      GET: ({ request }) => handler(request),
+      POST: ({ request }) => handler(request),
+      PUT: ({ request }) => handler(request),
+    },
+  },
+})
+`
+
+/** Copy a manifest path (rooted at the package) under destDir, stripping `src/`. */
+function copyPath(cap, relSrc, destDir) {
+  copy(join(PKG(cap), relSrc), join(destDir, relSrc.replace(/^src\//, '')))
+}
+
+/** True if any vendored .ts file under dir still imports a cross-package. */
+function references(dir, mod) {
+  for (const name of readdirSync(dir, { recursive: true })) {
+    const p = join(dir, name)
+    if (statSync(p).isFile() && /\.tsx?$/.test(p) && read(p).includes(mod)) return true
+  }
+  return false
+}
+
+/** Run fn(path, source) over every vendored .ts/.tsx file under dir. */
+function walkTs(dir, fn) {
+  for (const name of readdirSync(dir, { recursive: true })) {
+    const p = join(dir, name)
+    if (statSync(p).isFile() && /\.tsx?$/.test(p)) fn(p, read(p))
+  }
+}
+
+/** Rewrite every `from`-module import to `to` across vendored .ts files. */
+function rewriteImports(dir, from, to) {
+  walkTs(dir, (p, src) => {
+    if (src.includes(from)) write(p, src.split(from).join(to))
+  })
+}
+
+// Package source uses NodeNext `.js` extensions on relative imports (for tsdown);
+// the base app + app bundlers (Next/Vite) expect extensionless. Strip them on vendor.
+const JS_EXT = /(from\s+['"]\.\.?\/[^'"]*?)\.js(['"])/g
+
+/** Drop `.js` from relative import specifiers across vendored .ts files. */
+function stripJsExtensions(dir) {
+  walkTs(dir, (p, src) => {
+    const next = src.replace(JS_EXT, '$1$2')
+    if (next !== src) write(p, next)
+  })
+}
+
+/** Vendor @alfredmouelle/http into src/lib/http (once) and point imports at it. */
+function vendorHttp(projectDir, destDir) {
+  if (!references(destDir, '@alfredmouelle/http')) return
+  const httpDest = join(projectDir, 'src/lib/http')
+  if (!exists(httpDest)) {
+    copy(join(STACK_ROOT, 'packages/http/src'), httpDest)
+    stripJsExtensions(httpDest)
+  }
+  rewriteImports(destDir, '@alfredmouelle/http', '~/lib/http')
+}
+
+/** Dep ranges from the capability's manifest; skips vendored @alfredmouelle/* deps. */
+function resolveDeps(cap, names) {
+  const pkg = readJSON(join(PKG(cap), 'package.json'))
+  const out = {}
+  for (const d of names) {
+    if (d.startsWith('@alfredmouelle/')) continue
+    out[d] = pkg.dependencies?.[d] ?? 'latest'
+  }
+  return out
+}
+
+/**
+ * Vendor one capability into the fork.
+ * @returns {{ addDeps: Record<string,string>, envKeys: string[] }}
+ */
+export function vendorCapability({ projectDir, framework, projectName, cap, adapter }) {
+  const spec = CAPS[cap]
+  if (!spec) throw new Error(`Unknown capability: ${cap}`)
+  const aSpec = spec.adapters[adapter]
+  if (!aSpec) throw new Error(`Unknown ${cap} adapter: ${adapter}`)
+
+  const manifest = readJSON(join(PKG(cap), 'capability.json'))
+  const adManifest = manifest.adapters[adapter]
+  const destDir = join(projectDir, spec.dir)
+
+  // core (+ shared) and the chosen adapter; the barrel index.ts is replaced below.
+  const files = [...manifest.sharedFiles.filter((f) => f !== 'src/index.ts'), ...adManifest.files]
+  for (const f of files) copyPath(cap, f, destDir)
+  stripJsExtensions(destDir) // NodeNext `.js` specifiers → extensionless (app bundler)
+
+  // composition root
+  write(
+    join(destDir, 'index.ts'),
+    spec.kind === 'jobs'
+      ? jobsRoot(adapter, projectName)
+      : standardRoot({ ...spec, adapterKey: adapter, fn: aSpec.fn, args: aSpec.args }),
+  )
+
+  // jobs/inngest has an HTTP surface: serve handler + per-framework route shim.
+  if (spec.kind === 'jobs' && adapter === 'inngest') {
+    write(join(destDir, 'serve.ts'), JOBS_SERVE)
+    if (framework === 'next') {
+      write(join(projectDir, 'src/app/api/inngest/route.ts'), NEXT_INNGEST_ROUTE)
+    } else {
+      write(join(projectDir, 'src/routes/api/inngest.ts'), TANSTACK_INNGEST_ROUTE)
+    }
+  }
+
+  vendorHttp(projectDir, destDir)
+
+  return {
+    addDeps: resolveDeps(cap, [...adManifest.deps, ...(manifest.sharedDeps ?? [])]),
+    envKeys: adManifest.env,
+  }
+}

package/lib/env.mjs

@@ -1,10 +1,9 @@
-// Rebuilds src/env.ts `server` + `runtimeEnv` blocks from the final key set,
-// and generates .env.example + .env. Adds keys (e.g. a swapped mailer provider)
-// and prunes keys of stripped foundations/capabilities — deterministically.
+// Rebuilds src/env.ts `server` + `runtimeEnv` from the final key set; generates
+// .env.example + .env. Adds swapped-mailer keys, prunes stripped ones, deterministically.
 
 import { editFile, join, write } from './util.mjs'
 
-/** valibot schema text per known env key. */
+/** valibot schema text per env key. */
 const SCHEMAS = {
   DATABASE_URL: 'v.pipe(v.string(), v.url())',
   BETTER_AUTH_URL: 'v.pipe(v.string(), v.url())',
@@ -17,9 +16,30 @@ const SCHEMAS = {
   AWS_REGION: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
   AWS_ACCESS_KEY_ID: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
   AWS_SECRET_ACCESS_KEY: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  // capabilities — all optional; adapters validate required-ness at first use.
+  // emptyStringAsUndefined (env.ts) turns blank placeholders into undefined.
+  S3_BUCKET: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  S3_REGION: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  R2_BUCKET: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  R2_ACCOUNT_ID: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  R2_ACCESS_KEY_ID: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  R2_SECRET_ACCESS_KEY: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  GCS_BUCKET: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  GOOGLE_CLOUD_PROJECT: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  STORAGE_LOCAL_DIR: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  REDIS_URL: 'v.optional(v.pipe(v.string(), v.url()))',
+  POSTHOG_API_KEY: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  POSTHOG_HOST: 'v.optional(v.pipe(v.string(), v.url()))',
+  PLAUSIBLE_DOMAIN: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  PLAUSIBLE_API_HOST: 'v.optional(v.pipe(v.string(), v.url()))',
+  SENTRY_DSN: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  SENTRY_ENVIRONMENT: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  INNGEST_EVENT_KEY: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  INNGEST_SIGNING_KEY: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
+  TRIGGER_SECRET_KEY: 'v.optional(v.pipe(v.string(), v.minLength(1)))',
 }
 
-/** Placeholder values for the generated .env files. */
+/** Placeholder values for generated .env files. */
 const PLACEHOLDERS = {
   DATABASE_URL: 'postgres://postgres:postgres@localhost:5432/app',
   BETTER_AUTH_URL: 'http://localhost:3000',
@@ -29,7 +49,7 @@ const PLACEHOLDERS = {
 
 const indent = (s) => `    ${s}`
 
-/** Write the final env.ts and .env files. `keys` is an ordered string[]. */
+/** Write final env.ts + .env files. `keys`: ordered string[]. */
 export function writeEnv(projectDir, keys) {
   const seen = new Set()
   const ordered = keys.filter((k) => SCHEMAS[k] && !seen.has(k) && seen.add(k))

package/lib/foundations.mjs

@@ -0,0 +1,35 @@
+// Foundations the CLI can strip + the npm footprint each adds (deps/devDeps/scripts only).
+// File deletes, env keys, code seams live in strip.mjs/build.mjs (need framework-specific surgery).
+
+export const FOUNDATIONS = ['drizzle', 'trpc', 'better-auth', 'data-table']
+
+const DATA = {
+  drizzle: {
+    deps: ['drizzle-orm', 'pg'],
+    devDeps: ['drizzle-kit', 'dotenv', 'tsx', '@types/pg', '@faker-js/faker'],
+    scripts: ['db:generate', 'db:migrate', 'db:push', 'db:studio', 'db:seed'],
+  },
+  trpc: {
+    deps: ['@trpc/server', '@trpc/client', '@tanstack/react-query', 'superjson', 'valibot'],
+    // React Query bridge differs per framework
+    perFramework: { tanstack: ['@trpc/tanstack-react-query'], next: ['@trpc/react-query'] },
+  },
+  'better-auth': {
+    deps: ['better-auth'],
+  },
+  'data-table': {
+    deps: ['@tanstack/react-table'],
+  },
+}
+
+/** Every npm dep (prod + dev) a foundation contributes, for `framework`. */
+export function foundationDeps(name, framework) {
+  const d = DATA[name]
+  if (!d) return []
+  return [...(d.deps ?? []), ...(d.devDeps ?? []), ...(d.perFramework?.[framework] ?? [])]
+}
+
+/** package.json script names a foundation adds. */
+export function foundationScripts(name) {
+  return DATA[name]?.scripts ?? []
+}

package/lib/identity.mjs

@@ -1,7 +1,6 @@
-// Step A4 — stamp the project identity: title/meta + a README that ends with
-// the stack's `# Author` footer verbatim.
+// Stamp project identity: title/meta + README ending with the `# Author` footer verbatim.
 
-import { STACK_ROOT } from './manifests.mjs'
+import { TEMPLATES } from './paths.mjs'
 import { editFile, join, read, write } from './util.mjs'
 
 const titleFiles = {
@@ -10,12 +9,12 @@ const titleFiles = {
 }
 
 export function stampIdentity(projectDir, projectName, framework) {
-  // Swap the placeholder title 'App' in the root document/metadata.
+  // swap placeholder title 'App' in root document/metadata
   for (const rel of titleFiles[framework === 'next' ? 'next' : 'tanstack']) {
     editFile(join(projectDir, rel), (c) => c.replaceAll("title: 'App'", `title: '${projectName}'`))
   }
 
-  const footer = read(join(STACK_ROOT, 'patterns/_baseline/README-author.md'))
+  const footer = read(join(TEMPLATES, 'README-author.md'))
   const readme = `# ${projectName}
 
 Bootstrapped from the personal reference stack.

package/lib/mailer.mjs

@@ -1,13 +1,12 @@
-// Mailer provider swap. The base inlines the Resend adapter; if the user picks
-// another provider we swap the adapter files + the composition root (email/index.ts)
-// and return the dep/env deltas. Mirrors the mailer capability manifest.
+// Mailer provider swap. Base inlines Resend; other providers swap adapter files +
+// composition root (email/index.ts) and return dep/env deltas. Mirrors the mailer manifest.
 
-import { STACK_ROOT } from './manifests.mjs'
+import { STACK_ROOT } from './paths.mjs'
 import { copy, join, readJSON, remove, write } from './util.mjs'
 
 const EMAIL_DIR = 'src/server/email'
 
-/** getMailer() body per provider (composition root in email/index.ts). */
+/** getMailer() body per provider (composition root). */
 const FACTORY = {
   brevo: {
     import: "import { brevoAdapter } from './adapters/brevo/index'",
@@ -17,7 +16,7 @@ const FACTORY = {
   },
   ses: {
     import: "import { sesAdapter } from './adapters/ses/index'",
-    // SESv2 SDK reads AWS_REGION / AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY from env.
+    // SESv2 SDK reads AWS_REGION / AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY from env
     adapter: 'sesAdapter()',
     envKeys: ['EMAIL_FROM', 'AWS_REGION', 'AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY'],
     pkgDep: '@aws-sdk/client-sesv2',
@@ -63,10 +62,7 @@ export async function sendEmail(params: {
 }
 `
 
-/**
- * Swap the inlined mailer to `provider`. Returns { addDeps, removeDeps, envKeys }.
- * provider === 'resend' is a no-op (the base default).
- */
+/** Swap inlined mailer to `provider` → { addDeps, removeDeps, envKeys }. 'resend' is a no-op (base default). */
 export function swapMailer(projectDir, provider) {
   if (provider === 'resend') {
     return { addDeps: {}, removeDeps: [], envKeys: ['EMAIL_FROM', 'RESEND_API_KEY'] }
@@ -74,17 +70,17 @@ export function swapMailer(projectDir, provider) {
   const cfg = FACTORY[provider]
   if (!cfg) throw new Error(`Unknown mailer provider: ${provider}`)
 
-  // Swap adapter files: drop resend, copy the chosen adapter from the package.
+  // swap adapter files: drop resend, copy chosen adapter from package
   remove(join(projectDir, EMAIL_DIR, 'adapters/resend'))
   copy(
     join(STACK_ROOT, 'packages/mailer/src/adapters', provider),
     join(projectDir, EMAIL_DIR, 'adapters', provider),
   )
 
-  // Rewrite the composition root.
+  // rewrite composition root
   write(join(projectDir, EMAIL_DIR, 'index.ts'), INDEX_TS(cfg))
 
-  // Dep delta — pull the provider's range from the mailer package manifest.
+  // dep delta — pull provider's range from mailer package manifest
   const mailerPkg = readJSON(join(STACK_ROOT, 'packages/mailer/package.json'))
   const range = mailerPkg.dependencies?.[cfg.pkgDep] ?? 'latest'
   return {

package/lib/paths.mjs

@@ -0,0 +1,15 @@
+// Where the bundled stack assets live: cli/_stack when published (scripts/bundle.mjs), repo root in dev.
+
+import { existsSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const bundled = resolve(here, '..', '_stack')
+
+// Forkable source (base apps + mailer adapters): _stack when published, monorepo root in dev.
+export const STACK_ROOT = existsSync(bundled) ? bundled : resolve(here, '..', '..')
+
+// CLI-owned templates injected into the fork (root-wiring variants, biome.jsonc,
+// # Author README footer). Always shipped in the package.
+export const TEMPLATES = resolve(here, '..', 'templates')

package/lib/scaffold.mjs

@@ -1,7 +1,7 @@
-// Step A2 — fork a base app into the target dir and make it standalone
-// (its own Biome config, pnpm workspace + build allowlist, project name).
+// Fork a base app into the target dir + make it standalone
+// (own Biome config, pnpm workspace + build allowlist, project name).
 
-import { STACK_ROOT } from './manifests.mjs'
+import { STACK_ROOT, TEMPLATES } from './paths.mjs'
 import { copy, exists, join, readJSON, run, write, writeJSON } from './util.mjs'
 
 const RSYNC_EXCLUDES = [
@@ -20,10 +20,11 @@ const PNPM_WORKSPACE = `allowBuilds:
   esbuild: true
   sharp: true
   lightningcss: true
+  protobufjs: true
 `
 
-// Generated explicitly: npm strips `.gitignore` from published tarballs, so we
-// can't rely on the bundled base app's copy surviving. Both keep `.env.example`.
+// Generated explicitly: npm strips `.gitignore` from published tarballs, so the
+// bundled base app's copy won't survive. Both keep `.env.example`.
 const GITIGNORE = {
   tanstack: `node_modules
 .DS_Store
@@ -74,7 +75,7 @@ next-env.d.ts
 `,
 }
 
-/** Copy the base app into projectDir, minus build output & generated files. */
+/** Copy base app into projectDir, minus build output & generated files. */
 export function forkBase(framework, projectDir) {
   const base = join(STACK_ROOT, 'apps', framework === 'next' ? 'next-base' : 'tanstack-base')
   if (!exists(base)) throw new Error(`Base app not found: ${base}`)
@@ -86,19 +87,19 @@ export function forkBase(framework, projectDir) {
 
 /** Make the fork standalone (Biome, pnpm workspace, .gitignore, identity). */
 export function makeStandalone(projectDir, projectName, framework) {
-  // A fork needs its own Biome config (the base inherits the monorepo root's).
-  copy(join(STACK_ROOT, 'patterns/_baseline/biome.jsonc'), join(projectDir, 'biome.jsonc'))
+  // fork needs its own Biome config (base inherits the monorepo root's)
+  copy(join(TEMPLATES, 'biome.jsonc'), join(projectDir, 'biome.jsonc'))
 
-  // Biome's vcs.useIgnoreFile needs a .gitignore; also good project hygiene.
+  // Biome vcs.useIgnoreFile needs a .gitignore
   write(join(projectDir, '.gitignore'), GITIGNORE[framework === 'next' ? 'next' : 'tanstack'])
 
-  // Avoid ERR_PNPM_IGNORED_BUILDS on a fresh install (native build scripts).
+  // avoid ERR_PNPM_IGNORED_BUILDS on fresh install (native build scripts)
   write(join(projectDir, 'pnpm-workspace.yaml'), PNPM_WORKSPACE)
 
   const pkgPath = join(projectDir, 'package.json')
   const pkg = readJSON(pkgPath)
   pkg.name = projectName
-  delete pkg.private // a leaf project; let the user decide
+  delete pkg.private // leaf project
   pkg.private = true
   writeJSON(pkgPath, pkg)
 }