create-lumen 2.0.0-alpha.1 → 2.0.0-alpha.2

package/src/injector.js

@@ -1,492 +1,340 @@
 import { promises as fsp } from "fs";
 import path from "path";
-import { copyDirRecursive, writeFileRecursive } from "@/utils/fs.js";
-
-// Narrow a template tree copy to the selected language: .tsx/.ts for ts,
-// .jsx/.js for js (keeps the opposite language's files out of the project).
-function langFileFilter(language) {
-  return (name) => {
-    if (language === "ts") {
-      if (name.endsWith(".jsx")) return false;
-      if (name.endsWith(".js")) return false;
-      return true;
-    }
-    if (language === "js") {
-      if (name.endsWith(".tsx")) return false;
-      if (name.endsWith(".ts")) return false;
-      return true;
-    }
-    return true;
-  };
-}
-
-export async function injectArchitecture(projectPath, templatesDir, architecture, language, cssFramework) {
-  const ext = language === "ts" ? "tsx" : "jsx";
-  const srcDir = path.join(templatesDir, "architectures", architecture, "src");
-
-  // Remove Vite's default App files BEFORE copying architecture
-  const defaultAppTsx = path.join(projectPath, "src", "App.tsx");
-  const defaultAppJsx = path.join(projectPath, "src", "App.jsx");
-  try { await fsp.rm(defaultAppTsx, { force: true }); } catch {}
-  try { await fsp.rm(defaultAppJsx, { force: true }); } catch {}
-  // Remove Vite's default index.css (framework CSS lives in src/styles/,
-  // copied below — never at the src/ root).
-  try { await fsp.rm(path.join(projectPath, "src", "index.css"), { force: true }); } catch {}
-  try { await fsp.rm(path.join(projectPath, "src", "App.css"), { force: true }); } catch {}
-
-  // Copy the architecture tree into the project's src/
-  await copyDirRecursive(srcDir, path.join(projectPath, "src"), langFileFilter(language));
-
-  // Copy the architecture's main.tsx/main.jsx to src/main.{ext}
-  const mainSrc = path.join(
-    templatesDir,
-    "architectures",
-    architecture,
-    `main.${ext}`
+import {
+  FRAGMENT_SCOPES,
+  resolveFragments,
+  applyFragments,
+  langFileFilter,
+  pruneRedundantGitkeeps,
+} from "./engine/composition.js";
+
+export {
+  FRAGMENT_SCOPES,
+  resolveFragments,
+  applyFragments,
+  langFileFilter,
+  pruneRedundantGitkeeps,
+};
+
+/**
+ * Inject architecture templates into projectPath from composed fragments.
+ * Composes framework entry points, architecture layout, and styling component overlays.
+ *
+ * @param {string} projectPath
+ * @param {string} templatesDir
+ * @param {string} architecture
+ * @param {string} language
+ * @param {string} cssFramework
+ */
+export async function injectArchitecture(
+  projectPath,
+  templatesDir,
+  architecture,
+  language,
+  cssFramework
+) {
+  const responses = { architecture, language, cssFramework };
+  const allFragments = resolveFragments(responses, templatesDir);
+  const archFragments = allFragments.filter(
+    (f) =>
+      f.scope === FRAGMENT_SCOPES.FRAMEWORK ||
+      f.scope === FRAGMENT_SCOPES.ARCH ||
+      f.scope === FRAGMENT_SCOPES.STYLING
   );
-  try {
-    await fsp.access(mainSrc);
-    await fsp.copyFile(mainSrc, path.join(projectPath, "src", `main.${ext}`));
-  } catch {
-    // main file doesn't exist in template, skip
-  }
-
-  // Remove the opposite language's main file (Vite creates main.jsx by default)
-  const oppositeExt = language === "ts" ? "jsx" : "tsx";
-  const oppositeMain = path.join(projectPath, "src", `main.${oppositeExt}`);
-  try { await fsp.rm(oppositeMain, { force: true }); } catch {}
-
-  // Apply the chosen CSS framework's component styling on top of the base
-  // (only where the base ships framework-agnostic inline markup). Runs here,
-  // before conditional overlays, so icons/router can still override the files
-  // they own.
-  if (cssFramework === "tailwind" || cssFramework === "bootstrap") {
-    const variantSrc = path.join(
-      templatesDir,
-      "css",
-      "component-styles",
-      cssFramework,
-      architecture,
-      "src"
-    );
-    try {
-      await fsp.access(variantSrc);
-      await copyDirRecursive(
-        variantSrc,
-        path.join(projectPath, "src"),
-        langFileFilter(language)
-      );
-    } catch {
-      // no component-styles for this arch/framework
-    }
-  }
+  await applyFragments(projectPath, archFragments, {
+    language,
+    templatesDir,
+    responses,
+  });
 }
 
+/**
+ * Inject code formatter configuration and wiring from composed fragments.
+ *
+ * @param {string} projectPath
+ * @param {string} templatesDir
+ * @param {object} responses
+ */
 export async function injectFormatter(projectPath, templatesDir, responses) {
   if (!responses.formatter || responses.formatter === "none") return;
-
-  // Copy the formatter config file to the project root
-  const configFile =
-    responses.formatter === "prettier" ? ".prettierrc" : ".oxfmtrc.json";
-  const configSrc = path.join(
-    templatesDir,
-    "conditional",
-    "formatter",
-    responses.formatter,
-    configFile
+  const allFragments = resolveFragments(responses, templatesDir);
+  const formatterFragments = allFragments.filter(
+    (f) => f.scope === FRAGMENT_SCOPES.TOOLING && f.category === "formatter"
   );
-  try {
-    await fsp.access(configSrc);
-    await fsp.copyFile(configSrc, path.join(projectPath, configFile));
-  } catch {}
-
-  // Append format script(s) to package.json
-  const pkgPath = path.join(projectPath, "package.json");
-  try {
-    const content = await fsp.readFile(pkgPath, "utf8");
-    const pkg = JSON.parse(content);
-    if (!pkg.scripts) pkg.scripts = {};
-    if (responses.formatter === "prettier") {
-      pkg.scripts.format = "prettier --write .";
-      pkg.scripts["format:check"] = "prettier --check .";
-    } else if (responses.formatter === "oxfmt") {
-      pkg.scripts.format = "oxfmt .";
-      pkg.scripts["format:check"] = "oxfmt --check .";
-    }
-    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-  } catch {}
-
-  // Wire eslint-config-prettier only for the eslint + prettier combination
-  if (responses.linter === "eslint" && responses.formatter === "prettier") {
-    await wireEslintPrettier(projectPath, responses.language, responses.framework);
-  }
+  await applyFragments(projectPath, formatterFragments, {
+    language: responses.language,
+    templatesDir,
+    responses,
+  });
 }
 
-async function wireEslintPrettier(projectPath, language, framework) {
-  const ext = framework === "next" ? "mjs" : language === "ts" ? "ts" : "js";
-  const eslintConfigPath = path.join(projectPath, `eslint.config.${ext}`);
-  try {
-    let content = await fsp.readFile(eslintConfigPath, "utf8");
-
-    // Avoid double-injection on re-runs
-    if (content.includes("eslint-config-prettier")) return;
-
-    // Add the import after the last import line
-    const lines = content.split("\n");
-    let lastImportIdx = -1;
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].startsWith("import ")) lastImportIdx = i;
-    }
-    lines.splice(
-      lastImportIdx + 1,
-      0,
-      'import prettier from "eslint-config-prettier";'
-    );
-
-    let result = lines.join("\n");
+/**
+ * Inject conditional tooling features (state, router, icons, api client, testing, linter, scripts)
+ * using the composed fragment pipeline.
+ *
+ * @param {string} projectPath
+ * @param {string} templatesDir
+ * @param {object} responses
+ * @param {string} architecture
+ * @param {string} language
+ */
+export async function injectConditionals(
+  projectPath,
+  templatesDir,
+  responses,
+  architecture,
+  language
+) {
+  const mergedResponses = { ...responses, architecture, language };
+  const allFragments = resolveFragments(mergedResponses, templatesDir);
+  const conditionalFragments = allFragments.filter(
+    (f) => f.scope === FRAGMENT_SCOPES.TOOLING && f.category !== "formatter"
+  );
+  await applyFragments(projectPath, conditionalFragments, {
+    language,
+    templatesDir,
+    responses: mergedResponses,
+  });
 
-    // Append prettier as the LAST element of the eslint config.
-    // eslint-config-prettier exports a flat-config object (not an iterable),
-    // so it must be passed by reference, not spread — passing `...prettier`
-    // breaks under ESLint's jiti-based TS config loading.
-    // The JS template exports an array (`export default [...]`); the TS
-    // template uses a function call (`export default tseslint.config(...)`).
-    const pushLast = (_, head, tail) =>
-      head.replace(/,\s*$/, "") + ",\n  prettier," + tail;
-    if (result.includes("tseslint.config(")) {
-      result = result.replace(
-        /(export default tseslint\.config\([\s\S]*?)(\n\s*\);)/,
-        pushLast
-      );
-    } else if (result.includes("const eslintConfig = [")) {
-      result = result.replace(
-        /(const eslintConfig = \[[\s\S]*?)(\n\s*\];)/,
-        pushLast
-      );
-    } else {
-      result = result.replace(
-        /(export default \[[\s\S]*?)(\n\s*\];)/,
-        pushLast
-      );
-    }
+  // 8. UI Kit (shadcn gated to tailwind) — applied after fragments so its
+  // components.json, cn helper and primitives land on the composed tree.
+  await injectUiKit(projectPath, templatesDir, mergedResponses, architecture, language);
+}
 
-    await fsp.writeFile(eslintConfigPath, result, "utf8");
-  } catch {}
+/**
+ * Inject linter configuration and package scripts using the composed fragment pipeline.
+ *
+ * @param {string} projectPath
+ * @param {string} templatesDir
+ * @param {string} linter
+ * @param {string} language
+ * @param {string|object} framework
+ */
+export async function injectLinter(
+  projectPath,
+  templatesDir,
+  linter,
+  language,
+  framework
+) {
+  const responses = { linter, language, framework };
+  const allFragments = resolveFragments(responses, templatesDir);
+  const linterFragments = allFragments.filter(
+    (f) => f.scope === FRAGMENT_SCOPES.TOOLING && f.category === "linter"
+  );
+  await applyFragments(projectPath, linterFragments, {
+    language,
+    templatesDir,
+    responses,
+  });
 }
 
-export async function injectConditionals(projectPath, templatesDir, responses, architecture, language) {
-  const ext = language === "ts" ? "tsx" : "jsx";
+/**
+ * High-level composition API: inject all capability fragments in documented precedence order.
+ *
+ * @param {string} projectPath
+ * @param {string} templatesDir
+ * @param {object} responses
+ */
+export async function injectComposedFragments(projectPath, templatesDir, responses) {
+  const fragments = resolveFragments(responses, templatesDir);
+  await applyFragments(projectPath, fragments, {
+    language: responses.language,
+    templatesDir,
+    responses,
+  });
+}
 
-  // 1. State management
-  if (responses.stateManagement === "redux") {
-    await injectOverlay(
-      projectPath,
-      templatesDir,
-      `conditional/state/redux/${architecture}`,
-      language
-    );
-    await updateMainWithProvider(projectPath, "redux", architecture, ext);
-  } else if (responses.stateManagement === "zustand") {
-    await injectOverlay(
-      projectPath,
-      templatesDir,
-      `conditional/state/zustand/${architecture}`,
-      language
-    );
+export function getComponentsJson({
+  framework = "vite",
+  architecture = "feature-based",
+  language = "ts",
+}) {
+  const isNext = framework === "next";
+  const isTs = language === "ts";
+
+  if (isNext) {
+    // Next App Router contract stub
+    return {
+      $schema: "https://ui.shadcn.com/schema.json",
+      style: "new-york",
+      rsc: true,
+      tsx: isTs,
+      tailwind: {
+        config: "",
+        css: "app/globals.css",
+        baseColor: "neutral",
+        cssVariables: true,
+        prefix: "",
+      },
+      aliases: {
+        components: "@/components",
+        utils: "@/lib/utils",
+        ui: "@/components/ui",
+        lib: "@/lib",
+        hooks: "@/hooks",
+      },
+      iconLibrary: "lucide",
+    };
   }
 
-  // 2. Router (overwrites App.tsx with routed version)
-  if (responses.router) {
-    await injectOverlayVariant(
-      projectPath,
-      templatesDir,
-      `router/${architecture}`,
-      responses.cssFramework,
-      language
-    );
-  }
+  const isFeatureBased = architecture === "feature-based";
+  return {
+    $schema: "https://ui.shadcn.com/schema.json",
+    style: "new-york",
+    rsc: false,
+    tsx: isTs,
+    tailwind: {
+      config: "",
+      css: isFeatureBased
+        ? "src/shared/styles/globals.css"
+        : "src/styles/globals.css",
+      baseColor: "neutral",
+      cssVariables: true,
+      prefix: "",
+    },
+    aliases: isFeatureBased
+      ? {
+          components: "@/shared/components",
+          utils: "@/lib/utils",
+          ui: "@/shared/components/ui",
+          lib: "@/lib",
+          hooks: "@/shared/hooks",
+        }
+      : {
+          components: "@/components",
+          utils: "@/lib/utils",
+          ui: "@/ui",
+          lib: "@/lib",
+          hooks: "@/hooks",
+        },
+    iconLibrary: "lucide",
+  };
+}
 
-  // 3. Icons (overwrites home page)
-  if (responses.iconLibrary && responses.iconLibrary !== "none") {
-    await injectOverlayVariant(
-      projectPath,
-      templatesDir,
-      `icons/${responses.iconLibrary}/${architecture}`,
-      responses.cssFramework,
-      language
+export async function injectUiKit(
+  projectPath,
+  templatesDir,
+  responses,
+  architecture,
+  language
+) {
+  const uiKit = responses.uiKit || responses.ui?.kit || responses.ui || "none";
+  if (uiKit !== "shadcn") return;
+
+  if (responses.cssFramework !== "tailwind") {
+    throw new Error(
+      `ui.kit "shadcn" requires styling.engine "tailwind" (got "${responses.cssFramework}")`
     );
   }
 
-  // 4. API Client
-  if (responses.apiClient === "axios") {
-    await injectOverlay(
-      projectPath,
-      templatesDir,
-      `conditional/axios/${architecture}`,
-      language
-    );
-  } else if (responses.apiClient === "fetch") {
-    await injectOverlay(
-      projectPath,
-      templatesDir,
-      `conditional/fetch/${architecture}`,
-      language
-    );
-  }
+  const isTs = language === "ts";
+  const codeExt = isTs ? "tsx" : "jsx";
+  const utilExt = isTs ? "ts" : "js";
+  const framework = responses.framework || responses.frameworkName || "vite";
 
-  // 5. Testing
-  if (responses.testing === "vitest") {
-    await injectTesting(projectPath, templatesDir, "vitest", language, architecture);
-  } else if (responses.testing === "jest") {
-    await injectTesting(projectPath, templatesDir, "jest", language, architecture);
-  }
+  // 1. Write components.json
+  const componentsJson = getComponentsJson({
+    framework,
+    architecture,
+    language,
+  });
+  await fsp.writeFile(
+    path.join(projectPath, "components.json"),
+    JSON.stringify(componentsJson, null, 2) + "\n",
+    "utf8"
+  );
 
-  // 6. Linter
-  if (responses.linter === "eslint") {
-    await injectLinter(projectPath, templatesDir, "eslint", language, responses.framework);
-  } else if (responses.linter === "oxlint") {
-    await injectLinter(projectPath, templatesDir, "oxlint", language, responses.framework);
+  // 2. Write cn helper to src/lib/utils.{ts,js}
+  const libDir = path.join(projectPath, "src", "lib");
+  await fsp.mkdir(libDir, { recursive: true });
+  const utilsSrc = path.join(
+    templatesDir,
+    "ui",
+    "shadcn",
+    "lib",
+    `utils.${utilExt}`
+  );
+  const utilsDest = path.join(libDir, `utils.${utilExt}`);
+  try {
+    await fsp.access(utilsSrc);
+    await fsp.copyFile(utilsSrc, utilsDest);
+  } catch {
+    const code = isTs
+      ? `import { clsx, type ClassValue } from "clsx";\nimport { twMerge } from "tailwind-merge";\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n`
+      : `import { clsx } from "clsx";\nimport { twMerge } from "tailwind-merge";\n\nexport function cn(...inputs) {\n  return twMerge(clsx(inputs));\n}\n`;
+    await fsp.writeFile(utilsDest, code, "utf8");
   }
 
-  // 7. Create feature script (feature-based only)
+  // Also sync architecture's cn helper if present
   if (architecture === "feature-based") {
-    await injectCreateFeatureScript(projectPath, templatesDir, language);
+    const sharedUtilsDir = path.join(projectPath, "src", "shared", "utils");
+    await fsp.mkdir(sharedUtilsDir, { recursive: true });
+    await fsp.copyFile(utilsDest, path.join(sharedUtilsDir, `cn.${codeExt === "tsx" ? "ts" : "jsx"}`));
+  } else {
+    const typeUtilsDir = path.join(projectPath, "src", "utils");
+    await fsp.mkdir(typeUtilsDir, { recursive: true });
+    await fsp.copyFile(utilsDest, path.join(typeUtilsDir, `cn.${codeExt === "tsx" ? "ts" : "jsx"}`));
   }
 
-  // A .gitkeep only keeps a folder alive when that folder holds nothing else;
-  // once an overlay writes real files into it the placeholder is redundant.
-  await pruneRedundantGitkeeps(projectPath);
-}
+  // 3. Inject Button and Card primitives
+  const isFeatureBased = architecture === "feature-based";
+  const targetUiDir = isFeatureBased
+    ? path.join(projectPath, "src", "shared", "components", "ui")
+    : path.join(projectPath, "src", "ui");
 
-// Remove .gitkeep placeholders from src/ directories that now contain real
-// files (e.g. type-based `services/.gitkeep` after the axios/fetch client
-// overlay lands). A folder with nothing but its placeholder keeps it.
-async function pruneRedundantGitkeeps(projectPath) {
-  const walk = async (dir) => {
-    let entries;
-    try {
-      entries = await fsp.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        await walk(path.join(dir, entry.name));
-      }
-    }
-    if (entries.some((e) => e.name === ".gitkeep")) {
-      const hasRealFiles = entries.some((e) => e.isFile() && e.name !== ".gitkeep");
-      if (hasRealFiles) {
-        await fsp.rm(path.join(dir, ".gitkeep"), { force: true });
-      }
-    }
-  };
-  await walk(path.join(projectPath, "src"));
-}
+  await fsp.mkdir(targetUiDir, { recursive: true });
 
-// Overlays that ship presentational components (router, icons) carry optional
-// tailwind/bootstrap subfolders. Copy the root version first — it holds the
-// framework-agnostic skeleton (routed App, route tables) plus the inline
-// markup defaults used for cssFramework "none" — then overlay the framework's
-// subfolder so its markup-specific files (transitive layouts, home pages)
-// win; `copyDirRecursive` overwrites on name collision.
-async function injectOverlayVariant(projectPath, templatesDir, rel, cssFramework, language) {
-  const base = `conditional/${rel}`;
-  await injectOverlay(projectPath, templatesDir, base, language);
-  const variant =
-    cssFramework === "tailwind" || cssFramework === "bootstrap"
-      ? cssFramework
-      : "";
-  if (variant) {
-    await injectOverlay(
-      projectPath,
-      templatesDir,
-      `${base}/${variant}`,
-      language
-    );
-  }
-}
+  const buttonDest = path.join(targetUiDir, `Button.${codeExt}`);
+  const cardDest = path.join(targetUiDir, `Card.${codeExt}`);
+  const indexDest = path.join(targetUiDir, `index.${utilExt}`);
 
-async function injectOverlay(projectPath, templatesDir, overlayPath, language) {
-  const srcDir = path.join(templatesDir, overlayPath, "src");
-  try {
-    await fsp.access(srcDir);
-    await copyDirRecursive(
-      srcDir,
-      path.join(projectPath, "src"),
-      langFileFilter(language)
-    );
-  } catch {
-    // overlay src dir doesn't exist
-  }
-}
-
-async function injectTesting(projectPath, templatesDir, framework, language, architecture) {
-  const testingDir = path.join(templatesDir, "conditional", "testing", framework);
+  const buttonTemplate = path.join(
+    templatesDir,
+    "ui",
+    "shadcn",
+    "primitives",
+    `Button.${codeExt}`
+  );
+  const cardTemplate = path.join(
+    templatesDir,
+    "ui",
+    "shadcn",
+    "primitives",
+    `Card.${codeExt}`
+  );
+  const indexTemplate = path.join(
+    templatesDir,
+    "ui",
+    "shadcn",
+    "primitives",
+    `index.${utilExt}`
+  );
 
-  // Copy config files to project root
-  const configExt = language === "ts" ? "ts" : "js";
-  const configSrc = path.join(testingDir, `${framework}.config.${configExt}`);
   try {
-    await fsp.access(configSrc);
-    await fsp.copyFile(configSrc, path.join(projectPath, `${framework}.config.${configExt}`));
+    await fsp.access(buttonTemplate);
+    await fsp.copyFile(buttonTemplate, buttonDest);
   } catch {}
 
-  // Copy setup file
-  const setupSrc = path.join(testingDir, `src/test/setup.${configExt}`);
   try {
-    await fsp.access(setupSrc);
-    const setupDest = path.join(projectPath, "src", "test", `setup.${configExt}`);
-    await writeFileRecursive(setupDest, await fsp.readFile(setupSrc, "utf8"));
+    await fsp.access(cardTemplate);
+    await fsp.copyFile(cardTemplate, cardDest);
   } catch {}
 
-  // Jest keeps its setup at the template root (jest.setup.ts/js), referenced by
-  // jest.config as <rootDir>/jest.setup.ts — copy it to the project root.
-  if (framework === "jest") {
-    const jestSetupSrc = path.join(testingDir, `jest.setup.${configExt}`);
-    try {
-      await fsp.access(jestSetupSrc);
-      await fsp.copyFile(jestSetupSrc, path.join(projectPath, `jest.setup.${configExt}`));
-    } catch {}
-
-    // Unified Babel transform config for Jest (env + react + typescript presets).
-    const babelSrc = path.join(testingDir, "babel.config.cjs");
-    try {
-      await fsp.access(babelSrc);
-      await fsp.copyFile(babelSrc, path.join(projectPath, "babel.config.cjs"));
-    } catch {}
-  }
-
-  // Copy test file (architecture-scoped so the App import path resolves)
-  const testExt = language === "ts" ? "tsx" : "jsx";
-  const testSrc = path.join(testingDir, architecture, `src/__tests__/App.test.${testExt}`);
   try {
-    await fsp.access(testSrc);
-    const testDest = path.join(projectPath, "src", "__tests__", `App.test.${testExt}`);
-    await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
+    await fsp.access(indexTemplate);
+    await fsp.copyFile(indexTemplate, indexDest);
   } catch {}
 
-  // Add test script to package.json
-  const pkgPath = path.join(projectPath, "package.json");
-  try {
-    const content = await fsp.readFile(pkgPath, "utf8");
-    const pkg = JSON.parse(content);
-    if (!pkg.scripts) pkg.scripts = {};
-    if (framework === "vitest") {
-      pkg.scripts.test = "vitest";
-      pkg.scripts["test:run"] = "vitest run";
-    } else {
-      pkg.scripts.test = "jest";
-      pkg.scripts["test:watch"] = "jest --watch";
-    }
-    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-  } catch {}
-}
-
-export async function injectLinter(projectPath, templatesDir, linter, language, framework) {
-  const lintingDir = path.join(templatesDir, "conditional", "linting", linter);
-
-  if (linter === "eslint") {
-    if (framework === "next") {
-      const configSrc = path.join(lintingDir, "next", "eslint.config.mjs");
-      try {
-        await fsp.access(configSrc);
-        await fsp.copyFile(configSrc, path.join(projectPath, "eslint.config.mjs"));
-      } catch {}
-    } else {
-      const configExt = language === "ts" ? "ts" : "js";
-      const configSrc = path.join(lintingDir, `eslint.config.${configExt}`);
-      try {
-        await fsp.access(configSrc);
-        await fsp.copyFile(configSrc, path.join(projectPath, `eslint.config.${configExt}`));
-      } catch {}
-    }
-  } else if (linter === "oxlint") {
-    const configSrc = path.join(lintingDir, "oxlintrc.json");
+  // If type-based, also populate src/components/ui for maximum tooling compatibility
+  if (!isFeatureBased) {
+    const fallbackUiDir = path.join(projectPath, "src", "components", "ui");
+    await fsp.mkdir(fallbackUiDir, { recursive: true });
     try {
-      await fsp.access(configSrc);
-      await fsp.copyFile(configSrc, path.join(projectPath, "oxlintrc.json"));
+      await fsp.copyFile(buttonDest, path.join(fallbackUiDir, `Button.${codeExt}`));
+      await fsp.copyFile(cardDest, path.join(fallbackUiDir, `Card.${codeExt}`));
+      await fsp.copyFile(indexDest, path.join(fallbackUiDir, `index.${utilExt}`));
     } catch {}
   }
-
-  // Add lint script to package.json
-  const pkgPath = path.join(projectPath, "package.json");
-  try {
-    const content = await fsp.readFile(pkgPath, "utf8");
-    const pkg = JSON.parse(content);
-    if (!pkg.scripts) pkg.scripts = {};
-    if (linter === "eslint") {
-      pkg.scripts.lint = "eslint .";
-      pkg.scripts["lint:fix"] = "eslint . --fix";
-    } else {
-      pkg.scripts.lint = "oxlint .";
-    }
-    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-  } catch {}
-}
-
-async function injectCreateFeatureScript(projectPath, templatesDir, language) {
-  const scriptSrc = path.join(templatesDir, "architectures", "feature-based", "scripts", "create-feature.mjs");
-  const scriptDest = path.join(projectPath, "scripts", "create-feature.mjs");
-
-  try {
-    await fsp.access(scriptSrc);
-    let content = await fsp.readFile(scriptSrc, "utf8");
-
-    // Adapt to JS if needed
-    if (language === "js") {
-      // Replace .ts extensions with .js in the initialFiles
-      content = content
-        .replace(/services\/index\.ts/g, "services/index.js")
-        .replace(/store\/index\.ts/g, "store/index.js")
-        .replace(/hooks\/index\.ts/g, "hooks/index.js")
-        .replace(/pages\/index\.ts/g, "pages/index.js")
-        .replace(/types\/index\.ts/g, "types/index.js");
-    }
-
-    await writeFileRecursive(scriptDest, content);
-  } catch {}
-
-  // Add script to package.json
-  const pkgPath = path.join(projectPath, "package.json");
-  try {
-    const content = await fsp.readFile(pkgPath, "utf8");
-    const pkg = JSON.parse(content);
-    if (!pkg.scripts) pkg.scripts = {};
-    pkg.scripts["create:feature"] = "node scripts/create-feature.mjs";
-    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-  } catch {}
 }
 
-async function updateMainWithProvider(projectPath, stateType, architecture, ext) {
-  const mainPath = path.join(projectPath, "src", `main.${ext}`);
-  try {
-    let content = await fsp.readFile(mainPath, "utf8");
-
-    if (architecture === "feature-based") {
-      if (!content.includes("StoreProvider")) {
-        content = content.replace(
-          /import App from ['"]@\/app\/App['"]\n?/,
-          "import App from '@/app/App'\nimport { StoreProvider } from '@/app/providers/StoreProvider'\n"
-        );
-        content = content.replace(
-          /<App \/>/,
-          "<StoreProvider>\n        <App />\n      </StoreProvider>"
-        );
-      }
-    } else {
-      if (!content.includes("StoreProvider")) {
-        content = content.replace(
-          /import App from ['"]\.\/App['"]\n?/,
-          "import App from './App'\nimport { StoreProvider } from './providers/StoreProvider'\n"
-        );
-        content = content.replace(
-          /<App \/>/,
-          "<StoreProvider>\n        <App />\n      </StoreProvider>"
-        );
-      }
-    }
-
-    await fsp.writeFile(mainPath, content, "utf8");
-  } catch {}
-}