@nakedev/nextjs-fsd 0.1.0

package/dist/commands/generate.js

@@ -0,0 +1,403 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePage = generatePage;
+exports.generateSlice = generateSlice;
+exports.existingPages = existingPages;
+exports.generateLayout = generateLayout;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const types_1 = require("../types");
+const prompts_1 = require("../prompts");
+const config_1 = require("../utils/config");
+const copy_1 = require("../utils/copy");
+const naming_1 = require("../utils/naming");
+const render_1 = require("../utils/render");
+const project_1 = require("../utils/project");
+const init_1 = require("./init");
+async function generatePage(rawName, opts) {
+    const config = (0, config_1.readConfig)(process.cwd());
+    assertInputs("page", rawName, opts);
+    const name = rawName ??
+        (await (0, prompts_1.input)({
+            message: "Page name (kebab-case, becomes src/_pages/<name>/):",
+            validate: naming_1.validateSliceName,
+        }));
+    const naming = (0, naming_1.resolveNaming)(name);
+    let { client, auth, errors } = opts;
+    let title = opts.title?.trim() || undefined;
+    if (!opts.defaults) {
+        if (auth === undefined && client === undefined) {
+            const shape = await (0, prompts_1.select)({
+                message: "What shape is this page?",
+                choices: [
+                    { name: "Server component only", value: "server" },
+                    { name: "Server component + a \"use client\" leaf", value: "client" },
+                    {
+                        name: "Client leaf behind a session guard (useRequireSession)",
+                        value: "auth",
+                        disabled: config.features.auth ? false : "— needs `add auth` first",
+                    },
+                ],
+            });
+            client = shape !== "server";
+            auth = shape === "auth";
+        }
+        // Asked for `th`, not for `en`: the derived Title Case of a kebab name is
+        // already the right answer in English, while a Thai project would
+        // otherwise get an English heading and an English <title> on every page —
+        // two hand edits per page, every page.
+        if (opts.title === undefined && config.locale !== "en") {
+            title = (await (0, prompts_1.input)({
+                message: "Page title (shown as the heading and the browser title):",
+                default: toTitleCase(naming.name),
+            })).trim();
+        }
+        if (errors === undefined && config.features.errorHandling) {
+            errors = await (0, prompts_1.confirm)({
+                message: `Add an error catalog (model/${naming.name}-errors.ts)?`,
+                default: false,
+            });
+        }
+    }
+    if (auth && !config.features.auth) {
+        throw new Error("--auth needs the auth feature — run `nextjs-fsd add auth` first");
+    }
+    if (errors && !config.features.errorHandling) {
+        throw new Error("--errors needs the error-handling feature — run `nextjs-fsd add error-handling` first");
+    }
+    const route = opts.route === undefined ? naming.name : (0, naming_1.normalizeRoute)(opts.route);
+    const routeCheck = (0, naming_1.validateRoute)(route);
+    if (routeCheck !== true)
+        throw new Error(routeCheck);
+    const slice = `${config.srcDir}/_pages/${naming.name}`;
+    // A page that already exists is being extended, not recreated — `--errors`
+    // or `--client` on a slice generated bare earlier is the normal way those
+    // get added, so the existing files are not an error.
+    const extending = fs_extra_1.default.existsSync(path_1.default.join(process.cwd(), slice));
+    // A page being extended may already be routed from somewhere else —
+    // `--route "(admin)/dashboard"` the first time round. Writing the default
+    // route file now would produce two page.tsx that resolve to the same URL,
+    // which Next.js rejects at build time ("two parallel pages that resolve to
+    // the same path") — a broken build from a command that printed success.
+    const existingRoute = extending
+        ? findRouteFor(process.cwd(), config.appDir, config.alias, naming.name)
+        : undefined;
+    const hasContent = Boolean(client || auth);
+    const context = {
+        ...naming,
+        ...config,
+        copy: (0, copy_1.copyFor)(config.locale),
+        title: title || toTitleCase(naming.name),
+        hasContent,
+        auth: Boolean(auth),
+    };
+    const written = await (0, render_1.applyTemplates)(process.cwd(), [
+        { template: "generate/page/index.ts.hbs", output: `${slice}/index.ts` },
+        { template: "generate/page/page.tsx.hbs", output: `${slice}/ui/${naming.name}-page.tsx` },
+        {
+            template: "generate/page/content.tsx.hbs",
+            output: `${slice}/ui/${naming.name}-content.tsx`,
+            when: () => hasContent,
+        },
+        {
+            template: "generate/page/errors.ts.hbs",
+            output: `${slice}/model/${naming.name}-errors.ts`,
+            when: () => Boolean(errors),
+        },
+        {
+            template: "generate/page/route.tsx.hbs",
+            output: path_1.default.posix.join(config.appDir, route, "page.tsx"),
+            when: () => opts.routeFile !== false && existingRoute === undefined,
+        },
+    ], context, { skipExisting: extending });
+    if (extending && written.length === 0) {
+        throw new Error(`${slice} already has everything this would write.\n` +
+            "Pass --client or --errors to add a leaf component or an error catalog to it.");
+    }
+    (0, init_1.report)(written);
+    if (extending) {
+        console.log(picocolors_1.default.dim(`\nextended the existing ${naming.name} page; untouched files were left alone.`));
+        // The page component is one of those untouched files, so a leaf added now
+        // is not rendered by anything yet. Say the one line that wires it.
+        if (written.some((file) => file.endsWith(`${naming.name}-content.tsx`))) {
+            console.log(picocolors_1.default.yellow(`ui/${naming.name}-page.tsx does not render it yet — add:`) +
+                `\n  import { ${naming.pascal}Content } from "./${naming.name}-content";`);
+        }
+    }
+    if (existingRoute !== undefined) {
+        console.log(picocolors_1.default.dim(`\nalready routed from ${existingRoute} — left alone rather than adding a second page.tsx for the same URL.`));
+    }
+    else if (opts.routeFile === false) {
+        console.log(picocolors_1.default.yellow(`\nno route file — add one that re-exports the page and its metadata when you want it routable.`));
+    }
+    else {
+        // Route groups are directories Next.js reads and strips from the URL, so
+        // printing the path verbatim would name a URL that never exists.
+        const url = route
+            .split("/")
+            .filter((segment) => !segment.startsWith("(") && !segment.startsWith("@"))
+            .join("/");
+        console.log(`\n${picocolors_1.default.bold("Route:")} /${url}`);
+    }
+}
+async function generateSlice(rawLayer, rawName, opts) {
+    const config = (0, config_1.readConfig)(process.cwd());
+    assertSliceInputs(rawLayer, rawName, opts);
+    const layer = parseLayer(rawLayer) ??
+        (await (0, prompts_1.select)({
+            message: "Which layer?",
+            choices: [
+                { name: "features — a whole user action, reused by two or more pages", value: "features" },
+                { name: "entities — a business object, reused by two or more features", value: "entities" },
+                { name: "widgets — a composite UI block (FSD v2.1 discourages this; prefer features)", value: "widgets" },
+            ],
+        }));
+    const name = rawName ??
+        (await (0, prompts_1.input)({
+            message: `Slice name (kebab-case, becomes ${config.srcDir}/${layer}/<name>/):`,
+            validate: naming_1.validateSliceName,
+        }));
+    const naming = (0, naming_1.resolveNaming)(name);
+    const chosen = opts.segments
+        ? parseSegments(opts.segments)
+        : opts.defaults
+            ? ["ui"]
+            : (await (0, prompts_1.checkbox)({
+                message: "Which segments? (a slice gets only the ones it has code for)",
+                choices: [
+                    { name: "ui — components", value: "ui", checked: true },
+                    { name: "model — state and hooks", value: "model" },
+                    {
+                        name: "api — TanStack Query hooks",
+                        value: "api",
+                        disabled: config.features.errorHandling ? false : "— needs `add error-handling` first",
+                    },
+                    { name: "lib — pure helpers", value: "lib" },
+                ],
+            }));
+    if (chosen.length === 0) {
+        throw new Error("pick at least one segment — a slice with no segments is an empty directory");
+    }
+    if (chosen.includes("api") && !config.features.errorHandling) {
+        throw new Error("the api segment needs the error-handling feature — run `nextjs-fsd add error-handling` first.\n" +
+            "A bare fetch skips the bearer token, the single-flight 401 refresh, and the conversion into ApiError.");
+    }
+    let errors = opts.errors;
+    if (errors === undefined) {
+        errors = opts.defaults
+            ? false
+            : config.features.errorHandling &&
+                (await (0, prompts_1.confirm)({ message: `Add an error catalog (model/${naming.name}-errors.ts)?`, default: false }));
+    }
+    if (errors && !config.features.errorHandling) {
+        throw new Error("--errors needs the error-handling feature — run `nextjs-fsd add error-handling` first");
+    }
+    const segments = Object.fromEntries([...types_1.SEGMENTS, "errors"].map((segment) => [
+        segment,
+        segment === "errors" ? Boolean(errors) : chosen.includes(segment),
+    ]));
+    // Only the segments that are not on disk yet. Drives both what gets written
+    // and which export lines join an existing index.ts, so extending a slice
+    // never re-announces a segment it already had.
+    const onDisk = existingSegments(process.cwd(), slicePath(config.srcDir, layer, naming.name), naming.name);
+    const added = Object.fromEntries(Object.entries(segments).map(([segment, wanted]) => [segment, wanted && !onDisk.includes(segment)]));
+    const context = {
+        ...naming,
+        ...config,
+        copy: (0, copy_1.copyFor)(config.locale),
+        layer,
+        segments,
+        // A ui component that calls the slice's own model hook needs the browser.
+        needsClient: segments.model,
+    };
+    const slice = slicePath(config.srcDir, layer, naming.name);
+    const extending = fs_extra_1.default.existsSync(path_1.default.join(process.cwd(), slice));
+    const entries = [
+        // index.ts is handled separately when extending: it has to gain the new
+        // segments' exports without losing whatever is already in it (including
+        // lines someone edited by hand).
+        { template: "generate/slice/index.ts.hbs", output: `${slice}/index.ts`, when: () => !extending },
+        { template: "generate/slice/ui.tsx.hbs", output: `${slice}/ui/${naming.name}.tsx`, when: () => segments.ui },
+        { template: "generate/slice/model.ts.hbs", output: `${slice}/model/${naming.name}.ts`, when: () => segments.model },
+        { template: "generate/slice/api.ts.hbs", output: `${slice}/api/${naming.name}.ts`, when: () => segments.api },
+        { template: "generate/slice/lib.ts.hbs", output: `${slice}/lib/${naming.name}.ts`, when: () => segments.lib },
+        {
+            template: "generate/slice/errors.ts.hbs",
+            output: `${slice}/model/${naming.name}-errors.ts`,
+            when: () => segments.errors,
+        },
+    ];
+    const written = await (0, render_1.applyTemplates)(process.cwd(), entries, context, { skipExisting: extending });
+    if (extending) {
+        if (written.length === 0) {
+            throw new Error(`${slice} already has every segment this would write.\n` +
+                `It currently has: ${onDisk.join(", ") || "nothing"}.`);
+        }
+        // Rendered from the same template as a fresh index.ts, with only the new
+        // segments switched on, so the export lines cannot drift from the files
+        // they point at.
+        for (const line of (0, render_1.renderTemplate)("generate/slice/index.ts.hbs", { ...context, segments: added }).split("\n")) {
+            if (line.trim() !== "" && (0, project_1.appendExport)(process.cwd(), `${slice}/index.ts`, line)) {
+                if (!written.includes(`${slice}/index.ts`))
+                    written.push(`${slice}/index.ts`);
+            }
+        }
+    }
+    (0, init_1.report)(written);
+    if (extending)
+        console.log(picocolors_1.default.dim(`\nextended the existing ${naming.name} slice; untouched files were left alone.`));
+    console.log(`\n${picocolors_1.default.dim("imported as")} import { ${naming.pascal} } from "${config.alias}/${layer}/${naming.name}";` +
+        `\n${picocolors_1.default.dim("only through that index.ts — reaching into ui/ is the boundary violation steiger reports.")}` +
+        `\n${picocolors_1.default.dim("until something imports it, steiger reports fsd/insignificant-slice — that is the linter working, not a mistake.")}`);
+}
+/**
+ * The route file that already re-exports this page slice, if any.
+ *
+ * Found by reading the app directory rather than by guessing the path: a page
+ * generated with `--route "(admin)/dashboard"` lives nowhere the slice name
+ * would predict, and the whole point is to notice a route that is not where
+ * the default would have put it.
+ */
+function findRouteFor(projectDir, appDir, alias, name) {
+    const root = path_1.default.join(projectDir, appDir);
+    if (!fs_extra_1.default.existsSync(root))
+        return undefined;
+    const marker = `${alias}/_pages/${name}"`;
+    for (const entry of fs_extra_1.default.readdirSync(root, { recursive: true, encoding: "utf8" })) {
+        if (path_1.default.basename(entry) !== "page.tsx")
+            continue;
+        const file = path_1.default.join(root, entry);
+        if (fs_extra_1.default.readFileSync(file, "utf8").includes(marker)) {
+            return path_1.default.posix.join(appDir, entry.split(path_1.default.sep).join("/"));
+        }
+    }
+    return undefined;
+}
+function slicePath(srcDir, layer, name) {
+    return `${srcDir}/${layer}/${name}`;
+}
+/** Where each segment's generated file lands, relative to the slice. */
+function segmentFile(segment, name) {
+    return segment === "errors" ? `model/${name}-errors.ts` : `${segment}/${name}.${segment === "ui" ? "tsx" : "ts"}`;
+}
+/** Which segments a slice already has on disk. */
+function existingSegments(projectDir, slice, name) {
+    return [...types_1.SEGMENTS, "errors"].filter((segment) => fs_extra_1.default.existsSync(path_1.default.join(projectDir, slice, segmentFile(segment, name))));
+}
+/** Lists the page slices that exist, for the wizard-free error message. */
+function existingPages(projectDir, srcDir) {
+    const dir = path_1.default.join(projectDir, srcDir, "_pages");
+    if (!fs_extra_1.default.existsSync(dir))
+        return [];
+    return fs_extra_1.default
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+}
+function parseLayer(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (!types_1.SLICE_LAYERS.includes(normalized)) {
+        throw new Error(`unknown layer "${value}" — use ${types_1.SLICE_LAYERS.join(", ")}.\n` +
+            "`_pages` slices come from `generate page`, and `_app`/`shared` are written by `init` and `add`.");
+    }
+    return normalized;
+}
+function parseSegments(value) {
+    const parsed = value
+        .split(",")
+        .map((segment) => segment.trim().toLowerCase())
+        .filter(Boolean);
+    const unknown = parsed.filter((segment) => !types_1.SEGMENTS.includes(segment));
+    if (unknown.length > 0) {
+        throw new Error(`unknown segment${unknown.length > 1 ? "s" : ""} ${unknown.join(", ")} — use ${types_1.SEGMENTS.join(", ")}`);
+    }
+    return [...new Set(parsed)];
+}
+function toTitleCase(kebab) {
+    return kebab
+        .split("-")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(" ");
+}
+// The no-TTY case reaches here only for values a prompt would have asked for.
+// Listing all of them at once beats failing on the first one, then the second.
+function assertInputs(what, name, opts) {
+    if (process.stdin.isTTY || name !== undefined)
+        return;
+    throw new Error(`no interactive terminal to prompt on — \`generate ${what}\` needs <name> as an argument (flags cover the rest; see --help)`);
+}
+function assertSliceInputs(layer, name, opts) {
+    if (process.stdin.isTTY)
+        return;
+    const missing = [];
+    if (layer === undefined)
+        missing.push("<layer>");
+    if (name === undefined)
+        missing.push("<name>");
+    if (opts.segments === undefined && !opts.defaults)
+        missing.push("--segments (or --defaults for ui only)");
+    if (missing.length > 0) {
+        throw new Error(`no interactive terminal to prompt on — \`generate slice\` is missing: ${missing.join(", ")}. ` +
+            "Pass them as arguments/flags, or add --defaults.");
+    }
+}
+/**
+ * A shared shell for a group of routes: the component in `_app/layouts` plus
+ * the `layout.tsx` that re-exports it.
+ *
+ * `_app`, not `_pages`: a layout is not one route's content, it is what
+ * several routes have in common, and the app layer is where cross-page
+ * composition lives. The route file defaults to a route group — `(admin)` —
+ * because that is a layout's usual reason to exist: shared chrome for a set of
+ * pages, contributing nothing to the URL.
+ */
+async function generateLayout(rawName, opts) {
+    const config = (0, config_1.readConfig)(process.cwd());
+    assertInputs("layout", rawName, opts);
+    const name = rawName ??
+        (await (0, prompts_1.input)({
+            message: `Layout name (kebab-case, becomes ${config.srcDir}/_app/layouts/<name>-layout.tsx):`,
+            validate: naming_1.validateSliceName,
+        }));
+    const naming = (0, naming_1.resolveNaming)(name);
+    // "(admin)" rather than "admin": a layout's default home is a route group,
+    // which shares chrome without adding a URL segment.
+    const route = opts.route === undefined ? `(${naming.name})` : (0, naming_1.normalizeRoute)(opts.route);
+    const routeCheck = (0, naming_1.validateRoute)(route);
+    if (routeCheck !== true)
+        throw new Error(routeCheck);
+    const context = { ...naming, ...config, copy: (0, copy_1.copyFor)(config.locale) };
+    const layouts = `${config.srcDir}/_app/layouts`;
+    // Same rule as page and slice: an existing layout is being extended (given a
+    // route file it did not have), not recreated.
+    const extending = fs_extra_1.default.existsSync(path_1.default.join(process.cwd(), `${layouts}/${naming.name}-layout.tsx`));
+    const written = await (0, render_1.applyTemplates)(process.cwd(), [
+        { template: "generate/layout/layout.tsx.hbs", output: `${layouts}/${naming.name}-layout.tsx` },
+        {
+            template: "generate/layout/route.tsx.hbs",
+            output: path_1.default.posix.join(config.appDir, route, "layout.tsx"),
+            when: () => opts.routeFile !== false,
+        },
+    ], context, { skipExisting: extending });
+    if (extending && written.length === 0) {
+        throw new Error(`${layouts}/${naming.name}-layout.tsx already exists and is already applied at ${config.appDir}/${route}/layout.tsx.\n` +
+            "Pass --route <path> to apply it somewhere else as well.");
+    }
+    if ((0, project_1.appendExport)(process.cwd(), `${layouts}/index.ts`, `export { ${naming.pascal}Layout } from "./${naming.name}-layout";`)) {
+        written.push(`${layouts}/index.ts`);
+    }
+    (0, init_1.report)(written);
+    if (opts.routeFile === false) {
+        console.log(picocolors_1.default.yellow("\nno route file — add a layout.tsx that re-exports it when you want it applied."));
+    }
+    else {
+        console.log(`\n${picocolors_1.default.bold("Applies to:")} every route under ${config.appDir}/${route}/` +
+            (route.startsWith("(") ? picocolors_1.default.dim(" (a route group — it adds nothing to the URL)") : ""));
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProject = initProject;
+exports.addTailwindSources = addTailwindSources;
+exports.report = report;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const prompts_1 = require("../prompts");
+const config_1 = require("../utils/config");
+const copy_1 = require("../utils/copy");
+const render_1 = require("../utils/render");
+const project_1 = require("../utils/project");
+const version_1 = require("../utils/version");
+const STEIGER_DEV_DEPS = {
+    "@feature-sliced/steiger-plugin": "^0.7.0",
+    steiger: "^0.6.0",
+};
+async function initProject(projectDir, opts) {
+    if ((0, config_1.isProjectDir)(projectDir)) {
+        throw new Error("already a nextjs-fsd project (nextjs-fsd.config.json exists) — use `generate` / `add` from here, or delete the config file to re-init");
+    }
+    // Fails before anything is written if this is not an App Router project:
+    // half-initialising a Pages Router app leaves a src/ tree nothing imports.
+    const appDir = (0, project_1.detectAppDir)(projectDir);
+    const srcDir = "src";
+    const alias = "@";
+    const packageManager = (0, project_1.detectPackageManager)(projectDir);
+    const locale = opts.locale ??
+        (opts.defaults
+            ? "th"
+            : (await (0, prompts_1.select)({
+                message: "Language for the generated user-facing copy?",
+                choices: [
+                    { name: "Thai", value: "th" },
+                    { name: "English", value: "en" },
+                ],
+            })));
+    // Posix, like every other relative path this CLI reports or stores: joining
+    // with `path.join` would print `src\app\globals.css` on Windows inside a
+    // file list where every other line uses `/`. `path.join(projectDir, ...)`
+    // below still normalises it for the filesystem.
+    const stylesheet = `${appDir}/globals.css`;
+    const movesStylesheet = fs_extra_1.default.existsSync(path_1.default.join(projectDir, stylesheet));
+    if (!(opts.yes || opts.defaults)) {
+        console.log(picocolors_1.default.bold("\nThis will:"));
+        for (const line of [
+            `keep Next.js routing in ${picocolors_1.default.cyan(appDir + "/")} and put the FSD layers in ${picocolors_1.default.cyan(srcDir + "/")} (_app, _pages, shared)`,
+            movesStylesheet
+                ? `move ${picocolors_1.default.cyan(stylesheet)} to ${picocolors_1.default.cyan(`${srcDir}/_app/styles/globals.css`)} and repoint the import in ${appDir}/layout.tsx`
+                : `create ${picocolors_1.default.cyan(`${srcDir}/_app/styles/globals.css`)}`,
+            `point the ${picocolors_1.default.cyan(`${alias}/*`)} tsconfig alias at ./${srcDir}/*`,
+            `add ${picocolors_1.default.cyan("eslint.fsd.mjs")} — the import boundary as ESLint rules, so a wrong-way import is flagged in your editor (no new dependencies)`,
+            `add steiger + the FSD plugin and a steiger.config.ts for the whole-tree checks ESLint cannot make, then chain both into the lint script`,
+            `add ${picocolors_1.default.cyan("components.json")} so \`shadcn add\` writes into ${srcDir}/shared/ui instead of ./components/ui`,
+            `write ${picocolors_1.default.cyan("docs/fsd.md")}, a ${picocolors_1.default.cyan(".claude/skills/nextjs-fsd")} skill, and point AGENTS.md at both`,
+        ]) {
+            console.log(`  ${picocolors_1.default.dim("•")} ${line}`);
+        }
+        console.log();
+        if (!(await (0, prompts_1.confirm)({ message: "Proceed?", default: true }))) {
+            throw new Error("cancelled — nothing was written");
+        }
+    }
+    const context = {
+        srcDir,
+        appDir,
+        alias,
+        locale,
+        copy: (0, copy_1.copyFor)(locale),
+        lintCommand: `${packageManager} run lint`,
+        packageManager,
+        cssSourceApp: toPosix(path_1.default.relative(path_1.default.join(srcDir, "_app", "styles"), appDir)),
+        cssSourceSrc: toPosix(path_1.default.relative(path_1.default.join(srcDir, "_app", "styles"), srcDir)),
+    };
+    const written = await (0, render_1.applyTemplates)(projectDir, [
+        { template: "init/steiger.config.ts.hbs", output: "steiger.config.ts" },
+        { template: "init/eslint.fsd.mjs.hbs", output: "eslint.fsd.mjs" },
+        { template: "init/fsd.md.hbs", output: "docs/fsd.md" },
+        // Same content as the AGENTS.md section, aimed at the tool that reads
+        // .claude/skills — an agent's instinct on "add a settings screen" is to
+        // hand-write the files, which is exactly what the two linters then report.
+        { template: "init/skill.md.hbs", output: ".claude/skills/nextjs-fsd/SKILL.md" },
+        {
+            template: "init/globals.css.hbs",
+            output: `${srcDir}/_app/styles/globals.css`,
+            when: () => !movesStylesheet,
+        },
+        // Written before anyone runs `shadcn init`, because its own defaults put
+        // components in ./components/ui and a utils.ts at the project root —
+        // outside the layers entirely. The aliases here send them into
+        // shared/ui and shared/lib instead. Skipped if the project already has
+        // one; that file is the user's decision, not ours.
+        {
+            template: "init/components.json.hbs",
+            output: "components.json",
+            when: () => !fs_extra_1.default.existsSync(path_1.default.join(projectDir, "components.json")),
+        },
+    ], context);
+    if (movesStylesheet) {
+        // Moved rather than copied: the import in layout.tsx is its only
+        // reference, and leaving a second copy behind means the next person edits
+        // the one Tailwind no longer reads.
+        const destination = `${srcDir}/_app/styles/globals.css`;
+        await fs_extra_1.default.move(path_1.default.join(projectDir, stylesheet), path_1.default.join(projectDir, destination));
+        addTailwindSources(path_1.default.join(projectDir, destination), context.cssSourceApp, context.cssSourceSrc);
+        written.push(`${destination} (moved from ${stylesheet})`);
+        if ((0, project_1.patchLayoutStyleImport)(projectDir, appDir, alias))
+            written.push(`${appDir}/layout.tsx (stylesheet import)`);
+        else
+            console.log(picocolors_1.default.yellow(`\ncould not find \`import "./globals.css"\` in ${appDir}/layout.tsx — change it to \`import "${alias}/_app/styles/globals.css"\` by hand.`));
+    }
+    if ((0, project_1.patchTsconfigPaths)(projectDir, alias, srcDir))
+        written.push(`tsconfig.json (${alias}/* alias)`);
+    const eslintPatch = (0, project_1.patchEslintConfig)(projectDir);
+    if (eslintPatch === "patched")
+        written.push("eslint.config.mjs (spreads the FSD boundary rules)");
+    if ((0, project_1.appendScript)(projectDir, "lint", `steiger ./${srcDir}`))
+        written.push("package.json (lint script)");
+    written.push(...writeAgentDocs(projectDir, context));
+    if (eslintPatch !== "patched" && eslintPatch !== "already") {
+        console.log(picocolors_1.default.yellow(eslintPatch === "missing"
+            ? "\nno flat ESLint config found — add one, then spread the generated rules into it:"
+            : "\ncould not patch your ESLint config automatically — spread the generated rules into it by hand:") +
+            '\n  import fsdBoundary from "./eslint.fsd.mjs";' +
+            "\n  export default [...yourConfig, ...fsdBoundary];");
+    }
+    const added = (0, project_1.addDependencies)(projectDir, STEIGER_DEV_DEPS, "devDependencies");
+    const config = {
+        schemaVersion: config_1.CONFIG_SCHEMA_VERSION,
+        locale,
+        srcDir,
+        appDir,
+        alias,
+        packageManager,
+        features: (0, config_1.detectFeatures)(projectDir, srcDir),
+        scaffoldVersion: (0, version_1.cliVersion)(),
+    };
+    (0, config_1.writeConfig)(projectDir, config);
+    written.push("nextjs-fsd.config.json");
+    report(written, added);
+    if (added.length > 0 && opts.install !== false) {
+        (0, project_1.installDependencies)(projectDir, packageManager);
+    }
+    else if (added.length > 0) {
+        console.log(picocolors_1.default.yellow(`\nrun \`${packageManager} install\` to install: ${added.join(", ")}`));
+    }
+    // Only a render shows this one: create-next-app leaves
+    // `body { font-family: Arial, Helvetica, sans-serif }` in globals.css, and
+    // none of those faces carries Thai. The browser then falls back per glyph,
+    // so a Thai UI renders in a face nobody chose — and Thai stacks two marks
+    // above a consonant plus a vowel below, which Latin-tuned line heights clip.
+    // Not patched automatically: which face to use is the project's call, and
+    // rewriting someone's font stack is not what "init the layout" asked for.
+    if (locale === "th") {
+        console.log(picocolors_1.default.yellow("\nThai copy was generated, but this project's font stack cannot render it.") +
+            `\n  ${picocolors_1.default.dim("globals.css sets")} body { font-family: Arial, Helvetica, sans-serif } ${picocolors_1.default.dim("— no Thai coverage in any of those.")}` +
+            `\n  ${picocolors_1.default.dim("Load a Thai face in")} ${appDir}/layout.tsx ${picocolors_1.default.dim("and point --font-sans at it:")}` +
+            '\n    import { Noto_Sans_Thai } from "next/font/google";' +
+            '\n    const sans = Noto_Sans_Thai({ subsets: ["thai", "latin"], variable: "--font-sans" });' +
+            `\n  ${picocolors_1.default.dim("Then drop the Arial rule and loosen the line heights per size — Thai needs the room.")}`);
+    }
+    console.log(`\n${picocolors_1.default.bold("Next:")} ${picocolors_1.default.cyan("nextjs-fsd generate page <name>")}, ` +
+        `${picocolors_1.default.cyan("nextjs-fsd add error-handling")}, ${picocolors_1.default.cyan("nextjs-fsd add auth")}`);
+}
+/**
+ * Adds an FSD section to AGENTS.md (creating it if absent) and a CLAUDE.md
+ * that includes it.
+ *
+ * Appended, never rewritten: AGENTS.md is usually already the project's own
+ * instructions file, and the FSD conventions are one section of it.
+ */
+function writeAgentDocs(projectDir, context) {
+    const written = [];
+    const section = (0, render_1.renderTemplate)("init/agents-section.md.hbs", context);
+    const agents = path_1.default.join(projectDir, "AGENTS.md");
+    if (!fs_extra_1.default.existsSync(agents)) {
+        fs_extra_1.default.writeFileSync(agents, `# AGENTS.md\n${section}`);
+        written.push("AGENTS.md");
+    }
+    else if (!fs_extra_1.default.readFileSync(agents, "utf8").includes("Feature-Sliced Design")) {
+        fs_extra_1.default.appendFileSync(agents, section);
+        written.push("AGENTS.md (FSD section appended)");
+    }
+    const claude = path_1.default.join(projectDir, "CLAUDE.md");
+    if (!fs_extra_1.default.existsSync(claude)) {
+        fs_extra_1.default.writeFileSync(claude, (0, render_1.renderTemplate)("init/claude.md.hbs", context));
+        written.push("CLAUDE.md");
+    }
+    return written;
+}
+/**
+ * Names the trees Tailwind has to scan, because moving the stylesheet out of
+ * the route directory moves it out of what auto-detection would have found.
+ * Inserted after the last `@import` so it lands below `@import "tailwindcss"`
+ * — an `@source` above it is ignored.
+ */
+function addTailwindSources(cssFile, appSource, srcSource) {
+    const source = fs_extra_1.default.readFileSync(cssFile, "utf8");
+    if (source.includes("@source"))
+        return;
+    const block = `\n/* This file lives in the FSD app layer, not next to the routes, so name the\n` +
+        `   trees Tailwind has to scan for class names explicitly instead of relying on\n` +
+        `   where auto-detection decides the project root is. */\n` +
+        `@source "${appSource}";\n@source "${srcSource}";\n`;
+    const imports = [...source.matchAll(/^@import .*$/gm)];
+    const last = imports[imports.length - 1];
+    // `last.index === 0` is a real position, not "not found" — a stylesheet
+    // whose very first line is `@import "tailwindcss"` is the common case.
+    if (last?.index === undefined) {
+        fs_extra_1.default.writeFileSync(cssFile, block.trimStart() + "\n" + source);
+        return;
+    }
+    const insertAt = source.indexOf("\n", last.index) + 1;
+    fs_extra_1.default.writeFileSync(cssFile, source.slice(0, insertAt) + block + source.slice(insertAt));
+}
+function toPosix(value) {
+    return value.split(path_1.default.sep).join("/");
+}
+function report(written, added = []) {
+    console.log();
+    for (const file of written)
+        console.log(`  ${picocolors_1.default.green("+")} ${file}`);
+    for (const dep of added)
+        console.log(`  ${picocolors_1.default.green("+")} ${picocolors_1.default.dim("package.json:")} ${dep}`);
+}