create-projx 1.3.6 → 1.4.0

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { resolve as resolve2 } from "path";
 
 // src/utils.ts
 import { execSync } from "child_process";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { cp, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import { join, resolve } from "path";
 import { tmpdir } from "os";
@@ -27,6 +27,9 @@ function toKebab(s) {
 function toSnake(s) {
   return toKebab(s).replace(/-/g, "_");
 }
+function toTitle(s) {
+  return s.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
 function hasCommand(cmd) {
   try {
     execSync(`command -v ${cmd}`, { stdio: "ignore" });
@@ -277,8 +280,8 @@ function render(template, vars) {
       (_, expr) => {
         const parts = expr.split(".");
         let val = vars;
-        for (const p6 of parts) {
-          val = val?.[p6];
+        for (const p11 of parts) {
+          val = val?.[p11];
         }
         return String(val ?? "");
       }
@@ -287,6 +290,23 @@ function render(template, vars) {
   }
   return output.join("\n").replace(/\n{3,}/g, "\n\n");
 }
+function detectProjectName(cwd, components, componentPaths) {
+  for (const component of components) {
+    const dir = componentPaths[component] ?? component;
+    const pkgPath = join(cwd, dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const n = pkg.name;
+        if (n && n.includes("-")) {
+          return n.substring(0, n.lastIndexOf("-"));
+        }
+      } catch {
+      }
+    }
+  }
+  return toKebab(cwd.split("/").pop());
+}
 
 // src/prompts.ts
 import * as p from "@clack/prompts";
@@ -475,10 +495,10 @@ function mergeFileThreeWay(oursPath, baseContent, theirsContent) {
   }
 }
 async function collectAllFiles(dir, base) {
-  const { readdir: readdir3 } = await import("fs/promises");
+  const { readdir: readdir4 } = await import("fs/promises");
   const results = [];
   const walk = async (current) => {
-    const entries = await readdir3(current, { withFileTypes: true });
+    const entries = await readdir4(current, { withFileTypes: true });
     for (const entry of entries) {
       const full = join3(current, entry.name);
       if (entry.isDirectory()) {
@@ -549,9 +569,9 @@ function cleanupWorktree(cwd, worktree, branch) {
 }
 async function removeSkippedFiles(dir, skipPatterns) {
   if (skipPatterns.length === 0) return;
-  const { readdir: readdir3, unlink: unlink2 } = await import("fs/promises");
+  const { readdir: readdir4, unlink: unlink2 } = await import("fs/promises");
   const walk = async (current, base) => {
-    const entries = await readdir3(current, { withFileTypes: true });
+    const entries = await readdir4(current, { withFileTypes: true });
     for (const entry of entries) {
       const full = join3(current, entry.name);
       const rel = full.slice(base.length + 1);
@@ -657,8 +677,8 @@ async function applyTemplate(cwd, repoDir, components, componentPaths, vars, ver
   try {
     await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
     execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
-    const diff = execSync2("git diff --cached --stat", { cwd: worktree, stdio: "pipe" }).toString().trim();
-    if (!diff) {
+    const diff2 = execSync2("git diff --cached --stat", { cwd: worktree, stdio: "pipe" }).toString().trim();
+    if (!diff2) {
       cleanupWorktree(cwd, worktree, branch);
       return { status: "clean" };
     }
@@ -773,10 +793,10 @@ async function scaffold(opts, dest, localRepo) {
       exec("git init", dest);
       exec("git config core.hooksPath .githooks", dest);
     }
-    const spinner5 = p2.spinner();
-    spinner5.start("Scaffolding project");
+    const spinner7 = p2.spinner();
+    spinner7.start("Scaffolding project");
     await applyTemplate(dest, repoDir, opts.components, paths, vars, version);
-    spinner5.stop("Scaffold complete.");
+    spinner7.stop("Scaffold complete.");
     if (opts.install) {
       await installDeps(dest, opts.components);
     }
@@ -801,44 +821,44 @@ async function scaffold(opts, dest, localRepo) {
 }
 async function installDeps(dest, components) {
   for (const component of components) {
-    const spinner5 = p2.spinner();
+    const spinner7 = p2.spinner();
     try {
       switch (component) {
         case "fastapi":
           if (hasCommand("uv")) {
-            spinner5.start("Installing FastAPI dependencies (uv sync)");
+            spinner7.start("Installing FastAPI dependencies (uv sync)");
             exec("uv sync --all-extras", join4(dest, "fastapi"));
-            spinner5.stop("FastAPI dependencies installed.");
+            spinner7.stop("FastAPI dependencies installed.");
           } else {
             p2.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
           if (hasCommand("pnpm")) {
-            spinner5.start("Installing Fastify dependencies (pnpm install)");
+            spinner7.start("Installing Fastify dependencies (pnpm install)");
             exec("pnpm install", join4(dest, "fastify"));
-            spinner5.stop("Fastify dependencies installed.");
+            spinner7.stop("Fastify dependencies installed.");
           } else {
-            spinner5.start("Installing Fastify dependencies (npm install)");
+            spinner7.start("Installing Fastify dependencies (npm install)");
             exec("npm install", join4(dest, "fastify"));
-            spinner5.stop("Fastify dependencies installed.");
+            spinner7.stop("Fastify dependencies installed.");
           }
           break;
         case "frontend":
-          spinner5.start("Installing Frontend dependencies (npm install)");
+          spinner7.start("Installing Frontend dependencies (npm install)");
           exec("npm install", join4(dest, "frontend"));
-          spinner5.stop("Frontend dependencies installed.");
+          spinner7.stop("Frontend dependencies installed.");
           break;
         case "e2e":
-          spinner5.start("Installing E2E dependencies (npm install)");
+          spinner7.start("Installing E2E dependencies (npm install)");
           exec("npm install", join4(dest, "e2e"));
-          spinner5.stop("E2E dependencies installed.");
+          spinner7.stop("E2E dependencies installed.");
           break;
         case "mobile":
           if (hasCommand("flutter")) {
-            spinner5.start("Installing Flutter dependencies");
+            spinner7.start("Installing Flutter dependencies");
             exec("flutter pub get", join4(dest, "mobile"));
-            spinner5.stop("Flutter dependencies installed.");
+            spinner7.stop("Flutter dependencies installed.");
           } else {
             p2.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
@@ -847,7 +867,7 @@ async function installDeps(dest, components) {
           break;
       }
     } catch {
-      spinner5.stop(`Failed to install ${component} dependencies.`);
+      spinner7.stop(`Failed to install ${component} dependencies.`);
     }
   }
 }
@@ -865,7 +885,7 @@ function copyEnvExamples(dest, components) {
 }
 
 // src/update.ts
-import { existsSync as existsSync4, readFileSync } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { readFile as readFile5, writeFile as writeFile3, unlink } from "fs/promises";
 import { execSync as execSync3 } from "child_process";
 import { join as join5 } from "path";
@@ -926,11 +946,11 @@ async function update(cwd, localRepo) {
     const version = pkg.version;
     const name = detectProjectName(cwd, config.components, componentPaths);
     const vars = { projectName: name, components: config.components, paths: componentPaths };
-    const spinner5 = p3.spinner();
-    spinner5.start("Applying template update");
+    const spinner7 = p3.spinner();
+    spinner7.start("Applying template update");
     const rootSkip = config.skip ?? [];
     const result = await applyTemplate(cwd, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips, rootSkip);
-    spinner5.stop("Template applied.");
+    spinner7.stop("Template applied.");
     if (result.status === "merged") {
       saveBaselineRef(cwd);
       p3.log.success(`${result.mergedFiles?.length ?? 0} file(s) merged cleanly.`);
@@ -1077,26 +1097,9 @@ async function learnSkips(cwd, files, componentPaths) {
     }
   }
 }
-function detectProjectName(cwd, components, componentPaths) {
-  for (const component of components) {
-    const dir = componentPaths[component] ?? component;
-    const pkgPath = join5(cwd, dir, "package.json");
-    if (existsSync4(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const n = pkg.name;
-        if (n && n.includes("-")) {
-          return n.substring(0, n.lastIndexOf("-"));
-        }
-      } catch {
-      }
-    }
-  }
-  return toKebab(cwd.split("/").pop());
-}
 
 // src/add.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync5 } from "fs";
 import { readFile as readFile6 } from "fs/promises";
 import { join as join6 } from "path";
 import * as p4 from "@clack/prompts";
@@ -1133,14 +1136,14 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
     const existingPaths = await discoverComponentPaths(cwd, existing);
     const paths = { ...existingPaths };
     for (const c of toAdd) paths[c] = c;
-    const name = detectProjectName2(cwd, existing, paths);
+    const name = detectProjectName(cwd, existing, paths);
     const vars = { projectName: name, components: allComponents, paths };
     const pkg = JSON.parse(await readFile6(join6(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    const spinner5 = p4.spinner();
-    spinner5.start("Adding components");
+    const spinner7 = p4.spinner();
+    spinner7.start("Adding components");
     await writeTemplateToDir(cwd, repoDir, allComponents, paths, vars, version, "scaffold");
-    spinner5.stop("Components added.");
+    spinner7.stop("Components added.");
     if (!skipInstall) {
       await installDeps2(cwd, toAdd);
     }
@@ -1163,44 +1166,44 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
 }
 async function installDeps2(dest, components) {
   for (const component of components) {
-    const spinner5 = p4.spinner();
+    const spinner7 = p4.spinner();
     try {
       switch (component) {
         case "fastapi":
           if (hasCommand("uv")) {
-            spinner5.start("Installing FastAPI dependencies");
+            spinner7.start("Installing FastAPI dependencies");
             exec("uv sync --all-extras", join6(dest, "fastapi"));
-            spinner5.stop("FastAPI dependencies installed.");
+            spinner7.stop("FastAPI dependencies installed.");
           } else {
             p4.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
           if (hasCommand("pnpm")) {
-            spinner5.start("Installing Fastify dependencies");
+            spinner7.start("Installing Fastify dependencies");
             exec("pnpm install", join6(dest, "fastify"));
-            spinner5.stop("Fastify dependencies installed.");
+            spinner7.stop("Fastify dependencies installed.");
           } else {
-            spinner5.start("Installing Fastify dependencies");
+            spinner7.start("Installing Fastify dependencies");
             exec("npm install", join6(dest, "fastify"));
-            spinner5.stop("Fastify dependencies installed.");
+            spinner7.stop("Fastify dependencies installed.");
           }
           break;
         case "frontend":
-          spinner5.start("Installing Frontend dependencies");
+          spinner7.start("Installing Frontend dependencies");
           exec("npm install", join6(dest, "frontend"));
-          spinner5.stop("Frontend dependencies installed.");
+          spinner7.stop("Frontend dependencies installed.");
           break;
         case "e2e":
-          spinner5.start("Installing E2E dependencies");
+          spinner7.start("Installing E2E dependencies");
           exec("npm install", join6(dest, "e2e"));
-          spinner5.stop("E2E dependencies installed.");
+          spinner7.stop("E2E dependencies installed.");
           break;
         case "mobile":
           if (hasCommand("flutter")) {
-            spinner5.start("Installing Flutter dependencies");
+            spinner7.start("Installing Flutter dependencies");
             exec("flutter pub get", join6(dest, "mobile"));
-            spinner5.stop("Flutter dependencies installed.");
+            spinner7.stop("Flutter dependencies installed.");
           } else {
             p4.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
@@ -1209,27 +1212,10 @@ async function installDeps2(dest, components) {
           break;
       }
     } catch {
-      spinner5.stop(`Failed to install ${component} dependencies.`);
+      spinner7.stop(`Failed to install ${component} dependencies.`);
     }
   }
 }
-function detectProjectName2(cwd, components, paths) {
-  for (const component of components) {
-    const dir = paths[component] ?? component;
-    const pkgPath = join6(cwd, dir, "package.json");
-    if (existsSync5(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-        const n = pkg.name;
-        if (n && n.includes("-")) {
-          return n.substring(0, n.lastIndexOf("-"));
-        }
-      } catch {
-      }
-    }
-  }
-  return toKebab(cwd.split("/").pop());
-}
 
 // src/init.ts
 import { existsSync as existsSync7 } from "fs";
@@ -1338,10 +1324,10 @@ async function init(cwd, localRepo) {
     p5.log.error("You have uncommitted changes. Commit or stash them first.");
     process.exit(1);
   }
-  const spinner5 = p5.spinner();
-  spinner5.start("Scanning for components");
+  const spinner7 = p5.spinner();
+  spinner7.start("Scanning for components");
   const detected = await detectComponents(cwd);
-  spinner5.stop(
+  spinner7.stop(
     detected.length > 0 ? `Found ${detected.length} component(s).` : "No components detected."
   );
   let confirmed;
@@ -1461,6 +1447,1582 @@ function hasUncommittedChanges2(cwd) {
   }
 }
 
+// src/pin.ts
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import { join as join9 } from "path";
+import * as p6 from "@clack/prompts";
+function classifyPattern(pattern, componentPaths) {
+  const dirToComponent = {};
+  for (const [component, dir] of Object.entries(componentPaths)) {
+    dirToComponent[dir] = component;
+  }
+  for (const [dir, component] of Object.entries(dirToComponent)) {
+    if (pattern.startsWith(dir + "/")) {
+      return {
+        scope: "component",
+        component,
+        relative: pattern.slice(dir.length + 1)
+      };
+    }
+  }
+  return { scope: "root", relative: pattern };
+}
+async function pin(cwd, patterns) {
+  p6.intro("projx pin");
+  const configPath = join9(cwd, ".projx");
+  if (!existsSync8(configPath)) {
+    p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
+    process.exit(1);
+  }
+  const config = JSON.parse(await readFile8(configPath, "utf-8"));
+  const componentPaths = await discoverComponentPaths(cwd, config.components);
+  const rootAdds = [];
+  const componentAdds = {};
+  for (const pattern of patterns) {
+    if (pattern === ".projx" || pattern.endsWith(COMPONENT_MARKER)) {
+      p6.log.warn(`Cannot pin ${pattern} \u2014 config files are managed by projx.`);
+      continue;
+    }
+    const { scope, component, relative } = classifyPattern(pattern, componentPaths);
+    if (scope === "component" && component) {
+      if (!componentAdds[component]) componentAdds[component] = [];
+      componentAdds[component].push(relative);
+    } else {
+      rootAdds.push(relative);
+    }
+  }
+  for (const [component, additions] of Object.entries(componentAdds)) {
+    const dir = componentPaths[component];
+    const markerPath = join9(cwd, dir, COMPONENT_MARKER);
+    try {
+      const data = JSON.parse(await readFile8(markerPath, "utf-8"));
+      const existing = data.skip ?? [];
+      const merged = [.../* @__PURE__ */ new Set([...existing, ...additions])];
+      const added = merged.length - existing.length;
+      if (added > 0) {
+        data.skip = merged;
+        await writeFile4(markerPath, JSON.stringify(data, null, 2) + "\n");
+        p6.log.success(`${component}: pinned ${additions.join(", ")}`);
+      } else {
+        p6.log.info(`${component}: already pinned.`);
+      }
+    } catch {
+      p6.log.error(`Could not read marker for ${component}.`);
+    }
+  }
+  if (rootAdds.length > 0) {
+    const existing = config.skip ?? [];
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...rootAdds])];
+    const added = merged.length - existing.length;
+    if (added > 0) {
+      config.skip = merged;
+      await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n");
+      p6.log.success(`root: pinned ${rootAdds.join(", ")}`);
+    } else {
+      p6.log.info("root: already pinned.");
+    }
+  }
+  p6.outro("Skip list updated.");
+}
+async function unpin(cwd, patterns) {
+  p6.intro("projx unpin");
+  const configPath = join9(cwd, ".projx");
+  if (!existsSync8(configPath)) {
+    p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
+    process.exit(1);
+  }
+  const config = JSON.parse(await readFile8(configPath, "utf-8"));
+  const componentPaths = await discoverComponentPaths(cwd, config.components);
+  const rootRemoves = [];
+  const componentRemoves = {};
+  for (const pattern of patterns) {
+    const { scope, component, relative } = classifyPattern(pattern, componentPaths);
+    if (scope === "component" && component) {
+      if (!componentRemoves[component]) componentRemoves[component] = [];
+      componentRemoves[component].push(relative);
+    } else {
+      rootRemoves.push(relative);
+    }
+  }
+  for (const [component, removals] of Object.entries(componentRemoves)) {
+    const dir = componentPaths[component];
+    const markerPath = join9(cwd, dir, COMPONENT_MARKER);
+    try {
+      const data = JSON.parse(await readFile8(markerPath, "utf-8"));
+      const existing = data.skip ?? [];
+      const filtered = existing.filter((s) => !removals.includes(s));
+      const removed = existing.length - filtered.length;
+      if (removed > 0) {
+        if (filtered.length > 0) {
+          data.skip = filtered;
+        } else {
+          delete data.skip;
+        }
+        await writeFile4(markerPath, JSON.stringify(data, null, 2) + "\n");
+        p6.log.success(`${component}: unpinned ${removals.join(", ")}`);
+      } else {
+        p6.log.info(`${component}: not found in skip list.`);
+      }
+    } catch {
+      p6.log.error(`Could not read marker for ${component}.`);
+    }
+  }
+  if (rootRemoves.length > 0) {
+    const existing = config.skip ?? [];
+    const filtered = existing.filter((s) => !rootRemoves.includes(s));
+    const removed = existing.length - filtered.length;
+    if (removed > 0) {
+      if (filtered.length > 0) {
+        config.skip = filtered;
+      } else {
+        delete config.skip;
+      }
+      await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n");
+      p6.log.success(`root: unpinned ${rootRemoves.join(", ")}`);
+    } else {
+      p6.log.info("root: not found in skip list.");
+    }
+  }
+  p6.outro("Skip list updated.");
+}
+async function listPins(cwd) {
+  p6.intro("projx pin --list");
+  const configPath = join9(cwd, ".projx");
+  if (!existsSync8(configPath)) {
+    p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
+    process.exit(1);
+  }
+  const config = JSON.parse(await readFile8(configPath, "utf-8"));
+  const componentPaths = await discoverComponentPaths(cwd, config.components);
+  let hasAny = false;
+  if (config.skip && config.skip.length > 0) {
+    hasAny = true;
+    p6.log.info("root:");
+    for (const s of config.skip) {
+      p6.log.info(`  ${s}`);
+    }
+  }
+  for (const component of config.components) {
+    const dir = componentPaths[component];
+    const marker = await readComponentMarker(join9(cwd, dir));
+    if (marker?.skip && marker.skip.length > 0) {
+      hasAny = true;
+      const label = dir !== component ? `${component} (${dir}/)` : `${component}`;
+      p6.log.info(`${label}:`);
+      for (const s of marker.skip) {
+        p6.log.info(`  ${s}`);
+      }
+    }
+  }
+  if (!hasAny) {
+    p6.log.info("No pinned files. All template files will be updated.");
+  }
+  p6.outro("");
+}
+
+// src/doctor.ts
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile9, readdir as readdir3 } from "fs/promises";
+import { execSync as execSync5 } from "child_process";
+import { join as join10 } from "path";
+import * as p7 from "@clack/prompts";
+async function checkConfig(cwd) {
+  const results = [];
+  const configPath = join10(cwd, ".projx");
+  if (!existsSync9(configPath)) {
+    results.push({
+      name: ".projx exists",
+      status: "fail",
+      message: "No .projx file found.",
+      fix: "Run 'npx create-projx init' to initialize."
+    });
+    return { results };
+  }
+  let config;
+  try {
+    config = JSON.parse(await readFile9(configPath, "utf-8"));
+  } catch {
+    results.push({
+      name: ".projx valid JSON",
+      status: "fail",
+      message: ".projx contains invalid JSON."
+    });
+    return { results };
+  }
+  results.push({ name: ".projx exists", status: "pass", message: `v${config.version}` });
+  if (!config.version || !config.components || !Array.isArray(config.components)) {
+    results.push({
+      name: ".projx fields",
+      status: "fail",
+      message: "Missing required fields (version, components)."
+    });
+    return { results };
+  }
+  const invalid = config.components.filter((c) => !COMPONENTS.includes(c));
+  if (invalid.length > 0) {
+    results.push({
+      name: "component names",
+      status: "warn",
+      message: `Unknown components: ${invalid.join(", ")}`
+    });
+  } else {
+    results.push({ name: "component names", status: "pass", message: `${config.components.length} valid` });
+  }
+  return { results, config };
+}
+async function checkComponents(cwd, config, componentPaths) {
+  const results = [];
+  for (const component of config.components) {
+    const dir = componentPaths[component];
+    const fullDir = join10(cwd, dir);
+    if (!existsSync9(fullDir)) {
+      results.push({
+        name: `${component} directory`,
+        status: "fail",
+        message: `Directory ${dir}/ not found.`
+      });
+      continue;
+    }
+    const marker = await readComponentMarker(fullDir);
+    if (!marker) {
+      results.push({
+        name: `${component} marker`,
+        status: "fail",
+        message: `No ${COMPONENT_MARKER} in ${dir}/.`,
+        fix: `Run 'npx create-projx update' to regenerate markers.`
+      });
+      continue;
+    }
+    if (!marker.components.includes(component)) {
+      results.push({
+        name: `${component} marker`,
+        status: "warn",
+        message: `Marker in ${dir}/ does not list "${component}".`
+      });
+    } else {
+      const label = dir !== component ? `${dir}/ (${component})` : `${component}/`;
+      results.push({ name: `${component} marker`, status: "pass", message: label });
+    }
+  }
+  try {
+    const entries = await readdir3(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const markerPath = join10(cwd, entry.name, COMPONENT_MARKER);
+      if (!existsSync9(markerPath)) continue;
+      const isKnown = Object.values(componentPaths).includes(entry.name);
+      if (!isKnown) {
+        results.push({
+          name: `orphan marker`,
+          status: "warn",
+          message: `${entry.name}/ has a ${COMPONENT_MARKER} but is not in .projx components.`
+        });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function checkGit(cwd, fix) {
+  const results = [];
+  try {
+    execSync5("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    results.push({ name: "git repo", status: "pass", message: "OK" });
+  } catch {
+    results.push({ name: "git repo", status: "fail", message: "Not a git repository." });
+    return results;
+  }
+  try {
+    const ref = execSync5(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" }).toString().trim();
+    results.push({ name: "baseline ref", status: "pass", message: ref.slice(0, 8) });
+  } catch {
+    if (fix) {
+      saveBaselineRef(cwd);
+      try {
+        execSync5(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" });
+        results.push({ name: "baseline ref", status: "pass", message: "Created from git history." });
+      } catch {
+        results.push({
+          name: "baseline ref",
+          status: "warn",
+          message: "Missing. Could not auto-create.",
+          fix: "Run 'npx create-projx update' to establish baseline."
+        });
+      }
+    } else {
+      results.push({
+        name: "baseline ref",
+        status: "warn",
+        message: "Missing. Run 'projx doctor --fix' to create.",
+        autoFixable: true
+      });
+    }
+  }
+  try {
+    const worktrees = execSync5("git worktree list --porcelain", { cwd, stdio: "pipe" }).toString();
+    const stale = worktrees.split("\n").filter((l) => l.includes("projx-wt-") || l.includes("projx/tmp-"));
+    if (stale.length > 0) {
+      if (fix) {
+        execSync5("git worktree prune", { cwd, stdio: "pipe" });
+        results.push({ name: "worktrees", status: "pass", message: "Pruned stale worktrees." });
+      } else {
+        results.push({
+          name: "worktrees",
+          status: "warn",
+          message: "Stale projx worktrees found.",
+          fix: "Run 'projx doctor --fix' to prune.",
+          autoFixable: true
+        });
+      }
+    } else {
+      results.push({ name: "worktrees", status: "pass", message: "Clean" });
+    }
+  } catch {
+    results.push({ name: "worktrees", status: "pass", message: "OK" });
+  }
+  try {
+    const status = execSync5("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+    if (status) {
+      const count = status.split("\n").length;
+      results.push({ name: "working tree", status: "warn", message: `${count} uncommitted change(s).` });
+    } else {
+      results.push({ name: "working tree", status: "pass", message: "Clean" });
+    }
+  } catch {
+  }
+  return results;
+}
+async function checkSkipPatterns(cwd, config, componentPaths) {
+  const results = [];
+  if (config.skip && config.skip.length > 0) {
+    for (const pattern of config.skip) {
+      const matches = await patternMatchesAnything(cwd, pattern);
+      if (!matches) {
+        results.push({
+          name: "root skip",
+          status: "warn",
+          message: `"${pattern}" matches no files \u2014 stale?`
+        });
+      }
+    }
+  }
+  for (const component of config.components) {
+    const dir = componentPaths[component];
+    const marker = await readComponentMarker(join10(cwd, dir));
+    if (marker?.skip && marker.skip.length > 0) {
+      for (const pattern of marker.skip) {
+        const matches = await patternMatchesAnything(join10(cwd, dir), pattern);
+        if (!matches) {
+          results.push({
+            name: `${component} skip`,
+            status: "warn",
+            message: `"${pattern}" matches no files \u2014 stale?`
+          });
+        }
+      }
+    }
+  }
+  if (results.length === 0 && (config.skip?.length || config.components.some(() => true))) {
+    results.push({ name: "skip patterns", status: "pass", message: "All patterns match files." });
+  }
+  return results;
+}
+async function patternMatchesAnything(dir, pattern) {
+  if (pattern === "**") return true;
+  if (!existsSync9(dir)) return false;
+  const walk = async (current, base) => {
+    let entries;
+    try {
+      entries = await readdir3(current, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      const full = join10(current, entry.name);
+      const rel = full.slice(base.length + 1);
+      if (entry.isDirectory()) {
+        if (await walk(full, base)) return true;
+      } else if (matchesSkip(rel, [pattern])) {
+        return true;
+      }
+    }
+    return false;
+  };
+  return walk(dir, dir);
+}
+async function doctor(cwd, fix = false) {
+  p7.intro("projx doctor");
+  const allResults = [];
+  const { results: configResults, config } = await checkConfig(cwd);
+  allResults.push(...configResults);
+  if (!config) {
+    printReport(allResults);
+    process.exit(1);
+  }
+  const componentPaths = await discoverComponentPaths(cwd, config.components);
+  allResults.push(...await checkComponents(cwd, config, componentPaths));
+  allResults.push(...checkGit(cwd, fix));
+  allResults.push(...await checkSkipPatterns(cwd, config, componentPaths));
+  printReport(allResults);
+  const passed = allResults.filter((r) => r.status === "pass").length;
+  const warns = allResults.filter((r) => r.status === "warn").length;
+  const fails = allResults.filter((r) => r.status === "fail").length;
+  const fixable = allResults.filter((r) => r.autoFixable);
+  if (fixable.length > 0 && !fix) {
+    p7.log.info(`${fixable.length} issue(s) auto-fixable with --fix`);
+  }
+  p7.outro(`${passed} passed, ${warns} warning(s), ${fails} failed`);
+  if (fails > 0) process.exit(1);
+}
+function printReport(results) {
+  for (const r of results) {
+    const icon = r.status === "pass" ? "\u2713" : r.status === "warn" ? "\u26A0" : "\u2717";
+    const msg = `${icon} ${r.name} \u2014 ${r.message}`;
+    if (r.status === "pass") p7.log.success(msg);
+    else if (r.status === "warn") p7.log.warn(msg);
+    else p7.log.error(msg);
+    if (r.fix) p7.log.info(`  ${r.fix}`);
+  }
+}
+
+// src/diff.ts
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile10, mkdir as mkdir4, rm as rm3 } from "fs/promises";
+import { join as join11 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import * as p8 from "@clack/prompts";
+function isSkipped(file, componentPaths, componentSkips, rootSkip) {
+  for (const [component, dir] of Object.entries(componentPaths)) {
+    if (file.startsWith(dir + "/")) {
+      const relative = file.slice(dir.length + 1);
+      const skips = componentSkips[component] ?? [];
+      if (matchesSkip(relative, skips)) return true;
+    }
+  }
+  const base = file.split("/").pop();
+  if (base === ".projx" || base === ".projx-component") return false;
+  return matchesSkip(file, rootSkip);
+}
+function fileComponent(file, componentPaths) {
+  for (const [component, dir] of Object.entries(componentPaths)) {
+    if (file.startsWith(dir + "/")) return component;
+  }
+  return void 0;
+}
+async function diff(cwd, localRepo) {
+  p8.intro("projx diff");
+  const isLocal = !!localRepo;
+  const configPath = join11(cwd, ".projx");
+  if (!existsSync10(configPath)) {
+    p8.log.error("No .projx file found. Run 'npx create-projx init' first.");
+    process.exit(1);
+  }
+  const config = JSON.parse(await readFile10(configPath, "utf-8"));
+  const componentPaths = await discoverComponentPaths(cwd, config.components);
+  const componentSkips = {};
+  for (const component of config.components) {
+    const dir = componentPaths[component];
+    const marker = await readComponentMarker(join11(cwd, dir));
+    if (marker?.skip && marker.skip.length > 0) {
+      componentSkips[component] = marker.skip;
+    }
+  }
+  const rootSkip = config.skip ?? [];
+  const dlSpinner = p8.spinner();
+  dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
+  const repoDir = await downloadRepo(localRepo).catch((err) => {
+    dlSpinner.stop("Failed.");
+    p8.log.error(String(err));
+    process.exit(1);
+  });
+  dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
+  try {
+    const pkg = JSON.parse(await readFile10(join11(repoDir, "cli/package.json"), "utf-8"));
+    const version = pkg.version;
+    p8.log.info(`Current: v${config.version} \u2192 Template: v${version}`);
+    const name = detectProjectName(cwd, config.components, componentPaths);
+    const vars = { projectName: name, components: config.components, paths: componentPaths };
+    const spinner7 = p8.spinner();
+    spinner7.start("Analyzing changes");
+    const tmpTemplate = join11(tmpdir3(), `projx-diff-${Date.now()}`);
+    await mkdir4(tmpTemplate, { recursive: true });
+    await writeTemplateToDir(tmpTemplate, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips, rootSkip);
+    const baselineRef = getBaselineRef(cwd);
+    const templateFiles = await collectAllFiles(tmpTemplate, tmpTemplate);
+    const analyses = [];
+    for (const file of templateFiles) {
+      const component = fileComponent(file, componentPaths);
+      if (isSkipped(file, componentPaths, componentSkips, rootSkip)) {
+        analyses.push({ file, status: "skipped", component });
+        continue;
+      }
+      const oursPath = join11(cwd, file);
+      if (!existsSync10(oursPath)) {
+        analyses.push({ file, status: "new", component });
+        continue;
+      }
+      let oursContent;
+      let theirsContent;
+      try {
+        oursContent = await readFile10(oursPath, "utf-8");
+        theirsContent = await readFile10(join11(tmpTemplate, file), "utf-8");
+      } catch {
+        continue;
+      }
+      if (oursContent === theirsContent) {
+        analyses.push({ file, status: "unchanged", component });
+        continue;
+      }
+      if (!baselineRef) {
+        analyses.push({ file, status: "needs-merge", component });
+        continue;
+      }
+      const baseContent = getFileAtRef(cwd, baselineRef, file);
+      if (!baseContent) {
+        analyses.push({ file, status: "needs-merge", component });
+        continue;
+      }
+      if (oursContent === baseContent) {
+        analyses.push({ file, status: "clean-update", component });
+      } else if (theirsContent === baseContent) {
+        analyses.push({ file, status: "user-only", component });
+      } else {
+        analyses.push({ file, status: "needs-merge", component });
+      }
+    }
+    await rm3(tmpTemplate, { recursive: true, force: true });
+    spinner7.stop("Analysis complete.");
+    const groups = {
+      "new": [],
+      "clean-update": [],
+      "needs-merge": [],
+      "user-only": [],
+      "unchanged": [],
+      "skipped": []
+    };
+    for (const a of analyses) {
+      groups[a.status].push(a);
+    }
+    if (groups["new"].length > 0) {
+      p8.log.info(`New files (${groups["new"].length}):`);
+      for (const a of groups["new"]) p8.log.info(`  + ${a.file}`);
+    }
+    if (groups["clean-update"].length > 0) {
+      p8.log.success(`Clean updates \u2014 auto-merged (${groups["clean-update"].length}):`);
+      for (const a of groups["clean-update"]) p8.log.info(`  ~ ${a.file}`);
+    }
+    if (groups["needs-merge"].length > 0) {
+      p8.log.warn(`Needs merge \u2014 both sides changed (${groups["needs-merge"].length}):`);
+      for (const a of groups["needs-merge"]) p8.log.info(`  ! ${a.file}`);
+    }
+    if (groups["user-only"].length > 0) {
+      p8.log.info(`User-modified only \u2014 no template change (${groups["user-only"].length}):`);
+      for (const a of groups["user-only"]) p8.log.info(`  = ${a.file}`);
+    }
+    if (groups["skipped"].length > 0) {
+      p8.log.info(`Skipped (${groups["skipped"].length}):`);
+      for (const a of groups["skipped"]) p8.log.info(`  - ${a.file}`);
+    }
+    const unchanged = groups["unchanged"].length;
+    if (unchanged > 0) {
+      p8.log.info(`${unchanged} file(s) unchanged.`);
+    }
+    const total = analyses.length - unchanged;
+    if (total === 0) {
+      p8.outro("Everything is up to date.");
+    } else {
+      p8.outro(`${total} file(s) would be affected by update.`);
+    }
+  } finally {
+    await cleanupRepo(repoDir, isLocal);
+  }
+}
+
+// src/gen.ts
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile11, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { join as join12 } from "path";
+import * as p9 from "@clack/prompts";
+var FIELD_TYPES = ["string", "number", "boolean", "date", "datetime", "text", "json"];
+function toPascal(s) {
+  return s.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function pluralize(s) {
+  if (s.endsWith("s") || s.endsWith("x") || s.endsWith("z") || s.endsWith("sh") || s.endsWith("ch")) return s + "es";
+  if (s.endsWith("y") && !/[aeiou]y$/i.test(s)) return s.slice(0, -1) + "ies";
+  return s + "s";
+}
+async function promptEntityConfig(name) {
+  const snake = toSnake(name);
+  const tableName = pluralize(snake);
+  const kebab = toKebab(name);
+  const apiPrefix = "/" + pluralize(kebab);
+  const tbl = await p9.text({
+    message: "Table name",
+    placeholder: tableName,
+    defaultValue: tableName
+  });
+  if (p9.isCancel(tbl)) process.exit(0);
+  const prefix = await p9.text({
+    message: "API prefix",
+    placeholder: apiPrefix,
+    defaultValue: apiPrefix
+  });
+  if (p9.isCancel(prefix)) process.exit(0);
+  const readonly = await p9.confirm({
+    message: "Readonly?",
+    initialValue: false
+  });
+  if (p9.isCancel(readonly)) process.exit(0);
+  const softDelete = await p9.confirm({
+    message: "Soft delete?",
+    initialValue: false
+  });
+  if (p9.isCancel(softDelete)) process.exit(0);
+  const bulk = await p9.confirm({
+    message: "Bulk operations?",
+    initialValue: true
+  });
+  if (p9.isCancel(bulk)) process.exit(0);
+  const fields = [];
+  p9.log.info("Define fields (enter empty name to finish):");
+  while (true) {
+    const fieldName = await p9.text({
+      message: `Field ${fields.length + 1} name`,
+      placeholder: "done",
+      defaultValue: ""
+    });
+    if (p9.isCancel(fieldName)) process.exit(0);
+    if (!fieldName) break;
+    const fieldType = await p9.select({
+      message: `${fieldName} type`,
+      options: FIELD_TYPES.map((t) => ({ value: t, label: t })),
+      initialValue: "string"
+    });
+    if (p9.isCancel(fieldType)) process.exit(0);
+    const required = await p9.confirm({
+      message: `${fieldName} required?`,
+      initialValue: true
+    });
+    if (p9.isCancel(required)) process.exit(0);
+    fields.push({ name: toSnake(fieldName), type: fieldType, required });
+  }
+  if (fields.length === 0) {
+    p9.log.warn("No fields defined. Adding a default 'name' field.");
+    fields.push({ name: "name", type: "string", required: true });
+  }
+  const stringFields = fields.filter((f) => f.type === "string" || f.type === "text");
+  let searchableFields = [];
+  if (stringFields.length > 0) {
+    const selected = await p9.multiselect({
+      message: "Searchable fields",
+      options: stringFields.map((f) => ({ value: f.name, label: f.name })),
+      required: false
+    });
+    if (!p9.isCancel(selected)) {
+      searchableFields = selected;
+    }
+  }
+  return {
+    name,
+    tableName: tbl,
+    apiPrefix: prefix.startsWith("/") ? prefix : "/" + prefix,
+    readonly,
+    softDelete,
+    bulkOperations: bulk,
+    fields,
+    searchableFields
+  };
+}
+function parseFieldsFlag(raw) {
+  return raw.split(",").map((f) => {
+    const [nameType, ...rest] = f.trim().split(":");
+    const required = nameType.endsWith("!");
+    const name = toSnake(required ? nameType.slice(0, -1) : nameType);
+    const type = rest[0] || "string";
+    return { name, type, required: required || true };
+  });
+}
+function sqlalchemyType(type) {
+  switch (type) {
+    case "string":
+      return "String(255)";
+    case "number":
+      return "Integer";
+    case "boolean":
+      return "Boolean";
+    case "date":
+      return "Date";
+    case "datetime":
+      return "DateTime";
+    case "text":
+      return "Text";
+    case "json":
+      return "JSON";
+  }
+}
+function generateFastAPIModel(config) {
+  const className = toPascal(config.name);
+  const imports = /* @__PURE__ */ new Set(["Column"]);
+  for (const f of config.fields) {
+    switch (f.type) {
+      case "string":
+        imports.add("String");
+        break;
+      case "number":
+        imports.add("Integer");
+        break;
+      case "boolean":
+        imports.add("Boolean");
+        break;
+      case "date":
+        imports.add("Date");
+        break;
+      case "datetime":
+        imports.add("DateTime");
+        break;
+      case "text":
+        imports.add("Text");
+        break;
+      case "json":
+        imports.add("JSON");
+        break;
+    }
+  }
+  if (config.softDelete) imports.add("DateTime");
+  const importList = [...imports].sort().join(", ");
+  const lines = [];
+  lines.push(`from sqlalchemy import ${importList}`);
+  if (config.softDelete) {
+    lines.push(`from src.entities.base import BaseModel_, SoftDeleteMixin`);
+    lines.push("");
+    lines.push("");
+    lines.push(`class ${className}(SoftDeleteMixin, BaseModel_):`);
+  } else {
+    lines.push(`from src.entities.base import BaseModel_`);
+    lines.push("");
+    lines.push("");
+    lines.push(`class ${className}(BaseModel_):`);
+  }
+  lines.push(`    __tablename__ = "${config.tableName}"`);
+  lines.push(`    __api_prefix__ = "${config.apiPrefix}"`);
+  if (config.readonly) lines.push(`    __readonly__ = True`);
+  if (config.softDelete) lines.push(`    __soft_delete__ = True`);
+  if (!config.bulkOperations) lines.push(`    __bulk_operations__ = False`);
+  if (config.searchableFields.length > 0) {
+    const fields = config.searchableFields.map((f) => `"${f}"`).join(", ");
+    lines.push(`    __searchable_fields__ = {${fields}}`);
+  }
+  lines.push("");
+  for (const field of config.fields) {
+    const nullable = field.required ? "nullable=False" : "nullable=True";
+    lines.push(`    ${field.name} = Column(${sqlalchemyType(field.type)}, ${nullable})`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function typeboxType(type, required) {
+  const inner = (() => {
+    switch (type) {
+      case "string":
+        return "Type.String()";
+      case "number":
+        return "Type.Number()";
+      case "boolean":
+        return "Type.Boolean()";
+      case "date":
+        return "Type.String({ format: 'date' })";
+      case "datetime":
+        return "Type.String({ format: 'date-time' })";
+      case "text":
+        return "Type.String()";
+      case "json":
+        return "Type.Any()";
+    }
+  })();
+  if (!required) return `Type.Union([${inner}, Type.Null()])`;
+  return inner;
+}
+function typeboxOptional(type) {
+  switch (type) {
+    case "string":
+      return "Type.Optional(Type.String())";
+    case "number":
+      return "Type.Optional(Type.Number())";
+    case "boolean":
+      return "Type.Optional(Type.Boolean())";
+    case "date":
+      return "Type.Optional(Type.String({ format: 'date' }))";
+    case "datetime":
+      return "Type.Optional(Type.String({ format: 'date-time' }))";
+    case "text":
+      return "Type.Optional(Type.String())";
+    case "json":
+      return "Type.Optional(Type.Any())";
+  }
+}
+function fieldMetaType(type) {
+  switch (type) {
+    case "string":
+      return { type: "str", fieldType: "text" };
+    case "number":
+      return { type: "int", fieldType: "number" };
+    case "boolean":
+      return { type: "bool", fieldType: "boolean" };
+    case "date":
+      return { type: "date", fieldType: "date" };
+    case "datetime":
+      return { type: "datetime", fieldType: "datetime" };
+    case "text":
+      return { type: "str", fieldType: "textarea" };
+    case "json":
+      return { type: "dict", fieldType: "textarea" };
+  }
+}
+function prismaType(type, required) {
+  const nullable = required ? "" : "?";
+  switch (type) {
+    case "string":
+      return `String${nullable}   @db.VarChar(255)`;
+    case "number":
+      return `Int${nullable}`;
+    case "boolean":
+      return `Boolean${nullable}  @default(false)`;
+    case "date":
+      return `DateTime${nullable}`;
+    case "datetime":
+      return `DateTime${nullable}`;
+    case "text":
+      return `String${nullable}`;
+    case "json":
+      return `Json${nullable}`;
+  }
+}
+function generateFastifySchemas(config) {
+  const className = toPascal(config.name);
+  const lines = [];
+  lines.push(`import { Type, type Static } from '@sinclair/typebox';`);
+  lines.push("");
+  lines.push(`export const ${className}Schema = Type.Object({`);
+  lines.push(`  id: Type.String({ format: 'uuid' }),`);
+  for (const f of config.fields) {
+    lines.push(`  ${f.name}: ${typeboxType(f.type, f.required)},`);
+  }
+  lines.push(`  created_at: Type.String({ format: 'date-time' }),`);
+  lines.push(`  updated_at: Type.String({ format: 'date-time' }),`);
+  if (config.softDelete) lines.push(`  deleted_at: Type.Union([Type.String({ format: 'date-time' }), Type.Null()]),`);
+  lines.push(`});`);
+  lines.push("");
+  lines.push(`export type ${className} = Static<typeof ${className}Schema>;`);
+  lines.push("");
+  lines.push(`export const Create${className}Schema = Type.Object({`);
+  for (const f of config.fields) {
+    if (f.required) {
+      lines.push(`  ${f.name}: ${typeboxType(f.type, true)},`);
+    } else {
+      lines.push(`  ${f.name}: ${typeboxOptional(f.type)},`);
+    }
+  }
+  lines.push(`});`);
+  lines.push("");
+  lines.push(`export type Create${className} = Static<typeof Create${className}Schema>;`);
+  lines.push("");
+  lines.push(`export const Update${className}Schema = Type.Object({`);
+  for (const f of config.fields) {
+    lines.push(`  ${f.name}: ${typeboxOptional(f.type)},`);
+  }
+  lines.push(`});`);
+  lines.push("");
+  lines.push(`export type Update${className} = Static<typeof Update${className}Schema>;`);
+  lines.push("");
+  return lines.join("\n");
+}
+function generateFastifyIndex(config) {
+  const className = toPascal(config.name);
+  const camelConfig = className.charAt(0).toLowerCase() + className.slice(1) + "Config";
+  const allColumns = ["id", ...config.fields.map((f) => f.name), "created_at", "updated_at"];
+  if (config.softDelete) allColumns.push("deleted_at");
+  const lines = [];
+  lines.push(`import { EntityRegistry, type EntityConfig, type FieldMeta } from '../_base/index.js';`);
+  lines.push(`import { ${className}Schema, Create${className}Schema, Update${className}Schema } from './schemas.js';`);
+  lines.push("");
+  lines.push(`const fields: FieldMeta[] = [`);
+  lines.push(`  { key: 'id', label: 'Id', type: 'str', nullable: false, is_auto: true, is_primary_key: true, filterable: true, has_foreign_key: false, field_type: 'text' },`);
+  for (const f of config.fields) {
+    const meta = fieldMetaType(f.type);
+    lines.push(`  { key: '${f.name}', label: '${toTitle(f.name)}', type: '${meta.type}', nullable: ${!f.required}, is_auto: false, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: '${meta.fieldType}' },`);
+  }
+  lines.push(`  { key: 'created_at', label: 'Created At', type: 'datetime', nullable: false, is_auto: true, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: 'datetime' },`);
+  lines.push(`  { key: 'updated_at', label: 'Updated At', type: 'datetime', nullable: false, is_auto: true, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: 'datetime' },`);
+  if (config.softDelete) {
+    lines.push(`  { key: 'deleted_at', label: 'Deleted At', type: 'datetime', nullable: true, is_auto: true, is_primary_key: false, filterable: true, has_foreign_key: false, field_type: 'datetime' },`);
+  }
+  lines.push(`];`);
+  lines.push("");
+  const tags = config.apiPrefix.replace(/^\//, "");
+  lines.push(`export const ${camelConfig}: EntityConfig = {`);
+  lines.push(`  name: '${className}',`);
+  lines.push(`  tableName: '${config.tableName}',`);
+  lines.push(`  prismaModel: '${className}',`);
+  lines.push(`  apiPrefix: '${config.apiPrefix}',`);
+  lines.push(`  tags: ['${tags}'],`);
+  lines.push(`  readonly: ${config.readonly},`);
+  lines.push(`  softDelete: ${config.softDelete},`);
+  lines.push(`  bulkOperations: ${config.bulkOperations},`);
+  lines.push(`  columnNames: [${allColumns.map((c) => `'${c}'`).join(", ")}],`);
+  if (config.searchableFields.length > 0) {
+    lines.push(`  searchableFields: [${config.searchableFields.map((f) => `'${f}'`).join(", ")}],`);
+  } else {
+    lines.push(`  searchableFields: [],`);
+  }
+  lines.push(`  fields,`);
+  lines.push(`  schema: ${className}Schema,`);
+  lines.push(`  createSchema: Create${className}Schema,`);
+  lines.push(`  updateSchema: Update${className}Schema,`);
+  lines.push(`};`);
+  lines.push("");
+  lines.push(`EntityRegistry.register(${camelConfig});`);
+  lines.push("");
+  return lines.join("\n");
+}
+function generatePrismaModel(config) {
+  const className = toPascal(config.name);
+  const lines = [];
+  lines.push(`model ${className} {`);
+  lines.push(`  id         String   @id @default(uuid())`);
+  for (const f of config.fields) {
+    const padded = f.name.padEnd(10);
+    lines.push(`  ${padded} ${prismaType(f.type, f.required)}`);
+  }
+  if (config.softDelete) {
+    lines.push(`  deleted_at DateTime?`);
+  }
+  lines.push(`  created_at DateTime @default(now())`);
+  lines.push(`  updated_at DateTime @updatedAt`);
+  lines.push("");
+  for (const sf of config.searchableFields) {
+    lines.push(`  @@index([${sf}])`);
+  }
+  lines.push(`  @@map("${config.tableName}")`);
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function tsType(type, required) {
+  const base = (() => {
+    switch (type) {
+      case "string":
+      case "text":
+      case "date":
+      case "datetime":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "json":
+        return "Record<string, unknown>";
+    }
+  })();
+  return required ? base : `${base} | null`;
+}
+function generateFrontendInterface(config) {
+  const className = toPascal(config.name);
+  const lines = [];
+  lines.push(`export interface ${className} {`);
+  lines.push(`  id: string;`);
+  for (const f of config.fields) {
+    lines.push(`  ${f.name}: ${tsType(f.type, f.required)};`);
+  }
+  if (config.softDelete) lines.push(`  deleted_at: string | null;`);
+  lines.push(`  created_at: string;`);
+  lines.push(`  updated_at: string;`);
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`export interface Create${className} {`);
+  for (const f of config.fields) {
+    if (f.required) {
+      lines.push(`  ${f.name}: ${tsType(f.type, true)};`);
+    } else {
+      lines.push(`  ${f.name}?: ${tsType(f.type, false)};`);
+    }
+  }
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`export interface Update${className} {`);
+  for (const f of config.fields) {
+    lines.push(`  ${f.name}?: ${tsType(f.type, false)};`);
+  }
+  lines.push(`}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function dartType(type, required) {
+  const base = (() => {
+    switch (type) {
+      case "string":
+      case "text":
+        return "String";
+      case "number":
+        return "int";
+      case "boolean":
+        return "bool";
+      case "date":
+      case "datetime":
+        return "DateTime";
+      case "json":
+        return "Map<String, dynamic>";
+    }
+  })();
+  return required ? base : `${base}?`;
+}
+function toCamel(s) {
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function dartFromJson(fieldName, type, required) {
+  const key = `json['${fieldName}']`;
+  const isDate = type === "date" || type === "datetime";
+  if (isDate && required) return `DateTime.parse(${key} as String)`;
+  if (isDate && !required) return `${key} != null ? DateTime.parse(${key} as String) : null`;
+  if (type === "json" && !required) return `${key} as Map<String, dynamic>?`;
+  if (type === "json") return `${key} as Map<String, dynamic>`;
+  const dartT = (() => {
+    switch (type) {
+      case "string":
+      case "text":
+        return "String";
+      case "number":
+        return "int";
+      case "boolean":
+        return "bool";
+      default:
+        return "String";
+    }
+  })();
+  return required ? `${key} as ${dartT}` : `${key} as ${dartT}?`;
+}
+function dartToJson(fieldName, camelName, type) {
+  const isDate = type === "date" || type === "datetime";
+  if (isDate) return `'${fieldName}': ${camelName}?.toIso8601String()`;
+  return `'${fieldName}': ${camelName}`;
+}
+function generateDartModel(config) {
+  const className = toPascal(config.name);
+  const allFields = [
+    { snake: "id", camel: "id", type: "String", required: true, fieldType: "string" },
+    ...config.fields.map((f) => ({
+      snake: f.name,
+      camel: toCamel(f.name),
+      type: dartType(f.type, f.required),
+      required: f.required,
+      fieldType: f.type
+    }))
+  ];
+  if (config.softDelete) {
+    allFields.push({ snake: "deleted_at", camel: "deletedAt", type: "DateTime?", required: false, fieldType: "datetime" });
+  }
+  allFields.push(
+    { snake: "created_at", camel: "createdAt", type: "DateTime", required: true, fieldType: "datetime" },
+    { snake: "updated_at", camel: "updatedAt", type: "DateTime", required: true, fieldType: "datetime" }
+  );
+  const lines = [];
+  lines.push(`class ${className} {`);
+  for (const f of allFields) {
+    lines.push(`  final ${f.type} ${f.camel};`);
+  }
+  lines.push("");
+  lines.push(`  const ${className}({`);
+  for (const f of allFields) {
+    if (f.required) {
+      lines.push(`    required this.${f.camel},`);
+    } else {
+      lines.push(`    this.${f.camel},`);
+    }
+  }
+  lines.push(`  });`);
+  lines.push("");
+  lines.push(`  factory ${className}.fromJson(Map<String, dynamic> json) {`);
+  lines.push(`    return ${className}(`);
+  for (const f of allFields) {
+    lines.push(`      ${f.camel}: ${dartFromJson(f.snake, f.fieldType, f.required)},`);
+  }
+  lines.push(`    );`);
+  lines.push(`  }`);
+  lines.push("");
+  lines.push(`  Map<String, dynamic> toJson() {`);
+  lines.push(`    return {`);
+  for (const f of allFields) {
+    lines.push(`      ${dartToJson(f.snake, f.camel, f.fieldType)},`);
+  }
+  lines.push(`    };`);
+  lines.push(`  }`);
+  lines.push("");
+  lines.push(`  ${className} copyWith({`);
+  for (const f of allFields) {
+    lines.push(`    ${f.type.replace("?", "")}? ${f.camel},`);
+  }
+  lines.push(`  }) {`);
+  lines.push(`    return ${className}(`);
+  for (const f of allFields) {
+    lines.push(`      ${f.camel}: ${f.camel} ?? this.${f.camel},`);
+  }
+  lines.push(`    );`);
+  lines.push(`  }`);
+  lines.push(`}`);
+  lines.push("");
+  return lines.join("\n");
+}
+async function gen(cwd, entityName, fieldsFlag) {
+  p9.intro(`projx gen entity ${entityName}`);
+  const configPath = join12(cwd, ".projx");
+  if (!existsSync11(configPath)) {
+    p9.log.error("No .projx file found. Run 'npx create-projx init' first.");
+    process.exit(1);
+  }
+  const projxConfig = JSON.parse(await readFile11(configPath, "utf-8"));
+  const componentPaths = await discoverComponentPaths(cwd, projxConfig.components);
+  const hasFastapi = projxConfig.components.includes("fastapi");
+  const hasFastify = projxConfig.components.includes("fastify");
+  const hasFrontend = projxConfig.components.includes("frontend");
+  const hasMobile = projxConfig.components.includes("mobile");
+  if (!hasFastapi && !hasFastify) {
+    p9.log.error("No backend component found. Need fastapi or fastify.");
+    process.exit(1);
+  }
+  let config;
+  if (fieldsFlag) {
+    const fields = parseFieldsFlag(fieldsFlag);
+    const snake = toSnake(entityName);
+    const tableName = pluralize(snake);
+    const kebab = toKebab(entityName);
+    config = {
+      name: entityName,
+      tableName,
+      apiPrefix: "/" + pluralize(kebab),
+      readonly: false,
+      softDelete: false,
+      bulkOperations: true,
+      fields,
+      searchableFields: fields.filter((f) => f.type === "string" || f.type === "text").map((f) => f.name)
+    };
+  } else {
+    config = await promptEntityConfig(entityName);
+  }
+  const generated = [];
+  if (hasFastapi) {
+    const dir = componentPaths.fastapi;
+    const entityDir = join12(cwd, dir, "src/entities", toSnake(config.name));
+    if (existsSync11(entityDir)) {
+      p9.log.warn(`${dir}/src/entities/${toSnake(config.name)}/ already exists. Skipping FastAPI.`);
+    } else {
+      await mkdir5(entityDir, { recursive: true });
+      await writeFile5(join12(entityDir, "_model.py"), generateFastAPIModel(config));
+      generated.push(`${dir}/src/entities/${toSnake(config.name)}/_model.py`);
+    }
+  }
+  if (hasFastify) {
+    const dir = componentPaths.fastify;
+    const moduleDir = join12(cwd, dir, "src/modules", toKebab(config.name));
+    if (existsSync11(moduleDir)) {
+      p9.log.warn(`${dir}/src/modules/${toKebab(config.name)}/ already exists. Skipping Fastify.`);
+    } else {
+      await mkdir5(moduleDir, { recursive: true });
+      await writeFile5(join12(moduleDir, "schemas.ts"), generateFastifySchemas(config));
+      await writeFile5(join12(moduleDir, "index.ts"), generateFastifyIndex(config));
+      generated.push(`${dir}/src/modules/${toKebab(config.name)}/schemas.ts`);
+      generated.push(`${dir}/src/modules/${toKebab(config.name)}/index.ts`);
+      const appPath = join12(cwd, dir, "src/app.ts");
+      if (existsSync11(appPath)) {
+        const appContent = await readFile11(appPath, "utf-8");
+        const importLine = `import './modules/${toKebab(config.name)}/index.js';`;
+        if (!appContent.includes(importLine)) {
+          const updated = appContent.replace(
+            /^(import\s+'\.\/modules\/.*?';?\s*\n)/m,
+            `$1${importLine}
+`
+          );
+          if (updated !== appContent) {
+            await writeFile5(appPath, updated);
+            generated.push(`${dir}/src/app.ts (import added)`);
+          }
+        }
+      }
+      const prismaPath = join12(cwd, dir, "prisma/schema.prisma");
+      if (existsSync11(prismaPath)) {
+        const prismaContent = await readFile11(prismaPath, "utf-8");
+        const modelName = `model ${toPascal(config.name)}`;
+        if (!prismaContent.includes(modelName)) {
+          const prismaModel = generatePrismaModel(config);
+          await writeFile5(prismaPath, prismaContent.trimEnd() + "\n\n" + prismaModel + "\n");
+          generated.push(`${dir}/prisma/schema.prisma (model added)`);
+        }
+      }
+    }
+  }
+  if (hasFrontend) {
+    const dir = componentPaths.frontend;
+    const typesDir = join12(cwd, dir, "src/types");
+    const fileName = toKebab(config.name) + ".ts";
+    const filePath = join12(typesDir, fileName);
+    if (existsSync11(filePath)) {
+      p9.log.warn(`${dir}/src/types/${fileName} already exists. Skipping frontend types.`);
+    } else {
+      await mkdir5(typesDir, { recursive: true });
+      await writeFile5(filePath, generateFrontendInterface(config));
+      generated.push(`${dir}/src/types/${fileName}`);
+      const barrelPath = join12(typesDir, "index.ts");
+      const exportLine = `export * from './${toKebab(config.name)}';`;
+      if (existsSync11(barrelPath)) {
+        const content = await readFile11(barrelPath, "utf-8");
+        if (!content.includes(exportLine)) {
+          await writeFile5(barrelPath, content.trimEnd() + "\n" + exportLine + "\n");
+        }
+      } else {
+        await writeFile5(barrelPath, exportLine + "\n");
+      }
+      generated.push(`${dir}/src/types/index.ts`);
+    }
+  }
+  if (hasMobile) {
+    const dir = componentPaths.mobile;
+    const entityDir = join12(cwd, dir, "lib/entities", toSnake(config.name));
+    const modelPath = join12(entityDir, "model.dart");
+    if (existsSync11(modelPath)) {
+      p9.log.warn(`${dir}/lib/entities/${toSnake(config.name)}/model.dart already exists. Skipping mobile model.`);
+    } else {
+      await mkdir5(entityDir, { recursive: true });
+      await writeFile5(modelPath, generateDartModel(config));
+      generated.push(`${dir}/lib/entities/${toSnake(config.name)}/model.dart`);
+    }
+  }
+  if (generated.length === 0) {
+    p9.log.warn("Nothing generated.");
+    p9.outro("");
+    return;
+  }
+  p9.log.success("Generated:");
+  for (const f of generated) {
+    p9.log.info(`  ${f}`);
+  }
+  const className = toPascal(config.name);
+  if (hasFastapi) {
+    p9.log.info("");
+    p9.log.info("FastAPI next steps:");
+    p9.log.info(`  alembic revision --autogenerate -m "add ${config.tableName}"`);
+    p9.log.info("  alembic upgrade head");
+  }
+  if (hasFastify) {
+    p9.log.info("");
+    p9.log.info("Fastify next steps:");
+    p9.log.info(`  npx prisma migrate dev --name add_${toSnake(config.name)}`);
+  }
+  if (hasFrontend) {
+    p9.log.info("");
+    p9.log.info("Frontend usage:");
+    p9.log.info(`  import type { ${className} } from '../types/${toKebab(config.name)}';`);
+    p9.log.info(`  const { data } = await api.list<${className}>('${config.apiPrefix}');`);
+  }
+  if (hasMobile) {
+    p9.log.info("");
+    p9.log.info("Mobile usage:");
+    p9.log.info(`  final item = ${className}.fromJson(json);`);
+  }
+  p9.outro(`Entity ${className} created.`);
+}
+
+// src/sync.ts
+import { existsSync as existsSync12, readFileSync as readFileSync2 } from "fs";
+import { readFile as readFile12, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import { join as join13 } from "path";
+import * as p10 from "@clack/prompts";
+function toPascal2(s) {
+  return s.replace(/(?:^|[_\-\s])([a-zA-Z])/g, (_, c) => c.toUpperCase());
+}
+function toCamel2(s) {
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function metaTypeToTs(type, fieldType, nullable) {
+  const base = (() => {
+    switch (type) {
+      case "str":
+        return "string";
+      case "int":
+      case "float":
+        return "number";
+      case "bool":
+        return "boolean";
+      case "datetime":
+      case "date":
+        return "string";
+      case "dict":
+        return "Record<string, unknown>";
+      default:
+        return "unknown";
+    }
+  })();
+  return nullable ? `${base} | null` : base;
+}
+function metaTypeToDart(type, nullable) {
+  const base = (() => {
+    switch (type) {
+      case "str":
+        return "String";
+      case "int":
+        return "int";
+      case "float":
+        return "double";
+      case "bool":
+        return "bool";
+      case "datetime":
+      case "date":
+        return "DateTime";
+      case "dict":
+        return "Map<String, dynamic>";
+      default:
+        return "dynamic";
+    }
+  })();
+  return nullable ? `${base}?` : base;
+}
+function dartFromJsonExpr(key, type, nullable) {
+  const accessor = `json['${key}']`;
+  const isDate = type === "datetime" || type === "date";
+  if (isDate && nullable)
+    return `${accessor} != null ? DateTime.parse(${accessor} as String) : null`;
+  if (isDate) return `DateTime.parse(${accessor} as String)`;
+  if (type === "dict" && nullable)
+    return `${accessor} as Map<String, dynamic>?`;
+  if (type === "dict") return `${accessor} as Map<String, dynamic>`;
+  const dartT = (() => {
+    switch (type) {
+      case "str":
+        return "String";
+      case "int":
+        return "int";
+      case "float":
+        return "double";
+      case "bool":
+        return "bool";
+      default:
+        return "dynamic";
+    }
+  })();
+  return nullable ? `${accessor} as ${dartT}?` : `${accessor} as ${dartT}`;
+}
+function dartToJsonExpr(key, camel, type) {
+  const isDate = type === "datetime" || type === "date";
+  if (isDate) return `'${key}': ${camel}?.toIso8601String()`;
+  return `'${key}': ${camel}`;
+}
+function generateTsInterface(entity) {
+  const className = toPascal2(entity.name);
+  const lines = [];
+  lines.push(`export interface ${className} {`);
+  for (const f of entity.fields) {
+    lines.push(
+      `  ${f.key}: ${metaTypeToTs(f.type, f.field_type, f.nullable)};`
+    );
+  }
+  lines.push(`}`);
+  lines.push("");
+  const createFields = entity.fields.filter((f) => f.in_create);
+  lines.push(`export interface Create${className} {`);
+  for (const f of createFields) {
+    const optional = f.nullable ? "?" : "";
+    lines.push(
+      `  ${f.key}${optional}: ${metaTypeToTs(f.type, f.field_type, f.nullable)};`
+    );
+  }
+  lines.push(`}`);
+  lines.push("");
+  const updateFields = entity.fields.filter((f) => f.in_update);
+  lines.push(`export interface Update${className} {`);
+  for (const f of updateFields) {
+    lines.push(`  ${f.key}?: ${metaTypeToTs(f.type, f.field_type, true)};`);
+  }
+  lines.push(`}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function generateDartModel2(entity) {
+  const className = toPascal2(entity.name);
+  const lines = [];
+  const fields = entity.fields.map((f) => ({
+    snake: f.key,
+    camel: toCamel2(f.key),
+    type: metaTypeToDart(f.type, f.nullable),
+    nullable: f.nullable,
+    metaType: f.type
+  }));
+  lines.push(`class ${className} {`);
+  for (const f of fields) {
+    lines.push(`  final ${f.type} ${f.camel};`);
+  }
+  lines.push("");
+  lines.push(`  const ${className}({`);
+  for (const f of fields) {
+    if (f.nullable) {
+      lines.push(`    this.${f.camel},`);
+    } else {
+      lines.push(`    required this.${f.camel},`);
+    }
+  }
+  lines.push(`  });`);
+  lines.push("");
+  lines.push(`  factory ${className}.fromJson(Map<String, dynamic> json) {`);
+  lines.push(`    return ${className}(`);
+  for (const f of fields) {
+    lines.push(
+      `      ${f.camel}: ${dartFromJsonExpr(f.snake, f.metaType, f.nullable)},`
+    );
+  }
+  lines.push(`    );`);
+  lines.push(`  }`);
+  lines.push("");
+  lines.push(`  Map<String, dynamic> toJson() {`);
+  lines.push(`    return {`);
+  for (const f of fields) {
+    lines.push(`      ${dartToJsonExpr(f.snake, f.camel, f.metaType)},`);
+  }
+  lines.push(`    };`);
+  lines.push(`  }`);
+  lines.push("");
+  lines.push(`  ${className} copyWith({`);
+  for (const f of fields) {
+    lines.push(`    ${f.type.replace("?", "")}? ${f.camel},`);
+  }
+  lines.push(`  }) {`);
+  lines.push(`    return ${className}(`);
+  for (const f of fields) {
+    lines.push(`      ${f.camel}: ${f.camel} ?? this.${f.camel},`);
+  }
+  lines.push(`    );`);
+  lines.push(`  }`);
+  lines.push(`}`);
+  lines.push("");
+  return lines.join("\n");
+}
+async function sync(cwd, url) {
+  p10.intro("projx sync");
+  const configPath = join13(cwd, ".projx");
+  if (!existsSync12(configPath)) {
+    p10.log.error("No .projx file found. Run 'npx create-projx init' first.");
+    process.exit(1);
+  }
+  const projxConfig = JSON.parse(
+    await readFile12(configPath, "utf-8")
+  );
+  const componentPaths = await discoverComponentPaths(
+    cwd,
+    projxConfig.components
+  );
+  const hasFrontend = projxConfig.components.includes("frontend");
+  const hasMobile = projxConfig.components.includes("mobile");
+  if (!hasFrontend && !hasMobile) {
+    p10.log.error("No frontend or mobile component found. Nothing to sync.");
+    process.exit(1);
+  }
+  const metaUrl = url || detectMetaUrl(cwd);
+  const spinner7 = p10.spinner();
+  spinner7.start(`Fetching metadata from ${metaUrl}`);
+  let meta;
+  try {
+    const res = await fetch(metaUrl);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    meta = await res.json();
+  } catch (err) {
+    spinner7.stop("Failed.");
+    p10.log.error(`Could not fetch ${metaUrl}: ${err}`);
+    p10.log.info("Make sure your backend is running.");
+    p10.log.info(
+      "Or specify URL: projx sync --url http://localhost:8000/api/v1/_meta"
+    );
+    process.exit(1);
+  }
+  spinner7.stop(`Fetched ${meta.entities.length} entity(s).`);
+  const generated = [];
+  if (hasFrontend) {
+    const dir = componentPaths.frontend;
+    const typesDir = join13(cwd, dir, "src/types");
+    await mkdir6(typesDir, { recursive: true });
+    const barrelExports = [];
+    for (const entity of meta.entities) {
+      const fileName = toKebab(toSnake(entity.name)) + ".ts";
+      const filePath = join13(typesDir, fileName);
+      await writeFile6(filePath, generateTsInterface(entity));
+      generated.push(`${dir}/src/types/${fileName}`);
+      barrelExports.push(`export * from './${toKebab(toSnake(entity.name))}';`);
+    }
+    await writeFile6(
+      join13(typesDir, "index.ts"),
+      barrelExports.join("\n") + "\n"
+    );
+    generated.push(`${dir}/src/types/index.ts`);
+  }
+  if (hasMobile) {
+    const dir = componentPaths.mobile;
+    for (const entity of meta.entities) {
+      const entityDir = join13(cwd, dir, "lib/entities", toSnake(entity.name));
+      await mkdir6(entityDir, { recursive: true });
+      const modelPath = join13(entityDir, "model.dart");
+      await writeFile6(modelPath, generateDartModel2(entity));
+      generated.push(`${dir}/lib/entities/${toSnake(entity.name)}/model.dart`);
+    }
+  }
+  p10.log.success(`Synced ${meta.entities.length} entity(s):`);
+  for (const f of generated) {
+    p10.log.info(`  ${f}`);
+  }
+  if (hasFrontend) {
+    p10.log.info("");
+    p10.log.info("Frontend usage:");
+    for (const entity of meta.entities) {
+      const className = toPascal2(entity.name);
+      p10.log.info(
+        `  import type { ${className} } from '../types/${toKebab(toSnake(entity.name))}';`
+      );
+    }
+  }
+  p10.outro("Types are up to date.");
+}
+function detectMetaUrl(cwd) {
+  const envFiles = [".env", ".env.dev", ".env.local"];
+  for (const envFile of envFiles) {
+    const envPath = join13(cwd, envFile);
+    if (existsSync12(envPath)) {
+      try {
+        const content = readFileSync2(envPath, "utf-8");
+        const match = content.match(/VITE_API_URL\s*=\s*(.+)/);
+        if (match) {
+          const base = match[1].trim().replace(/["']/g, "");
+          return `${base}/api/v1/_meta`;
+        }
+      } catch {
+      }
+    }
+  }
+  const frontendEnvFiles = [
+    "frontend/.env",
+    "frontend/.env.local",
+    "frontend/.env.dev"
+  ];
+  for (const envFile of frontendEnvFiles) {
+    const envPath = join13(cwd, envFile);
+    if (existsSync12(envPath)) {
+      try {
+        const content = readFileSync2(envPath, "utf-8");
+        const match = content.match(/VITE_API_URL\s*=\s*(.+)/);
+        if (match) {
+          const base = match[1].trim().replace(/["']/g, "");
+          return `${base}/api/v1/_meta`;
+        }
+      } catch {
+      }
+    }
+  }
+  return "http://localhost:8000/api/v1/_meta";
+}
+
 // src/index.ts
 var args = process.argv.slice(2);
 function parseArgs() {
@@ -1469,6 +3031,7 @@ function parseArgs() {
   let localRepo;
   const options = {};
   const extraArgs = [];
+  const flags = {};
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "update" && !name) {
@@ -1483,6 +3046,30 @@ function parseArgs() {
       command = "init";
       continue;
     }
+    if (arg === "pin" && !name) {
+      command = "pin";
+      continue;
+    }
+    if (arg === "unpin" && !name) {
+      command = "unpin";
+      continue;
+    }
+    if (arg === "diff" && !name) {
+      command = "diff";
+      continue;
+    }
+    if (arg === "doctor" && !name) {
+      command = "doctor";
+      continue;
+    }
+    if (arg === "gen" && !name) {
+      command = "gen";
+      continue;
+    }
+    if (arg === "sync" && !name) {
+      command = "sync";
+      continue;
+    }
     if (arg === "--components") {
       const val = args[++i];
       if (val) {
@@ -1508,19 +3095,37 @@ function parseArgs() {
       options.components = options.components ?? ["fastify", "frontend", "e2e"];
       continue;
     }
+    if (arg === "--list" || arg === "-l") {
+      flags.list = true;
+      continue;
+    }
+    if (arg === "--fix") {
+      flags.fix = true;
+      continue;
+    }
+    if (arg === "--url") {
+      const val = args[++i];
+      if (val) extraArgs.push(`--url=${val}`);
+      continue;
+    }
     if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
     }
+    if (arg === "--fields") {
+      const val = args[++i];
+      if (val) extraArgs.push(`--fields=${val}`);
+      continue;
+    }
     if (!arg.startsWith("-")) {
-      if (command === "add") {
+      if (command === "add" || command === "pin" || command === "unpin" || command === "gen") {
         extraArgs.push(arg);
       } else if (!name) {
         name = arg;
       }
     }
   }
-  return { command, name, options, localRepo, extraArgs };
+  return { command, name, options, localRepo, extraArgs, flags };
 }
 function printHelp() {
   console.log(`
@@ -1529,6 +3134,13 @@ function printHelp() {
     projx init                    Adopt existing project into projx
     projx add <components...>     Add components to existing project
     projx update                  Update scaffolding to latest
+    projx diff                    Preview what update would change
+    projx pin <patterns...>       Skip files on future updates
+    projx unpin <patterns...>     Remove files from skip list
+    projx pin --list              Show all skip patterns
+    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
 
   Options:
     --components <list>  Comma-separated: fastapi,fastify,frontend,mobile,e2e,infra
@@ -1544,10 +3156,15 @@ function printHelp() {
     npx create-projx my-app -y
     npx create-projx add frontend mobile
     npx create-projx@latest update
+    npx create-projx diff
+    npx create-projx pin backend/pyproject.toml
+    npx create-projx doctor --fix
+    npx create-projx gen entity invoice
+    npx create-projx gen entity invoice --fields "name:string,amount:number,status:string"
 `);
 }
 async function main() {
-  const { command, name, options, localRepo, extraArgs } = parseArgs();
+  const { command, name, options, localRepo, extraArgs, flags } = parseArgs();
   if (command === "init") {
     await init(process.cwd(), localRepo);
     return;
@@ -1567,6 +3184,48 @@ async function main() {
     await add(process.cwd(), components, localRepo, options.install === false);
     return;
   }
+  if (command === "pin") {
+    if (flags.list || extraArgs.length === 0) {
+      await listPins(process.cwd());
+    } else {
+      await pin(process.cwd(), extraArgs);
+    }
+    return;
+  }
+  if (command === "unpin") {
+    if (extraArgs.length === 0) {
+      console.error("Error: specify patterns to unpin. Usage: projx unpin <patterns...>");
+      process.exit(1);
+    }
+    await unpin(process.cwd(), extraArgs);
+    return;
+  }
+  if (command === "diff") {
+    await diff(process.cwd(), localRepo);
+    return;
+  }
+  if (command === "doctor") {
+    await doctor(process.cwd(), flags.fix);
+    return;
+  }
+  if (command === "sync") {
+    const urlArg = extraArgs.find((a) => a.startsWith("--url="));
+    const url = urlArg ? urlArg.split("=").slice(1).join("=") : void 0;
+    await sync(process.cwd(), url);
+    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"]');
+      process.exit(1);
+    }
+    const entityName = extraArgs[1];
+    const fieldsArg = extraArgs.find((a) => a.startsWith("--fields="));
+    const fieldsFlag = fieldsArg ? fieldsArg.split("=").slice(1).join("=") : void 0;
+    await gen(process.cwd(), entityName, fieldsFlag);
+    return;
+  }
   let opts;
   if (options.components) {
     if (!name) {
@@ -1585,7 +3244,7 @@ async function main() {
     opts.install = options.install ?? opts.install;
   }
   const dest = resolve2(process.cwd(), opts.name);
-  if (existsSync8(dest)) {
+  if (existsSync13(dest)) {
     console.error(`Error: ${dest} already exists.`);
     process.exit(1);
   }