@git.zone/cli 1.12.7 → 1.13.0

package/assets/templates/npm/ts/paths.ts

@@ -0,0 +1,8 @@
+---
+fileName: paths.ts
+---
+import * as plugins from './plugins.js';
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);

package/assets/templates/npm/ts/plugins.ts

@@ -0,0 +1,12 @@
+---
+fileName: plugins.ts
+---
+// native scope
+import * as path from 'path';
+
+export { path };
+
+// @push.rocks scope
+import * as smartpath from '@push.rocks/smartpath';
+
+export { smartpath };

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/cli',
-    version: '1.12.7',
-    description: 'A CLI toolbelt to streamline local development cycles by using various gitzone utilities.'
+    version: '1.13.0',
+    description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxlQUFlO0lBQ3JCLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSwyRkFBMkY7Q0FDekcsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxlQUFlO0lBQ3JCLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSwrTEFBK0w7Q0FDN00sQ0FBQSJ9

package/npmextra.json

@@ -10,21 +10,26 @@
       "githost": "gitlab.com",
       "gitscope": "gitzone/private",
       "gitrepo": "gitzone",
-      "description": "A CLI toolbelt to streamline local development cycles by using various gitzone utilities.",
+      "description": "A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.",
       "npmPackagename": "@gitzone_private/gitzone",
       "license": "MIT",
       "keywords": [
         "CLI",
-        "development",
-        "git",
-        "npm",
-        "TypeScript",
-        "automation",
+        "local development",
+        "gitzone utilities",
         "project setup",
+        "version control",
         "code formatting",
+        "template management",
+        "npm packages",
+        "TypeScript",
+        "automation",
+        "commit management",
         "template creation",
-        "logging",
-        "meta project management"
+        "meta project management",
+        "sync",
+        "Docker",
+        "CI/CD"
       ]
     }
   },

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@git.zone/cli",
   "private": false,
-  "version": "1.12.7",
-  "description": "A CLI toolbelt to streamline local development cycles by using various gitzone utilities.",
+  "version": "1.13.0",
+  "description": "A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.",
   "main": "dist_ts/index.ts",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -16,16 +16,21 @@
   },
   "keywords": [
     "CLI",
-    "development",
-    "git",
-    "npm",
-    "TypeScript",
-    "automation",
+    "local development",
+    "gitzone utilities",
     "project setup",
+    "version control",
     "code formatting",
+    "template management",
+    "npm packages",
+    "TypeScript",
+    "automation",
+    "commit management",
     "template creation",
-    "logging",
-    "meta project management"
+    "meta project management",
+    "sync",
+    "Docker",
+    "CI/CD"
   ],
   "author": "Task Venture Capital GmbH",
   "license": "MIT",

package/readme.md

@@ -1,191 +1,155 @@
 # @git.zone/cli
 
-A CLI toolbelt to streamline local development cycles by using various gitzone utilities.
+A CLI toolbelt to streamline local development cycles by utilizing 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:
+To begin using `@git.zone/cli`, ensure that Node.js and npm are installed on your system. Once they are set up, install the CLI tool globally with 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.
+This command makes `gitzone` or `gzone` accessible from any directory on your system.
 
 ## 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`.
+The `gitzone` CLI provides a comprehensive set of utilities to optimize and manage the development lifecycle of projects, ranging from project initialization to version control, code formatting, and deployment processes. This usage guide will walk you through the available commands, their use cases, and provide detailed examples.
 
-### Getting Started
+### Initializing a New Project
 
-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:
+To bootstrap a new project aligned with modern TypeScript practices, use gitzone's template command. Choose from a range of templates tailored for different project types:
 
 ```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.
+Replace `[templatename]` with any of the following:
+- `npm`: Starts an npm module with TypeScript, complete with test and CI/CD integration.
+- `website`: Initializes a LitElement-based frontend application with features such as e2e testing and service worker setup.
+- `element`: Prepares a new standard setup for creating reusable web components with LitElement.
 
-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.
+**Example: Starting a New npm Project**
+1. Navigate to your desired directory in the terminal.
+2. Execute:
+   ```shell
+   gitzone template npm
+   ```
+3. Respond to the prompts to customize the project settings. This includes setting up essential metadata such as name and repository information.
 
-#### Committing Changes
+### Committing Changes
 
-To standardize commit messages and increment versions based on change types (fix, feat, breaking change):
+Standardizing commit messages and versionning with gitzone:
 
 ```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.
+This command provides an interactive prompt to create a conventional commit message, which will be automatically versioned based on the significance of the changes like `fix`, `feat`, or `BREAKING CHANGE`.
 
-#### Deprecating a Package
+### Handling Package Deprecation
 
-To deprecate an old package in favor of a new one:
+Replace an outdated package with a new one for your team and users:
 
 ```shell
 gitzone deprecate
 ```
 
-This command will prompt you for the old and new package names and will automatically deprecate the old package on npm.
+The utility collects information about old and new package names through interactive prompts, and proceeds with deprecation notices in npm, guiding users towards the updated package.
 
-#### Opening CI/CD Settings
+### CI/CD Utilities
 
-Quickly open the CI/CD settings page of your project repository:
+Access your project’s CI/CD settings instantly:
 
 ```shell
 gitzone open ci
 ```
 
-### Example Commands
+This command opens the settings page of the repository’s CI/CD configuration directly from your CLI, thus swiftly transitioning from local tasks to cloud configurations.
 
-#### Project Setup and Initialization
+### Maintaining Project Cleanliness
 
-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:
+For consistent code formatting across your project:
 
 ```shell
 gitzone format
 ```
 
-##### Building the Project
+This command applies uniform formatting styles using Prettier, ensuring your JS/TS and markdown files align with the project's style guide.
 
-To build your project as defined in your `package.json`:
+### Lifecycle Management Commands
+
+#### Clean Builds
+
+Remove generated files and prepare for a fresh build:
 
 ```shell
-npm run build
+gitzone clean
 ```
 
-##### Git and Version Control
+This utility cleans up build artifacts from your project directory so that you can run a fresh build without residual clutter affecting outcomes.
 
-Check the current project version:
+#### Sync and meta Configuration
+
+To manage metadata that guides your project configurations and module syncing:
 
 ```shell
-gitzone -v
+gitzone meta init
 ```
 
-To synchronize local repositories with remotes:
+This initialization sets the groundwork for supporting gitzone projects by helping you create a `.meta.json` file that tracks subprojects.
 
-```shell
-gitzone update
-```
+### Advanced Operations
 
-##### Metadata and Configuration
+#### Cloud and Docker Integrations
 
-To initialize or update metadata:
+For projects integrating cloud deployment or containerization:
 
 ```shell
-gitzone meta init
+gitzone docker prune
 ```
 
-### Continuous Integration and Delivery (CI/CD)
+This utility manages Docker resources by cleaning stale volumes, containers, and images, ensuring efficient resource use.
 
-#### Running Tests
+### Detailed Use Cases
 
-To execute tests defined in your `package.json`:
+#### **Project Setup and Template Management**
 
-```shell
-npm test
-```
+Whether creating an npm module or a web component, the command `gitzone template [templatename]` invokes smart scaffolding processes that automatically set up a robust project environment equipped with modern tooling like TypeScript, Prettier configurations, and testing frameworks.
+
+#### **Commit Management**
+
+The `gitzone commit` command assures that your commit messages complement semantic versioning practices. It proposes version bumps based on detected changes and helps maintain an accurate project change log.
 
-#### Building Documentation
+- **Interactive Commit:** Users engage in dialogues to define commit type (`fix`, `feat`, `BREAKING CHANGE`), scope, and description, resulting in uniform and meaningful commit logs.
+- **Automatic Versioning:** After message crafting, the versioning is attended by bumps similar to npm’s `npm version` with stages such as `major`, `minor`, and `patch`.
 
-Generate documentation:
+#### **Formatting and Configurations**
 
+A consistent format yields a professional and readable codebase:
 ```shell
-npm run buildDocs
+gitzone format
 ```
 
-### Troubleshooting and Debugging
+- **Prettier Integration:** Formats not only TypeScript and JavaScript files but also documents such as `readme.md`, maintaining consistency in both code and documentation style.
 
-#### Detailed Logs
+#### **Synced Meta Projects**
 
-Enable detailed logging for troubleshooting:
+Effectively supervise interconnected repositories or module collections:
+- **Meta Initialization (`meta init`)**: Lay down a foundation for a meta repository that orchestrates multiple projects by overseeing them through a centralized metadata file.
+- **Subproject Operations:** Commands such as `meta update`, `meta add`, `meta remove` enable dynamic management of subprojects, ensuring they remain updated with current features and aligned to the meta repository's standards.
 
-```shell
-gitzone --loglevel=debug
-```
+#### **CI/CD Integration**
 
-#### Cleaning Up
+Directly linking your local development processes to continuous integration settings with `gitzone open ci` provides seamless switches between code and configuration in cloud-based environments.
 
-To clean up project artifacts:
+#### **Real-time Docker Management**
 
-```shell
-gitzone clean
-```
+For developers employing Docker for service deployments, `gitzone docker prune` offers a quick remedy to residual services, optimizing local/docker-storage for a more streamlined experience in container management.
 
-### Summary
+### Leveraging gitzone
 
-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.
+By mastering the `gitzone` CLI commands, you gain unparalleled efficiency in managing your projects from conception to deployment. Encompassing a wide gamut of functionalities, from initial project scaffolding to synchronization of modularized repositories and beyond, `gitzone` serves as a linchpin for developers intent on optimizing their workflow. Understanding and utilizing its full potential catalyzes development cycles, granting the freedom to focus on innovation, collaboration, and delivering outstanding software products.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/cli',
-  version: '1.12.7',
-  description: 'A CLI toolbelt to streamline local development cycles by using various gitzone utilities.'
+  version: '1.13.0',
+  description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 }

package/assets/templates/npm/ts/some.plugins.ts

@@ -1,7 +0,0 @@
----
-fileName: {{module.name}}.plugins.ts
----
-const removeme = {};
-export {
-  removeme
-}