docker run -v `pwd`:`pwd` -w `pwd` --rm -it secretlint/secretlint secretlint "**/*"

npx @secretlint/quick-start "**/*"

docker run -v `pwd`:`pwd` -w `pwd` --rm -it secretlint/secretlint secretlint "**/*"

Luego, debes configurar un archivo de configuración:```
npx secretlint --init

:memo: Secretlint admite [glob pattern](https://github.com/mrmlnc/fast-glob#basic-syntax) y el patrón glob debe estar envuelto entre comillas dobles.

También es posible instalar Secretlint globalmente usando `npm install --global`. Pero no lo recomendamos, algunas reglas pueden romperse globalmente.

### Usando un Binario Ejecutable Único

**Requisitos previos:** Ninguno

Puede usar el comando `secretlint` sin Node.js utilizando un binario ejecutable único.

1. Descargue el último binario desde [Releases page](https://github.com/secretlint/secretlint/releases)
2. Cambie el permiso del archivo a ejecutable: `chmod +x ./secretlint`
3. Ejecute `./secretlint --init` para crear un archivo de configuración
4. Ejecute `./secretlint "**/*"` para analizar su proyecto

Para más detalles, por favor consulte el README de [publish/binary-compiler](https://github.com/secretlint/secretlint/blob/HEAD/publish/binary-compiler).

## Uso

`secretlint --help` muestra el uso.

    Secretlint CLI that scan secret/credential data.
    
    Usage
    $ secretlint [file|glob*]
    
    Note
    supported glob syntax is based on picomatch (the engine used by micromatch)
    https://github.com/micromatch/picomatch#globbing-features
    https://github.com/micromatch/micromatch#matching-features
    
    Options
    --init             setup config file. Create .secretlintrc.json file from your package.json
    --format           [String] formatter name. Default: "stylish". Available Formatter: checkstyle, compact, github, jslint-xml, junit, pretty-error, stylish, tap, unix, json, mask-result, table
    --output           [path:String] output file path that is written of reported result.
    --secretlintrc     [path:String] path to .secretlintrc config file. Default: .secretlintrc.*
    --secretlintignore [path:String] path to .secretlintignore file. Default: .secretlintignore
    --stdinFileName    [String] filename to process STDIN content. Some rules depend on filename to check content.
    --no-color         disable ANSI-color of output.
    --no-terminalLink  disable terminalLink of output.
    --no-maskSecrets   disable masking of secret values; secrets are masked by default.
    --no-glob          disable glob pattern interpretation; treat all inputs as literal file paths.
    --no-gitignore     disable .gitignore cascade respect; .gitignore files are
                       respected by default (since v13).
    
    Options for Developer
    --profile          Enable performance profile.
    --secretlintrcJSON [String] a JSON string of .secretlintrc. use JSON string instead of rc file.
    
    Experimental Options
    --locale            [String] locale tag for translating message. Default: en
    
    Examples
    # Scan a single file
    $ secretlint ./README.md

    # Scan all files (wrap glob in double quotes to avoid shell expansion)
    $ secretlint "**/*"
    $ secretlint "source/**/*.ini"

    # Treat inputs as literal paths (for SvelteKit (group) / Next.js [param] etc.)
    $ secretlint --no-glob "src/(auth)/login.ts"

    # Lint STDIN content (filename hint affects which rules apply)
    $ echo "SECRET" | secretlint --stdinFileName=secret.txt

    # Use a custom config file
    $ secretlint "**/*" --secretlintrc=.secretlintrc.custom.json

    # Scan files ignored by .gitignore (e.g. to verify build artifacts)
    $ secretlint --no-gitignore "dist/**/*"

    # Mask secrets in a file in-place
    $ secretlint .zsh_history --format=mask-result --output=.zsh_history

    # Output JSON for programmatic parsing
    $ secretlint "**/*" --format=json --output=secretlint-report.json

    # Output GitHub Actions annotations in CI
    $ secretlint "**/*" --format=github
    
    Exit Status
    Secretlint exits with the following values:
    
        - 0:
          - Linting succeeded, no errors found.
          - Found lint error but --output is specified.
        - 1:
          - Linting failed, errors found.
        - 2:
          - Unexpected error occurred, fatal error.

## Configuración

Secretlint tiene un archivo de configuración `.secretlintrc.{json,yml,js}`.

- Documento: [Configurando Secretlint](https://github.com/secretlint/secretlint/blob/HEAD/docs/configuration.md)

Después de ejecutar `secretlint --init`, tendrá un archivo `.secretlintrc.json` en su directorio.

En él, verá algunas reglas configuradas así:```json
{
  "rules": [
    {
      "id": "@secretlint/secretlint-rule-preset-recommend"
    }
  ]
}

Cuando usas un preset como `@secretlint/secretlint-rule-preset-recommend`, debes poner la opción en `rules`.

Por ejemplo, una opción para `@secretlint/secretlint-rule-preset-recommend > @secretlint/secretlint-rule-aws````json5
{
  "rules": [
    {
      "id": "@secretlint/secretlint-rule-preset-recommend",
      "rules": [
        {
          "id": "@secretlint/secretlint-rule-aws",
            "options": {
              "allows": [
	            // it will be ignored
                "xxxx-xxxx-xxxx-xxxx-xxxx"
              ]
            }
        }
      ]
    }
  ]
}

El id de mensaje de este error es `EXAMPLE_MESSAGE` en `@secretlint/secretlint-rule-example`.

Si deseas ignorar este error, por favor usa `allowMessageIds`.```json
{
  "rules": [
    {
      "id": "@secretlint/secretlint-rule-example",
      "allowMessageIds": ["EXAMPLE_MESSAGE"]
    }
  ]
}

### Ignorando archivos mediante `.gitignore` y `.secretlintignore`

Secretlint recorre el sistema de archivos de la misma manera que Git, respetando los archivos `.gitignore` anidados. Cualquier archivo o directorio que coincida con algún `.gitignore` en la ruta desde el directorio de trabajo hasta el archivo se omite.

`.secretlintignore` funciona de la misma manera que `.gitignore` y se consulta adicionalmente. El orden de resolución es:

1. Ignorados incorporados: `.git`, `node_modules` y la familia `.secretlintrc*`.
2. El archivo señalado por `--secretlintignore` (por defecto: `.secretlintignore`).
3. El `.gitignore` de cada directorio (en cascada).

Para escanear archivos que están en gitignore — por ejemplo, un archivo `.env` en un proyecto donde `.env` está en gitignore — pase `--no-gitignore`:```
secretlint --no-gitignore "**/*"

Para más detalles, consulte [Configuración de Secretlint](https://github.com/secretlint/secretlint/blob/HEAD/docs/configuration.md).

## Casos de Uso

### Ocultar secretos en mensajes de error de lint (Comportamiento predeterminado)

Secretlint oculta secretos en mensajes de error de lint de forma predeterminada. Esto es útil para evitar la exposición accidental de secretos en registros de CI, salida de terminal o al usar herramientas de agente de IA.```bash
# Secrets are masked by default
$ secretlint "**/*"

### Corregir secretos

Secretlint no puede corregir los secretos automáticamente.
Sin embargo, es útil que `--format=mask-result` enmascare los secretos del archivo de entrada.

Por ejemplo, puedes enmascarar los secretos del archivo `.zsh_history` y sobrescribirlo.```bash
$ secretlint .zsh_history --format=mask-result --output=.zsh_history

Añade hooks a `.husky/pre-commit`:```
npx husky add .husky/pre-commit "npx --no-install lint-staged"

> **Nota:** La bandera `--no-glob` es necesaria porque lint-staged pasa rutas de archivos literales que pueden contener caracteres especiales de glob (por ejemplo, patrones de enrutamiento `(group)` o `[param]` utilizados por Next.js, SvelteKit, etc.).

Esto significa que se revisa cada archivo preparado por Secretlint antes del commit.

#### [pre-commit](https://github.com/pre-commit/pre-commit)

**Caso de uso:** Tienes un proyecto que se está desarrollando con Docker. Fácil de integrar con secretlint.

Instalar [pre-commit](https://pre-commit.com/#install)

    # macOS. see also https://pre-commit.com/#install
    brew install pre-commit

Crear `.pre-commit-config.yaml`:```
-   repo: local
    hooks:
    -   id: secretlint
        name: secretlint
        language: docker_image
        entry: secretlint/secretlint:latest secretlint

### Pre-commit Hook globalmente

**Caso de uso:** Si deseas revisar cualquier proyecto con secretlint, puedes usar hooks de git globales.

[Git 2.9+](https://github.blog/2016-06-13-git-2-9-has-been-released/) admite [`core.hooksPath`](https://git-scm.com/docs/githooks).
Permite integrar secretlint globalmente.

Hemos creado un proyecto de ejemplo de git hooks usando secretlint + Docker.

- [secretlint/git-hooks](https://github.com/secretlint/git-hooks)
    - Requisito: Docker

Puedes configurarlo siguiendo los siguientes pasos:```shell script
# clone this repository
git clone https://github.com/secretlint/git-hooks git-hooks
cd git-hooks
# integrate secretlint to git hook globally
git config --global core.hooksPath $(pwd)/hooks

##### `--format github` para anotaciones en Pull Requests

Puedes usar `--format github` para mostrar errores de lint como anotaciones en los archivos de la Pull Request.
Este formateador genera [comandos de flujo de trabajo de GitHub Actions](https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions) que muestran anotaciones de error directamente en los archivos modificados de tu Pull Request.```yaml
      - name: Lint with Secretlint
        run: npx secretlint --format github "**/*"

#### Mega-Linter

[Mega-Linter](https://nvuillam.github.io/mega-linter/) es un agregador de linters compatible de forma nativa con cualquier herramienta de CI, que incluye [más de 80 aplicaciones de linting](https://nvuillam.github.io/mega-linter/supported-linters/), incluyendo [**secretlint**](https://nvuillam.github.io/mega-linter/descriptors/credentials_secretlint/) por defecto.

Puedes [instalarlo](https://nvuillam.github.io/mega-linter/installation/) en cualquier proyecto de repositorio usando el siguiente comando (Node.js debe estar instalado previamente)```shell
npx mega-linter-runner --install

## Política de Versionado Semántico

El proyecto Secretlint sigue [Versionado Semántico](https://semver.org/ "Semantic Versioning") ([secretlint-rule-preset-canary](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-preset-canary) es una excepción).

- Versión de Parche (diseñada para no romper tu compilación de lint)
    - Una corrección de errores en la CLI o el núcleo (incluyendo formateadores).
    - Mejoras en la documentación.
    - Cambios no visibles para el usuario, como refactorización.
    - Volver a publicar después de una publicación fallida (es decir, publicar una versión que no funciona para nadie).
- Versión Menor (podría romper tu compilación de lint)
    - Una nueva opción.
    - Una regla existente queda obsoleta.
    - Se crea una nueva capacidad de la CLI.
    - Se agregan nuevas API públicas (nuevas clases, nuevos métodos, nuevos argumentos para métodos existentes, etc.).
        - Podría romper las definiciones de TypeScript
    - Se crea un nuevo formateador.
- Versión Mayor (rompe tu compilación de lint)
    - Una nueva opción para una regla existente que resulta en que secretlint reporte más errores por defecto.
    - Se elimina un formateador existente.
    - Se agrega una nueva regla predeterminada al conjunto de reglas.
    - Se elimina o cambia parte de la API pública de forma incompatible.

## Motivación

- [git-secrets](https://github.com/awslabs/git-secrets) es útil, pero es difícil de configurar por proyecto.
	- Su principal caso de uso es la instalación global.
	- Secretlint quiere instalarse para un proyecto y personalizar la configuración por proyecto.
- [repo-security-scanner](https://github.com/UKHomeOffice/repo-security-scanner), [Gitleaks](https://github.com/zricethezav/gitleaks) y [truffleHog](https://github.com/dxa4481/truffleHog) son buenas herramientas de escaneo.
	- Secretlint necesita personalización flexible que incluya definiciones de ignorado y reglas personalizadas.
- [detect-secrets](https://github.com/Yelp/detect-secrets) es una herramienta similar, pero adopta un enfoque de exclusión voluntaria.
    - Secretlint adopta un enfoque de inclusión voluntaria.  
    - También necesitamos reglas personalizadas por el usuario.
		- Ver [Bring-your own-plugins (BYOP), via --custom-plugins option by KevinHock · Pull Request #255 · Yelp/detect-secrets](https://github.com/Yelp/detect-secrets/pull/255)
- GitHub admite [escaneo de secretos](https://docs.github.com/en/code-security/secret-security/about-secret-scanning), pero solo funciona después del commit [~~push~~](https://docs.github.com/en/code-security/secret-scanning/push-protection-for-users).
    - Secretlint funciona en tu máquina local, Secretlint puede prevenir el commit.

## Filosofía

- Reducir falsos positivos del linting.
- Integración con el flujo de trabajo de desarrollo.
- Capacitar a los usuarios para contribuir.

### Inclusión voluntaria en lugar de exclusión voluntaria

Secretlint adopta un enfoque de inclusión voluntaria.

En nuestra experiencia, las herramientas de linting que reportan varios errores por defecto son difíciles de usar.
El enfoque de inclusión voluntaria ayuda a introducir Secretlint de forma incremental.

Ayudará a reducir los falsos positivos mediante la configuración.

### Regla como Documentación

Consideramos una regla como una documentación.
Por lo tanto, cada regla debe tener una documentación razonable.

Necesitamos describir por qué este archivo es un error.
Una regla que no tiene documentación es simplemente dogmática.

Describe la razón del error y eso llevará a reducir los errores falsos positivos.

Además, la CLI de Secretlint admite hipervínculos en la terminal.
Significa que puedes saltar a la documentación de la regla directamente desde el mensaje de error de lint.

![clickable link in output](https://assets.kitploit.com/production/public/readmes/6649/890de2bdbaaae05b3b40c5bbe32b8389a7672beb231308453e585e308afca2be.png)

> Ejemplo en iTerm 2: Cmd + clic en el messageId del error y abre [AWSSecretAccessKey](https://github.com/secretlint/secretlint/blob/master/packages/%40secretlint/secretlint-rule-aws/README.md#awssecretaccesskey) en tu navegador.

Si quieres conocer la compatibilidad de terminales, consulta [Hyperlinks in Terminal Emulators](https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda).

Además, ¡Bienvenida la contribución a la documentación de secretlint!

### ¿Por qué Node.js?

- Gestor de Paquetes
	- Se requiere un gestor de paquetes para realizar un sistema flexible de complementos.
	- Node.js tiene npm y pnpm como gestor de paquetes.
	- El gestor de paquetes ayuda a instalar complementos/reglas personalizados por el usuario.
- Existen Implementaciones de Referencia
	- Node.js ya tiene herramientas de linting con complementos como ESLint, textlint, stylelint, etc.
	- Por lo tanto, los usuarios de Node.js están familiarizados con herramientas de linting con complementos.
	- Anteriormente, creé textlint con el mismo enfoque, por lo que estoy familiarizado con Node.js.
- Usuarios
    - JavaScript es un lenguaje popular.
    - Capacita a los usuarios para contribuir.
    - Los usuarios pueden crear sus propias reglas con sus propias manos.

Por supuesto, secretlint también es compatible con [Docker](https://hub.docker.com/r/secretlint/secretlint).

## Registro de Cambios

Ver [página de versiones](https://github.com/secretlint/secretlint/releases).

## Contribuir

Las solicitudes de extracción y las estrellas son siempre bienvenidas.

Para errores y solicitudes de características, [por favor crea un issue](https://github.com/secretlint/secretlint/issues).

Ver también, [CONTRIBUTING.md](https://github.com/secretlint/secretlint/blob/HEAD/CONTRIBUTING.md) y [CODE_OF_CONDUCT.md](https://github.com/secretlint/secretlint/blob/HEAD/CODE_OF_CONDUCT.md)

### Añadir Nueva Regla

Puedes usar el comando `pnpm run gen:rule` para crear una nueva regla.```shell script
pnpm run gen:rule