@patricio0312rev/skillset 0.1.0

package/templates/foundation/code-formatter-installer/ SKILL.md

@@ -0,0 +1,320 @@
+---
+name: code-formatter-installer
+description: Installs and configures Prettier, ESLint, EditorConfig, and other code quality tools to enforce consistent code style across the team. Generates config files, npm scripts, editor settings recommendations, and CI integration suggestions. Use when users request "setup prettier", "add eslint", "configure code formatting", or "enforce code style".
+---
+
+# Code Formatter & Linter Installer
+
+Establish consistent code formatting and linting across your project.
+
+## Core Workflow
+
+1. **Detect stack**: Identify language/framework (JS/TS, Python, Go, Rust)
+2. **Choose tools**: Select appropriate formatters and linters
+3. **Generate configs**: Create config files with best-practice rules
+4. **Add scripts**: Include npm/package scripts for format/lint
+5. **Configure editor**: Provide VS Code, IntelliJ, Vim settings
+6. **Setup pre-commit**: Add git hooks for automatic formatting
+7. **CI integration**: Suggest GitHub Actions or CI config
+
+## Tool Selection by Stack
+
+### JavaScript/TypeScript
+
+- **Formatter**: Prettier
+- **Linter**: ESLint + typescript-eslint
+- **Editor**: EditorConfig
+- **Hooks**: Husky + lint-staged
+
+### Python
+
+- **Formatter**: Black + isort
+- **Linter**: Ruff or Flake8 + mypy
+- **Hooks**: pre-commit
+
+### Go
+
+- **Formatter**: gofmt + goimports
+- **Linter**: golangci-lint
+
+### Rust
+
+- **Formatter**: rustfmt
+- **Linter**: clippy
+
+## Configuration Templates
+
+### Prettier (.prettierrc.json)
+
+```json
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 100,
+  "tabWidth": 2,
+  "arrowParens": "avoid"
+}
+```
+
+### ESLint (.eslintrc.json)
+
+```json
+{
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:react/recommended",
+    "prettier"
+  ],
+  "rules": {
+    "no-console": "warn",
+    "@typescript-eslint/no-unused-vars": "error"
+  }
+}
+```
+
+### EditorConfig (.editorconfig)
+
+```ini
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.py]
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false
+```
+
+### Python (pyproject.toml)
+
+```toml
+[tool.black]
+line-length = 100
+target-version = ['py311']
+
+[tool.isort]
+profile = "black"
+line_length = 100
+
+[tool.mypy]
+strict = true
+warn_return_any = true
+```
+
+## Package Scripts
+
+### JavaScript/TypeScript (package.json)
+
+```json
+{
+  "scripts": {
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint . --ext .ts,.tsx,.js,.jsx",
+    "lint:fix": "eslint . --ext .ts,.tsx,.js,.jsx --fix",
+    "typecheck": "tsc --noEmit"
+  }
+}
+```
+
+### Python
+
+```bash
+# Makefile or scripts
+format:
+	black .
+	isort .
+
+lint:
+	ruff check .
+	mypy .
+
+format-check:
+	black --check .
+	isort --check .
+```
+
+## Git Hooks Setup
+
+### Husky + lint-staged (Node.js)
+
+1. Install dependencies:
+
+```bash
+npm install --save-dev husky lint-staged
+npx husky init
+```
+
+2. Configure lint-staged (.lintstagedrc.json):
+
+```json
+{
+  "*.{ts,tsx,js,jsx}": ["eslint --fix", "prettier --write"],
+  "*.{json,md,yml}": ["prettier --write"]
+}
+```
+
+3. Add pre-commit hook (.husky/pre-commit):
+
+```bash
+#!/bin/sh
+npx lint-staged
+```
+
+### pre-commit (Python)
+
+1. Create .pre-commit-config.yaml:
+
+```yaml
+repos:
+  - repo: https://github.com/psf/black
+    rev: 24.1.1
+    hooks:
+      - id: black
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.2.0
+    hooks:
+      - id: ruff
+        args: [--fix]
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.8.0
+    hooks:
+      - id: mypy
+```
+
+2. Install:
+
+```bash
+pip install pre-commit
+pre-commit install
+```
+
+## Editor Configuration
+
+### VS Code (settings.json)
+
+```json
+{
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true
+  },
+  "[python]": {
+    "editor.defaultFormatter": "ms-python.black-formatter"
+  }
+}
+```
+
+### VS Code Extensions (.vscode/extensions.json)
+
+```json
+{
+  "recommendations": [
+    "esbenp.prettier-vscode",
+    "dbaeumer.vscode-eslint",
+    "editorconfig.editorconfig",
+    "ms-python.black-formatter"
+  ]
+}
+```
+
+### IntelliJ/WebStorm
+
+- Enable: Settings → Languages & Frameworks → JavaScript → Prettier → On save
+- Enable: Settings → Tools → Actions on Save → Reformat code
+
+## CI Integration
+
+### GitHub Actions (.github/workflows/lint.yml)
+
+```yaml
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm run format:check
+      - run: npm run lint
+      - run: npm run typecheck
+```
+
+### Pre-merge checks
+
+```yaml
+# .github/workflows/pr-checks.yml
+- name: Check formatting
+  run: |
+    npm run format:check || {
+      echo "Code is not formatted. Run 'npm run format' locally."
+      exit 1
+    }
+```
+
+## Installation Checklist
+
+For every setup, provide:
+
+- [ ] Config files (.prettierrc, .eslintrc, .editorconfig, etc.)
+- [ ] Ignore files (.prettierignore, .eslintignore)
+- [ ] Package scripts (format, lint, format:check, lint:fix)
+- [ ] Git hooks (husky/pre-commit)
+- [ ] Editor settings (.vscode/settings.json)
+- [ ] CI workflow (.github/workflows/lint.yml)
+- [ ] Documentation (README section on running lint/format)
+
+## Best Practices
+
+1. **Run formatter last**: Prettier should override other formatting rules
+2. **Extend configs**: Use popular presets (Airbnb, Standard, etc.)
+3. **Ignore generated files**: Add build outputs to ignore files
+4. **Make hooks skippable**: Allow `git commit --no-verify` for emergencies
+5. **Document process**: Add "Code Style" section to CONTRIBUTING.md
+6. **Test on clean install**: Ensure configs work without local editor setup
+7. **Keep rules minimal**: Start strict, relax if needed
+
+## Common Configurations
+
+See `assets/configs/` for ready-to-use config files:
+
+- Next.js + TypeScript
+- React + TypeScript
+- Node.js + TypeScript
+- Python FastAPI
+- Python Django
+
+## Bypass Instructions (Emergencies)
+
+```bash
+# Skip pre-commit hooks
+git commit --no-verify
+
+# Skip CI checks (not recommended)
+git push --no-verify
+```
+
+Document when bypass is acceptable (hotfixes, emergencies only).

package/templates/foundation/codebase-summarizer/ SKILL.md

@@ -0,0 +1,360 @@
+---
+name: codebase-summarizer
+description: Scans repository structure and generates comprehensive architecture documentation including system overview, entry points, module relationships, data flow diagrams, and "edit here for X" guides. Creates ARCHITECTURE.md for onboarding and navigation. Use when users request "document the codebase", "explain the architecture", "create onboarding docs", or "map the system".
+---
+
+# Codebase Summarizer
+
+Generate comprehensive architecture documentation from repository analysis.
+
+## Core Workflow
+
+1. **Scan structure**: Recursively analyze folder tree and file organization
+2. **Identify patterns**: Detect framework, architecture style, key directories
+3. **Map entry points**: Find main files, routes, APIs, CLI commands
+4. **Trace data flow**: Follow requests through layers (controllers → services → models)
+5. **Document modules**: Explain purpose and responsibilities of each directory
+6. **Create navigation**: Build "how to" guides for common tasks
+7. **Generate diagrams**: Add Mermaid diagrams for visual architecture
+
+## Documentation Structure
+
+### ARCHITECTURE.md Template
+
+````markdown
+# Architecture Overview
+
+## System Summary
+
+[Project Name] is a [type] application built with [stack]. It follows [architecture pattern] and handles [primary use cases].
+
+**Tech Stack:**
+
+- Frontend: [framework + key libraries]
+- Backend: [framework + key libraries]
+- Database: [database + ORM]
+- Infrastructure: [hosting + CI/CD]
+
+## High-Level Architecture
+
+```mermaid
+graph TB
+    Client[Client/Browser] --> API[API Layer]
+    API --> Services[Business Logic]
+    Services --> DB[(Database)]
+    Services --> Cache[(Redis Cache)]
+    API --> Queue[Message Queue]
+```
+````
+
+## Project Structure
+
+```
+src/
+├── app/              # Application entry point and routing
+├── components/       # Reusable UI components
+├── lib/              # Utility functions and helpers
+├── services/         # Business logic layer
+├── models/           # Data models and schemas
+└── types/            # TypeScript type definitions
+```
+
+## Key Components
+
+### Entry Points
+
+**Main Application:** `src/app/page.tsx`
+
+- Application entry point
+- Initializes providers and routing
+- Handles global error boundaries
+
+**API Routes:** `src/app/api/`
+
+- RESTful API endpoints
+- Authentication middleware
+- Request validation
+
+### Core Modules
+
+**Authentication (`src/services/auth/`)**
+
+- User login and registration
+- JWT token management
+- OAuth2 integration
+- Dependencies: bcrypt, jsonwebtoken
+
+**User Management (`src/services/users/`)**
+
+- CRUD operations for users
+- Profile management
+- Role-based access control
+- Dependencies: Prisma, validation libraries
+
+**Data Layer (`src/models/`)**
+
+- Database schemas
+- Prisma models
+- Query builders
+- Dependencies: Prisma Client
+
+## Data Flow
+
+### User Registration Flow
+
+```mermaid
+sequenceDiagram
+    Client->>API: POST /api/auth/register
+    API->>Validation: Validate input
+    Validation->>Services: UserService.create()
+    Services->>Database: Insert user
+    Database-->>Services: User created
+    Services->>Email: Send welcome email
+    Services-->>API: Return JWT
+    API-->>Client: 201 Created
+```
+
+### Request Lifecycle
+
+1. **Request arrives** → API route handler (`src/app/api/[endpoint]/route.ts`)
+2. **Middleware** → Auth, validation, rate limiting
+3. **Service layer** → Business logic (`src/services/`)
+4. **Data layer** → Database queries (`src/models/`)
+5. **Response** → Format and return data
+
+## Common Patterns
+
+### Service Pattern
+
+```typescript
+// src/services/users/user.service.ts
+export class UserService {
+  async findById(id: string) {
+    return prisma.user.findUnique({ where: { id } });
+  }
+
+  async create(data: CreateUserDto) {
+    // Validation, business logic, database operations
+  }
+}
+```
+
+### Repository Pattern
+
+```typescript
+// src/repositories/user.repository.ts
+export class UserRepository {
+  async findAll() {
+    /* DB queries only */
+  }
+  async findById(id: string) {
+    /* DB queries only */
+  }
+}
+```
+
+## How To Guides
+
+### Add a New API Endpoint
+
+1. **Create route file:** `src/app/api/[name]/route.ts`
+
+   ```typescript
+   export async function GET(req: Request) {
+     // Implementation
+   }
+   ```
+
+2. **Add service logic:** `src/services/[name].service.ts`
+3. **Define types:** `src/types/[name].ts`
+4. **Add tests:** `src/app/api/[name]/route.test.ts`
+5. **Update API docs:** Document in OpenAPI/Swagger
+
+### Add a New Database Model
+
+1. **Update schema:** `prisma/schema.prisma`
+
+   ```prisma
+   model NewModel {
+     id String @id @default(cuid())
+     // fields
+   }
+   ```
+
+2. **Run migration:** `npx prisma migrate dev --name add-new-model`
+3. **Generate types:** `npx prisma generate`
+4. **Create service:** `src/services/new-model.service.ts`
+5. **Add CRUD routes:** `src/app/api/new-model/`
+
+### Add a New React Component
+
+1. **Create component:** `src/components/NewComponent/NewComponent.tsx`
+2. **Add styles:** `NewComponent.module.css` or inline Tailwind
+3. **Write tests:** `NewComponent.test.tsx`
+4. **Add stories:** `NewComponent.stories.tsx` (if using Storybook)
+5. **Export:** Update `src/components/index.ts`
+
+### Modify Authentication
+
+1. **Service layer:** `src/services/auth/auth.service.ts`
+2. **Middleware:** `src/middleware/auth.middleware.ts`
+3. **Routes:** `src/app/api/auth/`
+4. **Update tests:** Ensure auth flows still work
+
+## Key Files Reference
+
+| File                   | Purpose                | Modify For            |
+| ---------------------- | ---------------------- | --------------------- |
+| `src/app/layout.tsx`   | Root layout, providers | Global layout changes |
+| `src/lib/db.ts`        | Database connection    | Connection config     |
+| `src/lib/api.ts`       | API client setup       | Request interceptors  |
+| `src/middleware.ts`    | Next.js middleware     | Auth, redirects       |
+| `prisma/schema.prisma` | Database schema        | Data model changes    |
+| `.env.example`         | Environment vars       | Adding config values  |
+
+## Dependencies
+
+### Critical Dependencies
+
+- `next` - React framework
+- `prisma` - ORM and database toolkit
+- `react` - UI library
+- `typescript` - Type safety
+
+### Key Libraries
+
+- `zod` - Schema validation
+- `bcrypt` - Password hashing
+- `jsonwebtoken` - JWT handling
+- `date-fns` - Date utilities
+
+## Development Workflow
+
+1. **Local setup:** See [DEVELOPMENT.md](DEVELOPMENT.md)
+2. **Making changes:** Branch → Implement → Test → PR
+3. **Running tests:** `pnpm test`
+4. **Database changes:** Prisma migrate workflow
+5. **Deployment:** Vercel automatic deployment
+
+## Troubleshooting
+
+**Database connection errors**
+
+- Check DATABASE_URL in .env
+- Ensure database is running
+- Run `npx prisma generate`
+
+**Type errors after schema changes**
+
+- Run `npx prisma generate`
+- Restart TypeScript server
+
+**Build fails**
+
+- Clear `.next` folder: `rm -rf .next`
+- Clear node_modules: `rm -rf node_modules && pnpm install`
+
+## Additional Resources
+
+- [API Documentation](./API.md) - Endpoint reference
+- [Development Guide](./DEVELOPMENT.md) - Setup and workflow
+- [Contributing Guide](./CONTRIBUTING.md) - Code standards
+- [Database Schema](./DATABASE.md) - Data model details
+
+````
+
+## Analysis Techniques
+
+### Identify Framework
+Look for telltale files:
+- `next.config.js` → Next.js
+- `vite.config.ts` → Vite
+- `nest-cli.json` → NestJS
+- `manage.py` → Django
+- `Cargo.toml` → Rust
+
+### Map Entry Points
+- Frontend: `index.html`, `main.tsx`, `app.tsx`, `_app.tsx`
+- Backend: `main.ts`, `server.ts`, `app.py`, `index.js`
+- CLI: `cli.ts`, `__main__.py`, `main.go`
+
+### Trace Request Flow
+Follow typical paths:
+1. Route/endpoint definition
+2. Middleware/guards
+3. Controller/handler
+4. Service/business logic
+5. Repository/model
+6. Database query
+
+### Module Categories
+- **Core**: Essential business logic
+- **Infrastructure**: Database, cache, queue
+- **Utilities**: Helpers, formatters, validators
+- **Features**: User-facing functionality
+- **Config**: Environment, settings
+
+## Mermaid Diagrams
+
+### Architecture Diagram
+```mermaid
+graph LR
+    Client --> NextJS
+    NextJS --> API
+    API --> Services
+    Services --> Prisma
+    Prisma --> PostgreSQL
+````
+
+### Data Flow
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant API
+    participant Service
+    participant DB
+    Client->>API: Request
+    API->>Service: Process
+    Service->>DB: Query
+    DB-->>Service: Data
+    Service-->>API: Result
+    API-->>Client: Response
+```
+
+### Module Relationships
+
+```mermaid
+graph TB
+    API[API Layer] --> Auth[Auth Service]
+    API --> Users[User Service]
+    Auth --> DB[(Database)]
+    Users --> DB
+    Users --> Cache[(Cache)]
+```
+
+## Best Practices
+
+1. **Start high-level**: Overview before details
+2. **Visual first**: Use diagrams for complex flows
+3. **Be specific**: Reference actual file paths
+4. **Show examples**: Include code snippets
+5. **Link related docs**: Reference other documentation
+6. **Keep updated**: Update as architecture evolves
+7. **Developer-focused**: Write for onboarding and daily use
+
+## Output Checklist
+
+Every codebase summary should include:
+
+- [ ] System overview and tech stack
+- [ ] High-level architecture diagram
+- [ ] Project structure explanation
+- [ ] Entry points identification
+- [ ] Module/directory purposes
+- [ ] Data flow diagrams
+- [ ] Common patterns documented
+- [ ] "How to" guides for common tasks
+- [ ] Key files reference table
+- [ ] Dependencies explanation
+- [ ] Troubleshooting section