create-vag/dist/create-vag-cli.js

The npm-initializer for creating a new vag repo

#!/usr/bin/env node

// src/create-vag-cli.ts
import * as prom from "@clack/prompts";
import chalk from "chalk";

// package.json
var package_default = {
  name: "create-vag",
  version: "0.1.10",
  description: "The npm-initializer for creating a new vag repo",
  private: false,
  repository: {
    type: "git",
    url: "git+https://github.com/charlyoleg2/vag.git"
  },
  homepage: "https://www.npmjs.com/package/create-vag",
  author: "charlyoleg",
  license: "ISC",
  keywords: [
    "git",
    "sub-repo",
    "vcstool",
    "subg",
    "vag"
  ],
  type: "module",
  exports: {
    ".": {
      types: "./dist/create-vag-api.d.ts",
      default: "./dist/create-vag-api.js"
    }
  },
  bin: {
    "create-vag": "dist/create-vag-cli.js"
  },
  files: [
    "dist/create-vag-cli.js",
    "dist/template/",
    "!dist/**/*.map",
    "!dist/**/*.spec.*"
  ],
  tsup: {
    entry: [
      "src/create-vag-api.ts",
      "src/create-vag-ref.ts",
      "src/create-vag-cli.ts"
    ],
    format: "esm",
    splitting: false,
    dts: false,
    sourcemap: false,
    clean: true
  },
  prettier: {
    useTabs: true,
    singleQuote: true,
    trailingComma: "none",
    printWidth: 100,
    plugins: [],
    overrides: []
  },
  scripts: {
    dev: "tsup --watch",
    build: "tsup",
    check: "tsc --noEmit",
    pretty: "prettier --check .",
    format: "prettier --write .",
    lint: "eslint .",
    "test:unit": "vitest",
    "test:unit:once": "vitest --run",
    copy_template: "shx cp -r template dist/",
    cleanCopy_template: "run-s clean:template copy_template",
    ci: "run-s check build pretty lint test:unit:once cleanCopy_template",
    run: "dist/create-vag-cli.js",
    "run:ref": "dist/create-vag-ref.js tmp2",
    "run:diff": "diff -rq tmp tmp2",
    "run:check": "run-s run:ref run:diff",
    cycle: "run-s clean ci run",
    "clean:template": "shx rm -fr dist/template",
    "clean:build": "shx rm -fr dist node_modules",
    "clean:output": "shx rm -fr tmp tmp2",
    clean: "run-s clean:build clean:output"
  },
  dependencies: {
    "@clack/prompts": "^0.11.0",
    chalk: "^5.3.0",
    handlebars: "^4.7.8"
  },
  devDependencies: {
    "@eslint/js": "^9.28.0",
    "@types/eslint__js": "^8.42.3",
    "@types/node": "^22.15.29",
    eslint: "^9.27.0",
    "eslint-config-prettier": "^10.1.5",
    "npm-run-all": "^4.1.5",
    prettier: "^3.5.3",
    shx: "^0.4.0",
    tsup: "^8.5.0",
    typescript: "^5.8.3",
    "typescript-eslint": "^8.33.0",
    vitest: "^3.1.4"
  }
};

// src/create-vag-cli.ts
import { setTimeout as sleep2 } from "timers/promises";

// src/create-vag-api.ts
import { setTimeout as sleep } from "timers/promises";
import { readFile, writeFile, access, mkdir } from "fs/promises";
import { dirname, extname } from "path";
import Handlebars from "handlebars";

// src/create-vag-common.ts
function firstLetterCapital(str) {
  const rStr = str.charAt(0).toUpperCase() + str.slice(1);
  return rStr;
}
function underline(str) {
  const strLen = str.length;
  const rStr = "=".repeat(strLen);
  return rStr;
}
function prefixOutputPath() {
  let rPreDir = ".";
  const scriptDir = new URL("", import.meta.url).toString();
  const regex = new RegExp("/node_modules/");
  if (!regex.test(scriptDir)) {
    rPreDir = "./tmp";
  }
  return rPreDir;
}

// src/create-vag-list.ts
var template_file_list = [
  ".editorconfig",
  ".gitignore",
  "package.json",
  "README.md",
  "{{projName}}_repos.yml"
];

// src/create-vag-api.ts
async function createMissingDir(outPath) {
  const outDir = dirname(outPath);
  try {
    await access(outDir);
  } catch (err) {
    if (err) {
      await mkdir(outDir, { recursive: true });
    }
  }
}
function isFileBinary(fpath) {
  const binaryExts = /* @__PURE__ */ new Set([".png"]);
  const infileExt = extname(fpath.toString());
  const rBool = binaryExts.has(infileExt);
  return rBool;
}
async function oneFile(onePath, cfg2, preDir2) {
  try {
    const onePathIn = Handlebars.compile(onePath)({
      projName: "projAbc",
      repoName: "projAbc_vag"
    });
    const onePathOut = Handlebars.compile(onePath)(cfg2);
    const fileIn1 = new URL(`./template/${onePathIn}.handlebars`, import.meta.url);
    const fileIn2 = new URL(`./template/${onePathIn}`, import.meta.url);
    let fileBin = false;
    let fileStr2 = "";
    const outPath = `${preDir2}/${cfg2.repoName}/${onePathOut}`;
    try {
      await access(fileIn1);
      try {
        const fileStr1 = await readFile(fileIn1, { encoding: "utf8" });
        const templateStr = Handlebars.compile(fileStr1);
        fileStr2 = templateStr(cfg2);
      } catch (err) {
        console.log(`err392: error while processing ${fileIn1.toString()}`);
        console.log(err);
      }
    } catch (err) {
      if (err) {
        if (isFileBinary(fileIn2)) {
          fileBin = true;
          const fileBuffer2 = await readFile(fileIn2);
          await createMissingDir(outPath);
          await writeFile(outPath, fileBuffer2);
        } else {
          fileStr2 = await readFile(fileIn2, { encoding: "utf8" });
        }
      }
    }
    if (!fileBin) {
      await createMissingDir(outPath);
      await writeFile(outPath, fileStr2);
    }
  } catch (err) {
    console.log(`err213: error while generating file ${onePath}`);
    console.error(err);
    throw `err214: error with path ${onePath}`;
  }
}
async function generate_boirlerplate(cfg12, preDir2) {
  console.log(`Boilerplate with:
  project name     : ${cfg12.projName}
  repository name  : ${cfg12.repoName}`);
  const cfg2 = {
    projName: cfg12.projName,
    ProjName: firstLetterCapital(cfg12.projName),
    ProjNameUnderline: underline(cfg12.projName),
    repoName: cfg12.repoName,
    RepoName: firstLetterCapital(cfg12.repoName),
    RepoNameUnderline: underline(cfg12.repoName)
  };
  for (const fpath of template_file_list) {
    await oneFile(fpath, cfg2, preDir2);
  }
  console.log(`generate ${template_file_list.length} files in ${preDir2}/${cfg12.repoName}/`);
  await sleep(100);
  const rResp = {
    vim: `vim ${cfg12.projName}_repos.yml`
  };
  return rResp;
}

// src/create-vag-cli.ts
var firstMsg = `Create a new ${chalk.italic("vag-top-repo")} with ${chalk.italic(package_default.name)} version ${chalk.italic(package_default.version)}`;
console.log(firstMsg);
var projName = process.argv[2] || "blabla";
var argN = process.argv.length - 2;
if (argN > 1) {
  console.log(`warn376: ${argN} arguments provided but only one supported!`);
}
prom.intro(chalk.inverse(" Your new vag-top-repo "));
var pCfg = await prom.group(
  {
    projName: () => prom.text({
      message: "Name of the project?",
      initialValue: `${projName}`
      //placeholder: `${projName}`
    }),
    repoName: () => prom.text({
      message: "Name of the top-repository?",
      initialValue: `${projName}_vag`
      //placeholder: `${projName}_vag`
    })
  },
  {
    onCancel: () => {
      prom.cancel("Operation aborted!");
      process.exit(0);
    }
  }
);
prom.outro("Your new vag-top-repository will be boilerplated!");
var cfg1 = {
  projName: pCfg.projName,
  repoName: pCfg.repoName
};
var preDir = prefixOutputPath();
var resp = await generate_boirlerplate(cfg1, preDir);
await sleep2(100);
function styl(str) {
  const rStr = chalk.bold.cyan(str);
  return rStr;
}
var lastMsg = `
Next steps:
  1: ${styl(`cd ${pCfg.repoName}`)}
  2: ${styl(`npm install`)}
  3: ${styl('git init && git add -A && git commit -m "Initial commit"')} (optional)
  4: ${styl(`${resp.vim}`)} (optional)
  5: ${styl(`npm run`)}
  6: ${styl(`npm run vag-list`)}
  7: ${styl(`npm run vag-clone`)}
  8: ${styl(`npm run vag-pull`)}
  9: ${styl(`npm run vag-status`)}
 10: ${styl(`npm run vag-diff`)}
`;
console.log(lastMsg);