@git.zone/cli 1.9.95

package/readme.md

@@ -0,0 +1,207 @@
+# @git.zone/cli
+
+A CLI toolbelt to streamline local development cycles by using various gitzone utilities.
+
+## Install
+
+To install the `@git.zone/cli` tool, you need to have Node.js and npm installed on your machine. Once you have those set up, you can install the CLI tool globally using the following command:
+
+```shell
+npm install -g @git.zone/cli
+```
+
+This will add the `gitzone` or `gzone` command to your PATH, allowing you to use the tool from any directory.
+
+## Usage
+
+The `gitzone` CLI is designed to streamline various aspects of the local development cycle, including project setup, maintenance, and deployment. Below, we'll go through several scenarios that demonstrate the capabilities of `gitzone`.
+
+### Getting Started
+
+To start using `gitzone`, you need to initialize a new project or use it with an existing one. This section will guide you through the initial setup and provide examples of the core commands.
+
+#### Initialize a New Project
+
+`gitzone` can create several types of projects, including standard npm modules, websites using LitElement, and custom web components. To create a new project, you can use the following command:
+
+```shell
+gitzone template [templatename]
+```
+
+Replace `[templatename]` with one of the following:
+- `npm`: A standard npm module with TypeScript support, testing, and CI/CD setup.
+- `website`: A LitElement-based website with e2e testing, bundling, and service worker support.
+- `element`: A LitElement standard setup for creating web components.
+
+Example of starting a new npm project:
+1. Open your terminal and navigate to the directory where you want to create your project.
+2. Execute the following command:
+    ```shell
+    gitzone template npm
+    ```
+3. Follow the interactive prompts to set up your project. You will be asked to provide information such as the project name, description, GitHub repository, etc.
+
+#### Committing Changes
+
+To standardize commit messages and increment versions based on change types (fix, feat, breaking change):
+
+```shell
+gitzone commit
+```
+
+This command will prompt you with a series of questions to help construct a standardized commit message and create a new commit.
+
+#### Deprecating a Package
+
+To deprecate an old package in favor of a new one:
+
+```shell
+gitzone deprecate
+```
+
+This command will prompt you for the old and new package names and will automatically deprecate the old package on npm.
+
+#### Opening CI/CD Settings
+
+Quickly open the CI/CD settings page of your project repository:
+
+```shell
+gitzone open ci
+```
+
+### Example Commands
+
+#### Project Setup and Initialization
+
+Let's go through how to scaffold a new web component project:
+
+1. Navigate to your desired directory.
+2. Run the following command:
+   ```shell
+   gitzone template element
+   ```
+3. Follow the prompts to set up your web component project.
+
+#### Managing Project Lifecycle
+
+Commands to manage your project's lifecycle:
+
+- **Commit Changes:**
+  ```shell
+  gitzone commit
+  ```
+- **Deprecate a Package:**
+  ```shell
+  gitzone deprecate
+  ```
+- **Format Project Files:**
+  ```shell
+  gitzone format
+  ```
+- **Regenerate Readme:**
+  ```shell
+  gitzone readme
+  ```
+- **Update Local Repositories:**
+  ```shell
+  gitzone update
+  ```
+
+#### Advanced Scenarios
+
+##### Formatting
+
+To ensure consistent formatting using Prettier:
+
+```shell
+gitzone format
+```
+
+##### Building the Project
+
+To build your project as defined in your `package.json`:
+
+```shell
+npm run build
+```
+
+##### Git and Version Control
+
+Check the current project version:
+
+```shell
+gitzone -v
+```
+
+To synchronize local repositories with remotes:
+
+```shell
+gitzone update
+```
+
+##### Metadata and Configuration
+
+To initialize or update metadata:
+
+```shell
+gitzone meta init
+```
+
+### Continuous Integration and Delivery (CI/CD)
+
+#### Running Tests
+
+To execute tests defined in your `package.json`:
+
+```shell
+npm test
+```
+
+#### Building Documentation
+
+Generate documentation:
+
+```shell
+npm run buildDocs
+```
+
+### Troubleshooting and Debugging
+
+#### Detailed Logs
+
+Enable detailed logging for troubleshooting:
+
+```shell
+gitzone --loglevel=debug
+```
+
+#### Cleaning Up
+
+To clean up project artifacts:
+
+```shell
+gitzone clean
+```
+
+### Summary
+
+The `gitzone` CLI tool provides a comprehensive suite of commands that streamline project setup, lifecycle management, and deployment, which are indispensable for modern development workflows. By familiarizing yourself with the different commands, you can maximize your productivity and focus on what really matters—writing code. Whether you are starting a new project, maintaining an existing one, or deploying your work, `gitzone` is your toolbelt for efficient development cycles.
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@git.zone/cli',
+  version: '1.9.95',
+  description: 'A CLI toolbelt to streamline local development cycles by using various gitzone utilities.'
+}

package/ts/classes.gitzoneconfig.ts

@@ -0,0 +1,47 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+
+export type TGitzoneProjectType = 'npm' | 'service' | 'wcc' | 'website';
+
+/**
+ * type of the actual gitzone data
+ */
+export interface IGitzoneConfigData {
+  projectType: TGitzoneProjectType;
+  module: {
+    githost: string;
+    gitscope: string;
+    gitrepo: string;
+    description: string;
+    npmPackageName: string;
+    license: string;
+    projectDomain: string;
+  };
+  copy: {[key: string]: string}
+  npmciOptions: {
+    npmAccessLevel: 'public' | 'private';
+  };
+}
+
+/**
+ * gitzone config
+ */
+export class GitzoneConfig {
+  public static async fromCwd() {
+    const gitzoneConfig = new GitzoneConfig();
+    await gitzoneConfig.readConfigFromCwd();
+    return gitzoneConfig;
+  }
+
+  public data: IGitzoneConfigData;
+
+  public async readConfigFromCwd() {
+    const npmextraInstance = new plugins.npmextra.Npmextra(paths.cwd);
+    this.data = npmextraInstance.dataFor<IGitzoneConfigData>('gitzone', {});
+    this.data.npmciOptions = npmextraInstance.dataFor<IGitzoneConfigData['npmciOptions']>('npmci', {
+      npmAccessLevel: 'public',
+    });
+  }
+
+  constructor() {}
+}

package/ts/classes.project.ts

@@ -0,0 +1,28 @@
+import * as plugins from './plugins.js'
+import * as paths from './paths.js';
+
+import { GitzoneConfig } from './classes.gitzoneconfig.js';
+import type { TGitzoneProjectType } from './classes.gitzoneconfig.js';
+
+/**
+ * the Project class is a tool to work with a gitzone project
+ */
+export class Project {
+  public static async fromCwd() {
+    const gitzoneConfig = await GitzoneConfig.fromCwd();
+    const project = new Project(gitzoneConfig);
+    if (!project.gitzoneConfig.data.projectType) {
+      throw new Error('Please define a project type');
+    }
+    return project;
+  }
+
+  public gitzoneConfig: GitzoneConfig;
+  public get type(): TGitzoneProjectType {
+    return this.gitzoneConfig.data.projectType;
+  }
+
+  constructor(gitzoneConfigArg: GitzoneConfig) {
+    this.gitzoneConfig = gitzoneConfigArg;
+  }
+}

package/ts/gitzone.cli.ts

@@ -0,0 +1,101 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+import { GitzoneConfig } from './classes.gitzoneconfig.js';
+
+const gitzoneSmartcli = new plugins.smartcli.Smartcli();
+
+export let run = async () => {
+  const done = plugins.smartpromise.defer();
+
+  // get packageInfo
+  const projectInfo = new plugins.projectinfo.ProjectInfo(paths.packageDir);
+
+  // check for updates
+  const smartupdateInstance = new plugins.smartupdate.SmartUpdate();
+  await smartupdateInstance.check(
+    'gitzone',
+    projectInfo.npm.version,
+    'http://gitzone.gitlab.io/gitzone/changelog.html'
+  );
+  console.log('---------------------------------------------');
+  gitzoneSmartcli.addVersion(projectInfo.npm.version);
+
+  // ======> Standard task <======
+
+  /**
+   * standard task
+   */
+  gitzoneSmartcli.standardCommand().subscribe(async (argvArg) => {
+    const modStandard = await import('./mod_standard/index.js');
+    await modStandard.run();
+  });
+
+  // ======> Specific tasks <======
+
+  /**
+   * commit something
+   */
+  gitzoneSmartcli.addCommand('commit').subscribe(async (argvArg) => {
+    const modCommit = await import('./mod_commit/index.js');
+    await modCommit.run(argvArg);
+  });
+
+  /**
+   * deprecate a package on npm
+   */
+  gitzoneSmartcli.addCommand('deprecate').subscribe(async (argvArg) => {
+    const modDeprecate = await import('./mod_deprecate/index.js');
+    await modDeprecate.run();
+  });
+
+  /**
+   * Update all files that comply with the gitzone standard
+   */
+  gitzoneSmartcli.addCommand('format').subscribe(async (argvArg) => {
+    const config = GitzoneConfig.fromCwd();
+    const modFormat = await import('./mod_format/index.js');
+    await modFormat.run();
+  });
+
+  /**
+   * run meta commands
+   */
+  gitzoneSmartcli.addCommand('meta').subscribe(async (argvArg) => {
+    const config = GitzoneConfig.fromCwd();
+    const modMeta = await import('./mod_meta/index.js');
+    modMeta.run(argvArg);
+  });
+
+  /**
+   * open assets
+   */
+  gitzoneSmartcli.addCommand('open').subscribe(async (argvArg) => {
+    const modOpen = await import('./mod_open/index.js');
+    modOpen.run(argvArg);
+  });
+
+  /**
+   * add a readme to a project
+   */
+  gitzoneSmartcli.addCommand('template').subscribe(async (argvArg) => {
+    const modTemplate = await import('./mod_template/index.js');
+    modTemplate.run(argvArg);
+  });
+
+  /**
+   * start working on a project
+   */
+  gitzoneSmartcli.addCommand('start').subscribe(async (argvArg) => {
+    const modTemplate = await import('./mod_start/index.js');
+    modTemplate.run(argvArg);
+  });
+
+  gitzoneSmartcli.addCommand('helpers').subscribe(async (argvArg) => {
+    const modHelpers = await import('./mod_helpers/index.js');
+    modHelpers.run(argvArg);
+  });
+
+  // start parsing of the cli
+  gitzoneSmartcli.startParse();
+  return await done.promise;
+};

package/ts/gitzone.logging.ts

@@ -0,0 +1,15 @@
+import * as plugins from './plugins.js';
+
+export const logger = new plugins.smartlog.Smartlog({
+  minimumLogLevel: 'silly',
+  logContext: {
+    company: 'Task Venture Capital GmbH',
+    companyunit: 'Lossless Cloud',
+    containerName: 'local',
+    environment: 'local',
+    runtime: 'node',
+    zone: 'gitzone',
+  },
+});
+
+logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());

package/ts/index.ts

@@ -0,0 +1,9 @@
+export const runCli = async () => {
+  const early = await import('@push.rocks/early');
+  early.start('gitzone');
+  const plugins = await import('./plugins.js');
+  const gitzoneCli = await import('./gitzone.cli.js');
+  early.stop().then(() => {
+    gitzoneCli.run();
+  });
+};

package/ts/mod_audit/index.ts

@@ -0,0 +1 @@
+import * as paths from '../paths.js';

package/ts/mod_commit/index.ts

@@ -0,0 +1,73 @@
+// this file contains code to create commits in a consistent way
+
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../gitzone.logging.js';
+
+export const run = async (argvArg: any) => {
+  const commitInteract = new plugins.smartinteract.SmartInteract();
+  commitInteract.addQuestions([
+    {
+      type: 'list',
+      name: `commitType`,
+      message: `Choose TYPE of the commit:`,
+      choices: [`fix`, `feat`, `BREAKING CHANGE`],
+      default: `fix`,
+    },
+    {
+      type: 'input',
+      name: `commitScope`,
+      message: `What is the SCOPE of the commit:`,
+      default: `core`,
+    },
+    {
+      type: `input`,
+      name: `commitDescription`,
+      message: `What is the DESCRIPTION of the commit?`,
+      default: `update`,
+    },
+    {
+      type: 'confirm',
+      name: `pushToOrigin`,
+      message: `Do you want to push this version now?`,
+      default: true,
+    },
+  ]);
+  const answerBucket = await commitInteract.runQueue();
+  const commitString = createCommitStringFromAnswerBucket(answerBucket);
+  const commitVersionType = (() => {
+    switch (answerBucket.getAnswerFor('commitType')) {
+      case 'fix':
+        return 'patch';
+      case 'feat':
+        return 'minor';
+      case 'BREAKING CHANGE':
+        return 'major';
+    }
+  })();
+
+  logger.log('info', `OK! Creating commit with message '${commitString}'`);
+  const smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+    sourceFilePaths: [],
+  });
+
+  logger.log('info', `Baking commitinfo into code`);
+  const commitInfo = new plugins.commitinfo.CommitInfo(paths.cwd, commitVersionType);
+  await commitInfo.writeIntoPotentialDirs();
+
+  logger.log('info', `Staging files for commit:`);
+  await smartshellInstance.exec(`git add -A`);
+  await smartshellInstance.exec(`git commit -m "${commitString}"`);
+  await smartshellInstance.exec(`npm version ${commitVersionType}`);
+  if (answerBucket.getAnswerFor('pushToOrigin') && !(process.env.CI === 'true')) {
+    await smartshellInstance.exec(`git push origin master --follow-tags`);
+  }
+};
+
+const createCommitStringFromAnswerBucket = (answerBucket: plugins.smartinteract.AnswerBucket) => {
+  const commitType = answerBucket.getAnswerFor('commitType');
+  const commitScope = answerBucket.getAnswerFor('commitScope');
+  const commitDescription = answerBucket.getAnswerFor('commitDescription');
+  return `${commitType}(${commitScope}): ${commitDescription}`;
+};

package/ts/mod_commit/mod.plugins.ts

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

package/ts/mod_deprecate/index.ts

@@ -0,0 +1,37 @@
+import * as plugins from './mod.plugins.js';
+
+import { logger } from '../gitzone.logging.js';
+
+export const run = async () => {
+  const smartInteract = new plugins.smartinteract.SmartInteract([
+    {
+      name: `oldPackageName`,
+      message: `Whats the name of the OLD package?`,
+      type: `input`,
+      default: ``,
+      validate: (stringInput) => {
+        return stringInput !== '' && !process.env.CI;
+      },
+    },
+    {
+      name: `newPackageName`,
+      message: `Whats the name of the NEW package?`,
+      type: `input`,
+      default: ``,
+      validate: (stringInput) => {
+        return stringInput !== '' && !process.env.CI;
+      },
+    },
+  ]);
+  const answerBucket = await smartInteract.runQueue();
+  const oldPackageName = answerBucket.getAnswerFor(`oldPackageName`);
+  const newPackageName = answerBucket.getAnswerFor(`newPackageName`);
+  logger.log('info', `Deprecating package ${oldPackageName} in favour of ${newPackageName}`);
+  const smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+  });
+  await smartshellInstance.exec(
+    `npm deprecate ${oldPackageName}@* ` +
+      `"${oldPackageName} has been deprecated in favour of ${newPackageName} - please upgrade asap!!!"`
+  );
+};

package/ts/mod_deprecate/mod.plugins.ts

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

package/ts/mod_format/format.cleanup.ts

@@ -0,0 +1,19 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { logger } from '../gitzone.logging.js';
+import { Project } from '../classes.project.js';
+
+const filesToDelete = ['defaults.yml', 'yarn.lock', 'package-lock.json', 'tslint.json'];
+
+export const run = async (projectArg: Project) => {
+  for (const relativeFilePath of filesToDelete) {
+    const fileExists = plugins.smartfile.fs.fileExistsSync(relativeFilePath);
+    if (fileExists) {
+      logger.log('info', `Found ${relativeFilePath}! Removing it!`);
+      plugins.smartfile.fs.removeSync(plugins.path.join(paths.cwd, relativeFilePath));
+    } else {
+      logger.log('info', `Project is free of ${relativeFilePath}`);
+    }
+  }
+};

package/ts/mod_format/format.copy.ts

@@ -0,0 +1,6 @@
+import type { Project } from '../classes.project.js';
+import * as plugins from '../plugins.js';
+
+export const run = async (projectArg: Project) => {
+  const gitzoneConfig = await projectArg.gitzoneConfig;
+}

package/ts/mod_format/format.gitignore.ts

@@ -0,0 +1,21 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { Project } from '../classes.project.js';
+
+import { logger } from '../gitzone.logging.js';
+const gitignorePath = plugins.path.join(paths.cwd, './.gitignore');
+
+export const run = async (projectArg: Project) => {
+  const gitignoreExists = await plugins.smartfile.fs.fileExists(gitignorePath);
+  const templateModule = await import('../mod_template/index.js');
+  const ciTemplate = await templateModule.getTemplate('gitignore');
+  if (gitignoreExists) {
+    // lets get the existing gitignore file
+    const existingGitIgnoreString = plugins.smartfile.fs.toStringSync(gitignorePath);
+    let customPart = existingGitIgnoreString.split('# custom\n')[1];
+    customPart ? null : (customPart = '');
+  }
+  ciTemplate.writeToDisk(paths.cwd);
+  logger.log('info', 'Added a .gitignore!');
+};

package/ts/mod_format/format.license.ts

@@ -0,0 +1,24 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import { Project } from '../classes.project.js';
+
+import { logger } from '../gitzone.logging.js';
+
+const incompatibleLicenses: string[] = [
+  "AGPL",
+  "GPL",
+  "SSPL",
+];
+
+export const run = async (projectArg: Project) => {
+  const licenseChecker = await plugins.smartlegal.createLicenseChecker();
+  const licenseCheckResult = await licenseChecker.excludeLicenseWithinPath(paths.cwd, incompatibleLicenses);
+  if (licenseCheckResult.failingModules.length === 0) {
+    logger.log('info', 'Success -> licenses passed!');
+  } else {
+    logger.log('error', 'Error -> licenses failed. Here is why:');
+    for (const failedModule of licenseCheckResult.failingModules) {
+      console.log(`${failedModule.name} fails with license ${failedModule.license}`);
+    }
+  }
+};