git-remote-ops 0.1.0

package/esm/deps/jsr.io/@cliffy/command/1.1.0/help/_help_generator.js

@@ -0,0 +1,357 @@
+import { Table } from "../../../table/1.1.0/mod.js";
+import { bold, brightBlue, brightMagenta, dim, getColorEnabled, green, italic, red, setColorEnabled, yellow, } from "../../../../@std/fmt/1.0.10/colors.js";
+import { getColumns } from "../../../internal/1.1.0/runtime/get_columns.js";
+import { inspect } from "../../../internal/1.1.0/runtime/inspect.js";
+import { dedent, getDescription, getFlag, parseArgumentsDefinition, } from "../_utils.js";
+import { Type } from "../type.js";
+/** Help text generator. */
+export class HelpGenerator {
+    cmd;
+    indent = 2;
+    options;
+    /** Generate help text for given command. */
+    static generate(cmd, options) {
+        return new HelpGenerator(cmd, options).generate();
+    }
+    constructor(cmd, options = {}) {
+        this.cmd = cmd;
+        this.options = {
+            types: false,
+            hints: true,
+            colors: true,
+            long: false,
+            width: getColumns() ?? 150,
+            maxWidth: Infinity,
+            ...options,
+        };
+        this.options.width = Math.min(this.options.width, this.options.maxWidth);
+    }
+    generate() {
+        const areColorsEnabled = getColorEnabled();
+        setColorEnabled(this.options.colors);
+        const result = this.generateHeader() +
+            this.generateMeta() +
+            this.generateDescription() +
+            this.generateArguments() +
+            this.generateOptions() +
+            this.generateCommands() +
+            this.generateEnvironmentVariables() +
+            this.generateExamples();
+        setColorEnabled(areColorsEnabled);
+        return result;
+    }
+    generateHeader() {
+        const usage = this.cmd.getUsage();
+        const rows = [
+            [
+                bold("Usage:"),
+                brightMagenta(this.cmd.getPath() +
+                    (usage ? " " + highlightArguments(usage, this.options.types) : "")),
+            ],
+        ];
+        const version = this.cmd.getVersion();
+        if (version) {
+            rows.push([bold("Version:"), yellow(`${this.cmd.getVersion()}`)]);
+        }
+        return "\n" +
+            Table.from(rows)
+                .padding(1)
+                .toString() +
+            "\n";
+    }
+    generateMeta() {
+        const meta = Object.entries(this.cmd.getMeta());
+        if (!meta.length) {
+            return "";
+        }
+        const rows = [];
+        for (const [name, value] of meta) {
+            rows.push([bold(`${name}: `) + value]);
+        }
+        return "\n" +
+            Table.from(rows)
+                .padding(1)
+                .toString() +
+            "\n";
+    }
+    generateDescription() {
+        if (!this.cmd.getDescription()) {
+            return "";
+        }
+        return this.label("Description") +
+            Table.from([
+                [dedent(this.cmd.getDescription())],
+            ])
+                .indent(this.indent)
+                .maxColWidth(this.options.width - this.indent)
+                .padding(1)
+                .toString() +
+            "\n";
+    }
+    generateArguments() {
+        const args = this.cmd.getArguments();
+        if (!args.length || !args.find((arg) => arg.description)) {
+            return "";
+        }
+        return this.label("Arguments") +
+            Table.from([
+                ...args
+                    .filter((arg) => arg.description)
+                    .map((argument) => [
+                    highlightArguments(argument.raw || "", this.options.types),
+                    red(bold("-")),
+                    getDescription(argument.description ?? "", !this.options.long),
+                    this.generateArgumentHints(argument),
+                ]),
+            ])
+                .padding([2, 1, 2])
+                .indent(this.indent)
+                .maxWidth(this.options.width - this.indent)
+                .flexShrink([0, 0, 1, 1])
+                .toString() +
+            "\n";
+    }
+    generateOptions() {
+        const options = this.cmd.getOptions(false);
+        if (!options.length) {
+            return "";
+        }
+        let groups = [];
+        const hasGroups = options.some((option) => option.groupName);
+        if (hasGroups) {
+            for (const option of options) {
+                let group = groups.find((group) => group.name === option.groupName);
+                if (!group) {
+                    group = {
+                        name: option.groupName,
+                        options: [],
+                    };
+                    groups.push(group);
+                }
+                group.options.push(option);
+            }
+        }
+        else {
+            groups = [{
+                    name: "Options",
+                    options,
+                }];
+        }
+        let result = "";
+        for (const group of groups) {
+            result += this.generateOptionGroup(group);
+        }
+        return result;
+    }
+    generateOptionGroup(group) {
+        if (!group.options.length) {
+            return "";
+        }
+        const hasTypeDefinitions = !!group.options.find((option) => !!option.typeDefinition);
+        if (hasTypeDefinitions) {
+            return this.label(group.name ?? "Options") +
+                Table.from([
+                    ...group.options.map((option) => [
+                        option.flags.map((flag) => brightBlue(flag)).join(", "),
+                        highlightArguments(option.typeDefinition || "", this.options.types),
+                        red(bold("-")),
+                        getDescription(option.description, !this.options.long),
+                        this.generateOptionHints(option),
+                    ]),
+                ])
+                    .padding([2, 2, 1, 2])
+                    .indent(this.indent)
+                    .maxWidth(this.options.width - this.indent)
+                    .flexShrink([0, 0, 0, 1, 1])
+                    .toString() +
+                "\n";
+        }
+        return this.label(group.name ?? "Options") +
+            Table.from([
+                ...group.options.map((option) => [
+                    option.flags.map((flag) => brightBlue(flag)).join(", "),
+                    red(bold("-")),
+                    getDescription(option.description, !this.options.long),
+                    this.generateOptionHints(option),
+                ]),
+            ])
+                .indent(this.indent)
+                .maxWidth(this.options.width - this.indent)
+                .flexShrink([0, 0, 1, 1])
+                .padding([2, 1, 2])
+                .toString() +
+            "\n";
+    }
+    generateCommands() {
+        const commands = this.cmd.getCommands(false);
+        if (!commands.length) {
+            return "";
+        }
+        const hasTypeDefinitions = !!commands.find((command) => !!command.getArgsDefinition());
+        if (hasTypeDefinitions) {
+            return this.label("Commands") +
+                Table.from([
+                    ...commands.map((command) => [
+                        [command.getName(), ...command.getAliases()].map((name) => brightBlue(name)).join(", "),
+                        highlightArguments(command.getArgsDefinition() || "", this.options.types),
+                        red(bold("-")),
+                        command.getShortDescription(),
+                    ]),
+                ])
+                    .indent(this.indent)
+                    .maxWidth(this.options.width - this.indent)
+                    .flexShrink([0, 0, 0, 1])
+                    .padding([2, 2, 1, 2])
+                    .toString() +
+                "\n";
+        }
+        return this.label("Commands") +
+            Table.from([
+                ...commands.map((command) => [
+                    [command.getName(), ...command.getAliases()].map((name) => brightBlue(name))
+                        .join(", "),
+                    red(bold("-")),
+                    command.getShortDescription(),
+                ]),
+            ])
+                .maxWidth(this.options.width - this.indent)
+                .flexShrink([0, 0, 1])
+                .padding([2, 1, 2])
+                .indent(this.indent)
+                .toString() +
+            "\n";
+    }
+    generateEnvironmentVariables() {
+        const envVars = this.cmd.getEnvVars(false);
+        if (!envVars.length) {
+            return "";
+        }
+        return this.label("Environment variables") +
+            Table.from([
+                ...envVars.map((envVar) => [
+                    envVar.names.map((name) => brightBlue(name)).join(", "),
+                    highlightArgumentDetails(envVar.details, this.options.types),
+                    red(bold("-")),
+                    this.options.long
+                        ? dedent(envVar.description)
+                        : envVar.description.trim().split("\n", 1)[0],
+                    envVar.required ? `(${yellow(`required`)})` : "",
+                ]),
+            ])
+                .padding([2, 2, 1, 2])
+                .indent(this.indent)
+                .maxWidth(this.options.width - this.indent)
+                .flexShrink([0, 0, 0, 1, 1])
+                .toString() +
+            "\n";
+    }
+    generateExamples() {
+        const examples = this.cmd.getExamples();
+        if (!examples.length) {
+            return "";
+        }
+        return this.label("Examples") +
+            Table.from(examples.map((example) => [
+                dim(bold(example.name)),
+                dedent(example.description),
+            ]))
+                .padding(1)
+                .indent(this.indent)
+                .maxWidth(this.options.width - this.indent)
+                .flexShrink([0, 1])
+                .toString() +
+            "\n";
+    }
+    generateOptionHints(option) {
+        if (!this.options.hints) {
+            return "";
+        }
+        const hints = [];
+        option.required && hints.push(yellow(`required`));
+        const type = this.cmd.getType(option.args[0]?.type)?.handler;
+        if (typeof option.default !== "undefined" ||
+            typeof option.defaultText !== "undefined") {
+            const defaultValue = typeof option.default === "function"
+                ? option.default()
+                : option.default;
+            const defaultText = typeof option.defaultText === "function"
+                ? option.defaultText(defaultValue)
+                : (typeof option.defaultText !== "undefined"
+                    ? option.defaultText
+                    : ((type instanceof Type && type.defaultText)
+                        ? type.defaultText()
+                        : defaultValue));
+            if (typeof defaultText !== "undefined") {
+                hints.push(bold(`Default: `) + inspect(defaultText, this.options.colors));
+            }
+        }
+        option.depends?.length && hints.push(yellow(bold(`Depends: `)) +
+            italic(option.depends.map(getFlag).join(", ")));
+        option.conflicts?.length && hints.push(red(bold(`Conflicts: `)) +
+            italic(option.conflicts.map(getFlag).join(", ")));
+        return this.generateHints(type, hints);
+    }
+    generateArgumentHints(option) {
+        if (!this.options.hints) {
+            return "";
+        }
+        const hints = [];
+        !option.optional && hints.push(yellow(`required`));
+        const type = this.cmd.getType(option.type)?.handler;
+        return this.generateHints(type, hints);
+    }
+    generateHints(type, hints) {
+        if (type instanceof Type) {
+            const possibleValues = type.values?.(this.cmd, this.cmd.getParent());
+            if (possibleValues?.length) {
+                hints.push(bold(`Values: `) +
+                    possibleValues.map((value) => inspect(value, this.options.colors)).join(", "));
+            }
+        }
+        if (hints.length) {
+            return `(${hints.join(", ")})`;
+        }
+        return "";
+    }
+    label(label) {
+        return "\n" + bold(`${label}:`) + "\n\n";
+    }
+}
+/**
+ * Colorize arguments string.
+ * @param argsDefinition Arguments definition: `<color1:string> <color2:string>`
+ * @param types Show types.
+ */
+function highlightArguments(argsDefinition, types = true) {
+    if (!argsDefinition) {
+        return "";
+    }
+    return parseArgumentsDefinition(argsDefinition, false, true)
+        .map((arg) => typeof arg === "string" ? arg : highlightArgumentDetails(arg, types))
+        .join(" ");
+}
+/**
+ * Colorize argument string.
+ * @param arg Argument details.
+ * @param types Show types.
+ */
+function highlightArgumentDetails(arg, types = true) {
+    let str = "";
+    str += yellow(arg.optional ? "[" : "<");
+    let name = "";
+    name += arg.name;
+    if (arg.variadic) {
+        name += "...";
+    }
+    name = brightMagenta(name);
+    str += name;
+    if (types) {
+        str += yellow(":");
+        str += red(arg.type);
+        if (arg.list) {
+            str += green("[]");
+        }
+    }
+    str += yellow(arg.optional ? "]" : ">");
+    return str;
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/mod.js

@@ -0,0 +1,13 @@
+export { Command } from "./command.js";
+export { ActionListType } from "./types/action_list.js";
+export { BooleanType } from "./types/boolean.js";
+export { ChildCommandType } from "./types/child_command.js";
+export { CommandType } from "./types/command.js";
+export { EnumType } from "./types/enum.js";
+export { FileType } from "./types/file.js";
+export { IntegerType } from "./types/integer.js";
+export { NumberType } from "./types/number.js";
+export { SecretType } from "./types/secret.js";
+export { StringType } from "./types/string.js";
+export { Type } from "./type.js";
+export { ValidationError } from "./_errors.js";

package/esm/deps/jsr.io/@cliffy/command/1.1.0/type.js

@@ -0,0 +1,27 @@
+/**
+ * Base class for custom types.
+ *
+ * **Custom type example:**
+ *
+ * ```ts
+ * import { Type, ArgumentValue } from "./mod.ts";
+ *
+ * export class ColorType extends Type<string> {
+ *   public parse({ label, name, value, type }: ArgumentValue): string {
+ *     if (["red", "blue"].includes(value)) {
+ *       throw new Error(
+ *         `${label} "${name}" must be of type "${type}", but got "${value}".` +
+ *         "Valid colors are: red, blue"
+ *       );
+ *     }
+ *     return value;
+ *   }
+ *
+ *   public override complete(): string[] {
+ *     return ["red", "blue"];
+ *   }
+ * }
+ * ```
+ */
+export class Type {
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/action_list.js

@@ -0,0 +1,16 @@
+import { StringType } from "./string.js";
+/** Completion list type. */
+export class ActionListType extends StringType {
+    cmd;
+    constructor(cmd) {
+        super();
+        this.cmd = cmd;
+    }
+    /** Complete action names. */
+    complete() {
+        return this.cmd.getCompletions()
+            .map((type) => type.name)
+            // filter unique values
+            .filter((value, index, self) => self.indexOf(value) === index);
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/boolean.js

@@ -0,0 +1,13 @@
+import { boolean } from "../../../flags/1.1.0/mod.js";
+import { Type } from "../type.js";
+/** Boolean type with auto completion. Allows `true`, `false`, `0` and `1`. */
+export class BooleanType extends Type {
+    /** Parse boolean type. */
+    parse(type) {
+        return boolean(type);
+    }
+    /** Complete boolean type. */
+    complete() {
+        return ["true", "false"];
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/child_command.js

@@ -0,0 +1,14 @@
+import { StringType } from "./string.js";
+/** String type with auto completion of child command names. */
+export class ChildCommandType extends StringType {
+    #cmd;
+    constructor(cmd) {
+        super();
+        this.#cmd = cmd;
+    }
+    /** Complete child command names. */
+    complete(cmd) {
+        return (this.#cmd ?? cmd)?.getCommands(false)
+            .map((cmd) => cmd.getName()) || [];
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/command.js

@@ -0,0 +1,9 @@
+import { StringType } from "./string.js";
+/** String type with auto completion of sibling command names. */
+export class CommandType extends StringType {
+    /** Complete sub-command names of global parent command. */
+    complete(_cmd, parent) {
+        return parent?.getCommands(false)
+            .map((cmd) => cmd.getName()) || [];
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/enum.js

@@ -0,0 +1,24 @@
+import { Type } from "../type.js";
+import { InvalidTypeError } from "../../../flags/1.1.0/mod.js";
+/** Enum type. Allows only provided values. */
+export class EnumType extends Type {
+    allowedValues;
+    constructor(values) {
+        super();
+        this.allowedValues = Array.isArray(values) ? values : Object.values(values);
+    }
+    parse(type) {
+        for (const value of this.allowedValues) {
+            if (value.toString() === type.value) {
+                return value;
+            }
+        }
+        throw new InvalidTypeError(type, this.allowedValues.slice());
+    }
+    values() {
+        return this.allowedValues.slice();
+    }
+    complete() {
+        return this.values();
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/file.js

@@ -0,0 +1,12 @@
+import { StringType } from "./string.js";
+// export interface FileTypeOptions {
+//   dirsOnly?: boolean;
+//   pattern?: string;
+//   ignore?: Array<string>;
+// }
+/** Integer type. */
+export class FileType extends StringType {
+    constructor() {
+        super();
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/integer.js

@@ -0,0 +1,9 @@
+import { Type } from "../type.js";
+import { integer } from "../../../flags/1.1.0/mod.js";
+/** Integer type. */
+export class IntegerType extends Type {
+    /** Parse integer type. */
+    parse(type) {
+        return integer(type);
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/number.js

@@ -0,0 +1,9 @@
+import { number } from "../../../flags/1.1.0/mod.js";
+import { Type } from "../type.js";
+/** Number type. */
+export class NumberType extends Type {
+    /** Parse number type. */
+    parse(type) {
+        return number(type);
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/secret.js

@@ -0,0 +1,7 @@
+import { StringType } from "./string.js";
+/** Secret type. Allows any value, and does not show values in help text. */
+export class SecretType extends StringType {
+    defaultText() {
+        return "******";
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types/string.js

@@ -0,0 +1,9 @@
+import { string } from "../../../flags/1.1.0/mod.js";
+import { Type } from "../type.js";
+/** String type. Allows any value. */
+export class StringType extends Type {
+    /** Complete string type. */
+    parse(type) {
+        return string(type);
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/types.js

@@ -0,0 +1,2 @@
+// deno-lint-ignore-file no-explicit-any
+export {};

package/esm/deps/jsr.io/@cliffy/command/1.1.0/upgrade/_check_version.js

@@ -0,0 +1,26 @@
+import { bold, yellow } from "../../../../@std/fmt/1.0.10/colors.js";
+import { Command } from "../command.js";
+/** Check if new version is available and add hint to version. */
+// deno-lint-ignore no-explicit-any
+export async function checkVersion(cmd) {
+    const mainCommand = cmd.getMainCommand();
+    const upgradeCommand = mainCommand.getCommand("upgrade");
+    if (!isUpgradeCommand(upgradeCommand)) {
+        return;
+    }
+    if (!await upgradeCommand.hasRequiredPermissions()) {
+        // If not all required permissions were pre-granted, skip the version check to prevent prompting user
+        return;
+    }
+    const latestVersion = await upgradeCommand.getLatestVersion();
+    const currentVersion = mainCommand.getVersion();
+    if (!currentVersion || currentVersion === latestVersion) {
+        return;
+    }
+    const versionHelpText = `(New version available: ${latestVersion}. Run '${mainCommand.getName()} upgrade' to upgrade to the latest version!)`;
+    mainCommand.version(`${currentVersion}  ${bold(yellow(versionHelpText))}`);
+}
+function isUpgradeCommand(command) {
+    return command instanceof Command && "getLatestVersion" in command &&
+        "hasRequiredPermissions" in command;
+}