@sdeverywhere/create 0.1.0

package/dist/index.js

@@ -0,0 +1,725 @@
+// src/index.ts
+import { relative as relative3 } from "path";
+import { bgCyan, black, bold as bold6, cyan as cyan6, green as green8 } from "kleur/colors";
+import ora8 from "ora";
+import prompts8 from "prompts";
+import detectPackageManager from "which-pm-runs";
+import yargs from "yargs-parser";
+
+// src/step-config.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join as joinPath, parse as parsePath, relative, resolve as resolvePath } from "path";
+import { bold, cyan, dim, green, reset, yellow } from "kleur/colors";
+import ora from "ora";
+import prompts from "prompts";
+import yaml from "yaml";
+import { parseAndGenerate, preprocessModel } from "@sdeverywhere/compile";
+var sampleCheckContent = `# yaml-language-server: $schema=SCHEMA_PATH
+
+# NOTE: This is just a simple check to get you started.  Replace "Some output" with
+# the name of some variable you'd like to test.  Additional tests can be developed
+# in the "playground" (beta) inside the model-check report.
+- describe: Some output
+  tests:
+    - it: should be > 0 for all input scenarios
+      scenarios:
+        - preset: matrix
+      datasets:
+        - name: Some output
+      predicates:
+        - gt: 0
+`;
+async function updateSdeConfig(projDir, mdlPath) {
+  const configPath = joinPath(projDir, "sde.config.js");
+  let configText = await readFile(configPath, "utf8");
+  configText = configText.replaceAll("MODEL_NAME.mdl", mdlPath);
+  await writeFile(configPath, configText);
+}
+async function generateCheckYaml(projDir, mdlPath) {
+  const checkYamlFile = mdlPath.replace(".mdl", ".check.yaml");
+  const checkYamlPath = joinPath(projDir, checkYamlFile);
+  if (!existsSync(checkYamlPath)) {
+    let relProjPath = relative(dirname(checkYamlPath), projDir);
+    if (relProjPath.length === 0) {
+      relProjPath = "./";
+    }
+    const nodeModulesPart = joinPath(relProjPath, "node_modules");
+    const checkCorePart = "@sdeverywhere/check-core/schema/check.schema.json";
+    const schemaPath = `${nodeModulesPart}/${checkCorePart}`;
+    const checkContent = sampleCheckContent.replace("SCHEMA_PATH", schemaPath);
+    await writeFile(checkYamlPath, checkContent);
+  }
+}
+async function chooseGenConfig(projDir, mdlPath) {
+  let mdlVars;
+  try {
+    mdlVars = await readModelVars(projDir, mdlPath);
+  } catch (e) {
+    console.log(e);
+    ora(yellow("The mdl file failed to load. We will continue setting things up, and you can diagnose the issue later.")).warn();
+    return;
+  }
+  let initialTime;
+  let finalTime;
+  const validVars = [];
+  for (const v of mdlVars) {
+    const varName = v.name.toLowerCase();
+    let skip = false;
+    switch (varName) {
+      case "final time":
+        skip = true;
+        if (v.kind === "const") {
+          finalTime = v.value;
+        }
+        break;
+      case "initial time":
+        skip = true;
+        if (v.kind === "const") {
+          initialTime = v.value;
+        }
+        break;
+      case "saveper":
+      case "time":
+      case "time step":
+        skip = true;
+        break;
+      default:
+        break;
+    }
+    if (!skip) {
+      validVars.push(v);
+    }
+  }
+  if (initialTime === void 0) {
+    initialTime = 0;
+  }
+  if (finalTime === void 0) {
+    finalTime = 100;
+  }
+  const datFiles = [];
+  const datPart = datFiles.join(";");
+  const modelCsvFile = joinPath(projDir, "config", "model.csv");
+  const origModelCsvContent = await readFile(modelCsvFile, "utf8");
+  const modelCsvHeader = origModelCsvContent.split("\n")[0];
+  const modelCsvLine = `${initialTime},${finalTime},${initialTime},${finalTime},${datPart}`;
+  const newModelCsvContent = `${modelCsvHeader}
+${modelCsvLine}
+`;
+  await writeFile(modelCsvFile, newModelCsvContent);
+  await chooseGenGraphConfig(projDir, validVars);
+  console.log();
+  await chooseGenSliderConfig(projDir, validVars);
+}
+async function chooseGenGraphConfig(projDir, mdlVars) {
+  const genResponse = await prompts({
+    type: "confirm",
+    name: "genGraph",
+    message: `Would you like to configure a graph to get you started? ${reset(dim("(recommended)"))}`,
+    initial: true
+  }, {
+    onCancel: () => {
+      ora().info(dim("Operation cancelled."));
+      process.exit(0);
+    }
+  });
+  if (!genResponse.genGraph) {
+    ora().info(dim(`No problem! You can edit the "${cyan("config/graphs.csv")}" file later.`));
+    return;
+  }
+  const outputVarNames = [];
+  for (const mdlVar of mdlVars) {
+    if (mdlVar.kind === "aux" || mdlVar.kind === "level") {
+      outputVarNames.push(mdlVar.name);
+    }
+  }
+  outputVarNames.sort((a, b) => {
+    return a.toLowerCase().localeCompare(b.toLowerCase());
+  });
+  const choices = outputVarNames.map((f) => {
+    return {
+      title: f,
+      value: f
+    };
+  });
+  const varsResponse = await prompts({
+    type: "autocompleteMultiselect",
+    name: "vars",
+    message: "Choose up to three output variables to display in the graph",
+    choices,
+    max: 3
+  }, {
+    onCancel: () => {
+      ora().info(dim("Operation cancelled."));
+      process.exit(0);
+    }
+  });
+  if (varsResponse.vars.length === 0) {
+    ora().info(dim(`No variables selected. You can edit the "${cyan("config/graphs.csv")}" file later.`));
+    return;
+  }
+  const graphsCsvFile = joinPath(projDir, "config", "graphs.csv");
+  const csvLine = graphsCsvLine(varsResponse.vars);
+  let graphsCsvContent = await readFile(graphsCsvFile, "utf8");
+  graphsCsvContent += `${csvLine}
+`;
+  await writeFile(graphsCsvFile, graphsCsvContent);
+  ora(green(`Added graph to "${bold("config/graphs.csv")}". ${dim("You can configure graphs in that file later.")}`)).succeed();
+}
+function graphsCsvLine(outputVarNames) {
+  const colors = ["blue", "red", "green"];
+  const a = Array(131).fill("");
+  a[0] = "1";
+  a[2] = "Graphs";
+  a[3] = "Graph Title";
+  a[7] = "line";
+  let index = 26;
+  let colorIndex = 0;
+  for (const outputVarName of outputVarNames) {
+    const escapedName = escapeCsvField(outputVarName);
+    a[index + 0] = escapedName;
+    a[index + 2] = "line";
+    a[index + 3] = escapedName;
+    a[index + 4] = colors[colorIndex];
+    index += 7;
+    colorIndex++;
+  }
+  return a.join(",");
+}
+async function chooseGenSliderConfig(projDir, mdlVars) {
+  const genResponse = await prompts({
+    type: "confirm",
+    name: "genSliders",
+    message: `Would you like to configure a few sliders to get you started? ${reset(dim("(recommended)"))}`,
+    initial: true
+  }, {
+    onCancel: () => {
+      ora().info(dim("Operation cancelled."));
+      process.exit(0);
+    }
+  });
+  if (!genResponse.genSliders) {
+    ora().info(dim(`No problem! You can edit the "${cyan("config/inputs.csv")}" file later.`));
+    return;
+  }
+  const inputVarNames = [];
+  for (const mdlVar of mdlVars) {
+    if (mdlVar.kind === "const") {
+      inputVarNames.push(mdlVar.name);
+    }
+  }
+  inputVarNames.sort((a, b) => {
+    return a.toLowerCase().localeCompare(b.toLowerCase());
+  });
+  const choices = inputVarNames.map((f) => {
+    return {
+      title: f,
+      value: f
+    };
+  });
+  const varsResponse = await prompts({
+    type: "autocompleteMultiselect",
+    name: "vars",
+    message: "Choose up to three input variables to control with sliders",
+    choices,
+    max: 3
+  }, {
+    onCancel: () => {
+      ora().info(dim("Operation cancelled."));
+      process.exit(0);
+    }
+  });
+  if (varsResponse.vars.length === 0) {
+    ora().info(dim(`No variables selected. You can edit the "${cyan("config/inputs.csv")}" file later.`));
+    return;
+  }
+  const inputsCsvFile = joinPath(projDir, "config", "inputs.csv");
+  let inputsCsvContent = await readFile(inputsCsvFile, "utf8");
+  let idNumber = 1;
+  for (const inputVarName of varsResponse.vars) {
+    const inputVar = mdlVars.find((v) => v.name === inputVarName);
+    if (inputVar && inputVar.kind === "const") {
+      const defaultValue = inputVar.value;
+      const csvLine = inputsCsvLine(inputVarName, defaultValue, idNumber.toString());
+      inputsCsvContent += `${csvLine}
+`;
+      idNumber++;
+    }
+  }
+  await writeFile(inputsCsvFile, inputsCsvContent);
+  const slidersText = varsResponse.vars.length > 1 ? "sliders" : "sliders";
+  ora(green(`Added ${slidersText} to "${bold("config/inputs.csv")}". ${dim("You can configure sliders in that file later.")}`)).succeed();
+}
+function inputsCsvLine(inputVarName, defaultValue, id) {
+  const escapedName = escapeCsvField(inputVarName);
+  const minValue = defaultValue - 1;
+  const maxValue = defaultValue + 1;
+  const step = 0.1;
+  const a = Array(28).fill("");
+  a[0] = id;
+  a[1] = "slider";
+  a[2] = "view1";
+  a[3] = escapedName;
+  a[4] = escapedName;
+  a[6] = "Sliders";
+  a[7] = minValue;
+  a[8] = maxValue;
+  a[9] = defaultValue;
+  a[10] = step;
+  a[11] = "(units)";
+  return a.join(",");
+}
+function escapeCsvField(s) {
+  return s.includes(",") ? `"${s}"` : s;
+}
+async function readModelVars(projDir, mdlPath) {
+  const buildDir = resolvePath(projDir, "sde-prep", "build");
+  await mkdir(buildDir, { recursive: true });
+  const spec = {};
+  const mdlFile = resolvePath(projDir, mdlPath);
+  const preprocessed = preprocessModel(mdlFile, spec, "genc", false);
+  const mdlDir = dirname(mdlFile);
+  const mdlName = parsePath(mdlFile).name;
+  await parseAndGenerate(preprocessed, spec, "printVarList", mdlDir, mdlName, buildDir);
+  const varsYamlFile = joinPath(buildDir, `${mdlName}_vars.yaml`);
+  const varsYamlContent = await readFile(varsYamlFile, "utf8");
+  const varObjs = yaml.parse(varsYamlContent);
+  const mdlVars = [];
+  for (const varObj of varObjs) {
+    switch (varObj.varType) {
+      case "const":
+        mdlVars.push({
+          kind: "const",
+          name: varObj.modelLHS,
+          value: Number.parseFloat(varObj.modelFormula)
+        });
+        break;
+      case "aux":
+        mdlVars.push({
+          kind: "aux",
+          name: varObj.modelLHS
+        });
+        break;
+      case "level":
+        mdlVars.push({
+          kind: "level",
+          name: varObj.modelLHS
+        });
+        break;
+      default:
+        break;
+    }
+  }
+  return mdlVars;
+}
+
+// src/step-deps.ts
+import { execa } from "execa";
+import { bold as bold2, cyan as cyan2, dim as dim2, green as green2, reset as reset2, yellow as yellow2 } from "kleur/colors";
+import ora2 from "ora";
+import prompts2 from "prompts";
+async function chooseInstallDeps(projDir, args, pkgManager) {
+  const installResponse = await prompts2({
+    type: "confirm",
+    name: "install",
+    message: `Would you like to install ${pkgManager} dependencies? ${reset2(dim2("(recommended)"))}`,
+    initial: true
+  }, {
+    onCancel: () => {
+      ora2().info(dim2("Operation cancelled. Your project folder has been created, but no dependencies have been installed."));
+      process.exit(0);
+    }
+  });
+  if (args.dryRun) {
+    ora2().info(dim2(`--dry-run enabled, skipping.`));
+    return;
+  } else if (!installResponse.install) {
+    ora2().info(dim2(`No problem! Remember to install dependencies after setup.`));
+    return;
+  }
+  const installExec = execa(pkgManager, ["install"], { cwd: projDir });
+  const installingPackagesMsg = "Installing packages...";
+  const installSpinner = ora2(installingPackagesMsg).start();
+  try {
+    await new Promise((resolve, reject) => {
+      var _a, _b;
+      (_a = installExec.stdout) == null ? void 0 : _a.on("data", function(data) {
+        installSpinner.text = `${installingPackagesMsg}
+${bold2(`[${pkgManager}]`)} ${data}`;
+      });
+      (_b = installExec.stderr) == null ? void 0 : _b.on("data", function(data) {
+        installSpinner.text = `${installingPackagesMsg}
+${bold2(`[${pkgManager}]`)} ${data}`;
+      });
+      installExec.on("error", (error) => reject(error));
+      installExec.on("exit", (code) => reject(`Install failed (code=${code})`));
+      installExec.on("close", () => resolve());
+    });
+    installSpinner.text = green2("Packages installed!");
+    installSpinner.succeed();
+  } catch (e) {
+    installSpinner.text = yellow2(`There was an error installing packages. Try running ${cyan2(`${pkgManager} install`)} in your project directory later.`);
+    installSpinner.warn();
+  }
+}
+
+// src/step-directory.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolvePath2 } from "path";
+import { bold as bold3, dim as dim3, green as green3, red } from "kleur/colors";
+import ora3 from "ora";
+import prompts3 from "prompts";
+async function chooseProjectDir(args) {
+  function isValidDir(dir) {
+    const packageJson = resolvePath2(dir, "package.json");
+    const packagesDir = resolvePath2(dir, "packages");
+    return !existsSync2(dir) || !existsSync2(packageJson) && !existsSync2(packagesDir);
+  }
+  const showValidDirMsg = (dir) => {
+    ora3(green3(`Using "${bold3(dir)}" as the project directory.`)).succeed();
+  };
+  const showInvalidDirMsg = (dir) => {
+    ora3(red(`"${bold3(dir)}" contains existing 'package.json' and/or 'packages' directory, stopping.`)).fail();
+  };
+  let projDir = args["_"][2];
+  if (projDir) {
+    if (isValidDir(projDir)) {
+      showValidDirMsg(projDir);
+    } else {
+      showInvalidDirMsg(projDir);
+      process.exit(0);
+    }
+  } else {
+    const dirResponse = await prompts3({
+      type: "text",
+      name: "directory",
+      message: "Where would you like to create your new project?",
+      initial: "<current directory>"
+    }, {
+      onCancel: () => {
+        ora3().info(dim3("Operation cancelled."));
+        process.exit(0);
+      }
+    });
+    projDir = dirResponse.directory;
+    if (projDir === "<current directory>") {
+      projDir = process.cwd();
+    }
+    if (isValidDir(projDir)) {
+      showValidDirMsg(projDir);
+    } else {
+      showInvalidDirMsg(projDir);
+      process.exit(0);
+    }
+  }
+  return projDir;
+}
+
+// src/step-emsdk.ts
+import { existsSync as existsSync3, rmSync } from "fs";
+import { join as joinPath2, resolve as resolvePath3 } from "path";
+import { execa as execa2 } from "execa";
+import { bold as bold4, cyan as cyan3, dim as dim4, green as green4, red as red2 } from "kleur/colors";
+import ora4 from "ora";
+import prompts4 from "prompts";
+var version = "2.0.34";
+async function chooseInstallEmsdk(projDir, args) {
+  const underParentDir = resolvePath3(projDir, "..", "emsdk");
+  const underProjDir = joinPath2(projDir, "emsdk");
+  const installResponse = await prompts4({
+    type: "select",
+    name: "install",
+    message: `Would you like to install the Emscripten SDK?`,
+    choices: [
+      {
+        title: `Install under parent directory (${bold4(underParentDir)})`,
+        description: "This is recommended so that it can be shared by multiple projects",
+        value: "parent"
+      },
+      {
+        title: `Install under project directory (${bold4(underProjDir)})"`,
+        description: "This is useful for keeping everything under a single project directory",
+        value: "project"
+      },
+      {
+        title: `Don't install`,
+        description: `It's OK, you can install it later`,
+        value: "skip"
+      }
+    ]
+  }, {
+    onCancel: () => {
+      ora4().info(dim4("Operation cancelled. Your project folder has been created, but the Emscripten SDK and other dependencies have not been installed."));
+      process.exit(0);
+    }
+  });
+  if (args.dryRun) {
+    ora4().info(dim4(`--dry-run enabled, skipping.`));
+    return;
+  } else if (installResponse.install === "skip") {
+    ora4().info(dim4(`No problem! Be sure to install the Emscripten SDK and configure it in "${cyan3("sde.config.js")}" after setup.`));
+    return;
+  }
+  const installDir = installResponse.install === "parent" ? underParentDir : underProjDir;
+  try {
+    await installEmscripten(installDir);
+  } catch (e) {
+    ora4(red2(`Failed to install Emscripten SDK: ${e.message}`)).fail();
+    process.exit(0);
+  }
+  ora4(green4(`Installed the Emscripten SDK in "${bold4(installDir)}"`)).succeed();
+}
+async function installEmscripten(emsdkDir) {
+  if (!existsSync3(emsdkDir)) {
+    console.log(`Downloading Emscripten SDK to ${emsdkDir}`);
+    await execa2("git", ["clone", "https://github.com/emscripten-core/emsdk.git", emsdkDir]);
+  } else {
+    console.log(`Found existing Emscripten SDK directory: ${emsdkDir}`);
+  }
+  if (process.env.CI) {
+    console.log("CI detected, removing .git directory...");
+    const gitDir = joinPath2(emsdkDir, ".git");
+    rmSync(gitDir, { recursive: true, force: true });
+  } else {
+    console.log("Local development detected, performing git pull...");
+    await execa2("git", ["pull"], { cwd: emsdkDir });
+  }
+  const emsdkCmd = async (...args) => {
+    return execa2("python3", ["emsdk.py", ...args], { cwd: emsdkDir });
+  };
+  console.log(`Activating Emscripten SDK ${version}...`);
+  await emsdkCmd("install", version);
+  await emsdkCmd("activate", version);
+}
+
+// src/step-git.ts
+import { execaCommand } from "execa";
+import { cyan as cyan4, dim as dim5, green as green5, reset as reset3 } from "kleur/colors";
+import ora5 from "ora";
+import prompts5 from "prompts";
+async function chooseGitInit(projDir, args) {
+  const gitResponse = await prompts5({
+    type: "confirm",
+    name: "git",
+    message: `Would you like to initialize a new git repository? ${reset3(dim5("(optional)"))}`,
+    initial: true
+  }, {
+    onCancel: () => {
+      ora5().info(dim5("Operation cancelled. Your project folder has already been created."));
+      process.exit(0);
+    }
+  });
+  if (args.dryRun) {
+    ora5().info(dim5(`--dry-run enabled, skipping.`));
+    return;
+  } else if (!gitResponse.git) {
+    ora5().info(dim5(`No problem! You can come back and run ${cyan4(`git init`)} later.`));
+    return;
+  }
+  await execaCommand("git init", { cwd: projDir });
+  ora5().succeed(green5("Git repository initialized!"));
+}
+
+// src/step-mdl.ts
+import { readdir, writeFile as writeFile2 } from "fs/promises";
+import { join as joinPath3, relative as relative2, resolve as resolvePath4 } from "path";
+import { bold as bold5, cyan as cyan5, dim as dim6, green as green6, yellow as yellow3 } from "kleur/colors";
+import ora6 from "ora";
+import prompts6 from "prompts";
+var sampleMdlContent = `{UTF-8}
+
+X = TIME
+  ~~|
+
+Y = 0
+  ~ [-10,10,0.1]
+  ~
+  |
+
+Z = X + Y
+  ~~|
+
+INITIAL TIME = 2000 ~~|
+FINAL TIME = 2100 ~~|
+TIME STEP = 1 ~~|
+SAVEPER = TIME STEP ~~|
+`;
+async function chooseMdlFile(projDir) {
+  async function getFiles(dir) {
+    const dirents = await readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(dirents.map((dirent) => {
+      const res = resolvePath4(dir, dirent.name);
+      return dirent.isDirectory() ? getFiles(res) : res;
+    }));
+    return files.flat();
+  }
+  const allFiles = await getFiles(projDir);
+  const mdlFiles = allFiles.filter((f) => f.endsWith(".mdl")).map((f) => relative2(projDir, f));
+  const mdlChoices = mdlFiles.map((f) => {
+    return {
+      title: f,
+      value: f
+    };
+  });
+  let mdlFile;
+  if (mdlFiles.length === 0) {
+    const sampleMdlFile = joinPath3(projDir, "sample.mdl");
+    await writeFile2(sampleMdlFile, sampleMdlContent);
+    ora6(yellow3(`No mdl files were found in "${projDir}". A "${cyan5("sample.mdl")}" file has been added to the project to get you started.`)).warn();
+    mdlFile = "sample.mdl";
+  } else if (mdlFiles.length === 1) {
+    ora6().succeed(`Found "${mdlFiles[0]}", will configure the project to use that mdl file.`);
+    mdlFile = mdlFiles[0];
+  } else {
+    const options = await prompts6([
+      {
+        type: "select",
+        name: "mdlFile",
+        message: "It looks like there are multiple mdl files. Which one would you like to use?",
+        choices: mdlChoices
+      }
+    ], {
+      onCancel: () => {
+        ora6().info(dim6("Operation cancelled."));
+        process.exit(0);
+      }
+    });
+    mdlFile = options.mdlFile;
+  }
+  ora6(green6(`Using "${bold5(mdlFile)}" as the model for the project.`)).succeed();
+  return mdlFile;
+}
+
+// src/step-template.ts
+import { existsSync as existsSync4, mkdtempSync, readdirSync, rmSync as rmSync2 } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+import { copy } from "fs-extra";
+import { tmpdir } from "os";
+import { join as joinPath4 } from "path";
+import degit from "degit";
+import { dim as dim7, green as green7, red as red3, yellow as yellow4 } from "kleur/colors";
+import ora7 from "ora";
+import prompts7 from "prompts";
+var TEMPLATES = [
+  {
+    title: "Default project",
+    description: "Includes recommended structure with config files, app, core library, model-check, etc",
+    value: "template-default"
+  },
+  {
+    title: "Minimal project",
+    description: "Includes simple config for model-check",
+    value: "template-minimal"
+  }
+];
+async function chooseTemplate(projDir, args, pkgManager) {
+  const options = await prompts7([
+    {
+      type: "select",
+      name: "template",
+      message: "Which template would you like to use?",
+      choices: TEMPLATES
+    }
+  ], {
+    onCancel: () => {
+      ora7().info(dim7("Operation cancelled."));
+      process.exit(0);
+    }
+  });
+  if (args.dryRun) {
+    ora7().info(dim7(`--dry-run enabled, skipping.`));
+    return;
+  }
+  const defaultRev = "main";
+  const commit = args.commit || defaultRev;
+  const templateTarget = `climateinteractive/SDEverywhere/examples/${options.template}`;
+  const hash = `#${commit}`;
+  const templateSpinner = ora7("Copying project files...").start();
+  await runDegit(templateTarget, hash, projDir, args, templateSpinner);
+  templateSpinner.text = green7("Template copied!");
+  templateSpinner.succeed();
+  if (options.template === "template-default" && pkgManager === "pnpm") {
+    const workspaceFile = joinPath4(projDir, "pnpm-workspace.yaml");
+    const workspaceContent = `packages:
+  - packages/*
+`;
+    await writeFile3(workspaceFile, workspaceContent);
+  }
+  return options.template;
+}
+async function runDegit(templateTarget, hash, dstDir, args, spinner) {
+  const verbose = args.verbose;
+  const emitter = degit(`${templateTarget}${hash}`, {
+    cache: false,
+    force: true,
+    verbose
+  });
+  try {
+    if (verbose) {
+      emitter.on("info", (info) => {
+        console.log(info.message);
+      });
+    }
+    const tmpDir = mkdtempSync(joinPath4(tmpdir(), "sde-create-"));
+    await emitter.clone(tmpDir);
+    if (!existsSync4(tmpDir) || readdirSync(tmpDir).length === 0) {
+      throw new Error("The requested template failed to download");
+    }
+    await copy(tmpDir, dstDir, {
+      overwrite: false,
+      errorOnExist: false
+    });
+    rmSync2(tmpDir, { recursive: true, force: true });
+  } catch (e) {
+    spinner.fail();
+    console.error(red3(e.message));
+    console.error(yellow4("There was a problem copying the template."));
+    console.error(yellow4("Please file a new issue with the command output here: https://github.com/climateinteractive/sdeverywhere/issues"));
+    process.exit(0);
+  }
+}
+
+// src/index.ts
+async function main() {
+  var _a;
+  const pkgManager = ((_a = detectPackageManager()) == null ? void 0 : _a.name) || "npm";
+  const args = yargs(process.argv);
+  prompts8.override(args);
+  console.log(`
+${bold6("Welcome to SDEverywhere!")}`);
+  console.log(`Let's create a new SDEverywhere project for your model.
+`);
+  const projDir = await chooseProjectDir(args);
+  console.log();
+  const templateName = await chooseTemplate(projDir, args, pkgManager);
+  console.log();
+  const mdlPath = await chooseMdlFile(projDir);
+  await updateSdeConfig(projDir, mdlPath);
+  await generateCheckYaml(projDir, mdlPath);
+  console.log();
+  if (templateName === "template-default" && !args.dryRun) {
+    await chooseGenConfig(projDir, mdlPath);
+    console.log();
+  }
+  await chooseInstallEmsdk(projDir, args);
+  console.log();
+  await chooseInstallDeps(projDir, args, pkgManager);
+  console.log();
+  await chooseGitInit(projDir, args);
+  console.log();
+  ora8(green8("Setup complete!")).succeed();
+  console.log(`
+${bgCyan(black(" Next steps "))}
+`);
+  const relProjDir = relative3(process.cwd(), projDir);
+  const devCmd = pkgManager === "npm" ? "npm run dev" : `${pkgManager} dev`;
+  if (relProjDir !== "") {
+    console.log(`You can now ${bold6(cyan6("cd"))} into the ${bold6(cyan6(relProjDir))} project directory.`);
+  }
+  console.log(`Run ${bold6(cyan6(devCmd))} to start the local dev server. ${bold6(cyan6("CTRL-C"))} to close.`);
+  console.log("");
+}
+export {
+  main
+};
+//# sourceMappingURL=index.js.map