rman 0.38.0 → 1.0.2

package/utils/progress-panel.js

@@ -0,0 +1,149 @@
+import colors from 'ansi-colors';
+import { LiveRegion } from './live-region.js';
+export function formatDuration(ms) {
+    return (ms / 1000).toFixed(1) + 's';
+}
+/**
+ * Shared live progress panel for any command that fans work out across packages: a spinner
+ * header (progress bar, running/failed counts, elapsed time) plus one or two lines per
+ * currently-running item, redrawn in place instead of scrolling - the same panel `run`/`build`
+ * use, pulled out so other package-fanning commands (e.g. `ci`) can reuse it instead of
+ * reimplementing it.
+ *
+ * Renders nothing when `enabled` is false (a non-TTY, or a command's own `--no-progress`) -
+ * callers are expected to fall back to their own plain logging in that case, the way `run`
+ * falls back to its "classic" per-step log.
+ */
+export class ProgressPanel {
+    title;
+    live;
+    items = new Map();
+    renderLoop;
+    spinnerFrame = 0;
+    startedAt = 0;
+    constructor(title, enabled) {
+        this.title = title;
+        this.live = new LiveRegion(enabled);
+    }
+    get enabled() {
+        return this.live.enabled;
+    }
+    /** Registers an item and returns it - callers mutate the returned object directly (`status`,
+     *  `currentStep`, `lastLine`, ...) to drive the next render tick. */
+    addItem(name, stepsTotal) {
+        const item = { name, status: 'pending', stepsTotal, log: [] };
+        this.items.set(name, item);
+        return item;
+    }
+    /** Starts the redraw loop. No-op (and no timer) when disabled. */
+    start() {
+        this.startedAt = Date.now();
+        if (!this.live.enabled)
+            return;
+        this.renderLoop = setInterval(() => this.render(), 100);
+    }
+    render() {
+        this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
+        const spinner = colors.cyan(SPINNER_FRAMES[this.spinnerFrame]);
+        const total = this.items.size;
+        let running = 0;
+        let done = 0;
+        let failedSoFar = 0;
+        for (const item of this.items.values()) {
+            if (item.status === 'running')
+                running++;
+            else if (item.status !== 'pending')
+                done++;
+            if (item.status === 'failed')
+                failedSoFar++;
+        }
+        const header = colors.bgCyan.black.bold(` ${this.title} `);
+        const bar = renderProgressBar(done, total);
+        const totalElapsed = formatDuration(Date.now() - this.startedAt);
+        const failedText = failedSoFar > 0 ? colors.red.bold(`${failedSoFar} failed`) : colors.gray(`${failedSoFar} failed`);
+        const lines = [
+            `${header} ${bar} ${colors.bold(`${done}/${total}`)}  ${colors.cyan(`${running} running`)}  ${failedText}  ${colors.yellow(totalElapsed)}`,
+        ];
+        const runningList = [...this.items.values()].filter(i => i.status === 'running');
+        /** Leave room for the header, a safety margin, and a possible "N more running" line - a
+         *  block taller than the terminal breaks cursor-up math (the terminal scrolls instead of
+         *  the cursor moving, so redraws land in the wrong place and pile up). */
+        const budget = Math.max(0, (process.stdout.rows || 24) - 3);
+        let used = 0;
+        let shown = 0;
+        for (const item of runningList) {
+            const elapsed = item.startedAt ? formatDuration(Date.now() - item.startedAt) : '';
+            const step = item.stepsTotal && item.stepsTotal > 1 && item.stepIndex != null
+                ? `${item.currentStep} (${item.stepIndex + 1}/${item.stepsTotal})`
+                : item.currentStep || '';
+            const group = [`${spinner} ${colors.bold(item.name)}  ${colors.gray(step)}  ${colors.yellow(elapsed)}`];
+            if (item.lastLine)
+                group.push(`    ${colors.dim(item.lastLine)}`);
+            if (used + group.length > budget)
+                break;
+            lines.push(...group);
+            used += group.length;
+            shown++;
+        }
+        const remaining = runningList.length - shown;
+        if (remaining > 0)
+            lines.push(colors.gray(`… and ${remaining} more running`));
+        this.live.render(lines);
+    }
+    /** Stops the redraw loop and erases the panel, leaving the cursor where it started. */
+    stop() {
+        if (this.renderLoop)
+            clearInterval(this.renderLoop);
+        this.renderLoop = undefined;
+        this.live.clear();
+    }
+    /**
+     * Prints the final per-item recap (✓/X/○) and the "N succeeded, M failed (Xs)" summary line,
+     * and returns the tally. Any item still 'pending' is counted (and printed) as 'skipped'. The
+     * per-item recap lines are only printed when the live panel was actually on - with it off, the
+     * caller's own plain logging already showed each item's outcome as it happened.
+     */
+    printSummary() {
+        let successCount = 0;
+        let failedCount = 0;
+        let skippedCount = 0;
+        for (const item of this.items.values()) {
+            if (item.status === 'pending')
+                item.status = 'skipped';
+            const duration = item.startedAt && item.finishedAt ? colors.gray(formatDuration(item.finishedAt - item.startedAt)) : '';
+            if (item.status === 'success') {
+                successCount++;
+                if (this.live.enabled)
+                    console.log(colors.green('✓'), item.name, duration);
+            }
+            else if (item.status === 'failed') {
+                failedCount++;
+                if (this.live.enabled) {
+                    console.log(colors.red.bold('X'), item.name, duration);
+                    if (item.log.length)
+                        console.log(colors.red(item.log.join('\n')));
+                }
+            }
+            else {
+                skippedCount++;
+                if (this.live.enabled)
+                    console.log(colors.gray('○'), item.name, colors.gray('skipped'));
+            }
+        }
+        const totalElapsed = formatDuration(Date.now() - this.startedAt);
+        const summary = [
+            colors.green(`${successCount} succeeded`),
+            failedCount > 0 ? colors.red(`${failedCount} failed`) : colors.gray(`${failedCount} failed`),
+        ];
+        if (skippedCount)
+            summary.push(colors.gray(`${skippedCount} skipped`));
+        console.log(summary.join(colors.gray(', ')), colors.gray(`(${totalElapsed})`));
+        return { successCount, failedCount, skippedCount };
+    }
+}
+/** Classic braille "dots" spinner (cli-spinners' default), one frame per render tick. */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+function renderProgressBar(done, total, width = 24) {
+    const filled = total ? Math.round((done / total) * width) : 0;
+    return colors.green('█'.repeat(filled)) + colors.gray('░'.repeat(width - filled));
+}

package/utils/workspace-range.d.ts

@@ -0,0 +1,17 @@
+export interface ParsedWorkspaceRange {
+    /** `'*'`/`'^'`/`'~'` for the bare selector forms; `'explicit'` when the protocol is followed by
+     *  a concrete semver version/range instead (e.g. `"workspace:^1.0.0"`, `"workspace:1.0.0"`). */
+    selector: '*' | '^' | '~' | 'explicit';
+    /** Only set when `selector === 'explicit'` - the literal range following `"workspace:"`. */
+    range?: string;
+}
+/** Parses a dependency range value for the pnpm/yarn `"workspace:"` protocol - `undefined` when
+ *  `value` isn't a workspace range at all (a plain semver range, or not a string). */
+export declare function parseWorkspaceRange(value: unknown): ParsedWorkspaceRange | undefined;
+/**
+ * Resolves a parsed workspace range against `version` (the dependency's actual current version)
+ * into the real range a registry consumer would need - the same substitution pnpm/yarn's own
+ * publish performs: `"*"` pins the exact version (no operator), `"^"`/`"~"` prepend themselves to
+ * it, and an explicit range is used verbatim (it was already a real range, just workspace-prefixed).
+ */
+export declare function resolveWorkspaceRange(parsed: ParsedWorkspaceRange, version: string): string;

package/utils/workspace-range.js

@@ -0,0 +1,28 @@
+/** Parses a dependency range value for the pnpm/yarn `"workspace:"` protocol - `undefined` when
+ *  `value` isn't a workspace range at all (a plain semver range, or not a string). */
+export function parseWorkspaceRange(value) {
+    if (typeof value !== 'string' || !value.startsWith('workspace:'))
+        return undefined;
+    const rest = value.slice('workspace:'.length);
+    if (rest === '*' || rest === '^' || rest === '~')
+        return { selector: rest };
+    return { selector: 'explicit', range: rest };
+}
+/**
+ * Resolves a parsed workspace range against `version` (the dependency's actual current version)
+ * into the real range a registry consumer would need - the same substitution pnpm/yarn's own
+ * publish performs: `"*"` pins the exact version (no operator), `"^"`/`"~"` prepend themselves to
+ * it, and an explicit range is used verbatim (it was already a real range, just workspace-prefixed).
+ */
+export function resolveWorkspaceRange(parsed, version) {
+    switch (parsed.selector) {
+        case '*':
+            return version;
+        case '^':
+            return `^${version}`;
+        case '~':
+            return `~${version}`;
+        case 'explicit':
+            return parsed.range;
+    }
+}

package/commands/build-command.d.ts

@@ -1,11 +0,0 @@
-import * as yargs from 'yargs';
-import { Repository } from '../core/repository.js';
-import { RunCommand } from './run-command.js';
-export declare class BuildCommand extends RunCommand<any> {
-    readonly repository: Repository;
-    static commandName: string;
-    constructor(repository: Repository, options?: RunCommand.Options);
-}
-export declare namespace BuildCommand {
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}

package/commands/build-command.js

@@ -1,26 +0,0 @@
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Repository } from '../core/repository.js';
-import { RunCommand } from './run-command.js';
-export class BuildCommand extends RunCommand {
-    repository;
-    static commandName = 'build';
-    constructor(repository, options) {
-        super(repository, 'build', options);
-        this.repository = repository;
-    }
-}
-(function (BuildCommand) {
-    function initCli(repository, program) {
-        program.command({
-            command: 'build [options...]',
-            describe: 'Alias for "run build"',
-            builder: cmd => cmd.example('$0 build', '# Builds packages').option(BuildCommand.cliCommandOptions),
-            handler: async (args) => {
-                const options = Command.composeOptions(BuildCommand.commandName, args, repository.config);
-                await new BuildCommand(repository, options).execute();
-            },
-        });
-    }
-    BuildCommand.initCli = initCli;
-})(BuildCommand || (BuildCommand = {}));

package/commands/changed-command.d.ts

@@ -1,16 +0,0 @@
-import * as yargs from 'yargs';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { ListCommand } from './list-command.js';
-export declare class ChangedCommand extends ListCommand {
-    readonly repository: Repository;
-    static commandName: string;
-    constructor(repository: Repository, options?: ListCommand.Options);
-    protected _filter(pkg: Package, inf: {
-        isDirty?: boolean;
-        isCommitted?: boolean;
-    }): boolean;
-}
-export declare namespace ChangedCommand {
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}

package/commands/changed-command.js

@@ -1,35 +0,0 @@
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { ListCommand } from './list-command.js';
-export class ChangedCommand extends ListCommand {
-    repository;
-    static commandName = 'changed';
-    constructor(repository, options) {
-        super(repository, options);
-        this.repository = repository;
-    }
-    _filter(pkg, inf) {
-        if (!super._filter(pkg, inf))
-            return false;
-        return !!(inf.isDirty || inf.isCommitted);
-    }
-}
-(function (ChangedCommand) {
-    function initCli(repository, program) {
-        program.command({
-            command: 'changed [options...]',
-            describe: 'List local packages that have changed since the last tagged release',
-            builder: cmd => cmd
-                .example('$0 changed', '# List changed packages')
-                .example('$0 changed --json', '# List changed packages in JSON format')
-                .option(ListCommand.cliCommandOptions),
-            handler: async (args) => {
-                const options = Command.composeOptions(ChangedCommand.commandName, args, repository.config);
-                await new ChangedCommand(repository, options).execute();
-            },
-        });
-    }
-    ChangedCommand.initCli = initCli;
-})(ChangedCommand || (ChangedCommand = {}));

package/commands/ci-command.d.ts

@@ -1,24 +0,0 @@
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import type { ExecuteCommandResult } from '../utils/exec.js';
-import { RunCommand } from './run-command.js';
-export declare class CleanInstallCommand extends RunCommand<CleanInstallCommand.Options> {
-    readonly repository: Repository;
-    static commandName: string;
-    constructor(repository: Repository, options?: CleanInstallCommand.Options);
-    protected _prepareTasks(packages: Package[]): Promise<Task[]>;
-    protected _exec(pkg: Package, command: string, args: {
-        cwd?: string;
-        dependencies?: string[];
-        command: string;
-    }, ctx?: any): Promise<ExecuteCommandResult>;
-    protected _fsDelete(fileOrDir: string): Promise<void>;
-}
-export declare namespace CleanInstallCommand {
-    interface Options extends RunCommand.Options {
-    }
-    const cliCommandOptions: Record<string, yargs.Options>;
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}

package/commands/ci-command.js

@@ -1,71 +0,0 @@
-import colors from 'ansi-colors';
-import logger from 'npmlog';
-import path from 'path';
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { fsDelete, fsExists } from '../utils/file-utils.js';
-import { RunCommand } from './run-command.js';
-export class CleanInstallCommand extends RunCommand {
-    repository;
-    static commandName = 'ci';
-    constructor(repository, options) {
-        super(repository, 'ci', options);
-        this.repository = repository;
-    }
-    async _prepareTasks(packages) {
-        const tasks = await super._prepareTasks(packages);
-        const client = this.repository.config.client || 'npm';
-        if (!(client === 'npm' || client === 'yargs'))
-            throw new Error(`Invalid npm client "${client}"`);
-        tasks.push(new Task(async () => {
-            const dirname = this.repository.dirname;
-            await this._fsDelete(path.join(dirname, 'node_modules'));
-            await this._fsDelete(path.join(dirname, 'package-lock.json'));
-            await this._fsDelete(path.join(dirname, 'yarn-lock.json'));
-            logger.info(this.commandName, colors.yellow('install'), 'Running ' + client + ' install');
-            return super._exec(this.repository.rootPackage, client + ' install', {
-                stdio: 'inherit',
-            });
-        }, { exclusive: true }));
-        return tasks;
-    }
-    async _exec(pkg, command, args, ctx) {
-        if (command === '#') {
-            if (pkg === this.repository.rootPackage)
-                return { code: 0 };
-            logger.info(this.commandName, 'Clearing ' + pkg.name);
-            const cwd = args.cwd || pkg.dirname;
-            await this._fsDelete(path.join(cwd, 'node_modules'));
-            await this._fsDelete(path.join(cwd, 'package-lock.json'));
-            await this._fsDelete(path.join(cwd, 'yarn-lock.json'));
-            return { code: 0 };
-        }
-        return super._exec(pkg, command, args, ctx);
-    }
-    async _fsDelete(fileOrDir) {
-        if (await fsExists(fileOrDir)) {
-            logger.info(this.commandName, colors.yellow('rmdir'), path.relative(this.repository.dirname, fileOrDir));
-            await fsDelete(fileOrDir);
-        }
-    }
-}
-(function (CleanInstallCommand) {
-    CleanInstallCommand.cliCommandOptions = {
-        ...RunCommand.cliCommandOptions,
-    };
-    function initCli(repository, program) {
-        program.command({
-            command: 'ci [...options]',
-            describe: 'Deletes all dependency modules and re-installs',
-            builder: cmd => cmd.example('$0 ci', '').option(CleanInstallCommand.cliCommandOptions),
-            handler: async (args) => {
-                const options = Command.composeOptions(CleanInstallCommand.commandName, args, repository.config);
-                await new CleanInstallCommand(repository, options).execute();
-            },
-        });
-    }
-    CleanInstallCommand.initCli = initCli;
-})(CleanInstallCommand || (CleanInstallCommand = {}));

package/commands/execute-command.d.ts

@@ -1,19 +0,0 @@
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { MultiTaskCommand } from './multi-task-command.js';
-export declare class ExecuteCommand extends MultiTaskCommand<ExecuteCommand.Options> {
-    readonly repository: Repository;
-    cmd: string;
-    argv?: string[] | undefined;
-    static commandName: string;
-    constructor(repository: Repository, cmd: string, argv?: string[] | undefined, options?: ExecuteCommand.Options);
-    protected _prepareTasks(packages: Package[]): Task[];
-}
-export declare namespace ExecuteCommand {
-    interface Options extends MultiTaskCommand.Options {
-    }
-    const cliCommandOptions: Record<string, yargs.Options>;
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}

package/commands/execute-command.js

@@ -1,75 +0,0 @@
-import colors from 'ansi-colors';
-import logger from 'npmlog';
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { exec } from '../utils/exec.js';
-import { MultiTaskCommand } from './multi-task-command.js';
-export class ExecuteCommand extends MultiTaskCommand {
-    repository;
-    cmd;
-    argv;
-    static commandName = 'exec';
-    constructor(repository, cmd, argv, options) {
-        super(repository, options);
-        this.repository = repository;
-        this.cmd = cmd;
-        this.argv = argv;
-    }
-    _prepareTasks(packages) {
-        const tasks = [];
-        for (const p of packages) {
-            const task = new Task(async () => {
-                const t = Date.now();
-                logger.verbose(this.commandName, p.name, colors.cyanBright.bold('executing'), logger.separator, this.cmd + ' ' + (this.argv?.join(' ') || ''));
-                const r = await exec(this.cmd, {
-                    cwd: p.dirname,
-                    argv: this.argv,
-                    stdio: 'inherit', //logger.levelIndex < 1000 ? 'inherit' : 'pipe',
-                });
-                logger.log(r.error ? 'error' : 'info', this.commandName, p.name, r.error ? colors.red.bold('failed') : colors.green.bold('success'), logger.separator, this.cmd, colors.yellow(' (' + (Date.now() - t) + ' ms') + ')');
-            }, {
-                name: p.name,
-                dependencies: this.options.parallel ? undefined : p.dependencies,
-                bail: this.options.bail,
-                concurrency: this.options.concurrency,
-            });
-            tasks.push(task);
-        }
-        return tasks;
-    }
-}
-(function (ExecuteCommand) {
-    ExecuteCommand.cliCommandOptions = {
-        ...MultiTaskCommand.cliCommandOptions,
-    };
-    function initCli(repository, program) {
-        program.command({
-            command: 'exec [cmd] [args..]',
-            describe: 'Execute an arbitrary command in each package',
-            builder: cmd => cmd
-                .example('$0 exec -- ls', '')
-                .example('$0 exec -- rm -rf ./node_modules', '')
-                .parserConfiguration({
-                'populate--': true,
-            })
-                .positional('cmd', {
-                describe: 'The command to execute. Any command flags must be passed after --',
-                type: 'string',
-            })
-                .positional('args', {
-                describe: 'Positional arguments to send to command',
-                type: 'string',
-            })
-                .option(ExecuteCommand.cliCommandOptions),
-            handler: async (args) => {
-                const argv = args['--'] || [];
-                const options = Command.composeOptions(ExecuteCommand.commandName, args, repository.config);
-                await new ExecuteCommand(repository, '' + argv.shift(), argv, options).execute();
-            },
-        });
-    }
-    ExecuteCommand.initCli = initCli;
-})(ExecuteCommand || (ExecuteCommand = {}));

package/commands/info-command.d.ts

@@ -1,10 +0,0 @@
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Repository } from '../core/repository.js';
-export declare class InfoCommand extends Command {
-    static commandName: string;
-    protected _execute(): Promise<any>;
-}
-export declare namespace InfoCommand {
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}

package/commands/info-command.js

@@ -1,57 +0,0 @@
-import colors from 'ansi-colors';
-import envinfo from 'envinfo';
-import semver from 'semver';
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Repository } from '../core/repository.js';
-export class InfoCommand extends Command {
-    static commandName = 'info';
-    async _execute() {
-        const systemInfo = JSON.parse(await envinfo.run({
-            System: ['OS', 'CPU', 'Memory', 'Shell'],
-            Binaries: ['Node', 'Yarn', 'npm'],
-            Utilities: ['Git'],
-            npmPackages: ['rman', 'typescript'],
-            npmGlobalPackages: ['typescript'],
-        }, { json: true }));
-        if (this.options.json) {
-            this.logger.output('', '%j', systemInfo);
-            return;
-        }
-        const maxName = Object.keys(systemInfo).reduce((l, p) => Object.keys(systemInfo[p]).reduce((i, x) => (l = Math.max(i, x.length)), l), 0);
-        for (const [categoryName, category] of Object.entries(systemInfo)) {
-            this.logger.output('', '', colors.whiteBright(categoryName) + ':');
-            for (const [n, v] of Object.entries(category)) {
-                const label = '    ' + colors.reset(n) + ' '.repeat(maxName - n.length) + ' :';
-                if (typeof v === 'string') {
-                    this.logger.output('', label, colors.yellowBright(v));
-                    continue;
-                }
-                if (v.version) {
-                    this.logger.output('', label, colors.yellowBright(v.version), v.path ? ' ' + colors.yellow(v.path) : '');
-                }
-                if (v.installed) {
-                    if (v.wanted === 'latest' || semver.intersects(v.installed, v.wanted)) {
-                        this.logger.output('', label, colors.yellowBright(v.installed));
-                    }
-                    else
-                        this.logger.output('', label, colors.red(v.installed), ' => ', colors.yellowBright(v.wanted));
-                }
-            }
-        }
-    }
-}
-(function (InfoCommand) {
-    function initCli(repository, program) {
-        program.command({
-            command: 'info [options...]',
-            describe: 'Prints local environment information',
-            builder: cmd => cmd.example('$0 info', '# Prints information').example('$0 info --json', '# Prints information in JSON format'),
-            handler: async (args) => {
-                const options = Command.composeOptions(InfoCommand.commandName, args, repository.config);
-                await new InfoCommand(options).execute();
-            },
-        });
-    }
-    InfoCommand.initCli = initCli;
-})(InfoCommand || (InfoCommand = {}));

package/commands/list-command.d.ts

@@ -1,38 +0,0 @@
-import EasyTable from 'easy-table';
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-export declare class ListCommand<TOptions extends ListCommand.Options = ListCommand.Options> extends Command<TOptions> {
-    readonly repository: Repository;
-    static commandName: string;
-    onPrepare?(pkg: Package, data: ListCommand.PackageOutput): ListCommand.PackageOutput;
-    onPrintTable?(pkg: Package, data: ListCommand.PackageOutput, table: EasyTable): ListCommand.PackageOutput;
-    constructor(repository: Repository, options?: TOptions);
-    protected _filter(pkg: Package, inf: {
-        isDirty?: boolean;
-        isCommitted?: boolean;
-    }): boolean;
-    protected _execute(): Promise<any>;
-}
-export declare namespace ListCommand {
-    interface Options {
-        json?: boolean;
-        parseable?: boolean;
-        short?: boolean;
-        toposort?: boolean;
-        graph?: boolean;
-        changed?: boolean;
-        filter?: string | ((pkg: Package) => boolean);
-    }
-    interface PackageOutput {
-        name: string;
-        version?: string;
-        location?: string;
-        private?: boolean;
-        isDirty?: boolean;
-        isCommitted?: boolean;
-    }
-    const cliCommandOptions: Record<string, yargs.Options>;
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}