@git.zone/cli 2.13.13 → 2.14.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/cli',
-    version: '2.13.13',
+    version: '2.14.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxlQUFlO0lBQ3JCLE9BQU8sRUFBRSxTQUFTO0lBQ2xCLFdBQVcsRUFBRSwrTEFBK0w7Q0FDN00sQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxlQUFlO0lBQ3JCLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSwrTEFBK0w7Q0FDN00sQ0FBQSJ9

package/dist_ts/gitzone.cli.js

@@ -1,61 +1,72 @@
-import * as plugins from './plugins.js';
-import * as paths from './paths.js';
-import { GitzoneConfig } from './classes.gitzoneconfig.js';
+import * as plugins from "./plugins.js";
+import * as paths from "./paths.js";
+import { GitzoneConfig } from "./classes.gitzoneconfig.js";
+import { getRawCliMode } from "./helpers.climode.js";
 const gitzoneSmartcli = new plugins.smartcli.Smartcli();
 export let run = async () => {
     const done = plugins.smartpromise.defer();
+    const rawCliMode = await getRawCliMode();
     // 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('---------------------------------------------');
+    if (rawCliMode.checkUpdates) {
+        const smartupdateInstance = new plugins.smartupdate.SmartUpdate();
+        await smartupdateInstance.check("gitzone", projectInfo.npm.version, "http://gitzone.gitlab.io/gitzone/changelog.html");
+    }
+    if (rawCliMode.output === "human") {
+        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();
+        const modStandard = await import("./mod_standard/index.js");
+        await modStandard.run(argvArg);
+    });
+    gitzoneSmartcli.addCommand("help").subscribe(async (argvArg) => {
+        const modStandard = await import("./mod_standard/index.js");
+        await modStandard.run(argvArg);
     });
     // ======> Specific tasks <======
     /**
      * commit something
      */
-    gitzoneSmartcli.addCommand('commit').subscribe(async (argvArg) => {
-        const modCommit = await import('./mod_commit/index.js');
+    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');
+    gitzoneSmartcli.addCommand("deprecate").subscribe(async (argvArg) => {
+        const modDeprecate = await import("./mod_deprecate/index.js");
         await modDeprecate.run();
     });
     /**
      * docker
      */
-    gitzoneSmartcli.addCommand('docker').subscribe(async (argvArg) => {
-        const modDocker = await import('./mod_docker/index.js');
+    gitzoneSmartcli.addCommand("docker").subscribe(async (argvArg) => {
+        const modDocker = await import("./mod_docker/index.js");
         await modDocker.run(argvArg);
     });
     /**
      * Update all files that comply with the gitzone standard
      */
-    gitzoneSmartcli.addCommand('format').subscribe(async (argvArg) => {
+    gitzoneSmartcli.addCommand("format").subscribe(async (argvArg) => {
         const config = GitzoneConfig.fromCwd();
-        const modFormat = await import('./mod_format/index.js');
+        const modFormat = await import("./mod_format/index.js");
         // Handle format with options
         // Default is dry-mode, use --write/-w to apply changes
         await modFormat.run({
+            ...argvArg,
             write: argvArg.write || argvArg.w,
-            dryRun: argvArg['dry-run'],
+            dryRun: argvArg["dry-run"],
             yes: argvArg.yes,
-            planOnly: argvArg['plan-only'],
-            savePlan: argvArg['save-plan'],
-            fromPlan: argvArg['from-plan'],
+            planOnly: argvArg["plan-only"],
+            savePlan: argvArg["save-plan"],
+            fromPlan: argvArg["from-plan"],
             detailed: argvArg.detailed,
             interactive: argvArg.interactive !== false,
             verbose: argvArg.verbose,
@@ -65,52 +76,52 @@ export let run = async () => {
     /**
      * run meta commands
      */
-    gitzoneSmartcli.addCommand('meta').subscribe(async (argvArg) => {
+    gitzoneSmartcli.addCommand("meta").subscribe(async (argvArg) => {
         const config = GitzoneConfig.fromCwd();
-        const modMeta = await import('./mod_meta/index.js');
+        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');
+    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');
+    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');
+    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');
+    gitzoneSmartcli.addCommand("helpers").subscribe(async (argvArg) => {
+        const modHelpers = await import("./mod_helpers/index.js");
         modHelpers.run(argvArg);
     });
     /**
      * manage release configuration
      */
-    gitzoneSmartcli.addCommand('config').subscribe(async (argvArg) => {
-        const modConfig = await import('./mod_config/index.js');
+    gitzoneSmartcli.addCommand("config").subscribe(async (argvArg) => {
+        const modConfig = await import("./mod_config/index.js");
         await modConfig.run(argvArg);
     });
     /**
      * manage development services (MongoDB, S3/MinIO)
      */
-    gitzoneSmartcli.addCommand('services').subscribe(async (argvArg) => {
-        const modServices = await import('./mod_services/index.js');
+    gitzoneSmartcli.addCommand("services").subscribe(async (argvArg) => {
+        const modServices = await import("./mod_services/index.js");
         await modServices.run(argvArg);
     });
     // start parsing of the cli
     gitzoneSmartcli.startParse();
     return await done.promise;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/helpers.climode.d.ts

@@ -0,0 +1,22 @@
+export type TCliOutputMode = "human" | "plain" | "json";
+export interface ICliMode {
+    output: TCliOutputMode;
+    interactive: boolean;
+    json: boolean;
+    plain: boolean;
+    quiet: boolean;
+    yes: boolean;
+    help: boolean;
+    agent: boolean;
+    checkUpdates: boolean;
+    isTty: boolean;
+    command?: string;
+}
+type TArgSource = Record<string, any> & {
+    _?: string[];
+};
+export declare const getCliMode: (argvArg?: TArgSource) => Promise<ICliMode>;
+export declare const getRawCliMode: () => Promise<ICliMode>;
+export declare const printJson: (data: unknown) => void;
+export declare const runWithSuppressedOutput: <T>(fn: () => Promise<T>) => Promise<T>;
+export {};

package/dist_ts/helpers.climode.js

@@ -0,0 +1,158 @@
+import { getCliConfigValue } from "./helpers.smartconfig.js";
+const camelCase = (value) => {
+    return value.replace(/-([a-z])/g, (_match, group) => group.toUpperCase());
+};
+const getArgValue = (argvArg, key) => {
+    const keyVariants = [key, camelCase(key), key.replace(/-/g, "")];
+    for (const keyVariant of keyVariants) {
+        if (argvArg[keyVariant] !== undefined) {
+            return argvArg[keyVariant];
+        }
+    }
+    return undefined;
+};
+const parseRawArgv = (argv) => {
+    const parsedArgv = { _: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const currentArg = argv[i];
+        if (currentArg.startsWith("--no-")) {
+            const key = currentArg.slice(5);
+            parsedArgv[key] = false;
+            parsedArgv[camelCase(key)] = false;
+            continue;
+        }
+        if (currentArg.startsWith("--")) {
+            const withoutPrefix = currentArg.slice(2);
+            const [rawKey, inlineValue] = withoutPrefix.split("=", 2);
+            if (inlineValue !== undefined) {
+                parsedArgv[rawKey] = inlineValue;
+                parsedArgv[camelCase(rawKey)] = inlineValue;
+                continue;
+            }
+            const nextArg = argv[i + 1];
+            if (nextArg && !nextArg.startsWith("-")) {
+                parsedArgv[rawKey] = nextArg;
+                parsedArgv[camelCase(rawKey)] = nextArg;
+                i++;
+            }
+            else {
+                parsedArgv[rawKey] = true;
+                parsedArgv[camelCase(rawKey)] = true;
+            }
+            continue;
+        }
+        if (currentArg.startsWith("-") && currentArg.length > 1) {
+            for (const shortFlag of currentArg.slice(1).split("")) {
+                parsedArgv[shortFlag] = true;
+            }
+            continue;
+        }
+        parsedArgv._ = parsedArgv._ || [];
+        parsedArgv._.push(currentArg);
+    }
+    return parsedArgv;
+};
+const normalizeOutputMode = (value) => {
+    if (value === "human" || value === "plain" || value === "json") {
+        return value;
+    }
+    return undefined;
+};
+const resolveCliMode = (argvArg, cliConfig) => {
+    const isTty = Boolean(process.stdout?.isTTY && process.stdin?.isTTY);
+    const agentMode = Boolean(getArgValue(argvArg, "agent"));
+    const outputOverride = normalizeOutputMode(getArgValue(argvArg, "output"));
+    let output = normalizeOutputMode(cliConfig.output) || (isTty ? "human" : "plain");
+    if (agentMode || getArgValue(argvArg, "json")) {
+        output = "json";
+    }
+    else if (getArgValue(argvArg, "plain")) {
+        output = "plain";
+    }
+    else if (outputOverride) {
+        output = outputOverride;
+    }
+    const interactiveSetting = getArgValue(argvArg, "interactive");
+    let interactive = cliConfig.interactive ?? isTty;
+    if (interactiveSetting === true) {
+        interactive = true;
+    }
+    else if (interactiveSetting === false) {
+        interactive = false;
+    }
+    if (!isTty || output !== "human" || agentMode) {
+        interactive = false;
+    }
+    const checkUpdatesSetting = getArgValue(argvArg, "check-updates");
+    let checkUpdates = cliConfig.checkUpdates ?? output === "human";
+    if (checkUpdatesSetting === true) {
+        checkUpdates = true;
+    }
+    else if (checkUpdatesSetting === false) {
+        checkUpdates = false;
+    }
+    if (output !== "human" || agentMode) {
+        checkUpdates = false;
+    }
+    return {
+        output,
+        interactive,
+        json: output === "json",
+        plain: output === "plain",
+        quiet: Boolean(getArgValue(argvArg, "quiet") ||
+            getArgValue(argvArg, "q") ||
+            output === "json"),
+        yes: Boolean(getArgValue(argvArg, "yes") || getArgValue(argvArg, "y")),
+        help: Boolean(getArgValue(argvArg, "help") ||
+            getArgValue(argvArg, "h") ||
+            argvArg._?.[0] === "help"),
+        agent: agentMode,
+        checkUpdates,
+        isTty,
+        command: argvArg._?.[0],
+    };
+};
+const getCliModeConfig = async () => {
+    return await getCliConfigValue("cli", {});
+};
+export const getCliMode = async (argvArg = {}) => {
+    const cliConfig = await getCliModeConfig();
+    return resolveCliMode(argvArg, cliConfig);
+};
+export const getRawCliMode = async () => {
+    const cliConfig = await getCliModeConfig();
+    const rawArgv = parseRawArgv(process.argv.slice(2));
+    return resolveCliMode(rawArgv, cliConfig);
+};
+export const printJson = (data) => {
+    console.log(JSON.stringify(data, null, 2));
+};
+export const runWithSuppressedOutput = async (fn) => {
+    const originalConsole = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+    };
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+    const noop = () => undefined;
+    console.log = noop;
+    console.info = noop;
+    console.warn = noop;
+    console.error = noop;
+    process.stdout.write = (() => true);
+    process.stderr.write = (() => true);
+    try {
+        return await fn();
+    }
+    finally {
+        console.log = originalConsole.log;
+        console.info = originalConsole.info;
+        console.warn = originalConsole.warn;
+        console.error = originalConsole.error;
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.climode.js","sourceRoot":"","sources":["../ts/helpers.climode.ts"],"names":[],"mappings":"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"}

package/dist_ts/helpers.smartconfig.d.ts

@@ -0,0 +1,11 @@
+export declare const CLI_NAMESPACE = "@git.zone/cli";
+export declare const getSmartconfigPath: (cwd?: string) => string;
+export declare const readSmartconfigFile: (cwd?: string) => Promise<Record<string, any>>;
+export declare const writeSmartconfigFile: (data: Record<string, any>, cwd?: string) => Promise<void>;
+export declare const normalizeCliConfigPath: (configPath: string) => string;
+export declare const getCliConfigPathSegments: (configPath: string) => string[];
+export declare const getCliNamespaceConfig: (smartconfigData: Record<string, any>) => Record<string, any>;
+export declare const getCliConfigValueFromData: (smartconfigData: Record<string, any>, configPath: string) => any;
+export declare const getCliConfigValue: <T>(configPath: string, defaultValue: T, cwd?: string) => Promise<T>;
+export declare const setCliConfigValueInData: (smartconfigData: Record<string, any>, configPath: string, value: any) => Record<string, any>;
+export declare const unsetCliConfigValueInData: (smartconfigData: Record<string, any>, configPath: string) => boolean;

package/dist_ts/helpers.smartconfig.js

@@ -0,0 +1,139 @@
+import * as plugins from "./plugins.js";
+import { rename, writeFile } from "fs/promises";
+export const CLI_NAMESPACE = "@git.zone/cli";
+const isPlainObject = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+export const getSmartconfigPath = (cwd = process.cwd()) => {
+    return plugins.path.join(cwd, ".smartconfig.json");
+};
+export const readSmartconfigFile = async (cwd = process.cwd()) => {
+    const smartconfigPath = getSmartconfigPath(cwd);
+    if (!(await plugins.smartfs.file(smartconfigPath).exists())) {
+        return {};
+    }
+    const content = (await plugins.smartfs
+        .file(smartconfigPath)
+        .encoding("utf8")
+        .read());
+    if (content.trim() === "") {
+        return {};
+    }
+    return JSON.parse(content);
+};
+export const writeSmartconfigFile = async (data, cwd = process.cwd()) => {
+    const smartconfigPath = getSmartconfigPath(cwd);
+    const tempPath = `${smartconfigPath}.tmp-${Date.now()}`;
+    const content = JSON.stringify(data, null, 2);
+    await writeFile(tempPath, content, "utf8");
+    await rename(tempPath, smartconfigPath);
+};
+export const normalizeCliConfigPath = (configPath) => {
+    const trimmedPath = configPath.trim();
+    if (!trimmedPath || trimmedPath === CLI_NAMESPACE) {
+        return "";
+    }
+    if (trimmedPath.startsWith(`${CLI_NAMESPACE}.`)) {
+        return trimmedPath.slice(`${CLI_NAMESPACE}.`.length);
+    }
+    return trimmedPath;
+};
+export const getCliConfigPathSegments = (configPath) => {
+    const normalizedPath = normalizeCliConfigPath(configPath);
+    if (!normalizedPath) {
+        return [];
+    }
+    return normalizedPath
+        .split(".")
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+};
+export const getCliNamespaceConfig = (smartconfigData) => {
+    const cliConfig = smartconfigData[CLI_NAMESPACE];
+    if (isPlainObject(cliConfig)) {
+        return cliConfig;
+    }
+    return {};
+};
+export const getCliConfigValueFromData = (smartconfigData, configPath) => {
+    const segments = getCliConfigPathSegments(configPath);
+    let currentValue = getCliNamespaceConfig(smartconfigData);
+    for (const segment of segments) {
+        if (!isPlainObject(currentValue) && !Array.isArray(currentValue)) {
+            return undefined;
+        }
+        currentValue = currentValue?.[segment];
+    }
+    return currentValue;
+};
+export const getCliConfigValue = async (configPath, defaultValue, cwd = process.cwd()) => {
+    const smartconfigData = await readSmartconfigFile(cwd);
+    const configValue = getCliConfigValueFromData(smartconfigData, configPath);
+    if (configValue === undefined) {
+        return defaultValue;
+    }
+    if (isPlainObject(defaultValue) && isPlainObject(configValue)) {
+        return {
+            ...defaultValue,
+            ...configValue,
+        };
+    }
+    return configValue;
+};
+export const setCliConfigValueInData = (smartconfigData, configPath, value) => {
+    const segments = getCliConfigPathSegments(configPath);
+    if (!isPlainObject(smartconfigData[CLI_NAMESPACE])) {
+        smartconfigData[CLI_NAMESPACE] = {};
+    }
+    if (segments.length === 0) {
+        smartconfigData[CLI_NAMESPACE] = value;
+        return smartconfigData;
+    }
+    let currentValue = smartconfigData[CLI_NAMESPACE];
+    for (const segment of segments.slice(0, -1)) {
+        if (!isPlainObject(currentValue[segment])) {
+            currentValue[segment] = {};
+        }
+        currentValue = currentValue[segment];
+    }
+    currentValue[segments[segments.length - 1]] = value;
+    return smartconfigData;
+};
+export const unsetCliConfigValueInData = (smartconfigData, configPath) => {
+    const segments = getCliConfigPathSegments(configPath);
+    if (segments.length === 0) {
+        if (smartconfigData[CLI_NAMESPACE] !== undefined) {
+            delete smartconfigData[CLI_NAMESPACE];
+            return true;
+        }
+        return false;
+    }
+    const parentSegments = segments.slice(0, -1);
+    let currentValue = getCliNamespaceConfig(smartconfigData);
+    const objectPath = [currentValue];
+    for (const segment of parentSegments) {
+        if (!isPlainObject(currentValue[segment])) {
+            return false;
+        }
+        currentValue = currentValue[segment];
+        objectPath.push(currentValue);
+    }
+    const lastSegment = segments[segments.length - 1];
+    if (!(lastSegment in currentValue)) {
+        return false;
+    }
+    delete currentValue[lastSegment];
+    for (let i = objectPath.length - 1; i >= 1; i--) {
+        if (Object.keys(objectPath[i]).length > 0) {
+            break;
+        }
+        const parentObject = objectPath[i - 1];
+        const parentKey = parentSegments[i - 1];
+        delete parentObject[parentKey];
+    }
+    if (Object.keys(getCliNamespaceConfig(smartconfigData)).length === 0) {
+        delete smartconfigData[CLI_NAMESPACE];
+    }
+    return true;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_commit/index.d.ts

@@ -1 +1,3 @@
+import type { ICliMode } from "../helpers.climode.js";
 export declare const run: (argvArg: any) => Promise<void>;
+export declare function showHelp(mode?: ICliMode): void;