@ngxtm/devkit 3.7.0 → 3.8.0

package/merged-commands/bazel-build-optimization.md

@@ -0,0 +1,397 @@
+---
+name: bazel-build-optimization
+description: Optimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise codebases.
+---
+
+# Bazel Build Optimization
+
+Production patterns for Bazel in large-scale monorepos.
+
+## Do not use this skill when
+
+- The task is unrelated to bazel build optimization
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Setting up Bazel for monorepos
+- Configuring remote caching/execution
+- Optimizing build times
+- Writing custom Bazel rules
+- Debugging build issues
+- Migrating to Bazel
+
+## Core Concepts
+
+### 1. Bazel Architecture
+
+```
+workspace/
+├── WORKSPACE.bazel       # External dependencies
+├── .bazelrc              # Build configurations
+├── .bazelversion         # Bazel version
+├── BUILD.bazel           # Root build file
+├── apps/
+│   └── web/
+│       └── BUILD.bazel
+├── libs/
+│   └── utils/
+│       └── BUILD.bazel
+└── tools/
+    └── bazel/
+        └── rules/
+```
+
+### 2. Key Concepts
+
+| Concept | Description |
+|---------|-------------|
+| **Target** | Buildable unit (library, binary, test) |
+| **Package** | Directory with BUILD file |
+| **Label** | Target identifier `//path/to:target` |
+| **Rule** | Defines how to build a target |
+| **Aspect** | Cross-cutting build behavior |
+
+## Templates
+
+### Template 1: WORKSPACE Configuration
+
+```python
+# WORKSPACE.bazel
+workspace(name = "myproject")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+# Rules for JavaScript/TypeScript
+http_archive(
+    name = "aspect_rules_js",
+    sha256 = "...",
+    strip_prefix = "rules_js-1.34.0",
+    url = "https://github.com/aspect-build/rules_js/releases/download/v1.34.0/rules_js-v1.34.0.tar.gz",
+)
+
+load("@aspect_rules_js//js:repositories.bzl", "rules_js_dependencies")
+rules_js_dependencies()
+
+load("@rules_nodejs//nodejs:repositories.bzl", "nodejs_register_toolchains")
+nodejs_register_toolchains(
+    name = "nodejs",
+    node_version = "20.9.0",
+)
+
+load("@aspect_rules_js//npm:repositories.bzl", "npm_translate_lock")
+npm_translate_lock(
+    name = "npm",
+    pnpm_lock = "//:pnpm-lock.yaml",
+    verify_node_modules_ignored = "//:.bazelignore",
+)
+
+load("@npm//:repositories.bzl", "npm_repositories")
+npm_repositories()
+
+# Rules for Python
+http_archive(
+    name = "rules_python",
+    sha256 = "...",
+    strip_prefix = "rules_python-0.27.0",
+    url = "https://github.com/bazelbuild/rules_python/releases/download/0.27.0/rules_python-0.27.0.tar.gz",
+)
+
+load("@rules_python//python:repositories.bzl", "py_repositories")
+py_repositories()
+```
+
+### Template 2: .bazelrc Configuration
+
+```bash
+# .bazelrc
+
+# Build settings
+build --enable_platform_specific_config
+build --incompatible_enable_cc_toolchain_resolution
+build --experimental_strict_conflict_checks
+
+# Performance
+build --jobs=auto
+build --local_cpu_resources=HOST_CPUS*.75
+build --local_ram_resources=HOST_RAM*.75
+
+# Caching
+build --disk_cache=~/.cache/bazel-disk
+build --repository_cache=~/.cache/bazel-repo
+
+# Remote caching (optional)
+build:remote-cache --remote_cache=grpcs://cache.example.com
+build:remote-cache --remote_upload_local_results=true
+build:remote-cache --remote_timeout=3600
+
+# Remote execution (optional)
+build:remote-exec --remote_executor=grpcs://remote.example.com
+build:remote-exec --remote_instance_name=projects/myproject/instances/default
+build:remote-exec --jobs=500
+
+# Platform configurations
+build:linux --platforms=//platforms:linux_x86_64
+build:macos --platforms=//platforms:macos_arm64
+
+# CI configuration
+build:ci --config=remote-cache
+build:ci --build_metadata=ROLE=CI
+build:ci --bes_results_url=https://results.example.com/invocation/
+build:ci --bes_backend=grpcs://bes.example.com
+
+# Test settings
+test --test_output=errors
+test --test_summary=detailed
+
+# Coverage
+coverage --combined_report=lcov
+coverage --instrumentation_filter="//..."
+
+# Convenience aliases
+build:opt --compilation_mode=opt
+build:dbg --compilation_mode=dbg
+
+# Import user settings
+try-import %workspace%/user.bazelrc
+```
+
+### Template 3: TypeScript Library BUILD
+
+```python
+# libs/utils/BUILD.bazel
+load("@aspect_rules_ts//ts:defs.bzl", "ts_project")
+load("@aspect_rules_js//js:defs.bzl", "js_library")
+load("@npm//:defs.bzl", "npm_link_all_packages")
+
+npm_link_all_packages(name = "node_modules")
+
+ts_project(
+    name = "utils_ts",
+    srcs = glob(["src/**/*.ts"]),
+    declaration = True,
+    source_map = True,
+    tsconfig = "//:tsconfig.json",
+    deps = [
+        ":node_modules/@types/node",
+    ],
+)
+
+js_library(
+    name = "utils",
+    srcs = [":utils_ts"],
+    visibility = ["//visibility:public"],
+)
+
+# Tests
+load("@aspect_rules_jest//jest:defs.bzl", "jest_test")
+
+jest_test(
+    name = "utils_test",
+    config = "//:jest.config.js",
+    data = [
+        ":utils",
+        "//:node_modules/jest",
+    ],
+    node_modules = "//:node_modules",
+)
+```
+
+### Template 4: Python Library BUILD
+
+```python
+# libs/ml/BUILD.bazel
+load("@rules_python//python:defs.bzl", "py_library", "py_test", "py_binary")
+load("@pip//:requirements.bzl", "requirement")
+
+py_library(
+    name = "ml",
+    srcs = glob(["src/**/*.py"]),
+    deps = [
+        requirement("numpy"),
+        requirement("pandas"),
+        requirement("scikit-learn"),
+        "//libs/utils:utils_py",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+py_test(
+    name = "ml_test",
+    srcs = glob(["tests/**/*.py"]),
+    deps = [
+        ":ml",
+        requirement("pytest"),
+    ],
+    size = "medium",
+    timeout = "moderate",
+)
+
+py_binary(
+    name = "train",
+    srcs = ["train.py"],
+    deps = [":ml"],
+    data = ["//data:training_data"],
+)
+```
+
+### Template 5: Custom Rule for Docker
+
+```python
+# tools/bazel/rules/docker.bzl
+def _docker_image_impl(ctx):
+    dockerfile = ctx.file.dockerfile
+    base_image = ctx.attr.base_image
+    layers = ctx.files.layers
+
+    # Build the image
+    output = ctx.actions.declare_file(ctx.attr.name + ".tar")
+
+    args = ctx.actions.args()
+    args.add("--dockerfile", dockerfile)
+    args.add("--output", output)
+    args.add("--base", base_image)
+    args.add_all("--layer", layers)
+
+    ctx.actions.run(
+        inputs = [dockerfile] + layers,
+        outputs = [output],
+        executable = ctx.executable._builder,
+        arguments = [args],
+        mnemonic = "DockerBuild",
+        progress_message = "Building Docker image %s" % ctx.label,
+    )
+
+    return [DefaultInfo(files = depset([output]))]
+
+docker_image = rule(
+    implementation = _docker_image_impl,
+    attrs = {
+        "dockerfile": attr.label(
+            allow_single_file = [".dockerfile", "Dockerfile"],
+            mandatory = True,
+        ),
+        "base_image": attr.string(mandatory = True),
+        "layers": attr.label_list(allow_files = True),
+        "_builder": attr.label(
+            default = "//tools/docker:builder",
+            executable = True,
+            cfg = "exec",
+        ),
+    },
+)
+```
+
+### Template 6: Query and Dependency Analysis
+
+```bash
+# Find all dependencies of a target
+bazel query "deps(//apps/web:web)"
+
+# Find reverse dependencies (what depends on this)
+bazel query "rdeps(//..., //libs/utils:utils)"
+
+# Find all targets in a package
+bazel query "//libs/..."
+
+# Find changed targets since commit
+bazel query "rdeps(//..., set($(git diff --name-only HEAD~1 | sed 's/.*/"&"/' | tr '\n' ' ')))"
+
+# Generate dependency graph
+bazel query "deps(//apps/web:web)" --output=graph | dot -Tpng > deps.png
+
+# Find all test targets
+bazel query "kind('.*_test', //...)"
+
+# Find targets with specific tag
+bazel query "attr(tags, 'integration', //...)"
+
+# Compute build graph size
+bazel query "deps(//...)" --output=package | wc -l
+```
+
+### Template 7: Remote Execution Setup
+
+```python
+# platforms/BUILD.bazel
+platform(
+    name = "linux_x86_64",
+    constraint_values = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    exec_properties = {
+        "container-image": "docker://gcr.io/myproject/bazel-worker:latest",
+        "OSFamily": "Linux",
+    },
+)
+
+platform(
+    name = "remote_linux",
+    parents = [":linux_x86_64"],
+    exec_properties = {
+        "Pool": "default",
+        "dockerNetwork": "standard",
+    },
+)
+
+# toolchains/BUILD.bazel
+toolchain(
+    name = "cc_toolchain_linux",
+    exec_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    target_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    toolchain = "@remotejdk11_linux//:jdk",
+    toolchain_type = "@bazel_tools//tools/jdk:runtime_toolchain_type",
+)
+```
+
+## Performance Optimization
+
+```bash
+# Profile build
+bazel build //... --profile=profile.json
+bazel analyze-profile profile.json
+
+# Identify slow actions
+bazel build //... --execution_log_json_file=exec_log.json
+
+# Memory profiling
+bazel build //... --memory_profile=memory.json
+
+# Skip analysis cache
+bazel build //... --notrack_incremental_state
+```
+
+## Best Practices
+
+### Do's
+- **Use fine-grained targets** - Better caching
+- **Pin dependencies** - Reproducible builds
+- **Enable remote caching** - Share build artifacts
+- **Use visibility wisely** - Enforce architecture
+- **Write BUILD files per directory** - Standard convention
+
+### Don'ts
+- **Don't use glob for deps** - Explicit is better
+- **Don't commit bazel-* dirs** - Add to .gitignore
+- **Don't skip WORKSPACE setup** - Foundation of build
+- **Don't ignore build warnings** - Technical debt
+
+## Resources
+
+- [Bazel Documentation](https://bazel.build/docs)
+- [Bazel Remote Execution](https://bazel.build/docs/remote-execution)
+- [rules_js](https://github.com/aspect-build/rules_js)

package/merged-commands/beautiful-prose.md

@@ -0,0 +1,22 @@
+---
+name: beautiful-prose
+description: "Hard-edged writing style contract for timeless, forceful English prose without AI tics"
+source: "https://github.com/SHADOWPR0/beautiful_prose"
+risk: safe
+---
+
+# Beautiful Prose
+
+## Overview
+
+Hard-edged writing style contract for timeless, forceful English prose without AI tics
+
+## When to Use This Skill
+
+Use this skill when you need to work with hard-edged writing style contract for timeless, forceful english prose without ai tics.
+
+## Instructions
+
+This skill provides guidance and patterns for hard-edged writing style contract for timeless, forceful english prose without ai tics.
+
+For more information, see the [source repository](https://github.com/SHADOWPR0/beautiful_prose).

package/merged-commands/behavioral-modes.md

@@ -0,0 +1,242 @@
+---
+name: behavioral-modes
+description: AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type.
+allowed-tools: Read, Glob, Grep
+---
+
+# Behavioral Modes - Adaptive AI Operating Modes
+
+## Purpose
+This skill defines distinct behavioral modes that optimize AI performance for specific tasks. Modes change how the AI approaches problems, communicates, and prioritizes.
+
+---
+
+## Available Modes
+
+### 1. 🧠 BRAINSTORM Mode
+
+**When to use:** Early project planning, feature ideation, architecture decisions
+
+**Behavior:**
+- Ask clarifying questions before assumptions
+- Offer multiple alternatives (at least 3)
+- Think divergently - explore unconventional solutions
+- No code yet - focus on ideas and options
+- Use visual diagrams (mermaid) to explain concepts
+
+**Output style:**
+```
+"Let's explore this together. Here are some approaches:
+
+Option A: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+Option B: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+What resonates with you? Or should we explore a different direction?"
+```
+
+---
+
+### 2. ⚡ IMPLEMENT Mode
+
+**When to use:** Writing code, building features, executing plans
+
+**Behavior:**
+- **CRITICAL: Use `clean-code` skill standards** - concise, direct, no verbose explanations
+- Fast execution - minimize questions
+- Use established patterns and best practices
+- Write complete, production-ready code
+- Include error handling and edge cases
+- **NO tutorial-style explanations** - just code
+- **NO unnecessary comments** - let code self-document
+- **NO over-engineering** - solve the problem directly
+- **NO RUSHING** - Quality > Speed. Read ALL references before coding.
+
+**Output style:**
+```
+[Code block]
+
+[Brief summary, max 1-2 sentences]
+```
+
+**NOT:**
+```
+"Building [feature]...
+
+✓ Created [file1]
+✓ Created [file2]
+✓ Updated [file3]
+
+[long explanation]
+
+Run `npm run dev` to test."
+```
+
+---
+
+### 3. 🔍 DEBUG Mode
+
+**When to use:** Fixing bugs, troubleshooting errors, investigating issues
+
+**Behavior:**
+- Ask for error messages and reproduction steps
+- Think systematically - check logs, trace data flow
+- Form hypothesis → test → verify
+- Explain the root cause, not just the fix
+- Prevent future occurrences
+
+**Output style:**
+```
+"Investigating...
+
+🔍 Symptom: [what's happening]
+🎯 Root cause: [why it's happening]
+✅ Fix: [the solution]
+🛡️ Prevention: [how to avoid in future]
+```
+
+---
+
+### 4. 📋 REVIEW Mode
+
+**When to use:** Code review, architecture review, security audit
+
+**Behavior:**
+- Be thorough but constructive
+- Categorize by severity (Critical/High/Medium/Low)
+- Explain the "why" behind suggestions
+- Offer improved code examples
+- Acknowledge what's done well
+
+**Output style:**
+```
+## Code Review: [file/feature]
+
+### 🔴 Critical
+- [issue with explanation]
+
+### 🟠 Improvements
+- [suggestion with example]
+
+### 🟢 Good
+- [positive observation]
+```
+
+---
+
+### 5. 📚 TEACH Mode
+
+**When to use:** Explaining concepts, documentation, onboarding
+
+**Behavior:**
+- Explain from fundamentals
+- Use analogies and examples
+- Progress from simple to complex
+- Include practical exercises
+- Check understanding
+
+**Output style:**
+```
+## Understanding [Concept]
+
+### What is it?
+[Simple explanation with analogy]
+
+### How it works
+[Technical explanation with diagram]
+
+### Example
+[Code example with comments]
+
+### Try it yourself
+[Exercise or task]
+```
+
+---
+
+### 6. 🚀 SHIP Mode
+
+**When to use:** Production deployment, final polish, release preparation
+
+**Behavior:**
+- Focus on stability over features
+- Check for missing error handling
+- Verify environment configs
+- Run all tests
+- Create deployment checklist
+
+**Output style:**
+```
+## Pre-Ship Checklist
+
+### ✅ Code Quality
+- [ ] No TypeScript errors
+- [ ] ESLint passing
+- [ ] All tests passing
+
+### ✅ Security
+- [ ] No exposed secrets
+- [ ] Input validation complete
+
+### ✅ Performance
+- [ ] Bundle size acceptable
+- [ ] No console.logs
+
+### 🚀 Ready to deploy
+```
+
+---
+
+## Mode Detection
+
+The AI should automatically detect the appropriate mode based on:
+
+| Trigger | Mode |
+|---------|------|
+| "what if", "ideas", "options" | BRAINSTORM |
+| "build", "create", "add" | IMPLEMENT |
+| "not working", "error", "bug" | DEBUG |
+| "review", "check", "audit" | REVIEW |
+| "explain", "how does", "learn" | TEACH |
+| "deploy", "release", "production" | SHIP |
+
+---
+
+## Multi-Agent Collaboration Patterns (2025)
+
+Modern architectures optimized for agent-to-agent collaboration:
+
+### 1. 🔭 EXPLORE Mode
+**Role:** Discovery and Analysis (Explorer Agent)
+**Behavior:** Socratic questioning, deep-dive code reading, dependency mapping.
+**Output:** `discovery-report.json`, architectural visualization.
+
+### 2. 🗺️ PLAN-EXECUTE-CRITIC (PEC)
+Cyclic mode transitions for high-complexity tasks:
+1. **Planner:** Decomposes the task into atomic steps (`task.md`).
+2. **Executor:** Performs the actual coding (`IMPLEMENT`).
+3. **Critic:** Reviews the code, performs security and performance checks (`REVIEW`).
+
+### 3. 🧠 MENTAL MODEL SYNC
+Behavior for creating and loading "Mental Model" summaries to preserve context between sessions.
+
+---
+
+## Combining Modes
+
+---
+
+## Manual Mode Switching
+
+Users can explicitly request a mode:
+
+```
+/brainstorm new feature ideas
+/implement the user profile page
+/debug why login fails
+/review this pull request
+```