plugin-agent-orchestrator 1.0.13 → 1.0.14

package/dist/node_modules/simple-git/dist/src/lib/runners/tasks-pending-queue.d.ts

@@ -0,0 +1,23 @@
+import { SimpleGitTask } from '../types';
+import { GitError } from '../errors/git-error';
+import { OutputLogger } from '../git-logger';
+type AnySimpleGitTask = SimpleGitTask<any>;
+type TaskInProgress = {
+    name: string;
+    logger: OutputLogger;
+    task: AnySimpleGitTask;
+};
+export declare class TasksPendingQueue {
+    private logLabel;
+    private _queue;
+    constructor(logLabel?: string);
+    private withProgress;
+    private createProgress;
+    push(task: AnySimpleGitTask): TaskInProgress;
+    fatal(err: GitError): void;
+    complete(task: AnySimpleGitTask): void;
+    attempt(task: AnySimpleGitTask): TaskInProgress;
+    static getName(name?: string): string;
+    private static counter;
+}
+export {};

package/dist/node_modules/simple-git/dist/src/lib/simple-git-api.d.ts

@@ -0,0 +1,20 @@
+import { SimpleGitBase } from '../../typings';
+import { outputHandler, SimpleGitExecutor, SimpleGitTask, SimpleGitTaskCallback } from './types';
+export declare class SimpleGitApi implements SimpleGitBase {
+    private _executor;
+    constructor(_executor: SimpleGitExecutor);
+    protected _runTask<T>(task: SimpleGitTask<T>, then?: SimpleGitTaskCallback<T>): any;
+    add(files: string | string[]): any;
+    cwd(directory: string | {
+        path: string;
+        root?: boolean;
+    }): any;
+    hashObject(path: string, write: boolean | unknown): any;
+    init(bare?: boolean | unknown): any;
+    merge(): any;
+    mergeFromTo(remote: string, branch: string): any;
+    outputHandler(handler: outputHandler): this;
+    push(): any;
+    stash(): any;
+    status(): any;
+}

package/dist/node_modules/simple-git/dist/src/lib/task-callback.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGitTask, SimpleGitTaskCallback } from './types';
+export declare function taskCallback<R>(task: SimpleGitTask<R>, response: Promise<R>, callback?: SimpleGitTaskCallback<R>): void;

package/dist/node_modules/simple-git/dist/src/lib/tasks/apply-patch.d.ts

@@ -0,0 +1,3 @@
+import { OptionFlags, Options, StringTask } from '../types';
+export type ApplyOptions = Options & OptionFlags<'--stat' | '--numstat' | '--summary' | '--check' | '--index' | '--intent-to-add' | '--3way' | '--apply' | '--no-add' | '-R' | '--reverse' | '--allow-binary-replacement' | '--binary' | '--reject' | '-z' | '--inaccurate-eof' | '--recount' | '--cached' | '--ignore-space-change' | '--ignore-whitespace' | '--verbose' | '--unsafe-paths'> & OptionFlags<'--whitespace', 'nowarn' | 'warn' | 'fix' | 'error' | 'error-all'> & OptionFlags<'--build-fake-ancestor' | '--exclude' | '--include' | '--directory', string> & OptionFlags<'-p' | '-C', number>;
+export declare function applyPatchTask(patches: string[], customArgs: string[]): StringTask<string>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/branch.d.ts

@@ -0,0 +1,7 @@
+import { BranchMultiDeleteResult, BranchSingleDeleteResult, BranchSummary } from '../../../typings';
+import { StringTask } from '../types';
+export declare function containsDeleteBranchCommand(commands: string[]): boolean;
+export declare function branchTask(customArgs: string[]): StringTask<BranchSummary | BranchSingleDeleteResult>;
+export declare function branchLocalTask(): StringTask<BranchSummary>;
+export declare function deleteBranchesTask(branches: string[], forceDelete?: boolean): StringTask<BranchMultiDeleteResult>;
+export declare function deleteBranchTask(branch: string, forceDelete?: boolean): StringTask<BranchSingleDeleteResult>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/change-working-directory.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGitExecutor } from '../types';
+export declare function changeWorkingDirectoryTask(directory: string, root?: SimpleGitExecutor): import("./task").EmptyTask;

package/dist/node_modules/simple-git/dist/src/lib/tasks/check-ignore.d.ts

@@ -0,0 +1,2 @@
+import { StringTask } from '../types';
+export declare function checkIgnoreTask(paths: string[]): StringTask<string[]>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/check-is-repo.d.ts

@@ -0,0 +1,9 @@
+import { Maybe, StringTask } from '../types';
+export declare enum CheckRepoActions {
+    BARE = "bare",
+    IN_TREE = "tree",
+    IS_REPO_ROOT = "root"
+}
+export declare function checkIsRepoTask(action: Maybe<CheckRepoActions>): StringTask<boolean>;
+export declare function checkIsRepoRootTask(): StringTask<boolean>;
+export declare function checkIsBareRepoTask(): StringTask<boolean>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/checkout.d.ts

@@ -0,0 +1,2 @@
+import type { SimpleGit } from '../../../typings';
+export default function (): Pick<SimpleGit, 'checkout' | 'checkoutBranch' | 'checkoutLocalBranch'>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/clean.d.ts

@@ -0,0 +1,25 @@
+import { CleanSummary } from '../../../typings';
+import { StringTask } from '../types';
+export declare const CONFIG_ERROR_INTERACTIVE_MODE = "Git clean interactive mode is not supported";
+export declare const CONFIG_ERROR_MODE_REQUIRED = "Git clean mode parameter (\"n\" or \"f\") is required";
+export declare const CONFIG_ERROR_UNKNOWN_OPTION = "Git clean unknown option found in: ";
+/**
+ * All supported option switches available for use in a `git.clean` operation
+ */
+export declare enum CleanOptions {
+    DRY_RUN = "n",
+    FORCE = "f",
+    IGNORED_INCLUDED = "x",
+    IGNORED_ONLY = "X",
+    EXCLUDING = "e",
+    QUIET = "q",
+    RECURSIVE = "d"
+}
+/**
+ * The two modes `git.clean` can run in - one of these must be supplied in order
+ * for the command to not throw a `TaskConfigurationError`
+ */
+export type CleanMode = CleanOptions.FORCE | CleanOptions.DRY_RUN;
+export declare function cleanWithOptionsTask(mode: CleanMode | string, customArgs: string[]): import("./task").EmptyTask | StringTask<CleanSummary>;
+export declare function cleanTask(mode: CleanMode, customArgs: string[]): StringTask<CleanSummary>;
+export declare function isCleanOptionsArray(input: string[]): input is CleanOptions[];

package/dist/node_modules/simple-git/dist/src/lib/tasks/clone.d.ts

@@ -0,0 +1,9 @@
+import { EmptyTask } from './task';
+import { OptionFlags, Options, StringTask } from '../types';
+import { SimpleGit } from '../../../typings';
+export type CloneOptions = Options & OptionFlags<'--bare' | '--dissociate' | '--mirror' | '--no-checkout' | '--no-remote-submodules' | '--no-shallow-submodules' | '--no-single-branch' | '--no-tags' | '--remote-submodules' | '--single-branch' | '--shallow-submodules' | '--verbose'> & OptionFlags<'--depth' | '-j' | '--jobs', number> & OptionFlags<'--branch' | '--origin' | '--recurse-submodules' | '--separate-git-dir' | '--shallow-exclude' | '--shallow-since' | '--template', string>;
+type CloneTaskBuilder = (repo: string | undefined, directory: string | undefined, customArgs: string[]) => StringTask<string> | EmptyTask;
+export declare const cloneTask: CloneTaskBuilder;
+export declare const cloneMirrorTask: CloneTaskBuilder;
+export default function (): Pick<SimpleGit, 'clone' | 'mirror'>;
+export {};

package/dist/node_modules/simple-git/dist/src/lib/tasks/commit.d.ts

@@ -0,0 +1,4 @@
+import type { CommitResult, SimpleGit } from '../../../typings';
+import type { StringTask } from '../types';
+export declare function commitTask(message: string[], files: string[], customArgs: string[]): StringTask<CommitResult>;
+export default function (): Pick<SimpleGit, 'commit'>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/config.d.ts

@@ -0,0 +1,8 @@
+import type { SimpleGit } from '../../../typings';
+export declare enum GitConfigScope {
+    system = "system",
+    global = "global",
+    local = "local",
+    worktree = "worktree"
+}
+export default function (): Pick<SimpleGit, 'addConfig' | 'getConfig' | 'listConfig'>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/count-objects.d.ts

@@ -0,0 +1,12 @@
+import type { SimpleGit } from '../../../typings';
+export interface CountObjectsResult {
+    count: number;
+    size: number;
+    inPack: number;
+    packs: number;
+    sizePack: number;
+    prunePackable: number;
+    garbage: number;
+    sizeGarbage: number;
+}
+export default function (): Pick<SimpleGit, 'countObjects'>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/diff-name-status.d.ts

@@ -0,0 +1,12 @@
+export declare enum DiffNameStatus {
+    ADDED = "A",
+    COPIED = "C",
+    DELETED = "D",
+    MODIFIED = "M",
+    RENAMED = "R",
+    CHANGED = "T",
+    UNMERGED = "U",
+    UNKNOWN = "X",
+    BROKEN = "B"
+}
+export declare function isDiffNameStatus(input: string): input is DiffNameStatus;

package/dist/node_modules/simple-git/dist/src/lib/tasks/diff.d.ts

@@ -0,0 +1,5 @@
+import { StringTask } from '../types';
+import { DiffResult } from '../../../typings';
+import { EmptyTask } from './task';
+export declare function diffSummaryTask(customArgs: string[]): StringTask<DiffResult> | EmptyTask;
+export declare function validateLogFormatConfig(customArgs: unknown[]): EmptyTask | void;

package/dist/node_modules/simple-git/dist/src/lib/tasks/fetch.d.ts

@@ -0,0 +1,4 @@
+import { FetchResult } from '../../../typings';
+import { StringTask } from '../types';
+import { EmptyTask } from './task';
+export declare function fetchTask(remote: string, branch: string, customArgs: string[]): StringTask<FetchResult> | EmptyTask;

package/dist/node_modules/simple-git/dist/src/lib/tasks/first-commit.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGit } from '../../../typings';
+export default function (): Pick<SimpleGit, 'firstCommit'>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/grep.d.ts

@@ -0,0 +1,12 @@
+import { SimpleGit } from '../../../typings';
+export interface GitGrepQuery extends Iterable<string> {
+    /** Adds one or more terms to be grouped as an "and" to any other terms */
+    and(...and: string[]): this;
+    /** Adds one or more search terms - git.grep will "or" this to other terms */
+    param(...param: string[]): this;
+}
+/**
+ * Creates a new builder for a `git.grep` query with optional params
+ */
+export declare function grepQueryBuilder(...params: string[]): GitGrepQuery;
+export default function (): Pick<SimpleGit, 'grep'>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/hash-object.d.ts

@@ -0,0 +1,5 @@
+import { StringTask } from '../types';
+/**
+ * Task used by `git.hashObject`
+ */
+export declare function hashObjectTask(filePath: string, write: boolean): StringTask<string>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/init.d.ts

@@ -0,0 +1,3 @@
+import { InitResult } from '../../../typings';
+import { StringTask } from '../types';
+export declare function initTask(bare: boolean | undefined, path: string, customArgs: string[]): StringTask<InitResult>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/log.d.ts

@@ -0,0 +1,32 @@
+import type { LogResult, Options, SimpleGit } from '../../../typings';
+import { StringTask } from '../types';
+export interface DefaultLogFields {
+    hash: string;
+    date: string;
+    message: string;
+    refs: string;
+    body: string;
+    author_name: string;
+    author_email: string;
+}
+export type LogOptions<T = DefaultLogFields> = {
+    file?: string;
+    format?: T;
+    from?: string;
+    mailMap?: boolean;
+    maxCount?: number;
+    multiLine?: boolean;
+    splitter?: string;
+    strictDate?: boolean;
+    symmetric?: boolean;
+    to?: string;
+};
+interface ParsedLogOptions {
+    fields: string[];
+    splitter: string;
+    commands: string[];
+}
+export declare function parseLogOptions<T extends Options>(opt?: Options | LogOptions<T>, customArgs?: string[]): ParsedLogOptions;
+export declare function logTask<T>(splitter: string, fields: string[], customArgs: string[]): StringTask<LogResult<T>>;
+export default function (): Pick<SimpleGit, 'log'>;
+export {};

package/dist/node_modules/simple-git/dist/src/lib/tasks/merge.d.ts

@@ -0,0 +1,4 @@
+import { MergeResult } from '../../../typings';
+import { StringTask } from '../types';
+import { EmptyTask } from './task';
+export declare function mergeTask(customArgs: string[]): EmptyTask | StringTask<MergeResult>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/move.d.ts

@@ -0,0 +1,3 @@
+import { MoveResult } from '../../../typings';
+import { StringTask } from '../types';
+export declare function moveTask(from: string | string[], to: string): StringTask<MoveResult>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/pull.d.ts

@@ -0,0 +1,3 @@
+import { PullResult } from '../../../typings';
+import { Maybe, StringTask } from '../types';
+export declare function pullTask(remote: Maybe<string>, branch: Maybe<string>, customArgs: string[]): StringTask<PullResult>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/push.d.ts

@@ -0,0 +1,9 @@
+import { PushResult } from '../../../typings';
+import { StringTask } from '../types';
+type PushRef = {
+    remote?: string;
+    branch?: string;
+};
+export declare function pushTagsTask(ref: PushRef | undefined, customArgs: string[]): StringTask<PushResult>;
+export declare function pushTask(ref: PushRef | undefined, customArgs: string[]): StringTask<PushResult>;
+export {};

package/dist/node_modules/simple-git/dist/src/lib/tasks/remote.d.ts

@@ -0,0 +1,8 @@
+import { type RemoteWithoutRefs, type RemoteWithRefs } from '../responses/GetRemoteSummary';
+import type { StringTask } from '../types';
+export declare function addRemoteTask(remoteName: string, remoteRepo: string, customArgs: string[]): StringTask<string>;
+export declare function getRemotesTask(verbose: true): StringTask<RemoteWithRefs[]>;
+export declare function getRemotesTask(verbose: false): StringTask<RemoteWithoutRefs[]>;
+export declare function listRemotesTask(customArgs: string[]): StringTask<string>;
+export declare function remoteTask(customArgs: string[]): StringTask<string>;
+export declare function removeRemoteTask(remoteName: string): StringTask<string>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/reset.d.ts

@@ -0,0 +1,11 @@
+import type { Maybe, OptionFlags, Options } from '../types';
+export declare enum ResetMode {
+    MIXED = "mixed",
+    SOFT = "soft",
+    HARD = "hard",
+    MERGE = "merge",
+    KEEP = "keep"
+}
+export type ResetOptions = Options & OptionFlags<'-q' | '--quiet' | '--no-quiet' | '--pathspec-from-nul'> & OptionFlags<'--pathspec-from-file', string>;
+export declare function resetTask(mode: Maybe<ResetMode>, customArgs: string[]): import("../types").StringTask<string>;
+export declare function getResetMode(mode: ResetMode | unknown): Maybe<ResetMode>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/show.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGit } from '../../../typings';
+export default function (): Pick<SimpleGit, 'showBuffer' | 'show'>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/stash-list.d.ts

@@ -0,0 +1,4 @@
+import { LogOptions, LogResult } from '../../../typings';
+import type { StringTask } from '../types';
+import type { EmptyTask } from './task';
+export declare function stashListTask(opt: LogOptions | undefined, customArgs: string[]): EmptyTask | StringTask<LogResult>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/status.d.ts

@@ -0,0 +1,3 @@
+import { StatusResult } from '../../../typings';
+import { StringTask } from '../types';
+export declare function statusTask(customArgs: string[]): StringTask<StatusResult>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/sub-module.d.ts

@@ -0,0 +1,5 @@
+import { StringTask } from '../types';
+export declare function addSubModuleTask(repo: string, path: string): StringTask<string>;
+export declare function initSubModuleTask(customArgs: string[]): StringTask<string>;
+export declare function subModuleTask(customArgs: string[]): StringTask<string>;
+export declare function updateSubModuleTask(customArgs: string[]): StringTask<string>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/tag.d.ts

@@ -0,0 +1,18 @@
+import { TagResult } from '../../../typings';
+import { StringTask } from '../types';
+/**
+ * Task used by `git.tags`
+ */
+export declare function tagListTask(customArgs?: string[]): StringTask<TagResult>;
+/**
+ * Task used by `git.addTag`
+ */
+export declare function addTagTask(name: string): StringTask<{
+    name: string;
+}>;
+/**
+ * Task used by `git.addTag`
+ */
+export declare function addAnnotatedTagTask(name: string, tagMessage: string): StringTask<{
+    name: string;
+}>;

package/dist/node_modules/simple-git/dist/src/lib/tasks/task.d.ts

@@ -0,0 +1,14 @@
+import type { BufferTask, EmptyTaskParser, SimpleGitTask, StringTask } from '../types';
+export declare const EMPTY_COMMANDS: [];
+export type EmptyTask = {
+    commands: typeof EMPTY_COMMANDS;
+    format: 'empty';
+    parser: EmptyTaskParser;
+    onError?: undefined;
+};
+export declare function adhocExecTask(parser: EmptyTaskParser): EmptyTask;
+export declare function configurationErrorTask(error: Error | string): EmptyTask;
+export declare function straightThroughStringTask(commands: string[], trimmed?: boolean): StringTask<string>;
+export declare function straightThroughBufferTask(commands: string[]): BufferTask<Buffer>;
+export declare function isBufferTask<R>(task: SimpleGitTask<R>): task is BufferTask<R>;
+export declare function isEmptyTask<R>(task: SimpleGitTask<R>): task is EmptyTask;

package/dist/node_modules/simple-git/dist/src/lib/tasks/version.d.ts

@@ -0,0 +1,9 @@
+import type { SimpleGit } from '../../../typings';
+export interface VersionResult {
+    major: number;
+    minor: number;
+    patch: number | string;
+    agent: string;
+    installed: boolean;
+}
+export default function (): Pick<SimpleGit, 'version'>;

package/dist/node_modules/simple-git/dist/src/lib/types/handlers.d.ts

@@ -0,0 +1,21 @@
+import { GitError } from '../errors/git-error';
+/**
+ * The node-style callback to a task accepts either two arguments with the first as a null
+ * and the second as the data, or just one argument which is an error.
+ */
+export type SimpleGitTaskCallback<T = string, E extends GitError = GitError> = (err: E | null, data: T) => void;
+/**
+ * The event data emitted to the progress handler whenever progress detail is received.
+ */
+export interface SimpleGitProgressEvent {
+    /** The underlying method called - push, pull etc */
+    method: string;
+    /** The type of progress being reported, note that any one task may emit many stages - for example `git clone` emits both `receiving` and `resolving` */
+    stage: 'compressing' | 'counting' | 'receiving' | 'resolving' | 'unknown' | 'writing' | string;
+    /** The percent progressed as a number 0 - 100 */
+    progress: number;
+    /** The number of items processed so far */
+    processed: number;
+    /** The total number of items to be processed */
+    total: number;
+}

package/dist/node_modules/simple-git/dist/src/lib/types/index.d.ts

@@ -0,0 +1,136 @@
+import type { SpawnOptions } from 'child_process';
+import type { SimpleGitTask } from './tasks';
+import type { SimpleGitProgressEvent } from './handlers';
+import { VulnerabilityCategoryFlags } from '@simple-git/argv-parser';
+export * from './handlers';
+export * from './tasks';
+/**
+ * Most tasks accept custom options as an array of strings as well as the
+ * options object. Unless the task is explicitly documented as such, the
+ * tasks will not accept both formats at the same time, preferring whichever
+ * appears last in the arguments.
+ */
+export type TaskOptions<O extends Options = Options> = string[] | O;
+/**
+ * Options supplied in most tasks as an optional trailing object
+ */
+export type OptionsValues = null | string | number | (string | number)[];
+export type Options = Record<string, OptionsValues>;
+export type OptionFlags<FLAGS extends string, VALUE = null> = Partial<Record<FLAGS, VALUE>>;
+/**
+ * A function called by the executor immediately after creating a child
+ * process. Allows the calling application to implement custom handling of
+ * the incoming stream of data from the `git`.
+ */
+export type outputHandler = (command: string, stdout: NodeJS.ReadableStream, stderr: NodeJS.ReadableStream, args: string[]) => void;
+/**
+ * Environment variables to be passed into the child process.
+ */
+export type GitExecutorEnv = NodeJS.ProcessEnv | undefined;
+/**
+ * Public interface of the Executor
+ */
+export interface SimpleGitExecutor {
+    env: GitExecutorEnv;
+    outputHandler?: outputHandler;
+    cwd: string;
+    chain(): SimpleGitExecutor;
+    push<R>(task: SimpleGitTask<R>): Promise<R>;
+}
+/**
+ * The resulting output from running the git child process
+ */
+export interface GitExecutorResult {
+    stdOut: Buffer[];
+    stdErr: Buffer[];
+    exitCode: number;
+    rejection: Maybe<Error>;
+}
+export interface SimpleGitPluginConfig {
+    abort: AbortSignal;
+    /**
+     * Name of the binary the child processes will spawn - defaults to `git`,
+     * supply as a tuple to enable the use of platforms that require `git` to be
+     * called through an alternative binary (eg: `wsl git ...`).
+     * Note: commands supplied in this way support a restricted set of characters
+     * and should not be used as a way to supply arbitrary config arguments etc.
+     */
+    binary: string | [string] | [string, string];
+    /**
+     * Configures the events that should be used to determine when the unederlying child process has
+     * been terminated.
+     *
+     * Version 2 will default to use `onClose=true, onExit=50` to mean the `close` event will be
+     * used to immediately treat the child process as closed and start using the data from `stdOut`
+     * / `stdErr`, whereas the `exit` event will wait `50ms` before treating the child process
+     * as closed.
+     *
+     * This will be changed in version 3 to use `onClose=true, onExit=false` so that only the
+     * close event is used to determine the termination of the process.
+     */
+    completion: {
+        onClose?: boolean | number;
+        onExit?: boolean | number;
+    };
+    /**
+     * Configures the content of errors thrown by the `simple-git` instance for each task
+     */
+    errors(error: Buffer | Error | undefined, result: Omit<GitExecutorResult, 'rejection'>): Buffer | Error | undefined;
+    /**
+     * Handler to be called with progress events emitted through the progress plugin
+     */
+    progress(data: SimpleGitProgressEvent): void;
+    /**
+     * Configuration for the `timeoutPlugin`
+     */
+    timeout: {
+        /**
+         * The number of milliseconds to wait after spawning the process / receiving
+         * content on the stdOut/stdErr streams before forcibly closing the git process.
+         */
+        block: number;
+        /**
+         * Reset timeout plugin after receiving data on `stdErr` - set to `false` to ignore
+         * `stdErr` content when determining whether to kill the process (defaults to `true`).
+         */
+        stdErr?: boolean;
+        /**
+         * Reset timeout plugin after receiving data on `stdOut` - set to `false` to ignore
+         * `stdOut` content when determining whether to kill the process (defaults to `true`).
+         */
+        stdOut?: boolean;
+    };
+    spawnOptions: Pick<SpawnOptions, 'uid' | 'gid'>;
+    unsafe: Partial<VulnerabilityCategoryFlags & {
+        /**
+         * Allows potentially unsafe values to be supplied in the `binary` configuration option and
+         * `git.customBinary()` method call.
+         */
+        allowUnsafeCustomBinary: boolean;
+    }>;
+}
+/**
+ * Optional configuration settings to be passed to the `simpleGit`
+ * builder.
+ */
+export interface SimpleGitOptions extends Partial<SimpleGitPluginConfig> {
+    /**
+     * Base directory for all tasks run through this `simple-git` instance
+     */
+    baseDir: string;
+    /**
+     * Limit for the number of child processes that will be spawned concurrently from a `simple-git` instance
+     */
+    maxConcurrentProcesses: number;
+    /**
+     * Per-command configuration parameters to be passed with the `-c` switch to `git`
+     */
+    config: string[];
+    /**
+     * Enable trimming of trailing white-space in `git.raw`
+     */
+    trimmed: boolean;
+}
+export type Maybe<T> = T | undefined;
+export type MaybeArray<T> = T | T[];
+export type Primitives = string | number | boolean;

package/dist/node_modules/simple-git/dist/src/lib/types/tasks.d.ts

@@ -0,0 +1,19 @@
+import { GitExecutorResult, SimpleGitExecutor } from './index';
+import { EmptyTask } from '../tasks/task';
+export type TaskResponseFormat = Buffer | string;
+export interface TaskParser<INPUT extends TaskResponseFormat, RESPONSE> {
+    (stdOut: INPUT, stdErr: INPUT): RESPONSE;
+}
+export interface EmptyTaskParser {
+    (executor: SimpleGitExecutor): void;
+}
+export interface SimpleGitTaskConfiguration<RESPONSE, FORMAT, INPUT extends TaskResponseFormat> {
+    commands: string[];
+    format: FORMAT;
+    parser: TaskParser<INPUT, RESPONSE>;
+    onError?: (result: GitExecutorResult, error: Error, done: (result: Buffer | Buffer[]) => void, fail: (error: string | Error) => void) => void;
+}
+export type StringTask<R> = SimpleGitTaskConfiguration<R, 'utf-8', string>;
+export type BufferTask<R> = SimpleGitTaskConfiguration<R, 'buffer', Buffer>;
+export type RunnableTask<R> = StringTask<R> | BufferTask<R>;
+export type SimpleGitTask<R> = RunnableTask<R> | EmptyTask;

package/dist/node_modules/simple-git/dist/src/lib/utils/argument-filters.d.ts

@@ -0,0 +1,14 @@
+import type { Options, Primitives } from '../types';
+export type ArgumentFilterPredicate<T> = (input: T | unknown) => input is T;
+export declare function filterType<T, K>(input: K, filter: ArgumentFilterPredicate<T>): K extends T ? T : undefined;
+export declare function filterType<T, K>(input: K, filter: ArgumentFilterPredicate<T>, def: T): T;
+export declare const filterArray: ArgumentFilterPredicate<Array<unknown>>;
+export declare function filterPrimitives(input: unknown, omit?: Array<'boolean' | 'string' | 'number'>): input is Primitives;
+export declare const filterNumber: ArgumentFilterPredicate<number>;
+export declare const filterString: ArgumentFilterPredicate<string>;
+export declare const filterStringOrStringArray: ArgumentFilterPredicate<string | string[]>;
+export declare function filterPlainObject<T extends Options>(input: T | unknown): input is T;
+export declare function filterFunction(input: unknown): input is (...args: unknown[]) => unknown;
+export declare const filterHasLength: ArgumentFilterPredicate<{
+    length: number;
+}>;

package/dist/node_modules/simple-git/dist/src/lib/utils/exit-codes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Known process exit codes used by the task parsers to determine whether an error
+ * was one they can automatically handle
+ */
+export declare enum ExitCodes {
+    SUCCESS = 0,
+    ERROR = 1,
+    NOT_FOUND = -2,
+    UNCLEAN = 128
+}

package/dist/node_modules/simple-git/dist/src/lib/utils/git-output-streams.d.ts

@@ -0,0 +1,7 @@
+import { TaskResponseFormat } from '../types';
+export declare class GitOutputStreams<T extends TaskResponseFormat = Buffer> {
+    readonly stdOut: T;
+    readonly stdErr: T;
+    constructor(stdOut: T, stdErr: T);
+    asStrings(): GitOutputStreams<string>;
+}

package/dist/node_modules/simple-git/dist/src/lib/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from './argument-filters';
+export * from './exit-codes';
+export * from './git-output-streams';
+export * from './line-parser';
+export * from './simple-git-options';
+export * from './task-options';
+export * from './task-parser';
+export * from './util';

package/dist/node_modules/simple-git/dist/src/lib/utils/line-parser.d.ts

@@ -0,0 +1,15 @@
+export declare class LineParser<T> {
+    protected matches: string[];
+    protected useMatches: (target: T, match: string[]) => boolean | void;
+    private _regExp;
+    constructor(regExp: RegExp | RegExp[], useMatches?: (target: T, match: string[]) => boolean | void);
+    parse: (line: (offset: number) => string | undefined, target: T) => boolean;
+    protected resetMatches(): void;
+    protected prepareMatches(): string[];
+    protected addMatch(reg: RegExp, index: number, line?: string): boolean;
+    protected pushMatch(_index: number, matched: string[]): void;
+}
+export declare class RemoteLineParser<T> extends LineParser<T> {
+    protected addMatch(reg: RegExp, index: number, line?: string): boolean;
+    protected pushMatch(index: number, matched: string[]): void;
+}

package/dist/node_modules/simple-git/dist/src/lib/utils/simple-git-options.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGitOptions } from '../types';
+export declare function createInstanceConfig(...options: Array<Partial<SimpleGitOptions> | undefined>): SimpleGitOptions;

package/dist/node_modules/simple-git/dist/src/lib/utils/task-options.d.ts

@@ -0,0 +1,13 @@
+import { Maybe, Options } from '../types';
+export declare function appendTaskOptions<T extends Options = Options>(options: Maybe<T>, commands?: string[]): string[];
+export declare function getTrailingOptions(args: IArguments, initialPrimitive?: number, objectOnly?: boolean): string[];
+/**
+ * Given any number of arguments, returns the trailing options argument, ignoring a trailing function argument
+ * if there is one. When not found, the return value is null.
+ */
+export declare function trailingOptionsArgument(args: IArguments): Maybe<Options>;
+/**
+ * Returns either the source argument when it is a `Function`, or the default
+ * `NOOP` function constant
+ */
+export declare function trailingFunctionArgument(args: unknown[] | IArguments | unknown, includeNoop?: boolean): Maybe<(...args: unknown[]) => unknown>;