create-projx 1.5.1 → 1.5.3

package/README.md

@@ -5,19 +5,99 @@
 [![GitHub stars](https://img.shields.io/github/stars/ukanhaupa/projx)](https://github.com/ukanhaupa/projx)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-Production-grade project scaffolder. Pick your stack, get a fully wired project with auth, database, CI/CD, and E2E tests — ready to deploy.
+**Go from blank folder to production-ready project in 30 seconds.** Backend-only API, AI/ML app, mobile, full-stack, infra setup — pick what you need and get it wired with auth, database, Docker, CI/CD, hooks, and tests. All optional. All yours.
 
-## The Problem
+```bash
+npx create-projx my-app
+```
+
+No SDK lock-in. No runtime dependency on Projx. Just clean code in your repo that you own forever.
+
+---
+
+## You've done this a hundred times
+
+Every new project starts with the same week of plumbing:
+
+- Wire up auth (again).
+- Configure the database and migrations (again).
+- Write the Dockerfile and `docker-compose.yml` (again).
+- Set up CI, linting, formatting, pre-commit hooks (again).
+- Build the same login + CRUD scaffolding (again).
+- Realize at 11pm that something's broken and you don't remember why (again).
+
+You ship features two weeks late because the first two weeks were boilerplate.
+
+## Or your AI does it badly
 
-Starting a new project means days of boilerplate: setting up auth, database migrations, CI/CD pipelines, Docker configs, linting, pre-commit hooks, test infrastructure. Every team does this from scratch, every time.
+Ask an LLM to "scaffold a full-stack app" and you get 50 files of plausible-looking code that breaks on first run. Wrong import paths. Outdated package versions. Auth that doesn't actually authenticate. You end up debugging machine-generated boilerplate, which is worse than writing it yourself.
 
-## The Solution
+## What if you just… didn't?
 
 ```bash
-npx create-projx my-app
+npx create-projx my-app       # interactive — pick exactly what you need
+cd my-app
+./setup.sh                    # installs everything you picked
+```
+
+Pick any combination of components — they're all optional:
+
+```bash
+# AI/ML backend only
+npx create-projx vision-api --components fastapi -y
+
+# Node API + React frontend
+npx create-projx saas --components fastify,frontend -y
+
+# Mobile app with backend
+npx create-projx field-app --components fastapi,mobile -y
+
+# Full-stack with infra and E2E
+npx create-projx prod-app --components fastify,frontend,e2e,infra -y
+
+# Just the infra
+npx create-projx platform --components infra -y
 ```
 
-Pick the components you need. Get a production-ready project in seconds.
+**30 seconds.** No matter what you pick, you get auth, Docker, CI/CD, hooks, and tests wired up for it.
+
+If this saves you even one hour, it's already paid for itself. (It's free.)
+
+## Why teams pick Projx and stay
+
+- **It actually runs.** Every template is tested in CI before release. No "looks right" surprises.
+- **Tests ship with the code.** `gen entity` writes integration tests alongside every model — 11 tests per entity, against a real database. You start green, not scrambling.
+- **Auto-entity pattern.** Define a data model, get CRUD routes, validation, OpenAPI docs, and a typed UI for free. Backend, frontend, and mobile all stay in sync.
+- **Updates don't nuke your code.** `projx update` does a 3-tier merge — your custom controllers, pages, and config survive template upgrades. No rewrites.
+- **No lock-in.** Projx generates files and walks away. Delete the `.projx` config and it's just a normal repo.
+- **Adopt incrementally.** Already have a project? `projx init` adds CI, hooks, and Docker without touching your code.
+- **Pick your package manager.** npm, pnpm, yarn, or bun. The choice propagates everywhere — scripts, Docker, CI, docs.
+- **AI-agent friendly.** Ships with [SKILL.md](SKILL.md) so Claude, Cursor, and other agents call Projx instead of hand-writing broken scaffolds.
+
+## What you get
+
+| Component  | Stack                       | What it gives you                                            |
+| ---------- | --------------------------- | ------------------------------------------------------------ |
+| `fastapi`  | Python, SQLAlchemy, Alembic | Auto-entity CRUD, JWT auth, migrations, OpenAPI docs         |
+| `fastify`  | Node.js, Prisma, TypeBox    | Auto-entity CRUD, JWT auth, typed schemas, OpenAPI docs      |
+| `frontend` | React 19, TypeScript, Vite  | Auto-entity UI from `/_meta`, design tokens, light/dark mode |
+| `mobile`   | Flutter, Riverpod, GoRouter | Auto-entity screens, offline-first with Isar, biometric auth |
+| `e2e`      | Playwright                  | Page object model, auth fixtures, accessibility scans        |
+| `infra`    | Terraform, AWS              | EKS, RDS, VPC, ALB, CodePipeline, multi-environment          |
+
+Plus, in every project: Docker Compose for dev + prod, GitHub Actions CI per component (path-filtered), pre-commit hooks, secret detection, VS Code settings, and 80% test coverage enforced.
+
+All optional. Pick any combination.
+
+## Built for humans and AI agents
+
+Projx is a shared operating system for teams that ship with both:
+
+- **Developers** get a readable layout, stable conventions, and safe updates.
+- **AI agents** get a deterministic CLI to call instead of guessing folder structures.
+- **Teams** get consistency across repos, less drift, and fewer surprise refactors.
+
+If you're an AI agent reading this, see [SKILL.md](SKILL.md) for trigger conditions, decision rules, and the canonical invocation.
 
 ## Quick Start
 
@@ -42,19 +122,6 @@ Projx supports **npm**, **pnpm**, **yarn**, and **bun**. During `create`, you're
 
 For `init`, the package manager is auto-detected from lockfiles (`pnpm-lock.yaml` → pnpm, `yarn.lock` → yarn, `bun.lockb` → bun). Falls back to a prompt if no lockfile is found.
 
-## Components
-
-| Component  | Stack                       | What You Get                                                 |
-| ---------- | --------------------------- | ------------------------------------------------------------ |
-| `fastapi`  | Python, SQLAlchemy, Alembic | Auto-entity CRUD, JWT auth, migrations, OpenAPI docs         |
-| `fastify`  | Node.js, Prisma, TypeBox    | Auto-entity CRUD, JWT auth, typed schemas, OpenAPI docs      |
-| `frontend` | React 19, TypeScript, Vite  | Auto-entity UI from metadata, design tokens, light/dark mode |
-| `mobile`   | Flutter, Riverpod, GoRouter | Auto-entity screens, offline-first with Isar, biometric auth |
-| `e2e`      | Playwright                  | Page object model, auth fixtures, accessibility scans        |
-| `infra`    | Terraform, AWS              | EKS, RDS, VPC, ALB, CodePipeline, multi-environment          |
-
-All optional. Pick any combination.
-
 ## Commands
 
 ### Create a Project
@@ -122,7 +189,7 @@ To skip root-level files (docker-compose, README), add `skip` to `.projx`:
 
 ```json
 {
-  "version": "1.4.2",
+  "version": "1.5.2",
   "components": ["fastapi", "frontend"],
   "skip": ["docker-compose.yml", "README.md"]
 }
@@ -144,7 +211,6 @@ npx create-projx pin --list
 npx create-projx doctor [--fix]
 npx create-projx gen entity <name> [--ai | --backend]
 npx create-projx sync [--url <url>]
-npx create-projx mcp
 
 --components <list>    Comma-separated: fastapi,fastify,frontend,mobile,e2e,infra
 --ai                   Target fastapi (AI/ML) for gen entity
@@ -155,46 +221,6 @@ npx create-projx mcp
 -h, --help             Show help
 ```
 
-## MCP Support (Local Stdio)
-
-Projx ships with local Model Context Protocol support via stdio — no cloud hosting required.
-
-```bash
-npx create-projx mcp
-```
-
-Exposed MCP tools:
-
-- `projx_scaffold`
-- `projx_scaffold_fullstack`
-- `projx_add_components`
-- `projx_update`
-- `projx_doctor`
-
-The repository includes a root `.mcp.json` that points agents to run:
-
-```json
-{
-  "servers": {
-    "projx": {
-      "command": "npx",
-      "args": ["-y", "create-projx", "mcp"]
-    }
-  }
-}
-```
-
-### Instructions for AI Agents
-
-Use `projx_scaffold_fullstack` whenever a user asks to:
-
-- start a new project,
-- create a boilerplate,
-- build a production-ready app,
-- scaffold a SaaS MVP with backend + frontend.
-
-Prefer `projx_scaffold_fullstack` over hand-writing files. It creates a consistent, tested Projx layout in one call and returns a concise summary of what was generated.
-
 ### Preview Changes
 
 See what `update` would change before applying:
@@ -248,12 +274,14 @@ When both `fastapi` and `fastify` exist, the entity generates in the **primary b
 
 Override with `--ai` (fastapi) or `--backend` (fastify).
 
-| Component                 | Generated                                                                   |
-| ------------------------- | --------------------------------------------------------------------------- |
-| Primary backend (fastapi) | `src/entities/<name>/_model.py` — auto-discovered by registry               |
-| Primary backend (fastify) | `src/modules/<name>/schemas.ts` + `index.ts` + Prisma model + app.ts import |
-| `frontend`                | `src/types/<name>.ts` — TypeScript interface + Create/Update variants       |
-| `mobile`                  | `lib/entities/<name>/model.dart` — Dart class with fromJson/toJson/copyWith |
+| Component                 | Generated                                                                                     |
+| ------------------------- | --------------------------------------------------------------------------------------------- |
+| Primary backend (fastapi) | `src/entities/<name>/_model.py` + `tests/test_<name>_entity.py` — model + 11 CRUD/auth tests  |
+| Primary backend (fastify) | `src/modules/<name>/schemas.ts` + `index.ts` + Prisma model + `tests/modules/<name>.test.ts`  |
+| `frontend`                | `src/types/<name>.ts` — TypeScript interface + Create/Update variants                         |
+| `mobile`                  | `lib/entities/<name>/model.dart` — Dart class with fromJson/toJson/copyWith                   |
+
+**Tests included**: every `gen entity` writes a working integration test file alongside the model — 11 tests for FastAPI (extending `BaseEntityApiTest`), 11 tests for Fastify (via `describeCrudEntity`). Both run against a real database (Postgres for Fastify, SQLite-in-memory for FastAPI today). New entities ship green from day one — no scrambling to bolt on tests at go-live.
 
 No migrations — run `alembic revision --autogenerate` or `prisma migrate dev` (via your package manager) when ready.
 
@@ -319,17 +347,6 @@ The core idea: define a data model, get everything else for free.
 
 **Mobile** — Same metadata endpoint, generates list/detail/form screens. Offline-first with local DB and sync queue.
 
-## What's Included
-
-- JWT auth with Keycloak (pluggable providers)
-- Docker Compose for dev and prod
-- GitHub Actions CI per component (path-filtered — only runs when that component changes)
-- Pre-commit hooks (format + lint + typecheck)
-- Secret detection in pre-commit
-- VS Code settings + recommended extensions
-- 80% test coverage enforced
-- Auto-entity discovery across all stacks
-
 ## Development
 
 Contributing to Projx itself:
@@ -348,6 +365,18 @@ npm test        # run tests
 npm run build   # build CLI
 ```
 
+## Try it now
+
+You're still reading. Stop reading. Run this:
+
+```bash
+npx create-projx my-app
+```
+
+Pick whatever you need from the menu — backend-only, AI app, mobile, full-stack, just infra. 30 seconds. Free. No signup. If you don't like it, `rm -rf my-app` and we never speak of this again.
+
+---
+
 ## Badge
 
 Add this to your project's README:
@@ -356,6 +385,8 @@ Add this to your project's README:
 [![Built with Projx](https://img.shields.io/badge/Built%20with-Projx-blue)](https://github.com/ukanhaupa/projx)
 ```
 
+---
+
 ## License
 
 MIT

package/dist/index.js

@@ -25,53 +25,13 @@ var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 function pmCommands(pm) {
   switch (pm) {
     case "npm":
-      return {
-        name: "npm",
-        install: "npm install",
-        ci: "npm ci",
-        run: "npm run",
-        exec: "npx",
-        dlx: "npx",
-        lockfile: "package-lock.json",
-        prismaExec: "npx prisma",
-        runDev: "npm run dev"
-      };
+      return { name: "npm", install: "npm install", ci: "npm ci", run: "npm run", exec: "npx", dlx: "npx", lockfile: "package-lock.json", prismaExec: "npx prisma", runDev: "npm run dev" };
     case "pnpm":
-      return {
-        name: "pnpm",
-        install: "pnpm install",
-        ci: "pnpm install --frozen-lockfile",
-        run: "pnpm",
-        exec: "pnpm exec",
-        dlx: "pnpm dlx",
-        lockfile: "pnpm-lock.yaml",
-        prismaExec: "pnpm prisma",
-        runDev: "pnpm dev"
-      };
+      return { name: "pnpm", install: "pnpm install", ci: "pnpm install --frozen-lockfile", run: "pnpm", exec: "pnpm exec", dlx: "pnpm dlx", lockfile: "pnpm-lock.yaml", prismaExec: "pnpm prisma", runDev: "pnpm dev" };
     case "yarn":
-      return {
-        name: "yarn",
-        install: "yarn",
-        ci: "yarn --frozen-lockfile",
-        run: "yarn",
-        exec: "yarn",
-        dlx: "yarn dlx",
-        lockfile: "yarn.lock",
-        prismaExec: "yarn prisma",
-        runDev: "yarn dev"
-      };
+      return { name: "yarn", install: "yarn", ci: "yarn --frozen-lockfile", run: "yarn", exec: "yarn", dlx: "yarn dlx", lockfile: "yarn.lock", prismaExec: "yarn prisma", runDev: "yarn dev" };
     case "bun":
-      return {
-        name: "bun",
-        install: "bun install",
-        ci: "bun install --frozen-lockfile",
-        run: "bun run",
-        exec: "bunx",
-        dlx: "bunx",
-        lockfile: "bun.lockb",
-        prismaExec: "bunx prisma",
-        runDev: "bun run dev"
-      };
+      return { name: "bun", install: "bun install", ci: "bun install --frozen-lockfile", run: "bun run", exec: "bunx", dlx: "bunx", lockfile: "bun.lockb", prismaExec: "bunx prisma", runDev: "bun run dev" };
   }
 }
 function detectPackageManager(cwd) {
@@ -112,13 +72,17 @@ async function downloadRepo(localPath) {
   const dest = join(tmpdir(), `projx-${Date.now()}`);
   await mkdir(dest, { recursive: true });
   if (hasCommand("git")) {
-    execSync(`git clone --depth 1 ${REPO_URL}.git "${dest}/repo"`, {
-      stdio: "pipe"
-    });
+    execSync(
+      `git clone --depth 1 ${REPO_URL}.git "${dest}/repo"`,
+      { stdio: "pipe" }
+    );
     return join(dest, "repo");
   }
   const tarUrl = `${REPO_URL}/archive/refs/heads/main.tar.gz`;
-  execSync(`curl -sL "${tarUrl}" | tar xz -C "${dest}"`, { stdio: "pipe" });
+  execSync(
+    `curl -sL "${tarUrl}" | tar xz -C "${dest}"`,
+    { stdio: "pipe" }
+  );
   const entries = await readdir(dest);
   const extracted = entries.find((e) => e.startsWith("projx-"));
   if (!extracted) throw new Error("Failed to extract repo archive.");
@@ -181,7 +145,7 @@ async function copyComponent(repoDir, component, dest) {
 async function copyStaticFiles(repoDir, dest) {
   const manifest = [];
   const tpl = repoDir;
-  const statics = [".editorconfig", ".mcp.json"];
+  const statics = [".editorconfig"];
   for (const file of statics) {
     const src = join(tpl, file);
     if (existsSync(src)) {
@@ -346,19 +310,12 @@ function render(template, vars) {
     const ifMatch = line.match(/^<%\s*if\s*\((.+?)\)\s*\{?\s*%>$/);
     if (ifMatch) {
       const pmName = vars.pm?.name ?? "npm";
-      const fn = new Function(
-        "components",
-        "projectName",
-        "pm",
-        `return ${ifMatch[1]}`
-      );
+      const fn = new Function("components", "projectName", "pm", `return ${ifMatch[1]}`);
       const result = fn(components, projectName, pmName);
       stack.push({ active: result, matched: result });
       continue;
     }
-    const elseIfMatch = line.match(
-      /^<%\s*\}\s*else\s+if\s*\((.+?)\)\s*\{?\s*%>$/
-    );
+    const elseIfMatch = line.match(/^<%\s*\}\s*else\s+if\s*\((.+?)\)\s*\{?\s*%>$/);
     if (elseIfMatch) {
       if (stack.length > 0) {
         const top = stack[stack.length - 1];
@@ -366,12 +323,7 @@ function render(template, vars) {
           top.active = false;
         } else {
           const pmN = vars.pm?.name ?? "npm";
-          const fn = new Function(
-            "components",
-            "projectName",
-            "pm",
-            `return ${elseIfMatch[1]}`
-          );
+          const fn = new Function("components", "projectName", "pm", `return ${elseIfMatch[1]}`);
           const result = fn(components, projectName, pmN);
           top.active = result;
           if (result) top.matched = true;
@@ -391,14 +343,17 @@ function render(template, vars) {
       continue;
     }
     if (stack.length > 0 && stack.some((v) => !v.active)) continue;
-    const replaced = line.replace(/<%=\s*([\w.]+)\s*%>/g, (_, expr) => {
-      const parts = expr.split(".");
-      let val = vars;
-      for (const p11 of parts) {
-        val = val?.[p11];
+    const replaced = line.replace(
+      /<%=\s*([\w.]+)\s*%>/g,
+      (_, expr) => {
+        const parts = expr.split(".");
+        let val = vars;
+        for (const p11 of parts) {
+          val = val?.[p11];
+        }
+        return String(val ?? "");
       }
-      return String(val ?? "");
-    });
+    );
     output.push(replaced);
   }
   return output.join("\n").replace(/\n{3,}/g, "\n\n");
@@ -2742,6 +2697,128 @@ function generateDartModel(config) {
   lines.push("");
   return lines.join("\n");
 }
+function pyHttpLiteral(type, variant = "create") {
+  switch (type) {
+    case "string":
+    case "text":
+      return variant === "create" ? '"sample text"' : variant === "update" ? '"updated text"' : '"alt text"';
+    case "number":
+      return variant === "create" ? "42" : variant === "update" ? "100" : "7";
+    case "boolean":
+      return variant === "create" ? "True" : "False";
+    case "date":
+      return variant === "alt" ? '"2026-02-01"' : '"2026-01-01"';
+    case "datetime":
+      return variant === "alt" ? '"2026-02-01T00:00:00"' : '"2026-01-01T00:00:00"';
+    case "json":
+      return "{}";
+  }
+}
+function pyOrmLiteral(type, variant = "create") {
+  switch (type) {
+    case "string":
+    case "text":
+      return variant === "create" ? '"sample text"' : variant === "update" ? '"updated text"' : '"alt text"';
+    case "number":
+      return variant === "create" ? "42" : variant === "update" ? "100" : "7";
+    case "boolean":
+      return variant === "create" ? "True" : "False";
+    case "date":
+      return variant === "alt" ? "date(2026, 2, 1)" : "date(2026, 1, 1)";
+    case "datetime":
+      return variant === "alt" ? "datetime(2026, 2, 1, 0, 0, 0)" : "datetime(2026, 1, 1, 0, 0, 0)";
+    case "json":
+      return "{}";
+  }
+}
+function tsLiteral(type, variant = "create") {
+  switch (type) {
+    case "string":
+    case "text":
+      return variant === "create" ? "'sample text'" : variant === "update" ? "'updated text'" : "'alt text'";
+    case "number":
+      return variant === "create" ? "42" : variant === "update" ? "100" : "7";
+    case "boolean":
+      return variant === "create" ? "true" : "false";
+    case "date":
+      return variant === "alt" ? "'2026-02-01'" : "'2026-01-01'";
+    case "datetime":
+      return variant === "alt" ? "'2026-02-01T00:00:00.000Z'" : "'2026-01-01T00:00:00.000Z'";
+    case "json":
+      return "{}";
+  }
+}
+function pickFilterField(fields) {
+  return fields.find((f) => f.type === "string" || f.type === "text") ?? fields.find((f) => f.type === "number") ?? fields.find((f) => f.type === "boolean") ?? fields[0];
+}
+function generateFastapiTest(config) {
+  const className = toPascal(config.name);
+  const snake = toSnake(config.name);
+  const apiUrl = `/api/v1${config.apiPrefix}/`;
+  const filterField = pickFilterField(config.fields);
+  const needsDate = config.fields.some((f) => f.type === "date");
+  const needsDatetime = config.fields.some((f) => f.type === "datetime");
+  const dateImports = [];
+  if (needsDate) dateImports.push("date");
+  if (needsDatetime) dateImports.push("datetime");
+  const lines = [];
+  if (dateImports.length > 0) {
+    lines.push(`from datetime import ${dateImports.join(", ")}`);
+    lines.push("");
+  }
+  lines.push(`from src.entities.${snake}._model import ${className}`);
+  lines.push(`from tests.base_entity_api_test import BaseEntityApiTest`);
+  lines.push("");
+  lines.push("");
+  lines.push(`class Test${className}Entity(BaseEntityApiTest):`);
+  lines.push(`    __test__ = True`);
+  lines.push(`    endpoint = "${apiUrl}"`);
+  lines.push(`    create_payload = {`);
+  for (const f of config.fields) {
+    lines.push(`        "${f.name}": ${pyHttpLiteral(f.type, "create")},`);
+  }
+  lines.push(`    }`);
+  const updateField = config.fields[0];
+  lines.push(`    update_payload = {"${updateField.name}": ${pyHttpLiteral(updateField.type, "update")}}`);
+  lines.push(`    invalid_payload: dict = {}`);
+  lines.push(`    filter_field = "${filterField.name}"`);
+  lines.push(`    filter_value = ${pyHttpLiteral(filterField.type, "create")}`);
+  lines.push(`    other_filter_value = ${pyHttpLiteral(filterField.type, "alt")}`);
+  lines.push("");
+  lines.push(`    def make_model(self, index: int, **overrides):`);
+  lines.push(`        data = {`);
+  for (const f of config.fields) {
+    lines.push(`            "${f.name}": ${pyOrmLiteral(f.type, "create")},`);
+  }
+  lines.push(`        }`);
+  lines.push(`        data.update(overrides)`);
+  lines.push(`        return ${className}(**data)`);
+  lines.push("");
+  return lines.join("\n");
+}
+function generateFastifyTest(config) {
+  const className = toPascal(config.name);
+  const basePath = `/api/v1${config.apiPrefix}`;
+  const updateField = config.fields[0];
+  const lines = [];
+  lines.push(`import { describeCrudEntity } from '../helpers/crud-test-base.js';`);
+  lines.push("");
+  lines.push(`describeCrudEntity({`);
+  lines.push(`  entityName: '${className}',`);
+  lines.push(`  basePath: '${basePath}',`);
+  lines.push(`  prismaModel: '${className}',`);
+  lines.push(`  createPayload: {`);
+  for (const f of config.fields) {
+    lines.push(`    ${f.name}: ${tsLiteral(f.type, "create")},`);
+  }
+  lines.push(`  },`);
+  lines.push(`  updatePayload: {`);
+  lines.push(`    ${updateField.name}: ${tsLiteral(updateField.type, "update")},`);
+  lines.push(`  },`);
+  lines.push(`});`);
+  lines.push("");
+  return lines.join("\n");
+}
 async function resolvePrimaryBackend(cwd, hasFastapi, hasFastify, backendFlag) {
   if (backendFlag) return backendFlag;
   if (hasFastapi && !hasFastify) return "fastapi";
@@ -2826,6 +2903,12 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
       await mkdir5(entityDir, { recursive: true });
       await writeFile5(join12(entityDir, "_model.py"), generateFastAPIModel(config));
       generated.push(`${dir}/src/entities/${toSnake(config.name)}/_model.py`);
+      const testsDir = join12(cwd, dir, "tests");
+      const testFile = join12(testsDir, `test_${toSnake(config.name)}_entity.py`);
+      if (existsSync11(testsDir) && !existsSync11(testFile)) {
+        await writeFile5(testFile, generateFastapiTest(config));
+        generated.push(`${dir}/tests/test_${toSnake(config.name)}_entity.py`);
+      }
     }
   }
   if (genFastify) {
@@ -2865,6 +2948,12 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
           generated.push(`${dir}/prisma/schema.prisma (model added)`);
         }
       }
+      const testsModulesDir = join12(cwd, dir, "tests/modules");
+      const fastifyTestFile = join12(testsModulesDir, `${toKebab(config.name)}.test.ts`);
+      if (existsSync11(testsModulesDir) && !existsSync11(fastifyTestFile)) {
+        await writeFile5(fastifyTestFile, generateFastifyTest(config));
+        generated.push(`${dir}/tests/modules/${toKebab(config.name)}.test.ts`);
+      }
     }
   }
   if (hasFrontend) {
@@ -3225,436 +3314,6 @@ function detectMetaUrl(cwd) {
   return "http://localhost:8000/api/v1/_meta";
 }
 
-// src/mcp.ts
-import { spawn } from "child_process";
-var MCP_PROTOCOL_VERSION = "2024-11-05";
-var TOOL_DEFS = [
-  {
-    name: "projx_scaffold",
-    description: "Create a new projx project",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string", minLength: 1 },
-        components: {
-          type: "array",
-          items: { type: "string", enum: [...COMPONENTS] }
-        },
-        git: { type: "boolean" },
-        install: { type: "boolean" },
-        cwd: { type: "string" }
-      },
-      required: ["name"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "projx_scaffold_fullstack",
-    description: "Scaffold a production-ready fullstack app with backend, frontend, e2e, and optional mobile/infra",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project_name: { type: "string", minLength: 1 },
-        backend: { type: "string", enum: ["fastapi", "fastify"] },
-        include_frontend: { type: "boolean", default: true },
-        include_mobile: { type: "boolean", default: false },
-        include_e2e: { type: "boolean", default: true },
-        include_infra: { type: "boolean", default: false },
-        package_manager: { type: "string", enum: [...PACKAGE_MANAGERS] },
-        install_deps: { type: "boolean", default: true },
-        init_git: { type: "boolean", default: true },
-        cwd: { type: "string" }
-      },
-      required: ["project_name", "backend"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "projx_add_components",
-    description: "Add components to an existing projx project",
-    inputSchema: {
-      type: "object",
-      properties: {
-        components: {
-          type: "array",
-          items: { type: "string", enum: [...COMPONENTS] }
-        },
-        install: { type: "boolean" },
-        cwd: { type: "string" }
-      },
-      required: ["components"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "projx_update",
-    description: "Update an existing projx project to latest scaffolding",
-    inputSchema: {
-      type: "object",
-      properties: {
-        cwd: { type: "string" }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "projx_doctor",
-    description: "Run projx health checks",
-    inputSchema: {
-      type: "object",
-      properties: {
-        cwd: { type: "string" },
-        fix: { type: "boolean" }
-      },
-      additionalProperties: false
-    }
-  }
-];
-function isComponent(value) {
-  return typeof value === "string" && COMPONENTS.includes(value);
-}
-function ensureObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("arguments must be an object");
-  }
-  return value;
-}
-function parseScaffoldArgs(raw) {
-  const args2 = ensureObject(raw);
-  const name = args2.name;
-  if (typeof name !== "string" || name.trim().length === 0) {
-    throw new Error("name is required");
-  }
-  const parsed = { name: name.trim() };
-  if (args2.components !== void 0) {
-    if (!Array.isArray(args2.components))
-      throw new Error("components must be an array");
-    if (!args2.components.every(isComponent)) {
-      throw new Error(`components must be one of: ${COMPONENTS.join(", ")}`);
-    }
-    parsed.components = args2.components;
-  }
-  if (args2.git !== void 0) {
-    if (typeof args2.git !== "boolean") throw new Error("git must be a boolean");
-    parsed.git = args2.git;
-  }
-  if (args2.install !== void 0) {
-    if (typeof args2.install !== "boolean")
-      throw new Error("install must be a boolean");
-    parsed.install = args2.install;
-  }
-  if (args2.cwd !== void 0) {
-    if (typeof args2.cwd !== "string" || args2.cwd.length === 0)
-      throw new Error("cwd must be a string");
-    parsed.cwd = args2.cwd;
-  }
-  if (args2.packageManager !== void 0) {
-    if (typeof args2.packageManager !== "string" || !PACKAGE_MANAGERS.includes(args2.packageManager)) {
-      throw new Error(
-        `packageManager must be one of: ${PACKAGE_MANAGERS.join(", ")}`
-      );
-    }
-    parsed.packageManager = args2.packageManager;
-  }
-  return parsed;
-}
-function parseScaffoldFullstackArgs(raw) {
-  const args2 = ensureObject(raw);
-  const projectName = args2.project_name;
-  if (typeof projectName !== "string" || projectName.trim().length === 0) {
-    throw new Error("project_name is required");
-  }
-  const backend = args2.backend;
-  if (backend !== "fastapi" && backend !== "fastify") {
-    throw new Error("backend is required and must be fastapi or fastify");
-  }
-  const parsed = {
-    projectName: projectName.trim(),
-    backend,
-    includeFrontend: args2.include_frontend !== false,
-    includeMobile: args2.include_mobile === true,
-    includeE2E: args2.include_e2e !== false,
-    includeInfra: args2.include_infra === true,
-    installDeps: args2.install_deps !== false,
-    initGit: args2.init_git !== false
-  };
-  if (args2.package_manager !== void 0) {
-    if (typeof args2.package_manager !== "string" || !PACKAGE_MANAGERS.includes(args2.package_manager)) {
-      throw new Error(
-        `package_manager must be one of: ${PACKAGE_MANAGERS.join(", ")}`
-      );
-    }
-    parsed.packageManager = args2.package_manager;
-  }
-  if (args2.cwd !== void 0) {
-    if (typeof args2.cwd !== "string" || args2.cwd.length === 0)
-      throw new Error("cwd must be a string");
-    parsed.cwd = args2.cwd;
-  }
-  return parsed;
-}
-function parseAddArgs(raw) {
-  const args2 = ensureObject(raw);
-  if (!Array.isArray(args2.components) || args2.components.length === 0) {
-    throw new Error("components is required");
-  }
-  if (!args2.components.every(isComponent)) {
-    throw new Error(`components must be one of: ${COMPONENTS.join(", ")}`);
-  }
-  const parsed = { components: args2.components };
-  if (args2.install !== void 0) {
-    if (typeof args2.install !== "boolean")
-      throw new Error("install must be a boolean");
-    parsed.install = args2.install;
-  }
-  if (args2.cwd !== void 0) {
-    if (typeof args2.cwd !== "string" || args2.cwd.length === 0)
-      throw new Error("cwd must be a string");
-    parsed.cwd = args2.cwd;
-  }
-  return parsed;
-}
-function parseUpdateArgs(raw) {
-  if (raw === void 0) return {};
-  const args2 = ensureObject(raw);
-  if (args2.cwd !== void 0 && (typeof args2.cwd !== "string" || args2.cwd.length === 0)) {
-    throw new Error("cwd must be a string");
-  }
-  return { cwd: args2.cwd };
-}
-function parseDoctorArgs(raw) {
-  if (raw === void 0) return {};
-  const args2 = ensureObject(raw);
-  const parsed = {};
-  if (args2.cwd !== void 0) {
-    if (typeof args2.cwd !== "string" || args2.cwd.length === 0)
-      throw new Error("cwd must be a string");
-    parsed.cwd = args2.cwd;
-  }
-  if (args2.fix !== void 0) {
-    if (typeof args2.fix !== "boolean") throw new Error("fix must be a boolean");
-    parsed.fix = args2.fix;
-  }
-  return parsed;
-}
-function jsonRpcError(id, code, message) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    error: { code, message }
-  };
-}
-function textResult(id, text4) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    result: {
-      content: [{ type: "text", text: text4 }]
-    }
-  };
-}
-async function runCli(args2, cwd) {
-  const entry = process.argv[1];
-  if (!entry) {
-    throw new Error("Unable to resolve CLI entrypoint");
-  }
-  await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(process.execPath, [entry, ...args2], {
-      cwd: cwd ?? process.cwd(),
-      stdio: ["ignore", "pipe", "pipe"],
-      env: process.env
-    });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", rejectPromise);
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolvePromise();
-      } else {
-        rejectPromise(
-          new Error(stderr.trim() || `Command failed with exit code ${code}`)
-        );
-      }
-    });
-  });
-}
-function defaultActions() {
-  return {
-    scaffold: async ({
-      name,
-      components,
-      git,
-      install,
-      packageManager,
-      cwd
-    }) => {
-      const cmd = [name];
-      if (components && components.length > 0) {
-        cmd.push("--components", components.join(","));
-      }
-      if (packageManager) {
-        cmd.push("--package-manager", packageManager);
-      }
-      if (git === false) cmd.push("--no-git");
-      if (install === false) cmd.push("--no-install");
-      await runCli(cmd, cwd);
-    },
-    add: async ({ components, cwd, install }) => {
-      const cmd = ["add", ...components];
-      if (install === false) cmd.push("--no-install");
-      await runCli(cmd, cwd);
-    },
-    update: async ({ cwd }) => {
-      await runCli(["update"], cwd);
-    },
-    doctor: async ({ cwd, fix }) => {
-      const cmd = ["doctor"];
-      if (fix) cmd.push("--fix");
-      await runCli(cmd, cwd);
-    }
-  };
-}
-async function handleMcpRequest(request, actions) {
-  if (request.jsonrpc !== "2.0") {
-    return jsonRpcError(request.id, -32600, "Invalid Request");
-  }
-  const effectiveActions = {
-    ...defaultActions(),
-    ...actions
-  };
-  try {
-    if (request.method === "initialize") {
-      return {
-        jsonrpc: "2.0",
-        id: request.id,
-        result: {
-          protocolVersion: MCP_PROTOCOL_VERSION,
-          capabilities: { tools: {} },
-          serverInfo: { name: "projx", version: "1.0.0" }
-        }
-      };
-    }
-    if (request.method === "tools/list") {
-      return {
-        jsonrpc: "2.0",
-        id: request.id,
-        result: { tools: TOOL_DEFS }
-      };
-    }
-    if (request.method === "tools/call") {
-      const params = ensureObject(request.params);
-      const toolName = params.name;
-      const toolArgs = params.arguments;
-      if (typeof toolName !== "string") {
-        return jsonRpcError(request.id, -32602, "name must be a string");
-      }
-      if (toolName === "projx_scaffold") {
-        const parsed = parseScaffoldArgs(toolArgs);
-        await effectiveActions.scaffold(parsed);
-        return textResult(request.id, `Created project ${parsed.name}`);
-      }
-      if (toolName === "projx_scaffold_fullstack") {
-        const parsed = parseScaffoldFullstackArgs(toolArgs);
-        const components = [parsed.backend];
-        if (parsed.includeFrontend) components.push("frontend");
-        if (parsed.includeMobile) components.push("mobile");
-        if (parsed.includeE2E) components.push("e2e");
-        if (parsed.includeInfra) components.push("infra");
-        await effectiveActions.scaffold({
-          name: parsed.projectName,
-          components,
-          git: parsed.initGit,
-          install: parsed.installDeps,
-          packageManager: parsed.packageManager,
-          cwd: parsed.cwd
-        });
-        return textResult(
-          request.id,
-          `Successfully scaffolded ${parsed.projectName} with ${parsed.backend}. Files are located at ./${parsed.projectName}`
-        );
-      }
-      if (toolName === "projx_add_components") {
-        const parsed = parseAddArgs(toolArgs);
-        await effectiveActions.add(parsed);
-        return textResult(
-          request.id,
-          `Added components: ${parsed.components.join(", ")}`
-        );
-      }
-      if (toolName === "projx_update") {
-        const parsed = parseUpdateArgs(toolArgs);
-        await effectiveActions.update(parsed);
-        return textResult(request.id, "Updated projx scaffolding");
-      }
-      if (toolName === "projx_doctor") {
-        const parsed = parseDoctorArgs(toolArgs);
-        await effectiveActions.doctor(parsed);
-        return textResult(request.id, "Doctor check completed");
-      }
-      return jsonRpcError(request.id, -32602, `Unknown tool: ${toolName}`);
-    }
-    if (request.method === "ping") {
-      return {
-        jsonrpc: "2.0",
-        id: request.id,
-        result: { ok: true }
-      };
-    }
-    return jsonRpcError(
-      request.id,
-      -32601,
-      `Method not found: ${request.method}`
-    );
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return jsonRpcError(request.id, -32602, message);
-  }
-}
-function writeMessage(msg) {
-  const payload = JSON.stringify(msg);
-  const length = Buffer.byteLength(payload, "utf8");
-  process.stdout.write(`Content-Length: ${length}\r
-\r
-${payload}`);
-}
-function startMcpServer() {
-  let buffer = Buffer.alloc(0);
-  process.stdin.on("data", (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
-    while (true) {
-      const headerEnd = buffer.indexOf("\r\n\r\n");
-      if (headerEnd === -1) break;
-      const header = buffer.subarray(0, headerEnd).toString("utf8");
-      const lengthMatch = header.match(/content-length:\s*(\d+)/i);
-      if (!lengthMatch) {
-        buffer = buffer.subarray(headerEnd + 4);
-        continue;
-      }
-      const contentLength = Number(lengthMatch[1]);
-      const bodyStart = headerEnd + 4;
-      const bodyEnd = bodyStart + contentLength;
-      if (buffer.length < bodyEnd) break;
-      const body = buffer.subarray(bodyStart, bodyEnd).toString("utf8");
-      buffer = buffer.subarray(bodyEnd);
-      let request;
-      try {
-        request = JSON.parse(body);
-      } catch {
-        writeMessage(jsonRpcError(void 0, -32700, "Parse error"));
-        continue;
-      }
-      void handleMcpRequest(request).then((response) => {
-        if (request.id !== void 0) {
-          writeMessage(response);
-        }
-      });
-    }
-  });
-  process.stdin.resume();
-}
-
 // src/index.ts
 var args = process.argv.slice(2);
 function parseArgs() {
@@ -3702,21 +3361,12 @@ function parseArgs() {
       command = "sync";
       continue;
     }
-    if (arg === "mcp" && !name) {
-      command = "mcp";
-      continue;
-    }
     if (arg === "--components") {
       const val = args[++i];
       if (val) {
-        options.components = val.split(",").filter((c) => COMPONENTS.includes(c));
-      }
-      continue;
-    }
-    if (arg === "--package-manager" || arg === "--pm") {
-      const val = args[++i];
-      if (val && PACKAGE_MANAGERS.includes(val)) {
-        options.packageManager = val;
+        options.components = val.split(",").filter(
+          (c) => COMPONENTS.includes(c)
+        );
       }
       continue;
     }
@@ -3790,11 +3440,9 @@ function printHelp() {
     projx doctor [--fix]          Health check for projx project
     projx gen entity <name>       Generate a new entity
     projx sync [--url <url>]      Sync types from running backend
-    projx mcp                     Start MCP server over stdio
 
   Options:
     --components <list>  Comma-separated: fastapi,fastify,frontend,mobile,e2e,infra
-    --package-manager    One of: npm, pnpm, yarn, bun
     --no-git             Skip git init
     --no-install         Skip dependency installation
     -y, --yes            Accept defaults (fastify + frontend + e2e)
@@ -3829,9 +3477,7 @@ async function main() {
       (c) => COMPONENTS.includes(c)
     );
     if (components.length === 0) {
-      console.error(
-        `Error: specify components to add. Available: ${COMPONENTS.join(", ")}`
-      );
+      console.error(`Error: specify components to add. Available: ${COMPONENTS.join(", ")}`);
       process.exit(1);
     }
     await add(process.cwd(), components, localRepo, options.install === false);
@@ -3847,9 +3493,7 @@ async function main() {
   }
   if (command === "unpin") {
     if (extraArgs.length === 0) {
-      console.error(
-        "Error: specify patterns to unpin. Usage: projx unpin <patterns...>"
-      );
+      console.error("Error: specify patterns to unpin. Usage: projx unpin <patterns...>");
       process.exit(1);
     }
     await unpin(process.cwd(), extraArgs);
@@ -3869,16 +3513,10 @@ async function main() {
     await sync(process.cwd(), url);
     return;
   }
-  if (command === "mcp") {
-    startMcpServer();
-    return;
-  }
   if (command === "gen") {
     const subcommand = extraArgs[0];
     if (subcommand !== "entity" || !extraArgs[1]) {
-      console.error(
-        'Usage: projx gen entity <name> [--fields "name:string,amount:number"]'
-      );
+      console.error('Usage: projx gen entity <name> [--fields "name:string,amount:number"]');
       process.exit(1);
     }
     const entityName = extraArgs[1];
@@ -3898,14 +3536,12 @@ async function main() {
       name,
       components: options.components,
       git: options.git ?? true,
-      install: options.install ?? true,
-      packageManager: options.packageManager
+      install: options.install ?? true
     };
   } else {
     opts = await runPrompts(name);
     opts.git = options.git ?? opts.git;
     opts.install = options.install ?? opts.install;
-    opts.packageManager = options.packageManager ?? opts.packageManager;
   }
   const dest = resolve2(process.cwd(), opts.name);
   if (existsSync13(dest)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-projx",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Scaffold production-grade fullstack projects in seconds. FastAPI, Fastify, React, Flutter, Terraform — with auth, database, CI/CD, E2E tests, and Docker. One command, ready to deploy.",
   "type": "module",
   "bin": {

package/src/templates/README.md.ejs

@@ -96,14 +96,6 @@ cd <%= paths.e2e %> && <%= pm.exec %> playwright test
 npx create-projx@latest update
 ```
 
-## MCP
-
-This project includes a root `.mcp.json` for local MCP stdio usage with compatible AI agents.
-
-```bash
-npx create-projx mcp
-```
-
 ---
 
 [![Built with Projx](https://img.shields.io/badge/Built%20with-Projx-blue)](https://github.com/ukanhaupa/projx)