bigbang-skills 1.0.0 → 1.1.0

package/README.md

@@ -1,52 +1,49 @@
 # BigBang — Pre-Project Rules Initializer
 
+[![npm version](https://img.shields.io/npm/v/bigbang-skills)](https://www.npmjs.com/package/bigbang-skills)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 Agent-agnostic skill that generates `AGENTS.md` with 23 maintainability rules before starting any project. Works with **opencode**, **Gemini**, **Cline**, **Cursor**, **Copilot**, and any AI agent that reads `AGENTS.md`.
 
-## Rules Included
-
-| # | Rule | Description |
-|---|------|-------------|
-| 1 | SOLID Principles | Verifiable against SOLID before writing |
-| 2 | YAGNI | No code until needed |
-| 3 | Design Patterns | Use established patterns where they solve real problems |
-| 4 | File Size Limit | Max 150 lines per file |
-| 5 | Folder Structure | Max 3 files per directory |
-| 6 | Naming Conventions | kebab-case, PascalCase, camelCase, UPPER_SNAKE_CASE |
-| 7 | Documentation | Doc comments on all public APIs |
-| 8 | Shareability | No secrets, no absolute paths, no team-specific config |
-| 9 | Single Responsibility | One thing per function/file/module |
-| 10 | Conventional Commits | feat:, fix:, chore:, etc. |
-| 11 | Testing Standards | 80% coverage, unit + integration |
-| 12 | Security Rules | No secrets, input validation, audit deps |
-| 13 | Error Handling | Typed errors, no empty catches, structured responses |
-| 14 | Performance Rules | No N+1, lazy loading, bundle budgets |
-| 15 | Dependency Rules | Minimize deps, pin versions, prefer stdlib |
-| 16 | Git Workflow | Branch naming, PR size, squash merge |
-| 17 | Changelog & Versioning | SemVer + Keep a Changelog |
-| 18 | API Design | RESTful, versioned, documented |
-| 19 | Database Rules | Migrations, naming, parameterized queries |
-| 20 | Logging & Observability | Structured JSON logs, health checks |
-| 21 | Docker Rules | Multi-stage builds, pinned versions, non-root |
-| 22 | Type Safety | Strict mode, no any, explicit return types |
-| 23 | Code Review Checklist | Checks, reviews, tests, docs, size |
-
-Also generates: linter config, CHANGELOG.md, Dockerfile, CI workflow, .env.example, and more.
+## Features
+
+- **Configurable presets** — strict (enterprise), prototype (fast/loose), library (public package), or fully custom
+- **Language-aware** — Python gets PEP 8 + mypy, Go gets gofmt, Rust gets clippy, JS/TS gets ESLint + strict TypeScript
+- **23 rules** — SOLID, YAGNI, design patterns, naming, testing, security, error handling, performance, deps, git, API design, database, logging, Docker, type safety, code review, and more
+- **Version-stamped** — generated AGENTS.md includes a BigBang version and date
+- **Before/after examples** — concrete snippets per rule
+- **Agent-agnostic** — generates AGENTS.md + agent-specific files (.cursorrules, .clinerules, etc.)
+
+## Rules
+
+| # | Rule | strict | prototype | library |
+|---|------|--------|-----------|---------|
+| 1–9 | Architecture + Style | ✓ | ✓ | ✓ |
+| 10 | Conventional Commits | ✓ | ✗ | ✓ |
+| 11 | Testing (≥90% cov) | ✓ | ✗ | ✓ |
+| 12–16 | Security + Process | ✓ | ✓ | ✓ |
+| 17 | Changelog + SemVer | ✓ | ✗ | ✓ |
+| 18 | API Design | ✓ | ✗ | ✓ |
+| 19 | Database | ✓ | ✗ | ✗ |
+| 20 | Logging | ✓ | ✗ | ✗ |
+| 21 | Docker | ✓ | ✗ | ✗ |
+| 22 | Type Safety | ✓ | ✓ | ✓ |
+| 23 | Code Review | ✓ | ✗ | ✓ |
+
+Also generates: linter config, CHANGELOG.md, bigbang.config.json, Dockerfile, CI workflow, .env.example, and more.
 
 ## Installation
 
 ```bash
-# via npm (recommended)
-npx bigbang-skills
-
-# or manually — clone the repo and symlink/copy to your skills directory
-git clone https://github.com/luckyman147/BigBang.git
+npm install bigbang-skills
 ```
 
-### For opencode
-Copy the `bigbang` folder to `~/.claude/skills/` or `$env:USERPROFILE\.claude\skills\`.
+Or clone the repo and copy to your skills directory:
 
-### For other agents
-Run the skill or manually generate `AGENTS.md` with the rules above — it's agent-agnostic.
+```bash
+git clone https://github.com/luckyman147/BigBang.git
+cp -r BigBang ~/.claude/skills/bigbang
+```
 
 ## Usage
 
@@ -56,7 +53,34 @@ When you start a new project, simply say:
 - "setup rules"
 - "initialize rules"
 
-The agent will ask about your project, then generate `AGENTS.md` + config files.
+Then choose a preset (strict/prototype/library) or customize each rule. The agent generates `AGENTS.md` + config files matching your stack.
+
+## Presets
+
+| Preset | File limit | Coverage | Docker/DB rules | Best for |
+|--------|-----------|----------|-----------------|----------|
+| **strict** | 150 lines | 90% | ✓ | Enterprise, production services |
+| **prototype** | 300 lines | off | ✗ | MVPs, hackathons, experiments |
+| **library** | 200 lines | 90% | ✗ | npm/PyPI/crates.io packages |
+
+## Customizing
+
+Copy `configs/bigbang.config.json` to your project root and toggle any rule:
+
+```json
+{
+  "rules": {
+    "file-size-limit": {
+      "enabled": true,
+      "maxLines": 200
+    }
+  }
+}
+```
+
+## Topics
+
+`ai-agents` `agent-skills` `coding-standards` `agents-md` `developer-tools` `project-initializer` `solid-principles` `yagni` `clean-code` `opencode` `cursor` `cline` `copilot`
 
 ## Author
 

package/SKILL.md

@@ -9,6 +9,18 @@ Before writing any code for a new project, create an `AGENTS.md` file in the pro
 
 The `AGENTS.md` file is the universal standard supported by most AI coding agents. If an agent uses a different filename (e.g., `.cursorrules`, `.clinerules`), also generate that equivalent file.
 
+## Included in this package
+
+| Path | Purpose |
+|------|---------|
+| `configs/bigbang.config.json` | Master config template — toggle rules, set thresholds |
+| `configs/strict.json` | Enterprise preset (all rules enforced, high bar) |
+| `configs/prototype.json` | Fast/loose preset (code quality only, skip process) |
+| `configs/library.json` | Public package preset (API surface, docs, backward compat) |
+| `configs/languages/*.json` | Language-specific rule overrides (Python, Go, Rust, JS/TS) |
+| `examples/*.md` | Before/after snippets for key rules |
+| `rules/*.md` | Individual rule files (contribution path) |
+
 ## Instructions
 
 ### Step 1: Detect the trigger
@@ -17,14 +29,44 @@ Trigger on any of:
 - "setup rules", "initialize rules", "set standards"
 - Any request that involves starting something new from scratch
 
-### Step 2: Ask project context (if not already provided)
+### Step 2: Ask project context
 Ask the user:
 - What does the project do? (brief description)
-- What language / framework?
+- What language / framework? (critical — determines language-specific rules)
 - Which AI agents will work on this project? (determines which rule files to generate)
 
-### Step 3: Generate AGENTS.md (and agent-specific files if needed)
-Create an `AGENTS.md` file in the root of the new project. This is the universal file that opencode, Gemini, Cline, and others read.
+### Step 3: Select config preset or customize
+Ask the user which preset they want, or offer to customize:
+
+1. **strict** (enterprise) — all 23 rules, 150-line file limit, 90% coverage, full process
+2. **prototype** (fast/loose) — essential quality rules only, relaxed limits, no process overhead
+3. **library** (public package) — API surface, docs, backward compat; skip infra/deploy rules
+4. **custom** — hand-pick each rule
+
+The presets are at `configs/{preset}.json`. For custom, load `configs/bigbang.config.json` and toggle rules interactively.
+
+### Step 4: Load language-specific rules
+Based on the language/framework detected in Step 2, load the corresponding config from `configs/languages/{language}.json`. This overrides generic rules with stack-appropriate ones:
+
+- **JavaScript/TypeScript** — ESLint + Prettier, strict TypeScript, vitest/jest
+- **Python** — Ruff, mypy/pyright, pytest, PEP 8 naming
+- **Go** — gofmt/gofumpt, golangci-lint, go test, idiomatic Go naming
+- **Rust** — rustfmt, clippy, cargo-test, built-in type safety
+- **Unknown** — fall back to generic rules + EditorConfig
+
+Adjust rules per language:
+- Python gets `snake_case` naming, type hints via mypy, `pyproject.toml` linting
+- Go skips generic "type safety" prose (compiler handles it), uses `gofmt`
+- Rust skips "type safety" and "dependency audit" (Cargo handles it), uses `cargo clippy`
+
+### Step 5: Generate AGENTS.md (and agent-specific files)
+Create an `AGENTS.md` file with a version stamp header:
+
+```markdown
+<!-- Generated by BigBang v1.1.0 on 2026-07-26 -->
+```
+
+Then include only the rules that are enabled in the selected config. Use language-specific wording where available.
 
 If the user specifies additional agents, also create their config files:
 - Cursor → also create `.cursorrules`
@@ -32,62 +74,34 @@ If the user specifies additional agents, also create their config files:
 - Copilot → also create `.github/copilot-instructions.md`
 - Windsurf → also create `.windsurfrules`
 
-All files contain the same rules (adapted to each format if needed). Write in plain markdown — no XML/angle brackets.
-
-#### Required sections:
-
-1. **SOLID Principles** — Each new class/function must be verifiable against SOLID before being written.
-2. **YAGNI** — Do not add code, abstractions, or dependencies until they are actually needed.
-3. **Design Patterns** — Use established design patterns (Factory, Strategy, Observer, etc.) where they solve a real problem, never for their own sake.
-4. **File Size Limit** — Every file must stay under 150 lines. If a file exceeds 120 lines during development, refactor before continuing.
-5. **Folder Structure** — Maximum 3 files per directory. If a directory would have a 4th file, create a subdirectory with a cohesive name.
-6. **Naming Conventions** — Enforce consistent naming across the project:
-   - Files: `kebab-case` for config/docs, `PascalCase` for components/classes, `camelCase` for utilities
-   - Folders: `kebab-case`
-   - Variables/Functions: `camelCase`
-   - Classes/Components: `PascalCase`
-   - Constants: `UPPER_SNAKE_CASE`
-   - Booleans: prefix with `is`, `has`, `should`, `can`
-7. **Documentation** — Every public function, class, and module must have a doc comment explaining what it does, its parameters, and its return value.
-8. **Shareability** — No hardcoded secrets, no absolute paths, no team-specific config. All configuration must be environment-based or in `.env.example`.
-9. **Single Responsibility** — A function does one thing. A file has one primary export. A module covers one domain.
-10. **Conventional Commits** — All commits must follow the Conventional Commits format:
-    - `feat:` new feature
-    - `fix:` bug fix
-    - `chore:` maintenance
-    - `refactor:` code change with no behavior change
-    - `docs:` documentation only
-    - `test:` adding/fixing tests
-    - `style:` formatting, linting
-    - `perf:` performance improvement
-    - Use scope when relevant: `feat(api):`, `fix(auth):`
-11. **Testing Standards** — Every feature must have tests:
-    - Unit tests for all pure functions and utilities
-    - Integration tests for API endpoints and data flows
-    - Test files mirror source structure under `tests/`
-    - Coverage threshold: minimum 80%
-    - Test naming: `describe('feature')` / `it('should ...')` pattern
-    - No test without an assertion
-12. **Security Rules** — No secrets in code. No hardcoded tokens, passwords, or API keys — always use environment variables. Validate all user input. Sanitize all output. Run `npm audit` (or equivalent) before shipping. No `eval()` or dynamic code execution.
-13. **Error Handling** — Every fallible operation must handle errors explicitly:
-    - No empty `catch` blocks
-    - Use typed errors / custom error classes
-    - Log errors with context (never log secrets)
-    - Return structured error responses in APIs
-    - Fail fast for programmer errors; handle gracefully for runtime errors
-14. **Performance Rules** — Avoid N+1 queries (use batching/eager loading). No expensive computations in hot paths. Lazy-load heavy modules. Set bundle size budgets for frontend projects. Profile before optimizing.
-15. **Dependency Rules** — Minimize external dependencies (every dep is a risk). Pin major versions. Audit dependencies regularly (`npm audit`, `go mod verify`, etc.). Prefer built-in / standard library solutions over npm packages. Remove unused deps.
-16. **Git Workflow Rules** — Branch naming: `feat/description`, `fix/description`, `chore/description`. Keep PRs under 300 lines. Squash merge to main. No direct pushes to main branch. Keep commits atomic (one concern per commit). Rebase instead of merge for feature branches.
-17. **Changelog & Versioning** — Maintain a `CHANGELOG.md` following Keep a Changelog format. Use Strict SemVer (MAJOR.MINOR.PATCH). Every release must bump the version and update the changelog. Breaking changes = MAJOR bump. New features = MINOR bump. Bug fixes = PATCH bump.
-18. **API Design Rules** — RESTful URL conventions (plural nouns, `/api/v1/` prefix). Consistent error response shape `{ error: string, code: number }`. Pagination with `?page&limit` or cursor-based. Version your APIs (URL or header). Document all endpoints (OpenAPI/Swagger). No breaking changes without a deprecation cycle.
-19. **Database Rules** — Use migrations for all schema changes (never raw SQL in code). Table names: `snake_case`, plural. Column names: `snake_case`. Always have `id` (PK), `created_at`, `updated_at` on every table. Index foreign keys and frequent query columns. Never use `SELECT *`. Use parameterized queries only (no raw string interpolation).
-20. **Logging & Observability** — Use structured logging (JSON format). Define log levels: DEBUG, INFO, WARN, ERROR, FATAL. Always include `request_id` and `correlation_id` in request-scoped logs. No `console.log` in production. Add health check endpoints (`/health`, `/ready`). Expose Prometheus metrics for key operations.
-21. **Docker Rules** — Use multi-stage builds to minimize image size. Pin base image versions (no `:latest`). Add `.dockerignore` (exclude `node_modules`, `.git`, etc.). Keep one process per container. Use non-root user. Scan images for vulnerabilities before shipping.
-22. **Type Safety Rules** — Enable strict mode in TypeScript (or equivalent). No `any` types. No type assertions (`as`) unless unavoidable. Prefer `unknown` over `any`. All function signatures must have explicit return types. Use branded types for IDs and primitives.
-23. **Code Review Checklist** — Every PR must: (a) pass all checks, (b) have at least one reviewer, (c) include tests for new code, (d) update docs if API changed, (e) be rebased on latest main, (f) have no unresolved comments, (g) be under 300 lines total.
-
-### Step 4: Generate linter / formatter config
-Based on the language/framework the user specified, generate the appropriate config file:
+#### Available rules (enabled/disabled by config):
+
+1. **SOLID Principles** — Each class/function verifiable against SOLID
+2. **YAGNI** — No speculative code
+3. **Design Patterns** — Use established patterns where they solve real problems
+4. **File Size Limit** — Configurable max lines (default 150, warn at 120)
+5. **Folder Structure** — Configurable max files per directory (default 3)
+6. **Naming Conventions** — Language-aware naming
+7. **Documentation** — Doc comments on all public APIs
+8. **Shareability** — No secrets, no absolute paths, no team-specific config
+9. **Single Responsibility** — One thing per function/file/module
+10. **Conventional Commits** — `feat:`, `fix:`, `chore:`, etc.
+11. **Testing Standards** — Configurable coverage threshold
+12. **Security Rules** — No secrets, input validation, audit deps
+13. **Error Handling** — Typed errors, no empty catches, structured responses
+14. **Performance Rules** — No N+1, lazy loading, bundle budgets
+15. **Dependency Rules** — Minimize deps, pin versions, prefer stdlib
+16. **Git Workflow** — Branch naming, PR size, squash merge
+17. **Changelog & Versioning** — SemVer + Keep a Changelog
+18. **API Design** — RESTful, versioned, documented
+19. **Database Rules** — Migrations, naming, parameterized queries
+20. **Logging & Observability** — Structured JSON logs, health checks
+21. **Docker Rules** — Multi-stage builds, pinned versions, non-root
+22. **Type Safety** — Language-aware (strict TS, mypy, etc.)
+23. **Code Review Checklist** — Checks, reviews, tests, docs, size
+
+### Step 6: Generate linter / formatter config
+Based on the language/framework, generate the appropriate config file:
 
 | Language/Framework | Config file | Tool |
 |---|---|---|
@@ -101,22 +115,21 @@ Based on the language/framework the user specified, generate the appropriate con
 
 Place the config in the project root. Also add a `lint` section to AGENTS.md referencing the tool and its rules.
 
-### Step 5: Generate supplementary config files
+### Step 7: Generate supplementary config files
 Based on the project type, generate these files where relevant:
 
 | File | When to create |
 |---|---|
-| `CHANGELOG.md` | Always — with Unreleased section |
+| `CHANGELOG.md` | Always — with Unreleased section + version header |
 | `.dockerignore` | If Docker is used or user plans to containerize |
 | `Dockerfile` | If the project is a web service or backend |
-| `.github/workflows/ci.yml` | If the project is hosted on GitHub |
+| `.github/workflows/ci.yml` | If the project is hosted on GitHub (include lint + test steps) |
 | `openapi.yaml` or `swagger.yaml` | If the project exposes an API |
 | `.env.example` | Always — with placeholder values |
 | `docker-compose.yml` | If the project needs local services (DB, cache, etc.) |
+| `bigbang.config.json` | Always — copy from configs/ with current preset applied |
 
-Place each file in the project root (or `.github/workflows/` for CI). Generate minimal, correct defaults — the user can expand later.
-
-### Step 6: Create folder skeleton (optional)
+### Step 8: Create folder skeleton (optional)
 If the user agrees, create the initial folder structure following the max-3-files-per-folder rule:
 
 ```
@@ -132,5 +145,12 @@ project-root/
 
 Each folder starts empty. New subdirectories are created as the 4th file would be needed.
 
-### Step 7: Confirm and proceed
-Show the user a summary of everything created (AGENTS.md, agent-specific files, linter config, supplementary files) and ask if they want to adjust anything before proceeding with the project.
+### Step 9: Confirm and proceed
+Show the user a summary:
+- Which preset was used (strict/prototype/library/custom)
+- Language detected
+- How many rules enabled
+- Files created (AGENTS.md, linter config, supplementary files)
+- AGENTS.md version stamp
+
+Ask if they want to adjust anything before proceeding.

package/configs/bigbang.config.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "bigbang.config.schema.json",
+  "version": "1.1.0",
+  "preset": "strict",
+  "language": "auto",
+  "rules": {
+    "solid-principles": true,
+    "yagni": true,
+    "design-patterns": true,
+    "file-size-limit": {
+      "enabled": true,
+      "maxLines": 150,
+      "warnAt": 120
+    },
+    "folder-structure": {
+      "enabled": true,
+      "maxFilesPerDir": 3
+    },
+    "naming-conventions": true,
+    "documentation": true,
+    "shareability": true,
+    "single-responsibility": true,
+    "conventional-commits": true,
+    "testing": {
+      "enabled": true,
+      "coverageThreshold": 80,
+      "requireUnitTests": true,
+      "requireIntegrationTests": false
+    },
+    "security": true,
+    "error-handling": true,
+    "performance": true,
+    "dependency-rules": true,
+    "git-workflow": {
+      "enabled": true,
+      "maxPrLines": 300,
+      "branchNaming": "feat|fix|chore/description"
+    },
+    "changelog": true,
+    "api-design": true,
+    "database": true,
+    "logging-observability": true,
+    "docker": false,
+    "type-safety": true,
+    "code-review": true
+  }
+}

package/configs/languages/go.json

@@ -0,0 +1,33 @@
+{
+  "language": "go",
+  "label": "Go",
+  "formatter": "gofmt or gofumpt",
+  "linter": "golangci-lint",
+  "typeSystem": "built-in",
+  "naming": {
+    "files": "snake_case.go",
+    "variables": "camelCase (exported = PascalCase)",
+    "functions": "PascalCase for exported, camelCase for private",
+    "classes": "struct PascalCase",
+    "constants": "PascalCase (idiomatic Go)",
+    "booleans": "is|has|should|can prefix"
+  },
+  "testing": {
+    "framework": "go test + testify",
+    "filePattern": "*_test.go",
+    "coverageTool": "go test -cover"
+  },
+  "typeSafety": {
+    "strictMode": "built-in",
+    "noAny": "avoid interface{}",
+    "noTypeAssertions": "use type switches when possible",
+    "preferUnknown": "not applicable",
+    "explicitReturnTypes": "required by compiler"
+  },
+  "formatting": {
+    "gofmt": true,
+    "lineLength": "no explicit limit (gofmt standard)",
+    "tabIndent": true
+  },
+  "filterRules": ["type-safety", "docker"]
+}

package/configs/languages/javascript.json

@@ -0,0 +1,34 @@
+{
+  "language": "javascript",
+  "label": "JavaScript / TypeScript",
+  "formatter": "prettier",
+  "linter": "eslint",
+  "typeSystem": "typescript",
+  "naming": {
+    "files": "kebab-case for config, PascalCase for components, camelCase for utilities",
+    "variables": "camelCase",
+    "functions": "camelCase",
+    "classes": "PascalCase",
+    "constants": "UPPER_SNAKE_CASE",
+    "booleans": "is|has|should|can prefix"
+  },
+  "testing": {
+    "framework": "vitest or jest",
+    "filePattern": "*.test.ts or *.spec.ts",
+    "coverageTool": "vitest --coverage or jest --coverage"
+  },
+  "typeSafety": {
+    "strictMode": true,
+    "noAny": true,
+    "noTypeAssertions": true,
+    "preferUnknown": true,
+    "explicitReturnTypes": true
+  },
+  "formatting": {
+    "semicolons": true,
+    "singleQuotes": true,
+    "trailingComma": "all",
+    "printWidth": 100
+  },
+  "filterRules": ["docker", "database"]
+}

package/configs/languages/python.json

@@ -0,0 +1,33 @@
+{
+  "language": "python",
+  "label": "Python",
+  "formatter": "ruff format",
+  "linter": "ruff check",
+  "typeSystem": "mypy or pyright",
+  "naming": {
+    "files": "snake_case.py",
+    "variables": "snake_case",
+    "functions": "snake_case",
+    "classes": "PascalCase",
+    "constants": "UPPER_SNAKE_CASE",
+    "booleans": "is|has|should|can prefix"
+  },
+  "testing": {
+    "framework": "pytest",
+    "filePattern": "test_*.py or *_test.py",
+    "coverageTool": "pytest --cov"
+  },
+  "typeSafety": {
+    "strictMode": true,
+    "noAny": "use type hints everywhere",
+    "noImplicitAny": true,
+    "preferUnknown": "use Any only when truly untyped",
+    "explicitReturnTypes": "function return annotations required"
+  },
+  "formatting": {
+    "lineLength": 88,
+    "quoteStyle": "double",
+    "sortImports": true
+  },
+  "filterRules": ["docker", "database", "api-design"]
+}

package/configs/languages/rust.json

@@ -0,0 +1,33 @@
+{
+  "language": "rust",
+  "label": "Rust",
+  "formatter": "rustfmt",
+  "linter": "clippy",
+  "typeSystem": "built-in (strict by default)",
+  "naming": {
+    "files": "snake_case.rs",
+    "variables": "snake_case",
+    "functions": "snake_case",
+    "classes": "PascalCase (structs/enums)",
+    "constants": "SCREAMING_SNAKE_CASE",
+    "booleans": "is|has|should|can prefix"
+  },
+  "testing": {
+    "framework": "built-in #[test]",
+    "filePattern": "test modules inside source files or tests/",
+    "coverageTool": "cargo-tarpaulin or cargo-llvm-cov"
+  },
+  "typeSafety": {
+    "strictMode": "built-in (compiler enforces)",
+    "noUnsafe": "avoid unsafe blocks unless absolutely necessary",
+    "noAny": "not applicable (no any type)",
+    "preferUnknown": "not applicable",
+    "explicitReturnTypes": "required for all function signatures"
+  },
+  "formatting": {
+    "maxWidth": 100,
+    "tabSpaces": 4,
+    "importGranularity": "crate"
+  },
+  "filterRules": ["type-safety", "docker"]
+}

package/configs/library.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "bigbang.config.schema.json",
+  "version": "1.1.0",
+  "preset": "library",
+  "description": "Public package: focus on API surface, docs, backward compat, skip infra/deploy rules",
+  "rules": {
+    "solid-principles": true,
+    "yagni": true,
+    "design-patterns": true,
+    "file-size-limit": { "enabled": true, "maxLines": 200, "warnAt": 170 },
+    "folder-structure": { "enabled": true, "maxFilesPerDir": 4 },
+    "naming-conventions": true,
+    "documentation": true,
+    "shareability": true,
+    "single-responsibility": true,
+    "conventional-commits": true,
+    "testing": { "enabled": true, "coverageThreshold": 90, "requireUnitTests": true, "requireIntegrationTests": false },
+    "security": true,
+    "error-handling": true,
+    "performance": true,
+    "dependency-rules": true,
+    "git-workflow": { "enabled": true, "maxPrLines": 300, "branchNaming": "feat|fix|chore/description" },
+    "changelog": true,
+    "api-design": true,
+    "database": false,
+    "logging-observability": false,
+    "docker": false,
+    "type-safety": true,
+    "code-review": true
+  }
+}

package/configs/prototype.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "bigbang.config.schema.json",
+  "version": "1.1.0",
+  "preset": "prototype",
+  "description": "Fast/loose: skip heavy process rules, focus on code quality essentials",
+  "rules": {
+    "solid-principles": true,
+    "yagni": true,
+    "design-patterns": false,
+    "file-size-limit": { "enabled": true, "maxLines": 300, "warnAt": 250 },
+    "folder-structure": { "enabled": false, "maxFilesPerDir": 5 },
+    "naming-conventions": true,
+    "documentation": false,
+    "shareability": true,
+    "single-responsibility": true,
+    "conventional-commits": false,
+    "testing": { "enabled": false, "coverageThreshold": 0, "requireUnitTests": false, "requireIntegrationTests": false },
+    "security": true,
+    "error-handling": true,
+    "performance": false,
+    "dependency-rules": true,
+    "git-workflow": { "enabled": false, "maxPrLines": 500, "branchNaming": "any" },
+    "changelog": false,
+    "api-design": false,
+    "database": false,
+    "logging-observability": false,
+    "docker": false,
+    "type-safety": true,
+    "code-review": false
+  }
+}

package/configs/strict.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "bigbang.config.schema.json",
+  "version": "1.1.0",
+  "preset": "strict",
+  "description": "Enterprise-grade: all rules enforced, strict limits, full process",
+  "rules": {
+    "solid-principles": true,
+    "yagni": true,
+    "design-patterns": true,
+    "file-size-limit": { "enabled": true, "maxLines": 150, "warnAt": 120 },
+    "folder-structure": { "enabled": true, "maxFilesPerDir": 3 },
+    "naming-conventions": true,
+    "documentation": true,
+    "shareability": true,
+    "single-responsibility": true,
+    "conventional-commits": true,
+    "testing": { "enabled": true, "coverageThreshold": 90, "requireUnitTests": true, "requireIntegrationTests": true },
+    "security": true,
+    "error-handling": true,
+    "performance": true,
+    "dependency-rules": true,
+    "git-workflow": { "enabled": true, "maxPrLines": 200, "branchNaming": "feat|fix|chore/description" },
+    "changelog": true,
+    "api-design": true,
+    "database": true,
+    "logging-observability": true,
+    "docker": true,
+    "type-safety": true,
+    "code-review": true
+  }
+}

package/examples/01-solid-principles.md

@@ -0,0 +1,125 @@
+# SOLID Principles — Before / After
+
+## Single Responsibility (S)
+
+**Before** — One class does too much:
+```typescript
+class ReportManager {
+  generateReport(data: any) { /* ... */ }
+  formatAsPDF(report: any) { /* ... */ }
+  sendEmail(report: any, to: string) { /* ... */ }
+  saveToDatabase(report: any) { /* ... */ }
+}
+```
+
+**After** — Each class owns one concern:
+```typescript
+class ReportGenerator {
+  generate(data: ReportData): Report { /* ... */ }
+}
+class ReportFormatter {
+  toPDF(report: Report): PDF { /* ... */ }
+}
+class EmailService {
+  send(to: string, attachment: PDF): void { /* ... */ }
+}
+class ReportRepository {
+  save(report: Report): void { /* ... */ }
+}
+```
+
+## Open/Closed (O)
+
+**Before** — Modifying existing code to add behavior:
+```typescript
+function calculateDiscount(order: Order, type: string) {
+  if (type === "gold") return order.total * 0.2;
+  if (type === "silver") return order.total * 0.1;
+  return 0;
+}
+```
+
+**After** — Extend without modifying:
+```typescript
+interface DiscountStrategy {
+  apply(total: number): number;
+}
+class GoldDiscount implements DiscountStrategy {
+  apply(total: number): number { return total * 0.2; }
+}
+class SilverDiscount implements DiscountStrategy {
+  apply(total: number): number { return total * 0.1; }
+}
+```
+
+## Liskov Substitution (L)
+
+**Before** — Subclass breaks parent contract:
+```typescript
+class Rectangle {
+  setWidth(w: number) { this.width = w; }
+  setHeight(h: number) { this.height = h; }
+}
+class Square extends Rectangle {
+  setWidth(w: number) { this.width = w; this.height = w; }  // breaks expectation
+}
+```
+
+**After** — Separate abstractions:
+```typescript
+interface Shape { area(): number; }
+class Rectangle implements Shape {
+  constructor(private width: number, private height: number) {}
+  area(): number { return this.width * this.height; }
+}
+class Square implements Shape {
+  constructor(private side: number) {}
+  area(): number { return this.side * this.side; }
+}
+```
+
+## Interface Segregation (I)
+
+**Before** — Fat interface forces useless implementations:
+```typescript
+interface Worker {
+  work(): void;
+  eat(): void;
+  sleep(): void;
+}
+class Robot implements Worker {
+  work() { /* ok */ }
+  eat() { throw new Error("does not eat"); }
+  sleep() { throw new Error("does not sleep"); }
+}
+```
+
+**After** — Focused interfaces:
+```typescript
+interface Workable { work(): void; }
+interface Eatable { eat(): void; }
+interface Sleepable { sleep(): void; }
+class Robot implements Workable {
+  work() { /* ok */ }
+}
+```
+
+## Dependency Inversion (D)
+
+**Before** — High-level depends on low-level concrete:
+```typescript
+class OrderService {
+  private db = new MySQLDatabase();  // tightly coupled
+}
+```
+
+**After** — Both depend on abstractions:
+```typescript
+interface Database { save(order: Order): void; }
+class OrderService {
+  constructor(private db: Database) {}  // any DB impl
+}
+class MySQLDatabase implements Database {
+  save(order: Order): void { /* ... */ }
+}
+```

package/examples/02-yagni.md

@@ -0,0 +1,42 @@
+# YAGNI — Before / After
+
+**Before** — Building for hypothetical future needs:
+```typescript
+// 3 interfaces, 2 abstract classes, 1 factory — for a 5-line function
+interface PaymentGateway {}
+interface PaymentValidator {}
+abstract class BasePayment {}
+class StripePayment extends BasePayment {}
+class PaymentFactory {
+  static create(type: string): BasePayment { /* ... */ }
+}
+
+function chargeUser(amount: number) {
+  const payment = PaymentFactory.create("stripe");
+  // ... 3 lines of actual logic
+}
+```
+
+**After** — Just the code you need right now:
+```typescript
+function chargeUser(amount: number) {
+  // call stripe API directly
+}
+```
+
+**Before** — Premature config system:
+```typescript
+// "what if we need XML, JSON, YAML, and TOML later?"
+interface ConfigParser { parse(raw: string): Config; }
+class JSONParser implements ConfigParser { /* ... */ }
+class XMLParser implements ConfigParser { /* ... */ }
+class ConfigParserFactory { /* ... */ }
+```
+
+**After** — Parse what you actually use:
+```typescript
+const config = JSON.parse(readFileSync("config.json"));
+```
+
+## Rule of thumb
+Write the simplest thing that works **today**. You'll know the right abstraction when you see the third repetition — not before.

package/examples/06-naming-conventions.md

@@ -0,0 +1,40 @@
+# Naming Conventions — Before / After
+
+**Before** — Inconsistent, cryptic:
+```typescript
+const x = 5;
+const user_info = getData();
+class data_manager {}
+function GetUser(id: number) { /* ... */ }
+const MY_VAR = "hello";
+const tmp = true;
+```
+
+**After** — Consistent, self-documenting:
+```typescript
+const pageSize = 5;
+const userInfo = fetchUserProfile();
+class DataManager {}
+function getUser(id: number): User { /* ... */ }
+const MY_VAR = "hello";
+const isActive = true;
+```
+
+## Quick reference
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Variable | camelCase | `userName` |
+| Function | camelCase | `getUser()` |
+| Class | PascalCase | `UserService` |
+| Constant (primitive) | UPPER_SNAKE_CASE | `MAX_RETRIES` |
+| Constant (object) | camelCase | `defaultConfig` |
+| Boolean | is/has/should/can prefix | `isLoading` |
+| Private field | _prefix or #prefix | `_cache` or `#cache` |
+| File (class) | PascalCase | `UserService.ts` |
+| File (utility) | camelCase | `formatDate.ts` |
+| File (config) | kebab-case | `eslint.config.js` |
+| Folder | kebab-case | `user-profile/` |
+| Enum | PascalCase | `PaymentStatus` |
+| Enum member | PascalCase | `PaymentStatus.Pending` |
+| Type/Interface | PascalCase | `UserPayload` |

package/install.sh

@@ -12,5 +12,5 @@ if [ -d "$SKILL_DIR" ]; then
 fi
 
 mkdir -p "$SKILL_DIR"
-cp -r "${REPO_DIR}"/SKILL.md "${SKILL_DIR}/"
+cp -r "${REPO_DIR}"/SKILL.md "${REPO_DIR}"/configs "${REPO_DIR}"/examples "${REPO_DIR}"/rules "${SKILL_DIR}/"
 echo "Installed bigbang skill to ${SKILL_DIR}"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bigbang-skills",
-  "version": "1.0.0",
-  "description": "Pre-project rules initializer for AI coding agents (opencode, Gemini, Cline, Cursor, Copilot). Generates AGENTS.md with SOLID, YAGNI, design patterns, naming conventions, testing, security, and 20+ maintainability rules.",
+  "version": "1.1.0",
+  "description": "Pre-project rules initializer for AI coding agents (opencode, Gemini, Cline, Cursor, Copilot). Generates AGENTS.md with configurable presets, language-aware rules, and 23 maintainability standards.",
   "keywords": [
     "opencode",
     "claude",
@@ -12,7 +12,12 @@
     "project-initializer",
     "solid",
     "yagni",
-    "clean-code"
+    "clean-code",
+    "agent-skills",
+    "developer-tools",
+    "cursor",
+    "cline",
+    "copilot"
   ],
   "author": "luckyman147",
   "license": "MIT",
@@ -27,6 +32,9 @@
   "files": [
     "SKILL.md",
     "install.ps1",
-    "install.sh"
+    "install.sh",
+    "configs/",
+    "examples/",
+    "rules/"
   ]
 }

package/rules/01-solid-principles.md

@@ -0,0 +1,14 @@
+---
+name: solid-principles
+description: Each class/function must be verifiable against SOLID before being written.
+appliesTo: all
+examples:
+  - examples/01-solid-principles.md
+category: architecture
+---
+
+- **S**ingle Responsibility: A class/function has exactly one reason to change.
+- **O**pen/Closed: Open for extension, closed for modification.
+- **L**iskov Substitution: Subtypes must be substitutable for their base types.
+- **I**nterface Segregation: Many specific interfaces > one general interface.
+- **D**ependency Inversion: Depend on abstractions, not concretions.

package/rules/02-yagni.md

@@ -0,0 +1,14 @@
+---
+name: yagni
+description: Don't add code, abstractions, or dependencies until they're actually needed.
+appliesTo: all
+examples:
+  - examples/02-yagni.md
+category: architecture
+---
+
+- No speculative abstractions (interfaces, factories, base classes "just in case").
+- No unused imports, parameters, or variables.
+- No dead code paths.
+- Refactor to a pattern only when you see the third repetition.
+- Delete unused code immediately.

package/rules/06-naming-conventions.md

@@ -0,0 +1,17 @@
+---
+name: naming-conventions
+description: Consistent naming across the project improves readability and shareability.
+appliesTo: all
+examples:
+  - examples/06-naming-conventions.md
+category: style
+---
+
+- **Files**: kebab-case for config/docs, PascalCase for components/classes, camelCase for utilities
+- **Folders**: kebab-case
+- **Variables/Functions**: camelCase
+- **Classes/Components**: PascalCase
+- **Constants**: UPPER_SNAKE_CASE
+- **Booleans**: prefix with is/has/should/can
+- **Private fields**: underscore prefix or JS # prefix
+- **Enums**: PascalCase type + PascalCase members

package/rules/README.md

@@ -0,0 +1,11 @@
+# Contributing Rules
+
+Each rule is a `.md` file with:
+- `name` — unique identifier (kebab-case)
+- `description` — one-liner
+- `appliesTo` — language/stack filter (or `all`)
+- `body` — the rule text to include in AGENTS.md
+- `examples` — optional references to `examples/`
+- `config` — optional default config values
+
+To propose a new rule, open a PR adding a file here. See existing rules for format.