@percepta/create 3.0.0

package/dist/index.js

@@ -0,0 +1,974 @@
+#!/usr/bin/env node
+import {
+  VALID_PROJECT_TYPES,
+  isValidProjectType,
+  promptProjectDetails,
+  toKebabCase,
+  toSnakeCase,
+  toTitleCase,
+  validateProjectName
+} from "./chunk-GEVZERMP.js";
+import {
+  derivePlaceholders,
+  writeManifest
+} from "./chunk-WMJT7CB5.js";
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/create.ts
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { randomBytes } from "crypto";
+import fs4 from "fs-extra";
+import chalk from "chalk";
+import ora from "ora";
+import { execSync, spawn } from "child_process";
+
+// src/utils/copy-template.ts
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs-extra";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  ".turbo",
+  ".vercel",
+  ".cursor"
+]);
+var SKIP_FILES = /* @__PURE__ */ new Set([
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  ".DS_Store"
+]);
+var TEMPLATE_FILE_MAPPINGS = {
+  "package.json.template": "package.json",
+  "gitignore.template": ".gitignore",
+  "env.example.template": ".env.example",
+  "npmrc.template": ".npmrc"
+};
+function shouldSkip(src) {
+  const basename = path.basename(src);
+  if (SKIP_DIRS.has(basename)) return true;
+  if (SKIP_FILES.has(basename)) return true;
+  return false;
+}
+function getTemplateDir(templateType) {
+  return path.resolve(__dirname, "../templates", templateType);
+}
+async function copyTemplate(targetDir, templateType) {
+  const templateDir = getTemplateDir(templateType);
+  if (!await fs.pathExists(templateDir)) {
+    throw new Error(`Template directory not found: ${templateDir}`);
+  }
+  await fs.ensureDir(targetDir);
+  await fs.copy(templateDir, targetDir, {
+    filter: (src) => !shouldSkip(src)
+  });
+  for (const [templateName, targetName] of Object.entries(
+    TEMPLATE_FILE_MAPPINGS
+  )) {
+    const templatePath = path.join(targetDir, templateName);
+    const targetPath = path.join(targetDir, targetName);
+    if (await fs.pathExists(templatePath)) {
+      await fs.move(templatePath, targetPath, { overwrite: true });
+    }
+  }
+  if (templateType === "webapp") {
+    const agentsPath = path.join(targetDir, "AGENTS.md");
+    const claudePath = path.join(targetDir, "CLAUDE.md");
+    if (await fs.pathExists(agentsPath)) {
+      if (await fs.pathExists(claudePath)) {
+        await fs.remove(claudePath);
+      }
+      await fs.ensureSymlink("AGENTS.md", claudePath);
+    }
+  }
+}
+
+// src/utils/replace-placeholders.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+var PLACEHOLDERS = {
+  __APP_NAME__: "name",
+  __APP_TITLE__: "title",
+  __DB_NAME__: "dbName",
+  __APP_NAME_UPPER__: "nameUpper",
+  __APP_NAME_SNAKE__: "nameSnake"
+};
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  ".turbo",
+  ".vercel"
+]);
+var SKIP_FILES2 = /* @__PURE__ */ new Set([
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock"
+]);
+var PROCESSABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".yml",
+  ".yaml",
+  ".md",
+  ".env",
+  ".sql",
+  ".tf",
+  ".tfvars",
+  ".sh",
+  ".mjs",
+  ".cjs"
+]);
+var PROCESSABLE_FILENAMES = /* @__PURE__ */ new Set([
+  "Dockerfile",
+  ".env.example",
+  ".env.local",
+  "terraform.tfvars.example"
+]);
+function shouldProcessFile(filePath) {
+  const fileName = path2.basename(filePath);
+  const ext = path2.extname(filePath);
+  if (SKIP_FILES2.has(fileName)) return false;
+  if (PROCESSABLE_FILENAMES.has(fileName)) return true;
+  return PROCESSABLE_EXTENSIONS.has(ext);
+}
+async function replaceInFile(filePath, config) {
+  let content;
+  try {
+    content = await fs2.readFile(filePath, "utf-8");
+  } catch {
+    return false;
+  }
+  let modified = false;
+  let newContent = content;
+  const sortedEntries = Object.entries(PLACEHOLDERS).sort(
+    (a, b) => b[0].length - a[0].length
+  );
+  for (const [placeholder, configKey] of sortedEntries) {
+    const value = config[configKey];
+    if (newContent.includes(placeholder)) {
+      newContent = newContent.split(placeholder).join(value);
+      modified = true;
+    }
+  }
+  if (modified) {
+    await fs2.writeFile(filePath, newContent);
+    return true;
+  }
+  return false;
+}
+function substituteName(name, config) {
+  const sortedEntries = Object.entries(PLACEHOLDERS).sort(
+    (a, b) => b[0].length - a[0].length
+  );
+  let result = name;
+  for (const [placeholder, configKey] of sortedEntries) {
+    if (result.includes(placeholder)) {
+      result = result.split(placeholder).join(
+        config[configKey]
+      );
+    }
+  }
+  return result;
+}
+async function processDirectory(dirPath, config, stats) {
+  const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS2.has(entry.name)) {
+        await processDirectory(fullPath, config, stats);
+      }
+    } else if (entry.isFile() && shouldProcessFile(fullPath)) {
+      stats.processed++;
+      if (await replaceInFile(fullPath, config)) {
+        stats.modified++;
+      }
+      const renamed = substituteName(entry.name, config);
+      if (renamed !== entry.name) {
+        await fs2.move(fullPath, path2.join(dirPath, renamed), {
+          overwrite: true
+        });
+      }
+    }
+  }
+}
+async function replacePlaceholders(targetDir, config) {
+  const stats = { processed: 0, modified: 0 };
+  await processDirectory(targetDir, config, stats);
+  return stats;
+}
+
+// src/utils/detect-monorepo.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+import { parse } from "yaml";
+var NOT_FOUND = {
+  found: false,
+  rootDir: null,
+  workspacePatterns: [],
+  packageDir: null
+};
+async function detectMonorepo(startDir) {
+  let current = path3.resolve(startDir);
+  const root = path3.parse(current).root;
+  while (current !== root) {
+    const workspaceFile = path3.join(current, "pnpm-workspace.yaml");
+    if (await fs3.pathExists(workspaceFile)) {
+      try {
+        const content = await fs3.readFile(workspaceFile, "utf-8");
+        const parsed = parse(content);
+        if (!parsed?.packages || !Array.isArray(parsed.packages)) {
+          return NOT_FOUND;
+        }
+        const workspacePatterns = parsed.packages;
+        const firstPattern = workspacePatterns[0];
+        if (!firstPattern) {
+          return NOT_FOUND;
+        }
+        const baseDir = firstPattern.replace(/\/?\*.*$/, "").trim();
+        const packageDir = path3.join(current, baseDir);
+        return {
+          found: true,
+          rootDir: current,
+          workspacePatterns,
+          packageDir
+        };
+      } catch {
+        return NOT_FOUND;
+      }
+    }
+    current = path3.dirname(current);
+  }
+  return NOT_FOUND;
+}
+
+// src/commands/create.ts
+var PACKAGE_MANAGER = "pnpm";
+function shPath(p) {
+  return p.split(path4.sep).join("/");
+}
+function runPackageManagerInstall(packageManager, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(packageManager, ["install"], {
+      cwd,
+      stdio: "ignore"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else
+        reject(
+          new Error(
+            `${packageManager} install exited with code ${code ?? "unknown"}`
+          )
+        );
+    });
+  });
+}
+function runWebappSetup(packageManager, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(packageManager, ["run", "setup"], { cwd, stdio: "inherit" });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${packageManager} run setup exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+var ANSI_PATTERN = /\x1b\[[0-9;]*[a-zA-Z]/g;
+function spawnDevServer(packageManager, cwd) {
+  const child = spawn(packageManager, ["run", "dev"], {
+    cwd,
+    stdio: ["inherit", "pipe", "pipe"]
+  });
+  const ready = new Promise((resolve, reject) => {
+    let resolved = false;
+    let detectedUrl = "http://localhost:3000";
+    let buffer = "";
+    const onChunk = (chunk) => {
+      const text = chunk.toString();
+      process.stdout.write(text);
+      buffer = (buffer + text).slice(-4096).replace(ANSI_PATTERN, "");
+      const urlMatch = buffer.match(/Local:\s+(https?:\/\/\S+?)(?:\s|$)/i);
+      if (urlMatch?.[1]) detectedUrl = urlMatch[1].trim();
+      if (!resolved && /Ready in /i.test(buffer)) {
+        resolved = true;
+        resolve({ url: detectedUrl });
+      }
+    };
+    child.stdout?.on("data", onChunk);
+    child.stderr?.on("data", (chunk) => process.stderr.write(chunk));
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (!resolved) {
+        reject(new Error(`${packageManager} run dev exited with code ${code ?? "unknown"} before becoming ready`));
+      }
+    });
+  });
+  return { child, ready };
+}
+function openInBrowser(url) {
+  const cmd = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
+  try {
+    const child = spawn(cmd[0], cmd.slice(1), { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function autoRunWebapp(packageDir) {
+  const packageManager = PACKAGE_MANAGER;
+  console.log();
+  console.log(chalk.bold("Running setup (docker, db, seed)..."));
+  console.log();
+  try {
+    await runWebappSetup(packageManager, packageDir);
+  } catch (error) {
+    console.log();
+    console.log(
+      chalk.yellow("!"),
+      "Setup failed. You can re-run it manually:",
+      chalk.cyan(`cd ${packageDir} && ${packageManager} run setup`)
+    );
+    console.log(chalk.dim(error.message));
+    return false;
+  }
+  console.log();
+  console.log(chalk.bold("Starting dev server..."));
+  console.log();
+  const { child, ready } = spawnDevServer(packageManager, packageDir);
+  const closed = new Promise((resolve) => {
+    child.on("close", () => resolve());
+  });
+  let url = "http://localhost:3000";
+  try {
+    ({ url } = await ready);
+  } catch (error) {
+    console.log();
+    console.log(chalk.yellow("!"), "Dev server failed to become ready.");
+    console.log(chalk.dim(error.message));
+    return false;
+  }
+  if (openInBrowser(url)) {
+    console.log();
+    console.log(chalk.green("\u2714"), "Opened", chalk.cyan(url));
+  } else {
+    console.log();
+    console.log(chalk.dim("Open"), chalk.cyan(url), chalk.dim("in your browser."));
+  }
+  await closed;
+  return true;
+}
+function readTemplateVersions() {
+  const versionsPath = path4.resolve(
+    path4.dirname(fileURLToPath2(import.meta.url)),
+    "../template-versions.json"
+  );
+  try {
+    const content = fs4.readFileSync(versionsPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function generateEnvLocal(packageDir) {
+  const examplePath = path4.join(packageDir, ".env.example");
+  const localPath = path4.join(packageDir, ".env.local");
+  if (!await fs4.pathExists(examplePath)) return;
+  if (await fs4.pathExists(localPath)) return;
+  const authSecret = randomBytes(32).toString("base64");
+  const encKey = randomBytes(16).toString("hex");
+  const content = (await fs4.readFile(examplePath, "utf-8")).replace(/^BETTER_AUTH_SECRET=.*$/m, `BETTER_AUTH_SECRET=${authSecret}`).replace(/^ENCRYPTION_SECRET_KEY=.*$/m, `ENCRYPTION_SECRET_KEY=${encKey}`);
+  await fs4.writeFile(localPath, content);
+}
+async function relocateWorkflowsToRoot(packageDir, monorepoRoot, appName) {
+  const sourceDir = path4.join(packageDir, ".github", "workflows");
+  if (!await fs4.pathExists(sourceDir)) return;
+  const targetDir = path4.join(monorepoRoot, ".github", "workflows");
+  await fs4.ensureDir(targetDir);
+  const entries = await fs4.readdir(sourceDir);
+  for (const name of entries) {
+    if (!name.startsWith(`${appName}-`)) continue;
+    if (!/\.(ya?ml)$/.test(name)) continue;
+    await fs4.move(path4.join(sourceDir, name), path4.join(targetDir, name), {
+      overwrite: true
+    });
+  }
+  if ((await fs4.readdir(sourceDir)).length === 0) {
+    await fs4.rmdir(sourceDir);
+    const packageGithub = path4.join(packageDir, ".github");
+    if ((await fs4.readdir(packageGithub)).length === 0) {
+      await fs4.rmdir(packageGithub);
+    }
+  }
+}
+async function writeMosaicFiles(packageDir, config, projectType) {
+  const templateVersions = readTemplateVersions();
+  const manifest = {
+    templateType: projectType,
+    templateVersion: templateVersions[projectType] || "1.0.0",
+    templateCommit: "npm",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    placeholders: derivePlaceholders(config.name, config.title),
+    source: {
+      templatePath: `packages/create-mosaic-module/templates/${projectType}`
+    }
+  };
+  await writeManifest(packageDir, manifest);
+  const notesPath = path4.join(packageDir, "mosaic-template-notes.md");
+  await fs4.writeFile(
+    notesPath,
+    `# Mosaic Divergence Notes
+
+Document intentional differences from the ${projectType} template here.
+Claude reads this file during sync to preserve your customizations.
+
+## Intentional Divergences
+
+_None yet \u2014 freshly created from template._
+`
+  );
+}
+function getProjectTypeLabel(projectType) {
+  switch (projectType) {
+    case "monorepo":
+      return "pnpm monorepo";
+    case "webapp":
+      return "Next.js webapp";
+    case "library":
+      return "TypeScript library";
+    default: {
+      const exhaustiveCheck = projectType;
+      throw new Error(`Unknown project type: ${exhaustiveCheck}`);
+    }
+  }
+}
+async function createProject(options) {
+  if (options.type !== void 0 && !isValidProjectType(options.type)) {
+    console.error(
+      chalk.red(
+        `Error: Invalid package type "${options.type}". Valid types are: ${VALID_PROJECT_TYPES.join(", ")}`
+      )
+    );
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk.bold("Creating a new Mosaic package..."));
+  console.log();
+  const monorepoContext = await detectMonorepo(cwd);
+  if (options.type === "monorepo" && monorepoContext.found) {
+    console.error(
+      chalk.red(
+        `Error: Already inside a monorepo at ${monorepoContext.rootDir}. Choose 'webapp' or 'library' to add a package, or run from outside the monorepo.`
+      )
+    );
+    process.exit(1);
+  }
+  if (monorepoContext.found) {
+    console.log(
+      chalk.dim("  Detected monorepo at"),
+      chalk.cyan(monorepoContext.rootDir)
+    );
+  } else {
+    console.log(
+      chalk.dim(
+        "  No monorepo detected. A new monorepo will be created."
+      )
+    );
+  }
+  console.log();
+  const projectName = options.name;
+  if (options.yes && !projectName) {
+    console.error(
+      chalk.red("Error: --name is required when using --yes flag")
+    );
+    process.exit(1);
+  }
+  if (projectName) {
+    const validation = validateProjectName(toKebabCase(projectName));
+    if (!validation.valid) {
+      console.error(chalk.red(`Invalid project name: ${validation.error}`));
+      process.exit(1);
+    }
+  }
+  let answers;
+  if (options.yes) {
+    const projectType = options.type || "webapp";
+    const kebabName = toKebabCase(projectName);
+    const directory = monorepoContext.found && monorepoContext.packageDir ? path4.join(monorepoContext.packageDir, kebabName) : path4.resolve(cwd, kebabName);
+    answers = {
+      projectType,
+      directory,
+      name: kebabName,
+      title: toTitleCase(kebabName),
+      installDeps: !options.skipInstall
+    };
+  } else {
+    answers = await promptProjectDetails({
+      projectType: options.type,
+      name: projectName ? toKebabCase(projectName) : void 0,
+      skipInstall: options.skipInstall,
+      monorepoContext
+    });
+    if (monorepoContext.found && monorepoContext.packageDir && !answers.directory) {
+      answers.directory = path4.join(monorepoContext.packageDir, answers.name);
+    }
+  }
+  const config = {
+    name: answers.name,
+    title: answers.title,
+    dbName: toSnakeCase(answers.name) + "_db",
+    nameUpper: answers.name.toUpperCase(),
+    nameSnake: toSnakeCase(answers.name)
+  };
+  const typeLabel = getProjectTypeLabel(answers.projectType);
+  if (monorepoContext.found) {
+    const packageDir = monorepoContext.packageDir ? path4.join(monorepoContext.packageDir, answers.name) : answers.directory;
+    console.log(chalk.dim("  Package type:"), typeLabel);
+    console.log(chalk.dim("  Target:"), packageDir);
+    console.log(chalk.dim("  Name:"), config.name);
+    console.log(chalk.dim("  Title:"), config.title);
+    if (answers.projectType === "webapp") {
+      console.log(chalk.dim("  Database:"), config.dbName);
+    }
+    console.log();
+    if (await fs4.pathExists(packageDir)) {
+      const files = await fs4.readdir(packageDir);
+      if (files.length > 0) {
+        console.error(
+          chalk.red(`Error: Directory ${packageDir} is not empty.`)
+        );
+        process.exit(1);
+      }
+    }
+    const copySpinner = ora("Copying template files...").start();
+    try {
+      await copyTemplate(packageDir, answers.projectType);
+      copySpinner.succeed("Copied template files");
+    } catch (error) {
+      copySpinner.fail("Failed to copy template files");
+      console.error(error);
+      process.exit(1);
+    }
+    const replaceSpinner = ora("Replacing placeholders...").start();
+    try {
+      const stats = await replacePlaceholders(packageDir, config);
+      replaceSpinner.succeed(
+        `Replaced placeholders in ${stats.modified} files`
+      );
+    } catch (error) {
+      replaceSpinner.fail("Failed to replace placeholders");
+      console.error(error);
+      process.exit(1);
+    }
+    await writeMosaicFiles(packageDir, config, answers.projectType);
+    if (answers.projectType === "webapp") {
+      await generateEnvLocal(packageDir);
+    }
+    if (answers.projectType === "webapp") {
+      await relocateWorkflowsToRoot(
+        packageDir,
+        monorepoContext.rootDir,
+        config.name
+      );
+    }
+    await warnIfMissingRootNpmrc(monorepoContext.rootDir);
+    let installSucceeded = false;
+    if (answers.installDeps) {
+      const packageManager = PACKAGE_MANAGER;
+      const installSpinner = ora(
+        `Installing dependencies with ${packageManager}...`
+      ).start();
+      try {
+        await runPackageManagerInstall(
+          packageManager,
+          monorepoContext.rootDir
+        );
+        installSpinner.succeed("Installed dependencies");
+        installSucceeded = true;
+      } catch {
+        installSpinner.warn(
+          `Failed to install dependencies. Run '${packageManager} install' from monorepo root.`
+        );
+      }
+    }
+    console.log();
+    console.log(
+      chalk.green("\u2714"),
+      chalk.bold(`Created ${typeLabel} at`),
+      chalk.cyan(path4.relative(monorepoContext.rootDir, packageDir))
+    );
+    console.log();
+    if (answers.projectType === "webapp" && installSucceeded) {
+      const devStarted = await autoRunWebapp(packageDir);
+      if (devStarted) return;
+    }
+    printNextStepsExisting(answers, options, packageDir);
+  } else {
+    const isBareMonorepo = answers.projectType === "monorepo";
+    const targetDir = answers.directory;
+    const packageDir = isBareMonorepo ? null : path4.join(targetDir, "packages", answers.name);
+    if (isBareMonorepo) {
+      console.log(chalk.dim("  Type:"), typeLabel);
+      console.log(chalk.dim("  Directory:"), targetDir);
+      console.log(chalk.dim("  Name:"), config.name);
+      console.log(chalk.dim("  Title:"), config.title);
+    } else {
+      console.log(chalk.dim("  Package type:"), typeLabel);
+      console.log(chalk.dim("  Monorepo directory:"), targetDir);
+      console.log(chalk.dim("  Package:"), `packages/${answers.name}/`);
+      console.log(chalk.dim("  Name:"), config.name);
+      console.log(chalk.dim("  Title:"), config.title);
+      if (answers.projectType === "webapp") {
+        console.log(chalk.dim("  Database:"), config.dbName);
+      }
+    }
+    console.log();
+    if (await fs4.pathExists(targetDir)) {
+      const files = await fs4.readdir(targetDir);
+      if (files.length > 0) {
+        console.error(
+          chalk.red(`Error: Directory ${targetDir} is not empty.`)
+        );
+        process.exit(1);
+      }
+    }
+    const monoSpinner = ora("Copying monorepo template...").start();
+    try {
+      await copyTemplate(targetDir, "monorepo");
+      monoSpinner.succeed("Copied monorepo template");
+    } catch (error) {
+      monoSpinner.fail("Failed to copy monorepo template");
+      console.error(error);
+      process.exit(1);
+    }
+    const monoReplaceSpinner = ora(
+      "Replacing monorepo placeholders..."
+    ).start();
+    try {
+      const stats = await replacePlaceholders(targetDir, config);
+      monoReplaceSpinner.succeed(
+        `Replaced placeholders in ${stats.modified} monorepo files`
+      );
+    } catch (error) {
+      monoReplaceSpinner.fail("Failed to replace monorepo placeholders");
+      console.error(error);
+      process.exit(1);
+    }
+    if (packageDir) {
+      const pkgSpinner = ora("Copying package template...").start();
+      try {
+        await copyTemplate(packageDir, answers.projectType);
+        pkgSpinner.succeed("Copied package template");
+      } catch (error) {
+        pkgSpinner.fail("Failed to copy package template");
+        console.error(error);
+        process.exit(1);
+      }
+      const pkgReplaceSpinner = ora(
+        "Replacing package placeholders..."
+      ).start();
+      try {
+        const stats = await replacePlaceholders(packageDir, config);
+        pkgReplaceSpinner.succeed(
+          `Replaced placeholders in ${stats.modified} package files`
+        );
+      } catch (error) {
+        pkgReplaceSpinner.fail("Failed to replace package placeholders");
+        console.error(error);
+        process.exit(1);
+      }
+      await writeMosaicFiles(packageDir, config, answers.projectType);
+      if (answers.projectType === "webapp") {
+        await generateEnvLocal(packageDir);
+      }
+      if (answers.projectType === "webapp") {
+        await relocateWorkflowsToRoot(packageDir, targetDir, config.name);
+      }
+    }
+    const gitSpinner = ora("Initializing git repository...").start();
+    try {
+      execSync("git init", { cwd: targetDir, stdio: "ignore" });
+      execSync("git add -A", { cwd: targetDir, stdio: "ignore" });
+      execSync('git commit -m "Initial commit from @percepta/create"', {
+        cwd: targetDir,
+        stdio: "ignore"
+      });
+      gitSpinner.succeed("Initialized git repository");
+    } catch {
+      gitSpinner.warn("Failed to initialize git repository");
+    }
+    let installSucceeded = false;
+    if (answers.installDeps) {
+      const packageManager = PACKAGE_MANAGER;
+      const installSpinner = ora(
+        `Installing dependencies with ${packageManager}...`
+      ).start();
+      try {
+        await runPackageManagerInstall(packageManager, targetDir);
+        installSpinner.succeed("Installed dependencies");
+        installSucceeded = true;
+      } catch {
+        installSpinner.warn(
+          `Failed to install dependencies. Run '${packageManager} install' manually.`
+        );
+      }
+    }
+    console.log();
+    console.log(
+      chalk.green("\u2714"),
+      chalk.bold(isBareMonorepo ? `Created ${typeLabel} at` : "Created monorepo at"),
+      chalk.cyan(targetDir)
+    );
+    if (!isBareMonorepo) {
+      console.log(
+        chalk.green("\u2714"),
+        chalk.bold(`Created ${typeLabel} at`),
+        chalk.cyan(`packages/${answers.name}/`)
+      );
+    }
+    console.log();
+    if (packageDir && answers.projectType === "webapp" && installSucceeded) {
+      const devStarted = await autoRunWebapp(packageDir);
+      if (devStarted) return;
+    }
+    printNextStepsNew(answers, options, targetDir);
+  }
+}
+function printWebappNextSteps(params) {
+  const {
+    pm,
+    answers,
+    variant,
+    monorepoRelativePath,
+    packageRelativePath
+  } = params;
+  const repoRel = shPath(monorepoRelativePath) || ".";
+  const pkgFromRoot = `packages/${answers.name}`;
+  const pnpmSteps = ["pnpm run setup", "pnpm dev"];
+  if (variant === "new") {
+    const oneLinerParts2 = [];
+    if (repoRel !== ".") oneLinerParts2.push(`cd ${repoRel}`);
+    if (!answers.installDeps) oneLinerParts2.push(`${pm} install`);
+    oneLinerParts2.push(`cd ${pkgFromRoot}`, ...pnpmSteps);
+    console.log(chalk.bold("Copy-paste (from your current directory):"));
+    console.log();
+    console.log(chalk.cyan(`  ${oneLinerParts2.join(" && ")}`));
+    console.log();
+    console.log(chalk.bold("Or step by step:"));
+    console.log();
+    let step2 = 1;
+    if (repoRel !== ".") {
+      console.log(chalk.dim(`  ${step2++}.`), `cd ${repoRel}`);
+    }
+    if (!answers.installDeps) {
+      console.log(chalk.dim(`  ${step2++}.`), `${pm} install`);
+    }
+    console.log(chalk.dim(`  ${step2++}.`), `cd ${pkgFromRoot}`);
+    for (const cmd of pnpmSteps) {
+      console.log(chalk.dim(`  ${step2++}.`), cmd);
+    }
+    return;
+  }
+  const pkgRel = shPath(packageRelativePath ?? ".") || ".";
+  const oneLinerParts = [];
+  if (!answers.installDeps) {
+    if (repoRel !== ".") oneLinerParts.push(`cd ${repoRel}`);
+    oneLinerParts.push(`${pm} install`, `cd ${pkgFromRoot}`);
+  } else if (pkgRel !== ".") {
+    oneLinerParts.push(`cd ${pkgRel}`);
+  }
+  oneLinerParts.push(...pnpmSteps);
+  console.log(chalk.bold("Copy-paste (from your current directory):"));
+  console.log();
+  console.log(chalk.cyan(`  ${oneLinerParts.join(" && ")}`));
+  console.log();
+  console.log(chalk.bold("Or step by step:"));
+  console.log();
+  let step = 1;
+  if (!answers.installDeps) {
+    if (repoRel !== ".") {
+      console.log(chalk.dim(`  ${step++}.`), `cd ${repoRel}`);
+    }
+    console.log(chalk.dim(`  ${step++}.`), `${pm} install`);
+    console.log(chalk.dim(`  ${step++}.`), `cd ${pkgFromRoot}`);
+  } else if (pkgRel !== ".") {
+    console.log(chalk.dim(`  ${step++}.`), `cd ${pkgRel}`);
+  }
+  for (const cmd of pnpmSteps) {
+    console.log(chalk.dim(`  ${step++}.`), cmd);
+  }
+}
+async function warnIfMissingRootNpmrc(rootDir) {
+  const rootNpmrc = path4.join(rootDir, ".npmrc");
+  let contents = "";
+  if (await fs4.pathExists(rootNpmrc)) {
+    contents = await fs4.readFile(rootNpmrc, "utf8");
+  }
+  if (contents.includes("@percepta:registry")) {
+    return;
+  }
+  console.log();
+  console.log(
+    chalk.yellow("!"),
+    chalk.bold("Root .npmrc is missing @percepta registry config.")
+  );
+  console.log(
+    chalk.dim(
+      "  pnpm reads .npmrc from the workspace root, so add these lines to"
+    )
+  );
+  console.log(chalk.dim(`  ${path4.join(rootDir, ".npmrc")}:`));
+  console.log();
+  console.log(
+    chalk.cyan("    @percepta:registry=https://registry.npmjs.org/")
+  );
+  console.log(
+    chalk.cyan("    //registry.npmjs.org/:_authToken=${NPM_TOKEN}")
+  );
+  console.log();
+}
+function printNextStepsNew(answers, options, targetDir) {
+  const pm = PACKAGE_MANAGER;
+  const relativePath = path4.relative(process.cwd(), targetDir) || ".";
+  console.log("Next steps:");
+  console.log();
+  switch (answers.projectType) {
+    case "monorepo": {
+      let step = 1;
+      const repoRel = shPath(relativePath);
+      if (repoRel !== ".") {
+        console.log(chalk.dim(`  ${step++}.`), `cd ${repoRel}`);
+      }
+      if (!answers.installDeps) {
+        console.log(chalk.dim(`  ${step++}.`), `${pm} install`);
+      }
+      console.log(
+        chalk.dim(`  ${step++}.`),
+        `Add a package: ${chalk.cyan(`npx @percepta/create --type webapp <name>`)}`
+      );
+      break;
+    }
+    case "webapp":
+      printWebappNextSteps({
+        pm,
+        answers,
+        variant: "new",
+        monorepoRelativePath: relativePath
+      });
+      break;
+    case "library": {
+      let step = 1;
+      const repoRel = shPath(relativePath);
+      if (repoRel !== ".") {
+        console.log(chalk.dim(`  ${step++}.`), `cd ${repoRel}`);
+      }
+      if (!answers.installDeps) {
+        console.log(chalk.dim(`  ${step++}.`), `${pm} install`);
+      }
+      console.log(
+        chalk.dim(`  ${step++}.`),
+        `cd packages/${answers.name}`
+      );
+      console.log(chalk.dim(`  ${step++}.`), `${pm} dev`);
+      console.log(
+        chalk.dim(`  ${step++}.`),
+        `Edit src/index.ts to add your library code`
+      );
+      break;
+    }
+  }
+  console.log();
+  console.log(
+    chalk.dim("For more information, see the README.md in your project.")
+  );
+  console.log();
+}
+function printNextStepsExisting(answers, options, packageDir) {
+  const pm = PACKAGE_MANAGER;
+  const packageRelativePath = path4.relative(process.cwd(), packageDir) || ".";
+  const monorepoRoot = path4.dirname(path4.dirname(packageDir));
+  const monorepoRelativePath = path4.relative(process.cwd(), monorepoRoot) || ".";
+  console.log("Next steps:");
+  console.log();
+  switch (answers.projectType) {
+    case "webapp":
+      printWebappNextSteps({
+        pm,
+        answers,
+        variant: "existing",
+        monorepoRelativePath,
+        packageRelativePath
+      });
+      break;
+    case "library": {
+      let step = 1;
+      const pkgRel = shPath(packageRelativePath);
+      if (pkgRel !== ".") {
+        console.log(chalk.dim(`  ${step++}.`), `cd ${pkgRel}`);
+      }
+      console.log(chalk.dim(`  ${step++}.`), `${pm} dev`);
+      console.log(
+        chalk.dim(`  ${step++}.`),
+        "Edit src/index.ts to add your library code"
+      );
+      break;
+    }
+  }
+  console.log();
+  console.log(
+    chalk.dim("For more information, see the README.md in your project.")
+  );
+  console.log();
+}
+
+// src/index.ts
+var packageJson = {
+  name: "@percepta/create",
+  version: "1.0.0"
+};
+program.name("create").description("Scaffold and manage Mosaic packages").version(packageJson.version);
+program.command("create", { isDefault: true }).description("Scaffold a new Mosaic package").option("-t, --type <type>", "Package type: monorepo, webapp, or library").option("--name <name>", "Project name").option("--skip-install", "Skip dependency installation (also skips the auto-run setup + dev + browser)", false).option("-y, --yes", "Skip all prompts and use defaults", false).action(createProject);
+program.command("status").description("Show template sync status for current app").option(
+  "--mosaic-template-path <path>",
+  "Path to local mosaic repo checkout"
+).action(async (options) => {
+  const { statusCommand } = await import("./status-MITGDLTT.js");
+  await statusCommand(options);
+});
+program.command("sync").description("Generate downstream sync context (template \u2192 app)").option(
+  "--mosaic-template-path <path>",
+  "Path to local mosaic repo checkout"
+).option("--to <version>", "Target template version (default: latest)").action(async (options) => {
+  const { syncCommand } = await import("./sync-J4SFZHDX.js");
+  await syncCommand(options);
+});
+program.command("upstream").description("Generate upstream context (app \u2192 template)").option(
+  "--mosaic-template-path <path>",
+  "Path to local mosaic repo checkout"
+).option("--files <patterns...>", "Specific files to propose upstream").action(async (options) => {
+  const { upstreamCommand } = await import("./upstream-AQI7P4EU.js");
+  await upstreamCommand(options);
+});
+program.command("init").description("Add .mosaic-template.json to an existing app").option("-t, --type <type>", "Template type (e.g., webapp, library)").option("--template-version <version>", "Template version to set").action(async (options) => {
+  const { initCommand } = await import("./init-Z4VGBHAK.js");
+  await initCommand(options);
+});
+program.parse();