@multiplatform.one/cli 7.10.0 → 7.15.0

package/src/commands/init.ts

@@ -1,671 +1,229 @@
-import { execSync } from "node:child_process";
-import { type Dirent, existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import inquirer from "inquirer";
-
-const repoUrl = "https://gitlab.com/bitspur/frappe/multiplatform.one.git";
-
-const services = ["frappe", "solana", "ethereum", "sui"] as const;
-
-/** Resolve a service name to its relative directory from the project root. */
-function serviceDir(name: string): string {
-  return `apps/${name}`;
-}
-// vscode + webext are no longer standalone apps: they are delivery targets
-// of the One platform app (apps/one/vscode, apps/one/webext) and ride with
-// the "one" selection.
-const apps = ["one", "keycloak", "storybook", "storybook-expo", "vocs"] as const;
-
-type Service = (typeof services)[number];
-type App = (typeof apps)[number];
-
-/** env variable prefixes to remove per service */
-const serviceEnvPrefixes: Record<Service, string[]> = {
-  frappe: ["FRAPPE_", "MARIADB_"],
-  solana: [],
-  ethereum: [],
-  sui: [],
-};
-
-/** env variable prefixes to remove per app */
-const appEnvPrefixes: Record<App, string[]> = {
-  one: ["ONE_", "VSCODE_", "WEBEXT_"],
-  keycloak: ["KEYCLOAK_"],
-  storybook: ["STORYBOOK_", "VR_DIFFING_ENGINE="],
-  "storybook-expo": [],
-  vocs: ["VOCS_"],
-};
-
-/** env section headers (comments) to remove per app/service */
-const serviceEnvSections: Record<Service, string[]> = {
-  frappe: ["# frappe", "# mariadb"],
-  solana: [],
-  ethereum: [],
-  sui: [],
-};
-
-const appEnvSections: Record<App, string[]> = {
-  one: ["# one", "# vscode", "# webext"],
-  keycloak: ["# keycloak"],
-  storybook: ["# storybook"],
-  "storybook-expo": [],
-  vocs: ["# vocs"],
-};
-
-/** launch.json configuration names per service/app */
-const serviceLaunchNames: Record<Service, string[]> = {
-  frappe: ["frappe dev"],
-  solana: ["solana dev", "solana localnet"],
-  ethereum: ["ethereum dev"],
-  sui: ["sui dev"],
-};
+/**
+ * `mpo init`: a consumer project is the multiplatform.one monorepo at one
+ * commit, pruned. scripts/scaffold.sh does the work (clone or archive at
+ * the ref, drop public/ and the singleton apps not asked for, rename
+ * apps/one to each product app, rewrite workspace: ranges to semver); this
+ * command picks the commit, asks what to keep, and finishes the repo.
+ */
 
-const appLaunchNames: Record<App, string[]> = {
-  one: ["one dev", "vscode dev", "webext dev"],
-  keycloak: ["keycloak dev", "keycloak storybook"],
-  storybook: ["storybook dev"],
-  "storybook-expo": ["storybook-expo dev"],
-  vocs: ["vocs dev"],
+import { existsSync, readdirSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import inquirer from "inquirer";
+import spawn from "nano-spawn";
+import { resolveSource, type SourceSpec } from "../source";
+import { mpoRange, validateName } from "./provenance";
+import { runScaffold, ScaffoldError } from "./scaffold";
+
+/** The apps that exist once per project; everything else under apps/ is a product app. */
+export const SINGLETON_APPS = [
+  "ethereum",
+  "frappe",
+  "keycloak",
+  "solana",
+  "storybook",
+  "storybook-expo",
+  "sui",
+  "uxpin",
+  "vocs",
+] as const;
+export type SingletonApp = (typeof SINGLETON_APPS)[number];
+
+const SINGLETON_DESCRIPTIONS: Record<SingletonApp, string> = {
+  ethereum: "Hardhat chain + contracts",
+  frappe: "Frappe bench (backend, docker compose)",
+  keycloak: "Keycloak theme + realm (auth, docker compose)",
+  solana: "Anchor programs + localnet",
+  storybook: "Storybook (web)",
+  "storybook-expo": "Storybook (native)",
+  sui: "Move packages + localnet",
+  uxpin: "UXPin Merge library",
+  vocs: "Docs site",
 };
 
-interface InitOptions {
-  name?: string;
-  services?: string;
-  apps?: string;
+export interface InitOptions {
+  /** Product apps besides the project name (each is a renamed apps/one). */
+  apps?: string[];
+  /** Singleton apps to keep. */
+  services?: string[];
+  /** Path or url to scaffold from instead of the CLI's recorded source. */
+  source?: string;
+  /** Commit, tag or branch at that source. */
   checkout?: string;
-  /** Path to clone.sh script (from CLI); if set, clone via script instead of execSync */
-  cloneScript?: string;
+  /** Range for @multiplatform.one/* (default: ^<cli version at the source>). */
+  mpoVersion?: string;
+  skipInstall?: boolean;
+  skipGit?: boolean;
+  /** Non-interactive: no prompts, no services unless passed. */
+  yes?: boolean;
+  /** Scaffold into an existing (non-empty) directory. */
+  into?: boolean;
+  /** Show the scaffold's per-path progress. */
+  verbose?: boolean;
 }
 
-/**
- * Shared modify step: remove unselected apps/services and rewrite configs.
- * Used by both init (with prompted selections) and update (with getPresentApps/getPresentServices).
- */
-export function runModifyStep(
-  dir: string,
-  selectedServices: string[],
-  selectedApps: string[],
-): void {
-  const services = selectedServices as Service[];
-  const apps = selectedApps as App[];
+function unique(values: string[]): string[] {
+  return [...new Set(values)];
+}
 
+export function validateServices(services: string[]): SingletonApp[] {
+  const known = new Set<string>(SINGLETON_APPS);
   for (const service of services) {
-    if (!services.includes(service)) {
-      const servicePath = join(dir, serviceDir(service));
-      if (existsSync(servicePath)) {
-        rmSync(servicePath, { recursive: true });
-        console.log(`Removed service: ${service}`);
-      }
-    }
-  }
-
-  for (const app of apps) {
-    if (!apps.includes(app)) {
-      const appPath = join(dir, "apps", app);
-      if (existsSync(appPath)) {
-        rmSync(appPath, { recursive: true });
-        console.log(`Removed app: ${app}`);
-      }
-    }
-  }
-
-  const packagesDir = join(dir, "packages");
-  if (existsSync(packagesDir)) {
-    const versionMap = new Map<string, string>();
-    for (const pkg of readdirSync(packagesDir)) {
-      const pkgJsonPath = join(packagesDir, pkg, "package.json");
-      if (existsSync(pkgJsonPath)) {
-        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-        if (pkgJson.name && pkgJson.version) {
-          versionMap.set(pkgJson.name, pkgJson.version);
-        }
-      }
-    }
-    for (const pkg of readdirSync(packagesDir)) {
-      const pkgJsonPath = join(packagesDir, pkg, "package.json");
-      if (existsSync(pkgJsonPath)) {
-        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-        if (!pkgJson.private) {
-          rmSync(join(packagesDir, pkg), { recursive: true });
-          console.log(`Removed public package: ${pkgJson.name}`);
-        }
+    if (!known.has(service)) {
+      throw new Error(
+        `Unknown service "${service}". Services are the singleton apps: ${SINGLETON_APPS.join(", ")}`,
+      );
+    }
+  }
+  return unique(services).sort() as SingletonApp[];
+}
+
+async function promptServices(): Promise<SingletonApp[]> {
+  const result = await inquirer.prompt([
+    {
+      message: "Which singleton apps should the project keep? (space to toggle, enter to confirm)",
+      name: "services",
+      type: "checkbox",
+      choices: SINGLETON_APPS.map((service) => ({
+        name: `${service} — ${SINGLETON_DESCRIPTIONS[service]}`,
+        value: service,
+        checked: false,
+      })),
+    },
+  ]);
+  return validateServices(result.services as string[]);
+}
+
+async function insideGitRepo(dir: string): Promise<boolean> {
+  return spawn("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir }).then(
+    () => true,
+    () => false,
+  );
+}
+
+async function scaffoldWithFallback(
+  spec: SourceSpec,
+  request: Parameters<typeof runScaffold>[0],
+): Promise<Awaited<ReturnType<typeof runScaffold>>> {
+  try {
+    return await runScaffold({ ...request, source: spec.source, ref: spec.ref });
+  } catch (err) {
+    if (spec.origin !== "tag" || !(err instanceof ScaffoldError)) throw err;
+    console.warn(`⚠️  ${err.message}; retrying from main`);
+    return runScaffold({ ...request, source: spec.source, ref: "main" });
+  }
+}
+
+export async function init(nameArg: string | undefined, options: InitOptions = {}): Promise<void> {
+  const interactive = !options.yes && process.stdout.isTTY;
+
+  // --into: the argument is the directory; the product app is named after it.
+  let targetDir: string;
+  let name: string;
+  if (options.into) {
+    targetDir = resolve(nameArg ?? ".");
+    name = validateName(options.apps?.[0] ?? basename(targetDir));
+  } else {
+    let projectName = nameArg;
+    if (!projectName) {
+      if (!interactive) {
+        projectName = "my-app";
+      } else {
+        const result = await inquirer.prompt([
+          { message: "What is the app name?", name: "name", type: "input", default: "my-app" },
+        ]);
+        projectName = result.name as string;
       }
     }
-    convertWorkspaceVersions(dir, versionMap);
-  }
-
-  cleanupPnpmWorkspace(dir, services, apps);
-  cleanupLaunchJson(dir, services, apps);
-  cleanupEnvFiles(dir, services, apps);
-  cleanupTsconfigs(dir);
-  cleanupMisc(dir);
-  removeLicenseHeaders(dir);
-}
-
-export async function init(nameArg: string | undefined, options: InitOptions) {
-  let projectName = nameArg;
-  if (!projectName) {
-    const result = await inquirer.prompt([
-      {
-        message: "What is the project name?",
-        name: "name",
-        type: "input",
-        default: "my-app",
-      },
-    ]);
-    projectName = result.name as string;
+    name = validateName(projectName);
+    targetDir = resolve(name);
   }
+  const apps = unique([name, ...(options.apps ?? []).map(validateName)]);
 
-  let selectedServices: Service[];
+  let services: SingletonApp[];
   if (options.services) {
-    selectedServices = options.services.split(",").map((s) => s.trim()) as Service[];
+    services = validateServices(options.services);
+  } else if (interactive) {
+    services = await promptServices();
   } else {
-    const result = await inquirer.prompt([
-      {
-        message: "Select services:",
-        name: "services",
-        type: "checkbox",
-        choices: services.map((s) => ({ name: s, value: s })),
-      },
-    ]);
-    selectedServices = result.services as Service[];
-  }
-
-  let selectedApps: App[];
-  if (options.apps) {
-    selectedApps = options.apps.split(",").map((s) => s.trim()) as App[];
-  } else {
-    const result = await inquirer.prompt([
-      {
-        message: "Select apps:",
-        name: "apps",
-        type: "checkbox",
-        choices: apps.map((a) => ({
-          name: a,
-          value: a,
-          checked: a === "one",
-        })),
-      },
-    ]);
-    selectedApps = result.apps as App[];
+    services = [];
   }
 
-  // Target dir: when project name is provided, use ./<name>; when not provided, we prompted above (default "my-app"). Init cannot run inside an existing git repo (enforced by CLI).
-  const targetDir = resolve(projectName);
-
-  if (existsSync(targetDir)) {
-    const entries = readdirSync(targetDir);
-    if (entries.length > 0) {
-      throw new Error(`Directory "${targetDir}" already exists and is not empty`);
-    }
-  }
-
-  // Clone repository (via script when provided by CLI, else inline)
-  const branch = options.checkout || "main";
-  console.log("\nCloning repository...");
-  if (options.cloneScript) {
-    execSync(`sh "${options.cloneScript}" "${repoUrl}" "${branch}" "${targetDir}"`, {
-      stdio: "inherit",
-    });
-  } else {
-    execSync(`git clone --depth 1 --branch "${branch}" ${repoUrl} "${targetDir}"`, {
-      stdio: "inherit",
-    });
-  }
-
-  // Remove .git to start fresh
-  rmSync(join(targetDir, ".git"), { recursive: true, force: true });
-
-  runModifyStep(targetDir, selectedServices, selectedApps);
-
-  // Init-only: update root package.json name
-  const rootPkgPath = join(targetDir, "package.json");
-  if (existsSync(rootPkgPath)) {
-    const rootPkg = JSON.parse(readFileSync(rootPkgPath, "utf-8"));
-    rootPkg.name = projectName;
-    rootPkg.packageManager = undefined;
-    writeFileSync(rootPkgPath, `${JSON.stringify(rootPkg, null, 2)}\n`);
-  }
-
-  // Copy .env.example to .env if it exists
-  const envDefaultPath = join(targetDir, ".env.example");
-  const envPath = join(targetDir, ".env");
-  if (existsSync(envDefaultPath) && !existsSync(envPath)) {
-    writeFileSync(envPath, readFileSync(envDefaultPath, "utf-8"));
-  }
-
-  // Remove storybook baselines
-  const lostpixelBaseline = join(targetDir, "apps", "storybook", ".lostpixel", "baseline");
-  if (existsSync(lostpixelBaseline)) {
-    rmSync(lostpixelBaseline, { recursive: true });
-  }
-
-  // Remove pnpm-lock.yaml for fresh install
-  const lockfile = join(targetDir, "pnpm-lock.yaml");
-  if (existsSync(lockfile)) {
-    rmSync(lockfile);
-  }
-
-  // Remove scaffolding artifacts
-  for (const artifact of [
-    "agent-os",
-    "public/cli/scripts/init.sh",
-    "public/cli/scripts/update.sh",
-    ".changeset",
-  ]) {
-    const p = join(targetDir, artifact);
-    if (existsSync(p)) {
-      rmSync(p, { recursive: true, force: true });
-    }
-  }
-
-  // Initialize project
-  console.log("\nInstalling dependencies...");
-  execSync("pnpm install", { cwd: targetDir, stdio: "inherit" });
-
-  console.log("\nInitializing git repository...");
-  execSync("git init", { cwd: targetDir, stdio: "inherit" });
-  execSync("git add -A", { cwd: targetDir, stdio: "inherit" });
-  execSync('git commit -m "Initial commit from multiplatform.one"', {
-    cwd: targetDir,
-    stdio: "inherit",
-  });
-
-  console.log(`\n✅ Project created at ${targetDir}`);
-  console.log("\nNext steps:");
-  console.log(`  cd ${projectName}`);
-  console.log("  pnpm dev");
-}
-
-function convertWorkspaceVersions(dir: string, versionMap: Map<string, string>) {
-  const files = findPackageJsonFiles(dir);
-  for (const file of files) {
-    const content = JSON.parse(readFileSync(file, "utf-8"));
-    let changed = false;
-    for (const depType of ["dependencies", "devDependencies", "peerDependencies"]) {
-      const deps = content[depType] as Record<string, string> | undefined;
-      if (!deps) continue;
-      for (const [depName, version] of Object.entries(deps)) {
-        if (typeof version === "string" && version.startsWith("workspace:")) {
-          const realVersion = versionMap.get(depName);
-          if (realVersion) {
-            // workspace:* -> ^version, workspace:^x -> ^x (keep the range)
-            const workspaceRange = version.replace("workspace:", "");
-            deps[depName] =
-              workspaceRange === "*" || workspaceRange === "^" ? `^${realVersion}` : workspaceRange;
-            changed = true;
-          }
-        }
-      }
-    }
-    if (changed) {
-      writeFileSync(file, `${JSON.stringify(content, null, 2)}\n`);
-    }
-  }
-}
-
-function findPackageJsonFiles(dir: string): string[] {
-  const results: string[] = [];
-  function walk(d: string) {
-    let entries: Dirent[];
-    try {
-      entries = readdirSync(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join(d, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (entry.name === "package.json") results.push(full);
-    }
-  }
-  walk(dir);
-  return results;
-}
-
-function cleanupPnpmWorkspace(dir: string, _services: Service[], _apps: App[]) {
-  const wsPath = join(dir, "pnpm-workspace.yaml");
-  if (!existsSync(wsPath)) return;
-
-  let content = readFileSync(wsPath, "utf-8");
-
-  // If no apps remain, remove apps/* entry
-  const appsDir = join(dir, "apps");
-  if (!existsSync(appsDir) || readdirSync(appsDir).length === 0) {
-    content = content.replace(/^\s*-\s*['"]?apps\/\*['"]?\s*$/gm, "");
-  }
-
-  // Check if packages dir still has entries
-  const pkgDir = join(dir, "packages");
-  if (!existsSync(pkgDir) || readdirSync(pkgDir).length === 0) {
-    content = content.replace(/^\s*-\s*['"]?packages\/\*['"]?\s*$/gm, "");
-  }
-
-  // Clean up multiple blank lines
-  content = `${content.replace(/\n{3,}/g, "\n\n").trim()}\n`;
-  writeFileSync(wsPath, content);
-}
-
-function cleanupLaunchJson(dir: string, services: Service[], apps: App[]) {
-  const launchPath = join(dir, ".vscode", "launch.json");
-  if (!existsSync(launchPath)) return;
-
-  const launch = JSON.parse(readFileSync(launchPath, "utf-8"));
-  const removedNames = new Set<string>();
-
-  // Collect names to remove for unselected services
-  for (const service of services) {
-    if (!services.includes(service)) {
-      for (const configName of serviceLaunchNames[service]) {
-        removedNames.add(configName);
-      }
-    }
-  }
-
-  // Collect names to remove for unselected apps
-  for (const app of apps) {
-    if (!apps.includes(app)) {
-      for (const configName of appLaunchNames[app]) {
-        removedNames.add(configName);
-      }
-    }
-  }
-
-  // Filter configurations
-  if (launch.configurations) {
-    launch.configurations = launch.configurations.filter(
-      (c: { name: string }) => !removedNames.has(c.name),
+  if (existsSync(targetDir) && readdirSync(targetDir).length > 0 && !options.into) {
+    throw new Error(
+      `Directory "${targetDir}" already exists and is not empty. ` +
+        "Pass --into to scaffold into it (paths that already exist are kept and pinned in " +
+        ".updateignore), or pick another name.",
     );
   }
 
-  // Filter compound configurations and remove empty compounds
-  if (launch.compounds) {
-    for (const compound of launch.compounds) {
-      if (compound.configurations) {
-        compound.configurations = compound.configurations.filter(
-          (configName: string) => !removedNames.has(configName),
-        );
-      }
-    }
-    launch.compounds = launch.compounds.filter(
-      (c: { configurations?: string[] }) => c.configurations && c.configurations.length > 0,
-    );
-  }
-
-  writeFileSync(launchPath, `${JSON.stringify(launch, null, 2)}\n`);
-}
+  const spec = resolveSource({ source: options.source, checkout: options.checkout });
+  if (spec.warning) console.warn(`⚠️  ${spec.warning}`);
 
-function cleanupEnvFiles(dir: string, services: Service[], apps: App[]) {
-  for (const envFile of [".env.example", ".env"]) {
-    const filePath = join(dir, envFile);
-    if (!existsSync(filePath)) continue;
+  console.log(`\nScaffolding ${targetDir} from ${spec.source} @ ${spec.ref}`);
+  console.log(`  apps      ${apps.join(", ")}`);
+  console.log(`  services  ${services.length ? services.join(", ") : "(none)"}`);
 
-    let lines = readFileSync(filePath, "utf-8").split("\n");
-
-    // Remove lines for unselected services
-    for (const service of services) {
-      if (!services.includes(service)) {
-        const prefixes = serviceEnvPrefixes[service];
-        const sections = serviceEnvSections[service];
-        lines = filterEnvLines(lines, prefixes, sections);
-      }
-    }
-
-    // Remove lines for unselected apps
-    for (const app of apps) {
-      if (!apps.includes(app)) {
-        const prefixes = appEnvPrefixes[app];
-        const sections = appEnvSections[app];
-        lines = filterEnvLines(lines, prefixes, sections);
-      }
-    }
-
-    // Clean up multiple blank lines
-    const content = lines
-      .join("\n")
-      .replace(/\n{3,}/g, "\n\n")
-      .trim();
-    writeFileSync(filePath, `${content}\n`);
-  }
-}
-
-function filterEnvLines(lines: string[], prefixes: string[], sections: string[]): string[] {
-  return lines.filter((line) => {
-    const trimmed = line.trim();
-    // Remove section headers
-    for (const section of sections) {
-      if (trimmed === section) return false;
-    }
-    // Remove lines with matching prefixes
-    for (const prefix of prefixes) {
-      if (prefix.endsWith("=")) {
-        // Exact match like "VR_DIFFING_ENGINE="
-        if (trimmed.startsWith(prefix)) return false;
-      } else {
-        // Prefix match like "FRAPPE_"
-        if (trimmed.startsWith(prefix) || trimmed.startsWith(`# ${prefix}`)) return false;
-      }
-    }
-    return true;
+  const provenance = await scaffoldWithFallback(spec, {
+    source: spec.source,
+    ref: spec.ref,
+    target: targetDir,
+    apps,
+    services,
+    mpoVersion: options.mpoVersion ? mpoRange(options.mpoVersion) : undefined,
+    into: options.into,
+    verbose: options.verbose,
   });
-}
-
-function cleanupTsconfigs(dir: string) {
-  const tsconfigFiles = findTsconfigFiles(dir);
-  for (const file of tsconfigFiles) {
-    try {
-      const content = readFileSync(file, "utf-8");
-      // Parse JSON with comments (tsconfig allows comments)
-      const json = JSON.parse(stripJsonComments(content));
-      if (!json.references) continue;
-
-      let changed = false;
-      json.references = json.references.filter((ref: { path: string }) => {
-        const refPath = resolve(join(file, "..", ref.path));
-        // Check if the referenced path exists (could be a dir or file)
-        const pathExists =
-          existsSync(refPath) ||
-          existsSync(`${refPath}.json`) ||
-          existsSync(join(refPath, "tsconfig.json"));
-        if (!pathExists) changed = true;
-        return pathExists;
-      });
-
-      if (changed) {
-        writeFileSync(file, `${JSON.stringify(json, null, 2)}\n`);
-      }
-    } catch {
-      // Skip files that can't be parsed
-    }
-  }
-}
-
-function findTsconfigFiles(dir: string): string[] {
-  const results: string[] = [];
-  function walk(d: string) {
-    let entries: Dirent[];
-    try {
-      entries = readdirSync(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join(d, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (entry.name.startsWith("tsconfig") && entry.name.endsWith(".json")) {
-        results.push(full);
-      }
-    }
-  }
-  walk(dir);
-  return results;
-}
-
-function stripJsonComments(str: string): string {
-  // Simple JSON comment stripper for tsconfig files
-  return str.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-}
-
-function cleanupMisc(dir: string) {
-  // Remove docker dns dir (if generating from template)
-  for (const subdir of ["docker/dns"]) {
-    const p = join(dir, subdir);
-    if (existsSync(p)) {
-      rmSync(p, { recursive: true });
-    }
-  }
-
-  // Remove VSCode psi-header config from settings.json
-  const settingsPath = join(dir, ".vscode", "settings.json");
-  if (existsSync(settingsPath)) {
-    try {
-      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-      const psiKeys = Object.keys(settings).filter((k) => k.startsWith("psi-header"));
-      const cleaned = { ...settings };
-      for (const key of psiKeys) {
-        cleaned[key] = undefined;
-      }
-      // Filter out undefined keys by serializing
-      const filtered = JSON.parse(JSON.stringify(cleaned));
-      writeFileSync(settingsPath, `${JSON.stringify(filtered, null, 2)}\n`);
-    } catch {
-      // Skip if settings can't be parsed
-    }
-  }
-
-  // Remove psi-header from extensions.json recommendations
-  const extPath = join(dir, ".vscode", "extensions.json");
-  if (existsSync(extPath)) {
-    try {
-      const ext = JSON.parse(readFileSync(extPath, "utf-8"));
-      if (ext.recommendations) {
-        ext.recommendations = ext.recommendations.filter((r: string) => r !== "psioniq.psi-header");
-      }
-      writeFileSync(extPath, `${JSON.stringify(ext, null, 2)}\n`);
-    } catch {
-      // Skip if can't be parsed
-    }
-  }
-}
-
-const licenseIndicators = ["File:", "Project:", "File Created:", "Author:", "Licensed under"];
-
-function removeLicenseHeaders(dir: string) {
-  const files = findSourceFiles(dir);
-  for (const file of files) {
-    try {
-      const content = readFileSync(file, "utf-8");
-      // Check for block comment license header at start of file
-      const match = content.match(/^\s*\/\*[\s\S]*?\*\//);
-      if (match) {
-        const comment = match[0];
-        const isLicense = licenseIndicators.some((indicator) => comment.includes(indicator));
-        if (isLicense && match.index !== undefined) {
-          const cleaned = content.slice(match.index + comment.length).replace(/^\s*\n/, "");
-          writeFileSync(file, cleaned);
-        }
-      }
-    } catch {
-      // Skip files that can't be read
-    }
-  }
-
-  // Also handle hash-style license headers for shell/yaml/python files
-  const hashFiles = findHashCommentFiles(dir);
-  for (const file of hashFiles) {
-    try {
-      const content = readFileSync(file, "utf-8");
-      const lines = content.split("\n");
-      let headerEnd = 0;
-      let inHeader = false;
-
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (i === 0 && line.startsWith("#!")) {
-          // Skip shebang
-          continue;
-        }
-        if (
-          line.startsWith("# File:") ||
-          line.startsWith("# Project:") ||
-          line.startsWith("# File Created:") ||
-          line.startsWith("# Author:")
-        ) {
-          inHeader = true;
-          headerEnd = i + 1;
-          continue;
-        }
-        if (inHeader && line.startsWith("#")) {
-          headerEnd = i + 1;
-          continue;
-        }
-        if (inHeader && line.trim() === "") {
-          headerEnd = i + 1;
-          break;
-        }
-        if (inHeader) break;
-      }
-
-      if (inHeader && headerEnd > 0) {
-        const shebang = lines[0].startsWith("#!") ? `${lines[0]}\n\n` : "";
-        const remaining = lines
-          .slice(headerEnd)
-          .join("\n")
-          .replace(/^\s*\n/, "");
-        writeFileSync(file, `${shebang}${remaining}`);
-      }
-    } catch {
-      // Skip files that can't be read
-    }
+  const sha = provenance.source!.sha;
+  console.log(`  source    ${sha}`);
+
+  // A fresh project gets its scaffold commit; a directory already inside a
+  // repository (--into, or nested in another project) is left for the
+  // owner to commit.
+  let scaffoldCommitted = false;
+  if (!options.skipGit && !(await insideGitRepo(targetDir))) {
+    await spawn("git", ["init", "--quiet"], { cwd: targetDir });
+    await spawn("git", ["add", "-A"], { cwd: targetDir });
+    scaffoldCommitted = await spawn(
+      "git",
+      [
+        "commit",
+        "--quiet",
+        "-m",
+        `feat: scaffold from multiplatform.one ${sha.slice(0, 12)} (mpo init)`,
+      ],
+      { cwd: targetDir },
+    ).then(
+      () => true,
+      () => {
+        console.warn("⚠️  git commit failed (missing git identity?) — repo left staged.");
+        return false;
+      },
+    );
   }
-}
 
-function findSourceFiles(dir: string): string[] {
-  const results: string[] = [];
-  const extensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"]);
-  function walk(d: string) {
-    let entries: Dirent[];
-    try {
-      entries = readdirSync(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join(d, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else {
-        const ext = `.${entry.name.split(".").pop()}`;
-        if (extensions.has(ext)) results.push(full);
-      }
+  if (!options.skipInstall) {
+    console.log("\nInstalling dependencies...");
+    await spawn("pnpm", ["install"], { cwd: targetDir, stdio: "inherit" });
+    if (scaffoldCommitted) {
+      // The lockfile belongs to the scaffold commit so a fresh init is clean.
+      await spawn("git", ["add", "--", "pnpm-lock.yaml"], { cwd: targetDir })
+        .then(() => spawn("git", ["commit", "--amend", "--no-edit", "--quiet"], { cwd: targetDir }))
+        .catch(() => {});
     }
+  } else {
+    console.log("Skipped pnpm install (--skip-install).");
   }
-  walk(dir);
-  return results;
-}
 
-function findHashCommentFiles(dir: string): string[] {
-  const results: string[] = [];
-  const extensions = new Set([".sh", ".mk", ".yaml", ".yml", ".py"]);
-  function walk(d: string) {
-    let entries: Dirent[];
-    try {
-      entries = readdirSync(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join(d, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else {
-        const ext = `.${entry.name.split(".").pop()}`;
-        if (extensions.has(ext) || entry.name === "Makefile") results.push(full);
-      }
-    }
-  }
-  walk(dir);
-  return results;
+  console.log(`\n✅ Project created at ${targetDir}`);
+  console.log("\nNext steps:");
+  if (!options.into) console.log(`  cd ${basename(targetDir)}`);
+  if (options.skipInstall) console.log("  pnpm install");
+  if (options.into || options.skipGit) {
+    console.log('  git add -A && git commit -m "feat: scaffold from multiplatform.one (mpo init)"');
+  }
+  console.log("  pnpm dev        # web + native dev server");
+  if (services.includes("frappe"))
+    console.log("  make frappe/dev # Frappe bench (see apps/frappe)");
+  console.log("\nLater: `mpo update` merges monorepo changes into the project without committing;");
+  console.log("`mpo add-app <name>` adds another product app.");
 }