@git.zone/cli 1.9.95

package/ts/mod_meta/meta.classes.meta.ts

@@ -0,0 +1,234 @@
+import * as plugins from './meta.plugins.js';
+import * as paths from '../paths.js';
+import * as interfaces from './meta.interfaces.js';
+
+import { logger } from '../gitzone.logging.js';
+
+export class Meta {
+  public cwd: string;
+  public dirName: string;
+  public filePaths: {
+    metaJson: string;
+    gitIgnore: string;
+    packageJson: string;
+  };
+
+  constructor(cwdArg: string) {
+    this.cwd = cwdArg;
+    this.dirName = plugins.path.basename(this.cwd);
+    this.filePaths = {
+      metaJson: plugins.path.join(this.cwd, './.meta.json'),
+      gitIgnore: plugins.path.join(this.cwd, './.gitignore'),
+      packageJson: plugins.path.join(this.cwd, './package.json'),
+    };
+  }
+
+  /**
+   * the meta repo data
+   */
+  public metaRepoData: interfaces.IMetaRepoData;
+  public smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+  });
+
+  /**
+   * sorts the metaRepoData
+   */
+  public async sortMetaRepoData() {
+    const stringifiedMetadata = plugins.smartjson.stringify(this.metaRepoData, []);
+    this.metaRepoData = plugins.smartjson.parse(stringifiedMetadata);
+  }
+
+  /**
+   * reads the meta file from disk
+   */
+  public async readDirectory() {
+    await this.syncToRemote(true);
+    logger.log('info', `reading directory`);
+    const metaFileExists = plugins.smartfile.fs.fileExistsSync(this.filePaths.metaJson);
+    if (!metaFileExists) {
+      throw new Error(`meta file does not exist at ${this.filePaths.metaJson}`);
+    }
+    this.metaRepoData = plugins.smartfile.fs.toObjectSync(this.filePaths.metaJson);
+  }
+
+  /**
+   * generates the gitignore file and stores it on disk
+   */
+  public async generateGitignore(): Promise<string> {
+    await this.sortMetaRepoData();
+    let gitignoreString = `# ignored repo directories\n`;
+    gitignoreString += `.nogit/\n`;
+    gitignoreString += `.pnpm-store/\n`;
+    for (const key of Object.keys(this.metaRepoData.projects)) {
+      gitignoreString = `${gitignoreString}${key}\n`;
+    }
+    return gitignoreString;
+  }
+
+  /**
+   * write to disk
+   */
+  public async writeToDisk() {
+    // write .meta.json to disk
+    plugins.smartfile.memory.toFsSync(
+      JSON.stringify(this.metaRepoData, null, 2),
+      this.filePaths.metaJson
+    );
+    // write .gitignore to disk
+    plugins.smartfile.memory.toFsSync(await this.generateGitignore(), this.filePaths.gitIgnore);
+  }
+
+  /**
+   * push to remote
+   */
+  public async syncToRemote(gitCleanArg = false) {
+    logger.log('info', `syncing from origin master`);
+    await this.smartshellInstance.exec(`cd ${this.cwd} && git pull origin master`);
+    if (gitCleanArg) {
+      logger.log('info', `cleaning the repository from old directories`);
+      await this.smartshellInstance.exec(`cd ${this.cwd} && git clean -fd`);
+    }
+    logger.log('info', `syncing  to remote origin master`);
+    await this.smartshellInstance.exec(`cd ${this.cwd} && git push origin master`);
+  }
+
+  /**
+   * update the locally cloned repositories
+   */
+  public async updateLocalRepos() {
+    await this.syncToRemote();
+    const projects = plugins.smartfile.fs.toObjectSync(this.filePaths.metaJson).projects;
+    const preExistingFolders = plugins.smartfile.fs.listFoldersSync(this.cwd);
+    for (const preExistingFolderArg of preExistingFolders) {
+      if (
+        preExistingFolderArg !== '.git' &&
+        !Object.keys(projects).find((projectFolder) =>
+          projectFolder.startsWith(preExistingFolderArg)
+        )
+      ) {
+        const response = await plugins.smartinteraction.SmartInteract.getCliConfirmation(
+          `Do you want to delete superfluous directory >>${preExistingFolderArg}<< ?`,
+          true
+        );
+        if (response) {
+          logger.log('warn', `Deleting >>${preExistingFolderArg}<<!`);
+        } else {
+          logger.log('warn', `Not deleting ${preExistingFolderArg} by request!`);
+        }
+      }
+    }
+
+    await this.readDirectory();
+    await this.sortMetaRepoData();
+    const missingRepos: string[] = [];
+    for (const key of Object.keys(this.metaRepoData.projects)) {
+      plugins.smartfile.fs.isDirectory(key)
+        ? logger.log('ok', `${key} -> is already cloned`)
+        : missingRepos.push(key);
+    }
+
+    logger.log('info', `found ${missingRepos.length} missing repos`);
+    for (const missingRepo of missingRepos) {
+      await this.smartshellInstance.exec(
+        `cd ${this.cwd} && git clone ${this.metaRepoData.projects[missingRepo]} ${missingRepo}`
+      );
+    }
+
+    logger.log('info', `write changes to disk`);
+    await this.writeToDisk();
+
+    logger.log('info', `persist changes with a git commit`);
+    await this.smartshellInstance.exec(
+      `cd ${this.cwd} && git add -A && git commit -m "updated structure"`
+    );
+    await this.syncToRemote();
+
+    // go recursive
+    const folders = await plugins.smartfile.fs.listFolders(this.cwd);
+    const childMetaRepositories: string[] = [];
+    for (const folder of folders) {
+      logger.log('info', folder);
+    }
+    console.log('Recursion still needs to be implemented');
+  }
+
+  // project manipulation
+
+  /**
+   * init a new meta project
+   */
+  public async initProject() {
+    await this.syncToRemote(true);
+    const fileExists = await plugins.smartfile.fs.fileExists(this.filePaths.metaJson);
+    if (!fileExists) {
+      await plugins.smartfile.memory.toFs(
+        JSON.stringify({
+          projects: {},
+        }),
+        this.filePaths.metaJson
+      );
+      logger.log(`success`, `created a new .meta.json in directory ${this.cwd}`);
+      await plugins.smartfile.memory.toFs(
+        JSON.stringify({
+          name: this.dirName,
+          version: '1.0.0',
+        }),
+        this.filePaths.packageJson
+      );
+      logger.log(`success`, `created a new package.json in directory ${this.cwd}`);
+    } else {
+      logger.log(`error`, `directory ${this.cwd} already has a .metaJson file. Doing nothing.`);
+    }
+    await this.smartshellInstance.exec(
+      `cd ${this.cwd} && git add -A && git commit -m "feat(project): init meta project for ${this.dirName}"`
+    );
+    await this.updateLocalRepos();
+  }
+
+  /**
+   * adds a project
+   */
+  public async addProject(projectNameArg: string, gitUrlArg) {
+    await this.readDirectory();
+
+    const existingProject = this.metaRepoData.projects[projectNameArg];
+
+    if (existingProject) {
+      throw new Error('Project already exists! Please remove it first before adding it again.');
+    }
+
+    this.metaRepoData.projects[projectNameArg] = gitUrlArg;
+
+    await this.sortMetaRepoData();
+    await this.writeToDisk();
+    await this.smartshellInstance.exec(
+      `cd ${this.cwd} && git add -A && git commit -m "feat(project): add ${projectNameArg}"`
+    );
+    await this.updateLocalRepos();
+  }
+
+  /**
+   * removes a project
+   */
+  public async removeProject(projectNameArg: string) {
+    await this.readDirectory();
+
+    const existingProject = this.metaRepoData.projects[projectNameArg];
+
+    if (!existingProject) {
+      logger.log('error', `Project ${projectNameArg} does not exist! So it cannot be removed`);
+      return;
+    }
+
+    delete this.metaRepoData.projects[projectNameArg];
+
+    logger.log('info', 'removing project from .meta.json');
+    await this.sortMetaRepoData();
+    await this.writeToDisk();
+
+    logger.log('info', 'removing directory from cwd');
+    await plugins.smartfile.fs.remove(plugins.path.join(paths.cwd, projectNameArg));
+    await this.updateLocalRepos();
+  }
+}

package/ts/mod_meta/meta.interfaces.ts

@@ -0,0 +1,3 @@
+export interface IMetaRepoData {
+  projects: { [key: string]: string };
+}

package/ts/mod_meta/meta.plugins.ts

@@ -0,0 +1,8 @@
+export * from '../plugins.js';
+
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartinteraction from '@push.rocks/smartinteract';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartshell from '@push.rocks/smartshell';
+
+export { smartfile, smartinteraction, smartjson, smartshell };

package/ts/mod_open/index.ts

@@ -0,0 +1,15 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+export let run = (argvArg) => {
+  let projectInfo = new plugins.projectinfo.ProjectInfo(paths.cwd);
+  if (argvArg._[1] === 'ci') {
+    plugins.smartopen.openUrl(
+      `https://gitlab.com/${projectInfo.git.gituser}/${projectInfo.git.gitrepo}/settings/ci_cd`
+    );
+  } else if (argvArg._[1] === 'pipelines') {
+    plugins.smartopen.openUrl(
+      `https://gitlab.com/${projectInfo.git.gituser}/${projectInfo.git.gitrepo}/pipelines`
+    );
+  }
+};

package/ts/mod_open/mod.plugins.ts

@@ -0,0 +1,5 @@
+export * from '../plugins.js';
+import * as smartopen from '@push.rocks/smartopen';
+import * as projectinfo from '@push.rocks/projectinfo';
+
+export { projectinfo, smartopen };

package/ts/mod_standard/index.ts

@@ -0,0 +1,29 @@
+/* -----------------------------------------------
+ * executes as standard  task
+ * ----------------------------------------------- */
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { logger } from '../gitzone.logging.js';
+
+export let run = () => {
+  const done = plugins.smartpromise.defer();
+  logger.log('warn', 'no action specified');
+  logger.log(
+    'info',
+    `
+    You can do one of the following things:
+    * create a new project with 'gitzone template [template]'
+      the following templates exist: ${(() => {
+        let projects = `\n`;
+        for (const template of plugins.smartfile.fs.listFoldersSync(paths.templatesDir)) {
+          projects += `       - ${template}\n`;
+        }
+        return projects;
+      })()}
+    * format a project with 'gitzone format'
+  `
+  );
+  done.resolve();
+  return done.promise;
+};

package/ts/mod_standard/mod.plugins.ts

@@ -0,0 +1,4 @@
+export * from '../plugins.js';
+
+import * as smartfile from '@push.rocks/smartfile';
+export { smartfile };

package/ts/mod_start/index.ts

@@ -0,0 +1,26 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { logger } from '../gitzone.logging.js';
+
+/**
+ * executes basic project setup for continuing to work.
+ * TODO: switch to smartgit
+ * @param argvArg
+ */
+export const run = async (argvArg: any) => {
+  logger.log('info', `preparing the project at ${paths.cwd} for development`);
+  const smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+  });
+
+  await smartshellInstance.execStrict(`cd ${paths.cwd} && git checkout master`);
+  await smartshellInstance.execStrict(`cd ${paths.cwd} && git pull origin master`);
+  await smartshellInstance.execStrict(`cd ${paths.cwd} && npm ci`);
+
+  await provideNoGitFiles();
+};
+
+const provideNoGitFiles = async () => {
+  logger.log('warn', 'nogit provision not yet implemented!');
+};

package/ts/mod_start/mod.plugins.ts

@@ -0,0 +1,6 @@
+export * from '../plugins.js';
+
+// pushrocks scope
+import * as smartshell from '@push.rocks/smartshell';
+
+export { smartshell };

package/ts/mod_template/index.ts

@@ -0,0 +1,52 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { logger } from '../gitzone.logging.js';
+
+export const getTemplatePath = (templateNameArg: string) => {
+  return plugins.path.join(paths.templatesDir, templateNameArg);
+};
+
+/**
+ * receives a template name and returns wether there is a corresponding template
+ */
+export const isTemplate = async (templateNameArg: string) => {
+  return plugins.smartfile.fs.isDirectory(getTemplatePath(templateNameArg));
+};
+
+export const getTemplate = async (templateNameArg: string) => {
+  if (isTemplate(templateNameArg)) {
+    const localScafTemplate = new plugins.smartscaf.ScafTemplate(getTemplatePath(templateNameArg));
+    await localScafTemplate.readTemplateFromDir();
+    return localScafTemplate;
+  } else {
+    return null;
+  }
+};
+
+export const run = async (argvArg: any) => {
+  let chosenTemplate: string = argvArg._[1];
+
+  if (!chosenTemplate) {
+    const smartinteract = new plugins.smartinteract.SmartInteract();
+    const answerBucket = await smartinteract.askQuestion({
+      type: 'list',
+      default: 'npm',
+      message: 'What template do you want to scaffold? (Only showing mpost common options)',
+      name: 'templateName',
+      choices: ['npm', 'service', 'wcc', 'website'],
+    });
+    chosenTemplate = answerBucket.value;
+  }
+
+  if (await isTemplate(chosenTemplate)) {
+    logger.log('info', `found requested template ${chosenTemplate}`);
+  } else {
+    logger.log('error', `Template ${chosenTemplate} not available`);
+    return;
+  }
+
+  const localScafTemplate = await getTemplate(chosenTemplate);
+  await localScafTemplate.askCliForMissingVariables();
+  await localScafTemplate.writeToDisk(paths.cwd);
+};

package/ts/mod_template/mod.plugins.ts

@@ -0,0 +1,7 @@
+export * from '../plugins.js';
+
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartinteract from '@push.rocks/smartinteract';
+import * as smartscaf from '@push.rocks/smartscaf';
+
+export { smartfile, smartinteract, smartscaf };

package/ts/paths.ts

@@ -0,0 +1,9 @@
+import * as plugins from './plugins.js';
+
+export let packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
+export let assetsDir = plugins.path.join(packageDir, './assets');
+export let templatesDir = plugins.path.join(assetsDir, 'templates');
+export let cwd = process.cwd();

package/ts/plugins.ts

@@ -0,0 +1,21 @@
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartlogDestinationLocal from '@push.rocks/smartlog-destination-local';
+import * as npmextra from '@push.rocks/npmextra';
+import * as path from 'path';
+import * as projectinfo from '@push.rocks/projectinfo';
+import * as smartcli from '@push.rocks/smartcli';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartupdate from '@push.rocks/smartupdate';
+
+export {
+  smartlog,
+  smartlogDestinationLocal,
+  npmextra,
+  path,
+  projectinfo,
+  smartcli,
+  smartpath,
+  smartpromise,
+  smartupdate,
+};