Local Tooling Initialization

Comprehensive setup for linting, formatting, type checking, testing, Git hooks, CI/CD, and publishing across TypeScript, Rust, and Python projects.

When to Use This Skill

Use this skill when you need to:

• Initialize tooling for a new TypeScript/Rust/Python project
• Set up monorepo with Nx + pnpm workspaces
• Configure Git hooks with lefthook (conventional commits, pre-commit, pre-push)
• Add GitHub Actions for CI/CD
• Set up automated publishing to npm/crates.io/PyPI
• Configure version bumping and changelog generation with Changesets
• Migrate from Husky to lefthook
• Choose between ESLint+Prettier vs Biome for TypeScript

Quick Start

TypeScript Project

Automated setup:

./scripts/init_typescript.sh

Choose tooling:

• Biome (recommended) - Fast, all-in-one, modern
• ESLint + Prettier - Traditional, highly configurable

What you get:

• Linting and formatting
• TypeScript strict mode
• Vitest for testing
• Package.json scripts

→ See: references/typescript.md

Rust Project

Manual setup (opinionated configs in assets/):

# Tools come with Rust
rustup component add rustfmt clippy

# Optional: Enhanced tooling
brew install cargo-nextest cargo-deny

# Copy configs from assets/configs/rust/
cp assets/configs/rust/rustfmt.toml .
cp assets/configs/rust/clippy.toml .

→ See: references/rust.md

Python Project

Using uv (recommended):

# Install uv
brew install uv

# Create project
uv init my-project
cd my-project

# Add dev dependencies
uv add --dev ruff mypy pytest

# Copy config from assets/
cp assets/configs/python/pyproject.toml .

→ See: references/python.md

Monorepo Setup

Create Nx + pnpm monorepo:

./scripts/init_monorepo.sh

Or manually:

npx create-nx-workspace@latest my-monorepo
# Choose: pnpm + integrated monorepo

→ See: references/monorepo.md

Workflow Decision Tree

1. Choose Project Type

Single Language Project → Use language-specific init script or manual setup → See Quick Start above

Monorepo (Multiple Packages) → Set up Nx + pnpm workspaces → See references/monorepo.md

2. Configure Git Hooks

Automated setup:

./scripts/setup_lefthook.sh

This configures:

• commit-msg - Conventional commits validation
• pre-commit - Format and lint staged files
• pre-push - Full validation (lint, type-check, test, build)

→ See: references/git-hooks.md

3. Set Up CI/CD

Copy workflow templates:

# Basic CI
cp assets/workflows/ci.yml .github/workflows/

# Language-specific workflows available in assets/

→ See: references/ci-cd.md

4. Configure Publishing (Optional)

For npm packages:

./scripts/setup_changesets.sh

Then copy publishing workflows from assets/workflows/.

→ See:

• references/version-management.md
• references/publishing.md

Language-Specific Guides

TypeScript/JavaScript

Tooling options:

• Biome - Fast, opinionated, all-in-one (recommended for new projects)
• ESLint + Prettier - Traditional, highly configurable (recommended for existing projects)

Testing:

• Vitest - Modern, fast, Vite-based (recommended)
• Jest - Established, widely used

Key decisions:

• Choose Biome for speed and simplicity
• Choose ESLint+Prettier for existing projects or specific plugins

→ Full guide: references/typescript.md

Rust

Built-in tools:

• rustfmt - Code formatting
• clippy - Linting
• cargo test - Testing

Enhanced tools:

• cargo-nextest - Faster test runner
• cargo-deny - Dependency security
• cargo-make - Task runner

→ Full guide: references/rust.md

Python

Modern stack (recommended):

• uv - Fast package manager
• ruff - Fast linting + formatting (replaces black, isort, flake8)
• mypy - Type checking
• pytest - Testing

→ Full guide: references/python.md

Git Hooks with lefthook

Why lefthook?

• Language-agnostic - Works across TS, Rust, Python
• Fast - Parallel execution, written in Go
• Simple - Single YAML config
• Better than Husky - Faster, works across languages

Setup

Automated:

./scripts/setup_lefthook.sh

Manual:

brew install lefthook
lefthook install

Configuration Example

lefthook.yml:

commit-msg:
  commands:
    commitlint:
      run: npx commitlint --edit {1}

pre-commit:
  parallel: true
  commands:
    format:
      glob: "*.{ts,rs,py}"
      run: format-staged-files {staged_files}
      stage_fixed: true

pre-push:
  commands:
    validate:
      run: ./scripts/validate_all.sh

→ Full guide: references/git-hooks.md

Monorepo Management

Nx + pnpm Workspaces

Key principle: Nx builds on top of pnpm, doesn't replace it.

• pnpm workspaces - Dependency management
• Nx - Task orchestration, caching, affected commands

Benefits

• Run tasks only for affected packages
• Intelligent caching
• Parallel execution
• Supports multiple languages

Common Commands

# Run target for all packages
nx run-many --target=build --all

# Run only for affected
nx affected --target=test

# Visualize dependencies
nx graph

→ Full guide: references/monorepo.md

Version Management & Publishing

Changesets Workflow

Recommended for monorepos and npm packages.

1. Add changeset:

pnpm changeset
# Select packages, type (major/minor/patch), write summary

2. Version packages:

pnpm changeset version
# Updates package.json, generates CHANGELOG.md

3. Publish:

pnpm changeset publish
git push --follow-tags

Automated Publishing

Use GitHub Actions to automate releases:

Copy workflow:

cp assets/workflows/publish-changesets.yml .github/workflows/

This creates "Version Packages" PR on main when changesets exist.

→ See:

• references/version-management.md
• references/publishing.md

CI/CD Setup

Match Local Validation

Best practice: Run same checks in CI as local pre-push hook.

GitHub Actions templates:

• ci.yml - Basic linting, testing, building
• publish-npm.yml - Automated npm publishing
• publish-crates.yml - Automated crates.io publishing
• publish-pypi.yml - Automated PyPI publishing

Matrix Testing

Test across multiple versions:

strategy:
  matrix:
    node-version: [18, 20, 21]
    os: [ubuntu-latest, macos-latest]

Nx Monorepo CI

Use affected commands to only test changed packages:

nx affected --target=test
nx affected --target=build

→ Full guide: references/ci-cd.md

Common Tasks

Initialize TypeScript Project

Automated:

./scripts/init_typescript.sh --biome
# or
./scripts/init_typescript.sh --eslint-prettier

Creates:

• tsconfig.json (strict mode)
• Linting config (biome.json or eslint.config.js)
• Formatting config (.prettierrc.json if ESLint)
• Testing config (vitest.config.ts)
• Package.json scripts

Set Up Git Hooks

./scripts/setup_lefthook.sh

Configures:

• Conventional commits validation
• Pre-commit: lint/format staged files
• Pre-push: full validation

Configure Changesets

./scripts/setup_changesets.sh

Sets up:

• .changeset/ directory
• Package.json scripts
• Public access configuration

Full Validation

./scripts/validate_all.sh

Runs:

• Format checking
• Linting
• Type checking
• Tests
• Builds

Bundled Resources

Scripts (scripts/)

Setup scripts:

• init_typescript.sh - Initialize TypeScript project
• setup_lefthook.sh - Configure Git hooks
• setup_changesets.sh - Set up version management
• validate_all.sh - Run all checks (used by pre-push)

Usage:

./scripts/script_name.sh

All scripts check if tools are installed/up-to-date before proceeding.

Config Templates (assets/configs/)

TypeScript:

• tsconfig.strict.json - Strict TypeScript config
• biome.json - Biome configuration
• eslint.config.js - ESLint flat config
• .prettierrc.json - Prettier configuration

Rust:

• rustfmt.toml - Rustfmt configuration
• clippy.toml - Clippy lints
• deny.toml - Cargo-deny configuration

Python:

• pyproject.toml - ruff, mypy, pytest config
• ruff.toml - Standalone ruff config

Monorepo:

• nx.json - Nx configuration
• pnpm-workspace.yaml - pnpm workspaces

Git Hooks:

• lefthook.yml - Complete lefthook config
• commitlint.config.js - Conventional commits

GitHub Workflows:

• ci.yml - Basic CI
• publish-changesets.yml - Automated releases
• publish-npm.yml - npm publishing
• publish-crates.yml - crates.io publishing
• publish-pypi.yml - PyPI publishing

Reference Documentation (references/)

Language guides:

• typescript.md - ESLint+Prettier vs Biome, testing, monorepo
• rust.md - rustfmt, clippy, cargo-nextest, cargo-deny
• python.md - ruff, mypy, pytest, uv vs poetry

Infrastructure:

• monorepo.md - Nx + pnpm workspaces setup
• git-hooks.md - lefthook configuration
• ci-cd.md - GitHub Actions workflows
• publishing.md - npm, crates.io, PyPI publishing
• version-management.md - Changesets workflow

Best Practices

1. Use lefthook over Husky - Faster, language-agnostic
2. Match CI and local - Same checks in pre-push and CI
3. Choose Biome for new TS projects - Faster, simpler
4. Use Nx affected commands - Only test changed packages
5. Automate versioning - Use Changesets for npm packages
6. Conventional commits - Enables automated changelogs
7. Pre-commit: staged files - Fast feedback
8. Pre-push: full validation - Catch issues before pushing
9. Type-check everything - TypeScript, mypy, clippy
10. Test before publish - Always run tests in pre-publish

Troubleshooting

Hooks Not Running

Check installation:

lefthook install
ls -la .git/hooks/

Test manually:

lefthook run pre-commit

Format Conflicts

ESLint + Prettier conflicts:

• Ensure eslint-config-prettier is last in config
• Run Prettier separately from ESLint

Biome + Prettier conflicts:

• Don't use both - choose one
• Biome is drop-in Prettier replacement

CI Failures

Debugging:

1. Run ./scripts/validate_all.sh locally
2. Check CI runs same commands
3. Verify Node/Rust/Python versions match
4. Check caching is working

Quick Reference

Setup new TypeScript project:

./scripts/init_typescript.sh

Setup Git hooks:

./scripts/setup_lefthook.sh

Setup Changesets:

./scripts/setup_changesets.sh

Run full validation:

./scripts/validate_all.sh

Common commands:

# TypeScript
npm run lint && npm run type-check && npm test

# Rust
cargo fmt -- --check && cargo clippy -- -D warnings && cargo test

# Python
ruff check . && mypy . && pytest

# Monorepo
nx affected --target=test
nx run-many --target=build --all

# Changesets
pnpm changeset
pnpm changeset version
pnpm changeset publish

Getting Help

• TypeScript: See references/typescript.md
• Rust: See references/rust.md
• Python: See references/python.md
• Monorepo: See references/monorepo.md
• Git Hooks: See references/git-hooks.md
• CI/CD: See references/ci-cd.md
• Publishing: See references/publishing.md and references/version-management.md

Source: aaronbassett/agent-foundry — distributed by TomeVault.