@multiplatform.one/cli 5.0.26 → 6.0.0

package/src/commands/init.ts

@@ -0,0 +1,682 @@
+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/multiplatform.one/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}`;
+}
+const apps = [
+  "one",
+  "keycloak",
+  "storybook",
+  "storybook-expo",
+  "vscode",
+  "webext",
+  "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_"],
+  keycloak: ["KEYCLOAK_"],
+  storybook: ["STORYBOOK_", "VR_DIFFING_ENGINE="],
+  "storybook-expo": [],
+  vscode: ["VSCODE_"],
+  webext: ["WEBEXT_"],
+  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"],
+  keycloak: ["# keycloak"],
+  storybook: ["# storybook"],
+  "storybook-expo": [],
+  vscode: ["# vscode"],
+  webext: ["# webext"],
+  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"],
+};
+
+const appLaunchNames: Record<App, string[]> = {
+  one: ["one dev"],
+  keycloak: ["keycloak dev", "keycloak storybook"],
+  storybook: ["storybook dev"],
+  "storybook-expo": ["storybook-expo dev"],
+  vscode: ["vscode dev"],
+  webext: ["webext dev"],
+  vocs: ["vocs dev"],
+};
+
+interface InitOptions {
+  name?: string;
+  services?: string;
+  apps?: string;
+  checkout?: string;
+  /** Path to clone.sh script (from CLI); if set, clone via script instead of execSync */
+  cloneScript?: string;
+}
+
+/**
+ * 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[];
+
+  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}`);
+        }
+      }
+    }
+    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;
+  }
+
+  let selectedServices: Service[];
+  if (options.services) {
+    selectedServices = options.services.split(",").map((s) => s.trim()) as Service[];
+  } 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[];
+  }
+
+  // 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),
+    );
+  }
+
+  // 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`);
+}
+
+function cleanupEnvFiles(dir: string, services: Service[], apps: App[]) {
+  for (const envFile of [".env.example", ".env"]) {
+    const filePath = join(dir, envFile);
+    if (!existsSync(filePath)) continue;
+
+    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;
+  });
+}
+
+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
+    }
+  }
+}
+
+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);
+      }
+    }
+  }
+  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;
+}