@cat-indev/catops-cli 0.0.1-alpha.39 → 0.0.1-alpha.41

package/dist/services/git.d.ts

@@ -1,9 +1,328 @@
 import type { ExecOptions, ExecResult } from "../core/types";
-export declare function clone(url: string, targetPath: string, exec?: ExecOptions): Promise<ExecResult>;
-export declare function checkout(branch: string, exec?: ExecOptions): Promise<ExecResult>;
-export declare function pull(exec?: ExecOptions): Promise<ExecResult>;
-export declare function fetch(exec?: ExecOptions): Promise<ExecResult>;
-export declare function tag(name: string, exec?: ExecOptions): Promise<ExecResult>;
-export declare function commit(message: string, exec?: ExecOptions): Promise<ExecResult>;
-export declare function push(exec?: ExecOptions): Promise<ExecResult>;
-export declare function revParse(exec?: ExecOptions): Promise<ExecResult>;
+export interface GitCommon {
+    /** retry/timeout/dryRun para esta llamada puntual (ver shell.exec). */
+    exec?: ExecOptions;
+}
+/** True si el objeto solo contiene claves de ExecOptions (retry/timeout/dryRun/env...). */
+export declare function isBareExec(value: unknown): value is ExecOptions;
+export interface GitCloneOptions extends GitCommon {
+    /** `--branch <name>`: rama a clonar en lugar de la default. */
+    branch?: string;
+    /** `--depth <n>`: clon shallow con n historias. */
+    depth?: number;
+    /** `--bare`: clon sin working tree (para repos remotos de despliegue). */
+    bare?: boolean;
+    /** `--single-branch`: clona solo la rama indicada, sin las demás refs. */
+    singleBranch?: boolean;
+}
+export declare function clone(url: string, targetPath: string, opts?: GitCloneOptions | ExecOptions): Promise<ExecResult>;
+export interface GitCheckoutOptions extends GitCommon {
+    /** `-b`: crear la rama y pasarse a ella. */
+    create?: boolean;
+    /** `--track`: crear la rama con upstream hacia una remota. */
+    track?: boolean;
+    /** `-f`: descartar cambios locales en conflicto. */
+    force?: boolean;
+    /** `--detach`: dejar HEAD en detached. */
+    detach?: boolean;
+    /** Rama/commit base cuando se crea (`git checkout -b dev origin/dev`). */
+    startPoint?: string;
+}
+export declare function checkout(branch: string, opts?: GitCheckoutOptions | ExecOptions): Promise<ExecResult>;
+export interface GitBranchOptions extends GitCommon {
+    /** Crea una rama: `git branch <create> [startPoint]`. */
+    create?: string;
+    /** Punto de partida al crear la rama. */
+    startPoint?: string;
+    /** `-f`: recrea/reapunta la rama existente. */
+    forceCreate?: boolean;
+    /** Borra una rama con `-d` (solo si está fusionada). */
+    delete?: string;
+    /** Borra con `-D`, ignorando estado de fusión. */
+    forceDelete?: string;
+    /** `--show-current`: imprime la rama actual. */
+    showCurrent?: boolean;
+    /** `-a`: lista también ramas remotas. */
+    all?: boolean;
+}
+export declare function branch(opts?: GitBranchOptions | ExecOptions): Promise<ExecResult>;
+export interface GitBranchCreateOptions extends GitCommon {
+    /** Punto de partida al crear (`git branch <name> <startPoint>`). */
+    startPoint?: string;
+    /** `-f`: recrea/reapunta una rama existente. */
+    force?: boolean;
+    /** `--track`: deja configurado el upstream hacia `startPoint` (o el remoto). */
+    track?: boolean;
+}
+export declare function branchCreate(name: string, opts?: GitBranchCreateOptions | ExecOptions): Promise<ExecResult>;
+export interface GitBranchDeleteOptions extends GitCommon {
+    /** `-D` en vez de `-d`: borra aunque la rama no esté fusionada. */
+    force?: boolean;
+}
+export declare function branchDelete(name: string, opts?: GitBranchDeleteOptions | ExecOptions): Promise<ExecResult>;
+export interface GitBranchRenameOptions extends GitCommon {
+    /** Si se omite, renombra la rama actual. */
+    oldName?: string;
+    /** `-M` en vez de `-m`: renombra aunque el nuevo nombre exista. */
+    force?: boolean;
+}
+export declare function branchRename(newName: string, opts?: GitBranchRenameOptions | ExecOptions): Promise<ExecResult>;
+export interface GitBranchListOptions extends GitCommon {
+    /** `-a`: ramas locales y remotas. */
+    all?: boolean;
+    /** `-r`: solo ramas remotas. */
+    remote?: boolean;
+    /** `--merged [commit]`: solo ramas ya fusionadas en commit. */
+    merged?: boolean | string;
+    /** `--no-merged [commit]`: solo ramas NO fusionadas en commit. */
+    noMerged?: boolean | string;
+    /** `--contains <commit>`: ramas que contienen el commit. */
+    contains?: string;
+    /** `-vv`: muestra SHA y upstream de cada rama. */
+    verbose?: boolean;
+    /** `--sort=<clave>` (ej. "-committerdate", "authordate"). */
+    sort?: string;
+    /** Patrón de filtro para `git branch --list <pattern>`. */
+    pattern?: string;
+}
+export declare function branchList(opts?: GitBranchListOptions | ExecOptions): Promise<ExecResult>;
+export declare function branchShowCurrent(opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export interface GitBranchUpstreamOptions extends GitCommon {
+    /** Upstream a asignar (ej. "origin/main"). */
+    upstream: string;
+    /** Rama a la que aplicar; si se omite, la actual. */
+    name?: string;
+}
+export declare function branchSetUpstream(opts?: GitBranchUpstreamOptions | ExecOptions): Promise<ExecResult>;
+export declare function branchUnsetUpstream(name?: string, opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export interface GitPullOptions extends GitCommon {
+    /** Origin/repositorio a traer (`git pull <remote>`). */
+    remote?: string;
+    /** Rama/refspec a traer (`git pull origin main`). */
+    branch?: string;
+    /** `--rebase`: reaplica el trabajo local sobre el remoto. */
+    rebase?: boolean;
+    /** `--no-rebase`: fuerza merge en vez de rebase. */
+    noRebase?: boolean;
+    /** `--ff-only`: solo avanza si se puede hacer fast-forward. */
+    ffOnly?: boolean;
+    /** `--no-ff`: crea commit de merge aunque haya fast-forward. */
+    noFF?: boolean;
+    /** `--prune`: borra refs remotas que desaparecieron. */
+    prune?: boolean;
+    /** `--tags`: trae también las etiquetas. */
+    tags?: boolean;
+}
+export declare function pull(opts?: GitPullOptions | ExecOptions): Promise<ExecResult>;
+export interface GitFetchOptions extends GitCommon {
+    /** Remote a fetchear; al indicarlo se omite `--all`. */
+    remote?: string;
+    /** Rama específica a fetchear. */
+    branch?: string;
+    /** `--depth <n>`: solo las n historias más recientes. */
+    depth?: number;
+    /** `--unshallow`: convierte un clon shallow en completo. */
+    unshallow?: boolean;
+    /** `--prune`: borra refs remotas huérfanas. */
+    prune?: boolean;
+    /** `--tags`: descarga también las etiquetas. */
+    tags?: boolean;
+    /** `--all` (default true si no se indica remote). */
+    all?: boolean;
+}
+export declare function fetch(opts?: GitFetchOptions | ExecOptions): Promise<ExecResult>;
+export interface GitAddOptions extends GitCommon {
+    /** `-A`: agrega también archivos borrados/renombrados del working tree. */
+    all?: boolean;
+    /** `-u`: solo actualiza archivos ya rastreados. */
+    update?: boolean;
+    /** `-f`: agrega archivos ignorados por .gitignore. */
+    force?: boolean;
+}
+export declare function add(files: string[] | string, opts?: GitAddOptions | ExecOptions): Promise<ExecResult>;
+export interface GitCommitOptions extends GitCommon {
+    /** Archivos a agregar automáticamente antes del commit (o "."). */
+    files?: string[] | string;
+    /** `-a`: hace add de los archivos modificados/eliminados rastreados. */
+    all?: boolean;
+    /** `--allow-empty`: permite commit sin cambios. */
+    allowEmpty?: boolean;
+    /** `--amend`: reemplaza el último commit en vez de crear uno nuevo. */
+    amend?: boolean;
+}
+/** Versión tipo: se traen los archivos indicados (si hay) y se commitea. */
+export declare function commit(message: string, ...rest: Array<string[] | string | GitCommitOptions>): Promise<ExecResult>;
+export interface GitPushOptions extends GitCommon {
+    /** Remote destino (ej. "origin"). */
+    remote?: string;
+    /** Rama/refspec a publicar (ej. "main"). */
+    branch?: string;
+    /** `--tags`: publica también las etiquetas. */
+    tags?: boolean;
+    /** `--force`: fuerza el push descartando conflicto remoto. */
+    force?: boolean;
+    /** `--force-with-lease`: fuerza solo si el remoto no avanzó desde nuestro fetch. */
+    forceWithLease?: boolean;
+    /** `-u`: setea el upstream para próximos pull/push sin argumentos. */
+    setUpstream?: boolean;
+}
+/** `git.push("origin", "main")` o `git.push({ remote: "origin", branch: "main", force: true })`. */
+export declare function push(...rawArgs: Array<string | GitPushOptions>): Promise<ExecResult>;
+export interface GitTagOptions extends GitCommon {
+    /** `-m <mgs>` con `-a`: crea una tag anotada con mensaje. */
+    message?: string;
+    /** `-a`: fuerza tag anotada (suele combinarse con message). */
+    annotated?: boolean;
+    /** `-f`: reemplaza una tag existente. */
+    force?: boolean;
+}
+export declare function tag(name: string, opts?: GitTagOptions | ExecOptions): Promise<ExecResult>;
+export declare function tagDelete(name: string, opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export interface GitTagListOptions extends GitCommon {
+    /** Patrón de filtro (ej. "v1.*"). */
+    pattern?: string;
+    /** `--sort=-creatordate`: ordena por fecha de creación. */
+    sort?: string;
+}
+export declare function tagList(opts?: GitTagListOptions | ExecOptions): Promise<ExecResult>;
+export interface GitMergeOptions extends GitCommon {
+    /** `-m <msg>`: mensaje del commit de merge. */
+    message?: string;
+    /** `--no-edit`: usa el mensaje default sin abrir editor. */
+    noEdit?: boolean;
+    /** `--ff-only`: aborta si no se puede hacer fast-forward. */
+    ffOnly?: boolean;
+    /** `--no-ff`: crea commit de merge aunque haya fast-forward. */
+    noFF?: boolean;
+    /** `--abort`: aborta un merge en conflicto. */
+    abort?: boolean;
+}
+/** `merge("develop", { noEdit: true })`, `merge({ abort: true })` o `merge("main", { ffOnly: true })`. */
+export declare function merge(...rawArgs: Array<string | GitMergeOptions>): Promise<ExecResult>;
+export interface GitRebaseOptions extends GitCommon {
+    /** Rama base (`git rebase main`). */
+    branch?: string;
+    /** `--onto <base>`: base concreta para reaplicar. */
+    onto?: string;
+    /** `--interactive`: abre editor para reordenar commits. */
+    interactive?: boolean;
+    /** `--continue`: continúa tras resolver conflictos. */
+    continue?: boolean;
+    /** `--abort`: aborta el rebase en curso. */
+    abort?: boolean;
+    /** `--skip`: salta el commit conflictivo. */
+    skip?: boolean;
+}
+export declare function rebase(opts?: GitRebaseOptions | ExecOptions): Promise<ExecResult>;
+export interface GitStatusOptions extends GitCommon {
+    /** `-s`: salida corta. */
+    short?: boolean;
+    /** `-b`: muestra la rama actual (con -s). */
+    branch?: boolean;
+    /** `--porcelain`: salida estable para scripting. */
+    porcelain?: boolean;
+    /** `--untracked-files=no|normal|all`. */
+    untrackedFiles?: "no" | "normal" | "all";
+}
+export declare function status(opts?: GitStatusOptions | ExecOptions): Promise<ExecResult>;
+export interface GitLogOptions extends GitCommon {
+    /** `--max-count <n>`: limita a los n commits más recientes. */
+    maxCount?: number;
+    /** `--since <fecha>`: commits desde una fecha/expresión. */
+    since?: string;
+    /** `--until <fecha>`: commits hasta una fecha/expresión. */
+    until?: string;
+    /** `--author <patron>`: filtra por autor. */
+    author?: string;
+    /** `--oneline`: resumen de una línea por commit. */
+    oneline?: boolean;
+    /** `--graph`: muestra el grafo de ramas. */
+    graph?: boolean;
+    /** `--all`: incluye todas las ramas. */
+    allBranches?: boolean;
+    /** `--pretty=format:<fmt>`: formato personalizado (NOTA: usa %h, %s, %an, ...). */
+    format?: string;
+    /** Rama o rango a consultar. */
+    branch?: string;
+}
+export declare function log(opts?: GitLogOptions | ExecOptions): Promise<ExecResult>;
+export interface GitDiffOptions extends GitCommon {
+    /** `--cached`: diff del índice (staged). */
+    cached?: boolean;
+    /** `--stat`: resumen de archivos cambiados. */
+    stat?: boolean;
+    /** `--name-only`: solo nombres de archivos. */
+    nameOnly?: boolean;
+    /** Archivos/rangos a comparar. */
+    files?: string[] | string;
+}
+export declare function diff(opts?: GitDiffOptions | ExecOptions): Promise<ExecResult>;
+export interface GitShowOptions extends GitCommon {
+    /** `--stat`: resumen de archivos del commit. */
+    stat?: boolean;
+    /** `--name-only`: solo nombres de archivos. */
+    nameOnly?: boolean;
+}
+export declare function show(ref: string, opts?: GitShowOptions | ExecOptions): Promise<ExecResult>;
+export interface GitRemoteOptions extends GitCommon {
+    /** `-v`: lista remotes con sus URLs. */
+    verbose?: boolean;
+    /** `git remote show <name>`: detalle de un remote. */
+    show?: string;
+    /** `git remote get-url <name>`. */
+    getUrl?: string;
+}
+export declare function remote(opts?: GitRemoteOptions | ExecOptions): Promise<ExecResult>;
+export declare function remoteAdd(name: string, url: string, opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export declare function remoteRemove(name: string, opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export declare function remoteSetUrl(name: string, url: string, opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export interface GitStashOptions extends GitCommon {
+    /** `-m <msg>`: mensaje descriptivo del stash. */
+    message?: string;
+    /** `-k`: mantiene el índice (deja staged lo que estaba staged). */
+    keepIndex?: boolean;
+    /** `-u`: incluye archivos untracked. */
+    includeUntracked?: boolean;
+    /** `-q`: sin salida. */
+    quiet?: boolean;
+}
+export declare function stashPush(opts?: GitStashOptions | ExecOptions): Promise<ExecResult>;
+export interface GitStashIndexOptions extends GitCommon {
+    /** Índice del stash: `stash@{n}`. */
+    index?: number;
+}
+export declare function stashPop(opts?: GitStashIndexOptions | ExecOptions): Promise<ExecResult>;
+export declare function stashApply(opts?: GitStashIndexOptions | ExecOptions): Promise<ExecResult>;
+export declare function stashList(opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export declare function stashDrop(opts?: GitStashIndexOptions | ExecOptions): Promise<ExecResult>;
+export interface GitResetOptions extends GitCommon {
+    /** `--soft | --mixed | --hard`. */
+    mode?: "soft" | "mixed" | "hard";
+    /** Commit al que volver (por defecto HEAD). */
+    commit?: string;
+}
+export declare function reset(opts?: GitResetOptions | ExecOptions): Promise<ExecResult>;
+export interface GitInitOptions extends GitCommon {
+    /** `--bare`: repo sin working tree. */
+    bare?: boolean;
+    /** `-b <name>`: rama inicial (ej. "main"). */
+    initialBranch?: string;
+}
+export declare function init(opts?: GitInitOptions | ExecOptions): Promise<ExecResult>;
+export declare function configGet(name: string, opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export declare function configSet(name: string, value: string, opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export declare function configList(opts?: GitCommon | ExecOptions): Promise<ExecResult>;
+export interface GitRevParseOptions extends GitCommon {
+    /** Ref a resolver (por defecto "HEAD"). */
+    ref?: string;
+    /** `--short`: SHA abreviado. */
+    short?: boolean;
+    /** `--verify`: falla si el ref no existe. */
+    verify?: boolean;
+    /** `--abbrev-ref`: nombre corto de la rama (branch actual). */
+    abbrevRef?: boolean;
+    /** `--show-toplevel`: ruta absoluta de la raíz del repo. */
+    showTopLevel?: boolean;
+}
+/** `revParse()`, `revParse("HEAD~1")` o `revParse({ short: true })`. */
+export declare function revParse(...rawArgs: Array<string | GitRevParseOptions>): Promise<ExecResult>;