npm package: @rich-apis/vibe-tools
Description: CLI toolkit for the stuff you keep re-doing. Env validation, JSON-to-TypeScript, changelogs, depcheck, gitignore, ESLint + Prettier config, test setup, Dockerfile, CI workflow, README scaffold, git hooks, editorconfig, secret scanning, API scaffolding, de
Author: rich-apis
Latest version: 2.11.0

# @rich-apis/vibe-tools

CLI toolkit for the stuff you keep re-doing. Env checks, JSON-to-TypeScript, changelogs, dependency audits, tsconfig, gitignore, ESLint + Prettier config, test setup, Dockerfiles, CI workflows, git hooks, editorconfig, secret scanning, API scaffolding, deploy configs, project health check, project diagnostics, version bump, PR descriptions, release workflow, package.json generator, GitHub repo templates, monorepo workspace setup, README scaffold - one `init` to set up a project, individual commands when you need them.

Zero runtime dependencies. Node.js 18+.

## Install

```bash
npm install -g @rich-apis/vibe-tools
```

Or run directly:

```bash
npx @rich-apis/vibe-tools env
```

## Commands

### `vibe init` - Scaffold a project in one shot

Creates .gitignore, tsconfig.json, eslint.config.js, .prettierrc, .env.example, and README.md. Skips files that already exist. Reads package.json for metadata when available.

```bash
vibe init                         # node defaults
vibe init --type react            # react config set
vibe init --type library          # npm library config set
vibe init --force                 # overwrite existing files
```

Three project types: `node`, `react`, `library`.

### `vibe env` - Validate .env files

Catches missing variables, duplicates, syntax errors, and leaked secrets. Compares against .env.example if one exists.

```bash
vibe env                          # check .env against .env.example
vibe env .env.production          # check a specific file
vibe env --strict                 # fail on warnings too (CI mode)
vibe env --example .env.template  # custom example path
```

Returns exit code 1 on errors. Drop it in CI.

### `vibe json2ts` - JSON to TypeScript

Reads JSON from a file or stdin, outputs TypeScript interfaces. Handles nested objects and arrays.

```bash
vibe json2ts data.json
vibe json2ts -n User api-response.json
echo '{"id": 1, "name": "test"}' | vibe json2ts
vibe json2ts --export -n Config settings.json
```

### `vibe changelog` - Changelog from git

Reads git log and groups commits. Recognizes Conventional Commits if you use them, works fine if you don't.

```bash
vibe changelog
vibe changelog --from v1.0.0 --to v1.1.0
vibe changelog --format plain
```

### `vibe depcheck` - Find unused dependencies

Scans source files for import/require statements and compares against package.json. Finds unused and missing deps.

```bash
vibe depcheck
vibe depcheck --dev                     # include devDependencies
vibe depcheck --ignore eslint           # skip specific packages
vibe depcheck ./packages/api            # check a subdirectory
```

Outputs the exact npm commands to fix what it finds.

### `vibe tsconfig` - Generate tsconfig.json

Prints a tsconfig.json for common project types. Stdout by default so you can review before saving.

```bash
vibe tsconfig                         # Node.js defaults
vibe tsconfig --type react            # React / Next.js setup
vibe tsconfig --type library          # npm library setup
vibe tsconfig --type react --write    # write to ./tsconfig.json
```

Three presets: `node`, `react`, `library`. All strict by default.

### `vibe gitignore` - Generate .gitignore

Prints a .gitignore for common project types. Six presets, stdout by default.

```bash
vibe gitignore                        # Node.js defaults
vibe gitignore python                 # Python
vibe gitignore rust --write           # Rust, write to ./.gitignore
vibe gitignore go --append            # add Go rules to existing file
vibe gitignore --list                 # show all available types
```

Types: `node`, `react`, `python`, `go`, `rust`, `java`.

### `vibe readme` - Scaffold README.md

Generates a README from your package.json. Pulls name, description, install instructions, scripts, and license.

```bash
vibe readme                           # print to stdout
vibe readme --write                   # write to ./README.md
vibe readme > README.md               # same thing, with redirect
```

### `vibe dockerize` - Generate Dockerfile

Multi-stage Dockerfile for five project types. Detects your package manager (npm, yarn, pnpm, bun) and Node version automatically.

```bash
vibe dockerize                        # Node.js defaults
vibe dockerize python --write         # Python, write to ./Dockerfile
vibe dockerize react                  # React static build with nginx
vibe dockerize go                     # Go multi-stage
vibe dockerize --list                 # show all available types
```

Types: `node`, `react`, `python`, `go`, `rust`.

### `vibe ci` - Generate GitHub Actions workflow

Outputs a CI workflow for GitHub Actions. Detects package manager and Node version like `dockerize` does.

```bash
vibe ci                               # Node.js defaults
vibe ci python --write                # Python, write to .github/workflows/ci.yml
vibe ci rust --write                  # Rust with cargo test + clippy
vibe ci --list                        # show all available types
```

Types: `node`, `react`, `python`, `go`, `rust`.

### `vibe lint` - Generate ESLint + Prettier config

Outputs ESLint flat config and .prettierrc for common project types. Uses `typescript-eslint` by default.

```bash
vibe lint                            # Node.js defaults
vibe lint react --write              # React with plugins, write both files
vibe lint library --eslint           # library preset, ESLint only
vibe lint --prettier                 # Prettier config only
vibe lint --list                     # show all available types
```

Types: `node`, `react`, `library`. Also included in `vibe init`.

### `vibe test` - Generate test configuration

Outputs test config for vitest, jest, or node:test. Detects ESM vs CommonJS for jest setup.

```bash
vibe test                            # vitest config (default)
vibe test jest --write               # jest with ts-jest, write to disk
vibe test vitest --coverage --write  # vitest + v8 coverage
vibe test node                       # node:test runner setup
vibe test --list                     # show available frameworks
```

Three frameworks: `vitest`, `jest`, `node`. Shows install commands and package.json scripts to add.

### `vibe hook` - Generate git hooks

Creates pre-commit and pre-push hooks as shell scripts in `.git/hooks/`. No husky, no dependencies. Detects your package manager and existing npm scripts.

```bash
vibe hook                         # both pre-commit and pre-push
vibe hook --pre-commit            # just pre-commit
vibe hook --pre-push --no-test    # pre-push without test step
vibe hook --force                 # overwrite existing hooks
vibe hook --list                  # show available hook types
```

Pre-commit runs lint + format checks. Pre-push runs tests. Both use whatever scripts you have in package.json.

### `vibe editorconfig` - Generate .editorconfig

Consistent indentation and formatting across editors and IDEs. Five presets, stdout by default.

```bash
vibe editorconfig                 # Node.js defaults (2-space indent)
vibe editorconfig python          # Python (4-space indent)
vibe editorconfig go --write      # Go (tabs), write to ./.editorconfig
vibe editorconfig --list          # show all available types
```

Types: `node`, `python`, `go`, `rust`, `java`.

### `vibe security` - Scan for secrets and insecure code

Walks your source files looking for hardcoded API keys, tokens, passwords, and common insecure patterns. Useful in CI to catch mistakes before they ship.

```bash
vibe security                        # scan current directory
vibe security ./packages/api         # scan a subdirectory
vibe security --strict               # fail on warnings too (CI mode)
```

Detects:
- AWS keys, GitHub tokens, Slack tokens, Stripe keys, OpenAI keys, Telegram tokens
- Hardcoded passwords, private keys, JWT tokens
- eval(), innerHTML, SQL injection vectors, disabled TLS, shell injection
- Missing .gitignore or .env not listed in .gitignore

Findings in test files are flagged as warnings, not errors. Returns exit code 1 on errors.

### `vibe api` - Scaffold API boilerplate

Generates a typed server entry point with health check, CRUD routes, and error handling. Three frameworks, stdout by default.

```bash
vibe api                             # Express (default)
vibe api fastify --write             # Fastify, write to src/server.ts
vibe api hono --cors --auth --write  # Hono with CORS + auth middleware
vibe api --list                      # show available frameworks
```

Frameworks: `express`, `fastify`, `hono`.

`--cors` adds CORS headers. `--auth` adds a bearer token middleware stub. Prints install commands and package.json scripts to add after generating.

### `vibe deploy` - Generate deploy configuration

Outputs a deploy config for common hosting platforms. Detects your project type, Node version, and framework from package.json.

```bash
vibe deploy                          # vercel.json (default)
vibe deploy fly --write              # fly.toml
vibe deploy netlify --write          # netlify.toml
vibe deploy render --write           # render.yaml
vibe deploy railway --write          # railway.json
vibe deploy --list                   # show all platforms
```

Platforms: `vercel`, `netlify`, `fly`, `render`, `railway`. Auto-detects Next.js, React, Express, Fastify, and Hono projects.

### `vibe check` - Project health check

Runs env validation, dependency audit, and security scan in one command. Prints a pass/fail/skip summary per check.

```bash
vibe check                           # check current directory
vibe check ./packages/api            # check a subdirectory
vibe check --strict                  # fail on warnings too
```

Skips env if no .env file exists. Skips depcheck if no package.json exists. Always runs security.

### `vibe bump` - Bump package version

Reads version from package.json, increments it, writes it back. Optionally creates a git commit and tag.

```bash
vibe bump patch                  # 1.2.3 -> 1.2.4
vibe bump minor --tag            # 1.2.3 -> 1.3.0, tags v1.3.0
vibe bump major --commit --tag   # 1.2.3 -> 2.0.0, commits and tags
vibe bump --dry-run              # show what would happen
```

Also updates package-lock.json if it exists. Defaults to `patch` when no type is given.

### `vibe pr` - Generate PR description

Reads commits on your branch vs the base branch and generates a markdown PR description. Paste it straight into GitHub.

```bash
vibe pr                          # diff vs main
vibe pr --base develop           # diff vs develop
vibe pr --format plain           # commit list only
```

Auto-detects main vs master. Groups commits by type (feat, fix, etc.) and includes diff stats.

### `vibe release` - Bump + changelog + commit + tag (pro)

Chains the release workflow into a single command. Reads commits since the last tag, bumps the version, prepends a changelog entry, commits, and tags.

```bash
vibe release patch              # 1.2.3 -> 1.2.4, full release
vibe release minor              # 1.2.3 -> 1.3.0
vibe release major --no-tag     # 2.0.0, skip the git tag
vibe release --dry-run          # preview without writing
vibe release patch --push       # release and push to remote
```

Options: `--no-changelog`, `--no-commit`, `--no-tag`, `--push`, `--dry-run`.

### `vibe pkg` - Generate package.json

Creates a package.json with modern defaults for three project types. Reads the current directory name for the package name. Stdout by default so you can review before saving.

```bash
vibe pkg                             # app preset (default)
vibe pkg library --write             # npm library with exports map
vibe pkg cli --name my-tool --write  # CLI tool with bin entry
vibe pkg --private                   # private project
vibe pkg --list                      # show available presets
```

Presets: `app`, `library`, `cli`. All use ESM, Node 18+, TypeScript.

### `vibe github` - Generate GitHub repo boilerplate

Creates issue templates, PR template, and CODEOWNERS under `.github/`. Writes files by default since multiple files are involved.

```bash
vibe github                          # all templates
vibe github --issues                 # issue templates only
vibe github --pr                     # PR template only
vibe github --codeowners --owner @myteam
vibe github --dry-run                # preview without writing
```

### `vibe workspace` - Set up monorepo workspaces

Adds workspace configuration to your project. Detects your package manager and generates the right config format. Optionally scaffolds a starter package.

```bash
vibe workspace                           # npm workspaces (auto-detect)
vibe workspace pnpm                      # pnpm with pnpm-workspace.yaml
vibe workspace --scaffold                # create packages/core starter
vibe workspace --dir apps --scaffold --name web
vibe workspace --tsrefs                  # add TypeScript project references
vibe workspace --dry-run                 # preview without writing
```

Managers: `npm`, `yarn`, `pnpm`. Auto-detects from lock files.

### `vibe doctor` - Diagnose project setup

Checks Node.js version, package manager, config files, package.json health, and git status. Like `brew doctor` but for your project.

```bash
vibe doctor                              # check current directory
vibe doctor ./packages/api               # check a subdirectory
vibe doctor --fix                        # show fix commands for each issue
```

Checks: Node.js version, npm, package manager lockfile, git repo, .gitignore, package.json fields, tsconfig.json, .editorconfig, .env setup, ESLint config. Returns exit code 1 on failures.

### `vibe license` - License management

```bash
vibe license              # show current tier
vibe license VT-PRO-XXXX # activate a key
```

## Tiers

| Feature | Free | Pro ($5) | Premium ($25) |
|---------|------|----------|---------------|
| All 25 commands | yes | yes | yes |
| release command | - | yes | yes |
| --json output | - | yes | yes |
| --group (changelog) | - | yes | yes |
| --readonly (json2ts) | - | yes | yes |
| --compose (dockerize) | - | yes | yes |
| Batch processing | - | coming | coming |
| Custom rules | - | - | coming |

One-time purchase. No subscription.

Upgrade: https://rich-apis.store/vibe-tools

## Requirements

Node.js 18+

## License

MIT