vag_tools 0.0.3

package/README.md

@@ -0,0 +1,8 @@
+README of vag (core-package)
+============================
+
+
+Presentation
+------------
+
+*vag* is a tool for managing git repositories.

package/dist/vag_cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/vag_cli.js

@@ -0,0 +1,839 @@
+#!/usr/bin/env node
+
+// src/vag_cli.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/vag_core.ts
+import path from "node:path";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import fse from "fs-extra";
+import YAML from "yaml";
+import { simpleGit } from "simple-git";
+
+// package.json
+var package_default = {
+  name: "vag_tools",
+  version: "0.0.3",
+  description: "api and cli for managing sub-git-repositories",
+  type: "module",
+  main: "./dist/vag_api.js",
+  types: "./dist/vag_api.d.ts",
+  bin: {
+    vag: "dist/vag_cli.js",
+    vagg: "dist/vagg_server.js"
+  },
+  files: [
+    "dist/",
+    "!dist/**/*.map",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  engines: {
+    node: ">=20.10.0"
+  },
+  tsup: {
+    entry: [
+      "src/vag_cli.ts",
+      "src/vagg_server.ts"
+    ],
+    format: "esm",
+    splitting: false,
+    dts: true,
+    sourcemap: true,
+    clean: true
+  },
+  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",
+    ci: "run-s check build pretty lint",
+    clean: "shx rm -fr build dist tmp",
+    "test:basic": "node build/tests/vag.test.js",
+    "test:cli": "tests/vag-cli.test.sh",
+    "test:coverage": "vitest run --coverage",
+    test: "run-s test:basic test:cli test:vitest",
+    "dist:build": "tsc --build tsconfig.dist.json",
+    clean_all: "run-s clean"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/charlyoleg2/vag.git"
+  },
+  keywords: [
+    "git",
+    "sub-repo",
+    "multi-repo",
+    "submodule",
+    "subtree",
+    "vcs",
+    "vcstool",
+    "repositories"
+  ],
+  author: "charlyoleg",
+  license: "ISC",
+  bugs: {
+    url: "https://github.com/charlyoleg2/vag/issues"
+  },
+  homepage: "https://github.com/charlyoleg2/vag#readme",
+  dependencies: {
+    "fs-extra": "^11.2.0",
+    "simple-git": "^3.22.0",
+    yaml: "^2.3.4",
+    yargs: "^17.7.2"
+  },
+  devDependencies: {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.19",
+    "@types/yargs": "^17.0.32",
+    eslint: "^8.56.0",
+    "npm-run-all": "^4.1.5",
+    prettier: "^3.2.5",
+    shx: "^0.3.4",
+    tsup: "^8.0.2",
+    typescript: "^5.3.3",
+    "typescript-eslint": "^7.0.1",
+    vitest: "^1.2.2"
+  },
+  prettier: {
+    useTabs: true,
+    singleQuote: true,
+    trailingComma: "none",
+    printWidth: 100,
+    plugins: [],
+    overrides: []
+  }
+};
+
+// src/vag_core.ts
+var vag_version_short = package_default.version;
+var regex_pointSlash = /^\.\//;
+var regex_trailingSlash = /\/$/;
+async function isGitRepo(pathDir2) {
+  let isRepo = false;
+  let isRepoCandidate = false;
+  const subdirs = await fse.readdir(pathDir2, { withFileTypes: true });
+  for (const subitem of subdirs) {
+    if (subitem.isDirectory() && subitem.name === ".git") {
+      isRepoCandidate = true;
+    }
+  }
+  if (isRepoCandidate) {
+    try {
+      const git2 = simpleGit(pathDir2);
+      const git2cmd = await git2.revparse(["--show-prefix"]);
+      if (git2cmd === "") {
+        isRepo = true;
+      }
+    } catch (err) {
+    }
+    if (!isRepo) {
+      console.log(
+        `INFO299: the directory ${pathDir2} contains a sub-directory .git but is not a git-repository`
+      );
+    }
+  }
+  return isRepo;
+}
+async function searchGitRepo(pathDir, deepSearch = true) {
+  let r_list = [];
+  const local_list = await fse.readdir(pathDir, { withFileTypes: true });
+  for (const item of local_list) {
+    if (item.isDirectory()) {
+      const pathDir2 = pathDir + "/" + item.name;
+      if ([".git", "node_modules"].includes(item.name)) {
+      } else {
+        const isRepo = await isGitRepo(pathDir2);
+        if (isRepo) {
+          r_list.push(pathDir2);
+        }
+        if (deepSearch || !isRepo) {
+          r_list = r_list.concat(await searchGitRepo(pathDir2, deepSearch));
+        }
+      }
+    }
+  }
+  return r_list;
+}
+function array_intersection(arr1, arr2) {
+  return arr1.filter((elem) => arr2.includes(elem));
+}
+function array_exclude(arr_base, arr_exclude) {
+  return arr_base.filter((elem) => !arr_exclude.includes(elem));
+}
+async function git_clone(localPath, remote_url, version) {
+  let r_code = -1;
+  try {
+    if (!fs.existsSync(localPath)) {
+      const git = simpleGit();
+      const gitlog = await git.clone(remote_url, localPath);
+      console.log(gitlog);
+      r_code = await git_checkout(localPath, version);
+    } else {
+      const fstat = await fsp.stat(localPath);
+      if (fstat.isDirectory()) {
+        const isRepo = await isGitRepo(localPath);
+        if (isRepo) {
+          const git2 = simpleGit(localPath);
+          const remote = await git2.getRemotes(true);
+          const remote_url2 = remote[0].refs.fetch;
+          if (remote_url2 === remote_url2) {
+            console.log(
+              `INFO398: the git-repo ${localPath} is already cloned! Then just git-pull!`
+            );
+            const gitlog2 = await git2.pull();
+            console.log(gitlog2);
+            r_code = await git_checkout(localPath, version);
+          } else {
+            console.log(
+              `WARN381: Warning, the git-repo ${localPath} already exist but with an unexpected remote! git-clone/pull aborted!`
+            );
+          }
+        } else {
+          console.log(
+            `WARN869: Warning, the directory ${localPath} already exist but is not a git-repo! git-clone aborted!`
+          );
+        }
+      } else {
+        console.log(
+          `WARN537: Warning, the path ${localPath} already exist and is a file! git-clone aborted!`
+        );
+      }
+    }
+  } catch (error) {
+    console.log(`ERR162: Error by cloning ${localPath}  from  ${remote_url}`);
+    console.error(error);
+  }
+  return r_code;
+}
+async function git_checkout(repoPath, version) {
+  let r_code = -2;
+  try {
+    const git = simpleGit(repoPath);
+    const gitlog = await git.checkout(version);
+    console.log(gitlog);
+    r_code = 0;
+  } catch (error) {
+    console.log(`ERR523: Error by checkout ${repoPath}  for version  ${version}`);
+    console.error(error);
+  }
+  return r_code;
+}
+async function git_verify(repoPath, remote_url, version) {
+  let r_code = 0;
+  const one_info = await one_repo_info(repoPath);
+  if (one_info.url === remote_url) {
+    console.log(`remote_url: Ok`);
+  } else {
+    console.log(`remote_url: Nok   ${remote_url} versus ${one_info.url}`);
+    r_code = -1;
+  }
+  if (one_info.branch === version || one_info.commit === version) {
+    console.log(`version: Ok`);
+  } else {
+    console.log(
+      `version: Nok   ${version} versus ${one_info.branch} versus ${one_info.commit}`
+    );
+    r_code = -1;
+  }
+  return r_code;
+}
+async function git_custom(repoPath, gitCommand) {
+  let r_code = -1;
+  try {
+    const git = simpleGit(repoPath);
+    const gitCommand2 = gitCommand.split(" ");
+    const gitlog = await git.raw(...gitCommand2);
+    console.log(gitlog);
+    r_code = 0;
+  } catch (error) {
+    console.log(`ERR772: Error by git-command ${gitCommand}  on repo  ${repoPath}`);
+    console.error(error);
+  }
+  return r_code;
+}
+async function one_repo_info(localPath) {
+  let one_info = {
+    localPath: "undefined",
+    url: "undefined",
+    branch: "undefined",
+    commit: "undefined"
+  };
+  const localPath2 = localPath.replace(regex_pointSlash, "");
+  try {
+    const git = simpleGit(localPath);
+    const remote = await git.getRemotes(true);
+    const remote_url = remote[0].refs.fetch;
+    const branch = await git.branch();
+    const branch_current = branch.current;
+    const commit = await git.log();
+    const commit_hash = commit.latest.hash;
+    one_info = {
+      localPath: localPath2,
+      url: remote_url,
+      branch: branch_current,
+      commit: commit_hash
+    };
+  } catch (error) {
+    console.log(`ERR398: Error by git-operations on repo  ${localPath}`);
+    console.error(error);
+  }
+  return one_info;
+}
+async function get_repos_info(repos) {
+  const repos_info = [];
+  for (const [idx, localPath] of repos.entries()) {
+    console.log(`===> ${idx + 1} - get info of git-repo  ${localPath}`);
+    const one_info = await one_repo_info(localPath);
+    repos_info.push(one_info);
+  }
+  return repos_info;
+}
+async function validate_yaml_external(yamlPath) {
+  let fyaml;
+  try {
+    const fstr = await fse.readFile(yamlPath, "utf-8");
+    fyaml = YAML.parse(fstr);
+  } catch (error) {
+    console.log(`ERR439: Error by reading the yaml-file ${yamlPath}!`);
+    console.error(error);
+    return -1;
+  }
+  try {
+    if (!Object.hasOwn(fyaml, "repositories"))
+      throw 'The property "repositories" is missing!';
+    for (const repo in fyaml.repositories) {
+      if (!Object.hasOwn(fyaml.repositories[repo], "url"))
+        throw `The property "url" is missing for repo ${repo} !`;
+      if (!Object.hasOwn(fyaml.repositories[repo], "version"))
+        throw `The property "version" is missing for repo ${repo} !`;
+      if (!Object.hasOwn(fyaml.repositories[repo], "type")) {
+        console.log(`WARN390: Warning, the property "type" is missing for repo ${repo} !`);
+      } else if (fyaml.repositories[repo].type !== "git") {
+        console.log(
+          `WARN395: Warning, the property "type" of repo ${repo} is not git but ${fyaml.repositories[repo].type}!`
+        );
+      }
+    }
+    console.log(`The yaml-file ${yamlPath} is valid!`);
+    return 0;
+  } catch (error) {
+    console.error(error);
+    console.log(`Invalid yaml-file ${yamlPath}!`);
+    return -2;
+  }
+}
+function isPathAbsolute(path2) {
+  let r_absolute = false;
+  const regex_slash = /^\//;
+  if (regex_slash.test(path2)) {
+    r_absolute = true;
+  }
+  return r_absolute;
+}
+var Vag = class {
+  /** The top directory from where to search repositories. */
+  discoverDir;
+  /** When a repository is encountered, should it be inspected for searching sub-repositories? */
+  deepSearch;
+  /** The path to the yaml-file that provides the repositories to be cloned. */
+  importYaml;
+  /** The base directory where the directories listed in the yaml-file should be cloned. */
+  importDir;
+  /** The list of the path of the discovered repositories. It is populated by the `init()` method. */
+  listD;
+  /** An object with the content of the yaml-file. It is populated by the `init()` method. */
+  listC;
+  /**
+   * The constructor of the `Vag` class.
+   * `listD` is initialized to an empty list.
+   * `listC` is initialized to an empty object.
+   */
+  constructor(discoverDir = ".", deepSearch = true, importYaml = "", importDir = "") {
+    this.discoverDir = discoverDir;
+    this.deepSearch = deepSearch;
+    this.importYaml = importYaml;
+    this.importDir = importDir;
+    this.listD = [];
+    this.listC = {};
+  }
+  // this init function cannot be included in the constructor because the constructor can not be async
+  async discover_repos(discoverDir = this.discoverDir, deepSearch = this.deepSearch) {
+    this.discoverDir = discoverDir;
+    this.deepSearch = deepSearch;
+    if (this.discoverDir === "") {
+      console.log(`ERR282: Error, the discoverDir cannot be an empty string`);
+      return -1;
+    }
+    if (!isPathAbsolute(this.discoverDir)) {
+      if (!regex_pointSlash.test(this.discoverDir) && this.discoverDir !== ".") {
+        this.discoverDir = "./" + this.discoverDir;
+      }
+    }
+    this.discoverDir = this.discoverDir.replace(regex_trailingSlash, "");
+    try {
+      await fse.readdir(this.discoverDir, { withFileTypes: true });
+    } catch (err) {
+      console.log(`ERR638: Error, the path ${this.discoverDir} doesn't exist!`);
+      console.log(err);
+      return -1;
+    }
+    this.listD = await searchGitRepo(this.discoverDir, this.deepSearch);
+    console.log(`Number of discovered cloned git repos: ${this.listD.length}`);
+    return 0;
+  }
+  async import_yaml(importYaml = this.importYaml, importDir = this.importDir) {
+    let r_code = 0;
+    this.importYaml = importYaml;
+    this.importDir = importDir;
+    if (this.importYaml !== "") {
+      let baseDir = path.dirname(this.importYaml);
+      if (this.importDir !== "") {
+        baseDir = this.importDir;
+      }
+      if (["", "."].includes(baseDir)) {
+        baseDir = "";
+      } else {
+        if (!regex_trailingSlash.test(baseDir)) {
+          baseDir = baseDir + "/";
+        }
+      }
+      const list_non_git = [];
+      try {
+        const fstr = await fse.readFile(this.importYaml, "utf-8");
+        const fyaml = YAML.parse(fstr);
+        for (const repoDir in fyaml.repositories) {
+          let repoDir2 = repoDir;
+          if (!isPathAbsolute(repoDir2)) {
+            repoDir2 = baseDir + repoDir;
+            if (!regex_pointSlash.test(repoDir2)) {
+              repoDir2 = "./" + repoDir2;
+            }
+          }
+          if (!Object.hasOwn(fyaml.repositories[repoDir], "type") || fyaml.repositories[repoDir].type === "git") {
+            this.listC[repoDir2] = {
+              url: fyaml.repositories[repoDir].url,
+              version: fyaml.repositories[repoDir].version
+            };
+          } else {
+            list_non_git.push(repoDir2);
+          }
+        }
+      } catch (error) {
+        console.log(
+          `ERR826: Error, the imported-yaml-file ${this.importYaml} is not valid!`
+        );
+        console.error(error);
+        r_code = -1;
+      }
+      console.log(
+        `From imported Yaml, number of git-repos: ${Object.keys(this.listC).length}`
+      );
+      console.log(`From imported Yaml, number of excluded repos: ${list_non_git.length}`);
+      for (const [idx, repoDir] of list_non_git.entries()) {
+        console.log(
+          `  ${(idx + 1).toString().padStart(3, " ")} - Excluded repo: ${repoDir}`
+        );
+      }
+    }
+    return r_code;
+  }
+  /**
+   * The `init` method populate populate `listD` and `listC`.
+   * It must be called just after instanciating `Vag`.
+   * The configuration properties `discoverDir`, `deepSearch`, `importYaml` and `importDir` can be reassinged by `init`.
+   */
+  async init(discoverDir = this.discoverDir, deepSearch = this.deepSearch, importYaml = this.importYaml, importDir = this.importDir) {
+    let r_code = 0;
+    r_code += await this.discover_repos(discoverDir, deepSearch);
+    r_code += await this.import_yaml(importYaml, importDir);
+    return r_code;
+  }
+  /** List the discovered repositories. */
+  d_list() {
+    return this.listD;
+  }
+  /** List the wished repositories (a.k.a. configured repositories). */
+  c_list() {
+    return Object.keys(this.listC);
+  }
+  /** List the git-repos which are in the D-list and in the C-list. I.e. Intersection of D and C. */
+  cd_list() {
+    return array_intersection(this.listD, Object.keys(this.listC));
+  }
+  /** List the git-repos which are in the D-list but not in the C-list. I.e. D not C. */
+  dnc_list() {
+    return array_exclude(this.listD, Object.keys(this.listC));
+  }
+  /** List the git-repos which are in the C-list but not in the D-list. I.e. C not D. */
+  cnd_list() {
+    return array_exclude(Object.keys(this.listC), this.listD);
+  }
+  /** Clone the repositories of `listC`. */
+  async c_clone() {
+    let r_code = 0;
+    for (const [idx, localPath] of Object.keys(this.listC).entries()) {
+      const repo = this.listC[localPath];
+      console.log(
+        `===> ${idx + 1} - clone  ${localPath}  from  ${repo.url}  at version  ${repo.version}`
+      );
+      r_code += await git_clone(localPath, repo.url, repo.version);
+    }
+    return r_code;
+  }
+  /** Checkout the repositories listed in `listC` and `listD`. */
+  async cd_checkout() {
+    let r_code = 0;
+    const list_cd = this.cd_list();
+    for (const [idx, localPath] of list_cd.entries()) {
+      const repo = this.listC[localPath];
+      console.log(`===> ${idx + 1} - checkout  ${localPath}  at version  ${repo.version}`);
+      r_code += await git_checkout(localPath, repo.version);
+    }
+    return r_code;
+  }
+  /** For the repositories listed in `listC` and `listD`, verify if they fit with the configuration of Yaml-file. */
+  async cd_verify() {
+    let r_code = 0;
+    const list_cd = this.cd_list();
+    for (const [idx, localPath] of list_cd.entries()) {
+      const repo = this.listC[localPath];
+      console.log(`===> ${idx + 1} - verify  ${localPath}`);
+      r_code += await git_verify(localPath, repo.url, repo.version);
+    }
+    const all_nb = list_cd.length;
+    const nok_nb = Math.abs(r_code);
+    const ok_nb = all_nb - nok_nb;
+    console.log(`Verify ${all_nb} repos : ${ok_nb} Ok, ${nok_nb} Nok`);
+    return r_code;
+  }
+  /** Run a custom git-command on the discoverd repositories (`listD`). */
+  async d_custom(git_command, only_configured_repo = false) {
+    let r_code = 0;
+    let repos = this.d_list();
+    if (only_configured_repo) {
+      repos = this.cd_list();
+    }
+    for (const [idx, localPath] of repos.entries()) {
+      console.log(
+        `===> ${idx + 1} - On git-repo  ${localPath}  with command  git ${git_command}`
+      );
+      r_code += await git_custom(localPath, git_command);
+    }
+    return r_code;
+  }
+  /** Git-fetch on the discoverd repositories (`listD`). */
+  async d_fetch(only_configured_repo = false) {
+    return await this.d_custom("fetch --prune", only_configured_repo);
+  }
+  /** Git-pull on the discoverd repositories (`listD`). */
+  async d_pull(only_configured_repo = false) {
+    return await this.d_custom("pull", only_configured_repo);
+  }
+  /** Git-push on the discoverd repositories (`listD`). */
+  async d_push(only_configured_repo = false) {
+    return await this.d_custom("push", only_configured_repo);
+  }
+  /** Show the current branch of the discoverd repositories (`listD`). */
+  async d_branch(only_configured_repo = false) {
+    return await this.d_custom("branch --show-current", only_configured_repo);
+  }
+  /** Git-status on the discoverd repositories (`listD`). */
+  async d_status(only_configured_repo = false) {
+    return await this.d_custom("status", only_configured_repo);
+  }
+  /** Git-diff on the discoverd repositories (`listD`). */
+  async d_diff(only_configured_repo = false) {
+    return await this.d_custom("diff", only_configured_repo);
+  }
+  /** `Git-log -n 3` on the discoverd repositories (`listD`). */
+  async d_log(only_configured_repo = false) {
+    return await this.d_custom("log -n 3", only_configured_repo);
+  }
+  /** `Git-remote -vv` on the discoverd repositories (`listD`). */
+  async d_remote(only_configured_repo = false) {
+    return await this.d_custom("remote -vv", only_configured_repo);
+  }
+  /** `Git-stash list` on the discoverd repositories (`listD`). */
+  async d_stash_list(only_configured_repo = false) {
+    return await this.d_custom("stash list", only_configured_repo);
+  }
+  /** `Git-clean -dxf` on the discoverd repositories (`listD`). */
+  async d_clean(only_configured_repo = false) {
+    return await this.d_custom("clean -dxf", only_configured_repo);
+  }
+  /** Export in a Yaml-file the list of discoverd repositories (`listD`). */
+  async d_export_yaml(yamlPath, commit_version = false) {
+    let r_code = -1;
+    if (yamlPath === "") {
+      console.log(`ERR482: Error, the discoverDir cannot be an empty string`);
+      return -1;
+    }
+    const repos = this.d_list();
+    const repos_info = await get_repos_info(repos);
+    const fyaml = { repositories: {} };
+    for (const repo of repos_info) {
+      let version = repo.branch;
+      if (commit_version) {
+        version = repo.commit;
+      }
+      fyaml.repositories[repo.localPath] = {
+        type: "git",
+        url: repo.url,
+        version
+      };
+    }
+    const fstr = YAML.stringify(fyaml);
+    try {
+      await fse.outputFile(yamlPath, fstr);
+      r_code = 0;
+    } catch (error) {
+      console.log(`ERR218: Error by writting the yaml-file ${yamlPath}!`);
+      console.error(error);
+    }
+    console.log(`The yaml-file ${yamlPath} has been written!`);
+    return r_code;
+  }
+  /**
+   * Validate a yaml-file that could be imported later on.
+   *
+   * @param yamlPath the path to the yaml-file to be checked/validated.
+   * @returns an integer-code. 0 if the validation is successful, negative otherwise.
+   */
+  async validate_yaml(yamlPath) {
+    if (yamlPath === "") {
+      console.log(`ERR482: Error, the discoverDir cannot be an empty string`);
+      return -1;
+    }
+    return await validate_yaml_external(yamlPath);
+  }
+  /**
+   * Return a string with the three numbers (major, minor, patch) written in the package.json.
+   *
+   * @returns the string Major.Minor.Patch
+   */
+  static version_short() {
+    return vag_version_short;
+  }
+};
+
+// src/vag_cli.ts
+var cmd = {
+  list: false,
+  clone: false,
+  checkout: false,
+  verify: false,
+  fetch: false,
+  pull: false,
+  push: false,
+  branch: false,
+  status: false,
+  diff: false,
+  log: false,
+  remote: false,
+  stash_list: false,
+  clean: false,
+  custom: false,
+  export_yaml: false,
+  validate_yaml: false,
+  versions: false
+};
+var argv = yargs(hideBin(process.argv)).scriptName("vag").usage("Usage: $0 <global-options> command <command-options>").example([
+  [
+    "$0 clone --importYaml repos.yml --importDir subRepos",
+    "clone the git-repos listed in repos.yml in the directory subRepos"
+  ],
+  [
+    "$0 status --discoverDir=subRepos",
+    "show the status of all discovered git-repos with the directory subRepos"
+  ],
+  [
+    "$0 custom --git_command 'log -u -n1'",
+    "apply the cutom-command git-log to all discovered git-repos"
+  ],
+  [
+    "$0 export_yaml --yaml_path=myRepos.yml --commit_version=true",
+    "export the discovered git-repos in the yaml-file myRepos.yml"
+  ]
+]).option("discoverDir", {
+  alias: "d",
+  type: "string",
+  description: "directory-path for searching git-repositories.",
+  default: "."
+}).option("deepSearch", {
+  alias: "D",
+  type: "boolean",
+  description: "search further for git-repos within found git-repos.",
+  default: true
+}).option("importYaml", {
+  alias: "y",
+  type: "string",
+  description: "path to the yaml-file containing the list of repos.",
+  default: ""
+}).option("importDir", {
+  alias: "b",
+  type: "string",
+  description: "path to the directory where to clone the repos. If not specified, the directory of the yaml-file is used.",
+  default: ""
+}).option("only_configured", {
+  alias: "c",
+  type: "boolean",
+  description: "not on all discovered git-repos but only if in importYaml",
+  default: false
+}).command("list", "print the lists of git-repositories", {}, () => {
+  cmd.list = true;
+}).command("clone", "clone the git-repositories listed in the importYaml file", {}, () => {
+  cmd.clone = true;
+}).command("checkout", "checkout the git-repos according to the importYaml file", {}, () => {
+  cmd.checkout = true;
+}).command("verify", "verify if the discovered git-repos fit with the importYaml", {}, () => {
+  cmd.verify = true;
+}).command("fetch", "git fetch --prune the discovered git-repositories", {}, () => {
+  cmd.fetch = true;
+}).command("pull", "pull the discovered git-repositories", {}, () => {
+  cmd.pull = true;
+}).command("push", "push the discovered git-repositories", {}, () => {
+  cmd.push = true;
+}).command("branch", "show branch of the discovered git-repositories", {}, () => {
+  cmd.branch = true;
+}).command("status", "show status of the discovered git-repositories", {}, () => {
+  cmd.status = true;
+}).command("diff", "show diff of the discovered git-repositories", {}, () => {
+  cmd.diff = true;
+}).command("log", "show log of the discovered git-repositories", {}, () => {
+  cmd.log = true;
+}).command("remote", "show remote of the discovered git-repositories", {}, () => {
+  cmd.remote = true;
+}).command("stash_list", "show stash_list of the discovered git-repositories", {}, () => {
+  cmd.stash_list = true;
+}).command("clean", "git clean -dxf of the discovered git-repositories", {}, () => {
+  cmd.clean = true;
+}).command(
+  "custom",
+  "git custom command for each of the discovered git-repos",
+  {
+    git_command: {
+      type: "string",
+      description: "the git-command to be apply",
+      demandOption: true
+    }
+  },
+  () => {
+    cmd.custom = true;
+  }
+).command(
+  "export_yaml",
+  "export the discovered git-repositories in a yaml-file",
+  {
+    yaml_path: {
+      type: "string",
+      description: "the path to the output yaml-file",
+      demandOption: true
+    },
+    commit_version: {
+      type: "boolean",
+      description: "Use commit-hash instead of branch-name for version",
+      default: false
+    }
+  },
+  () => {
+    cmd.export_yaml = true;
+  }
+).command(
+  "validate_yaml",
+  "validate the syntax of a yaml-file",
+  {
+    yaml_path: {
+      type: "string",
+      description: "the path to the output yaml-file",
+      demandOption: true
+    }
+  },
+  () => {
+    cmd.validate_yaml = true;
+  }
+).command("versions", "print the versions of vag", {}, () => {
+  cmd.versions = true;
+}).strict().parseSync();
+var vag = new Vag(argv.discoverDir, argv.deepSearch, argv.importYaml, argv.importDir);
+await vag.init();
+function display_repo_list(repos) {
+  for (const [idx, repo] of repos.entries()) {
+    console.log(`  ${idx + 1} : ${repo}`);
+  }
+}
+if (cmd.list) {
+  const d_list = vag.d_list();
+  const c_list = vag.c_list();
+  const cd_list = vag.cd_list();
+  const dnc_list = vag.dnc_list();
+  const cnd_list = vag.cnd_list();
+  console.log(`List-D : ${d_list.length} discovered git-repositories`);
+  display_repo_list(d_list);
+  console.log(`List-C : ${c_list.length} configured git-repositories`);
+  display_repo_list(c_list);
+  console.log(`List-CD : ${cd_list.length} configured and discovered git-repositories`);
+  display_repo_list(cd_list);
+  console.log(`List-DnC : ${dnc_list.length} discovered git-repositories but not configured`);
+  display_repo_list(dnc_list);
+  console.log(`List-CnD : ${cnd_list.length} configured git-repositories but not discovered`);
+  display_repo_list(cnd_list);
+}
+if (cmd.clone) {
+  await vag.c_clone();
+}
+if (cmd.checkout) {
+  await vag.cd_checkout();
+}
+if (cmd.verify) {
+  await vag.cd_verify();
+}
+if (cmd.fetch) {
+  await vag.d_fetch(argv.only_configured);
+}
+if (cmd.pull) {
+  await vag.d_pull(argv.only_configured);
+}
+if (cmd.push) {
+  await vag.d_push(argv.only_configured);
+}
+if (cmd.branch) {
+  await vag.d_branch(argv.only_configured);
+}
+if (cmd.status) {
+  await vag.d_status(argv.only_configured);
+}
+if (cmd.diff) {
+  await vag.d_diff(argv.only_configured);
+}
+if (cmd.log) {
+  await vag.d_log(argv.only_configured);
+}
+if (cmd.remote) {
+  await vag.d_remote(argv.only_configured);
+}
+if (cmd.stash_list) {
+  await vag.d_stash_list(argv.only_configured);
+}
+if (cmd.clean) {
+  await vag.d_clean(argv.only_configured);
+}
+if (cmd.custom) {
+  await vag.d_custom(argv.git_command, argv.only_configured);
+}
+if (cmd.export_yaml) {
+  await vag.d_export_yaml(argv.yaml_path, argv.commit_version);
+}
+if (cmd.validate_yaml) {
+  await vag.validate_yaml(argv.yaml_path);
+}
+if (cmd.versions) {
+  console.log(`vag-version-short : ${Vag.version_short()}`);
+}
+//# sourceMappingURL=vag_cli.js.map

package/dist/vagg_server.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/vagg_server.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+// src/vagg_server.ts
+console.log("hello from vagg_server.ts!");
+//# sourceMappingURL=vagg_server.js.map

package/package.json

@@ -0,0 +1,97 @@
+{
+	"name": "vag_tools",
+	"version": "0.0.3",
+	"description": "api and cli for managing sub-git-repositories",
+	"type": "module",
+	"main": "./dist/vag_api.js",
+	"types": "./dist/vag_api.d.ts",
+	"bin": {
+		"vag": "dist/vag_cli.js",
+		"vagg": "dist/vagg_server.js"
+	},
+	"files": [
+		"dist/",
+		"!dist/**/*.map",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"engines": {
+		"node": ">=20.10.0"
+	},
+	"tsup": {
+		"entry": [
+			"src/vag_cli.ts",
+			"src/vagg_server.ts"
+		],
+		"format": "esm",
+		"splitting": false,
+		"dts": true,
+		"sourcemap": true,
+		"clean": true
+	},
+	"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",
+		"ci": "run-s check build pretty lint",
+		"clean": "shx rm -fr build dist tmp",
+		"test:basic": "node build/tests/vag.test.js",
+		"test:cli": "tests/vag-cli.test.sh",
+		"test:coverage": "vitest run --coverage",
+		"test": "run-s test:basic test:cli test:vitest",
+		"dist:build": "tsc --build tsconfig.dist.json",
+		"clean_all": "run-s clean"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/charlyoleg2/vag.git"
+	},
+	"keywords": [
+		"git",
+		"sub-repo",
+		"multi-repo",
+		"submodule",
+		"subtree",
+		"vcs",
+		"vcstool",
+		"repositories"
+	],
+	"author": "charlyoleg",
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/charlyoleg2/vag/issues"
+	},
+	"homepage": "https://github.com/charlyoleg2/vag#readme",
+	"dependencies": {
+		"fs-extra": "^11.2.0",
+		"simple-git": "^3.22.0",
+		"yaml": "^2.3.4",
+		"yargs": "^17.7.2"
+	},
+	"devDependencies": {
+		"@types/fs-extra": "^11.0.4",
+		"@types/node": "^20.11.19",
+		"@types/yargs": "^17.0.32",
+		"eslint": "^8.56.0",
+		"npm-run-all": "^4.1.5",
+		"prettier": "^3.2.5",
+		"shx": "^0.3.4",
+		"tsup": "^8.0.2",
+		"typescript": "^5.3.3",
+		"typescript-eslint": "^7.0.1",
+		"vitest": "^1.2.2"
+	},
+	"prettier": {
+		"useTabs": true,
+		"singleQuote": true,
+		"trailingComma": "none",
+		"printWidth": 100,
+		"plugins": [],
+		"overrides": []
+	}
+}