blockmine 1.21.0 → 1.23.0

package/.claude/skills/build-engineering/resources/build-security.md

@@ -0,0 +1,95 @@
+# Build Security
+
+Guide to supply chain security including SBOM generation, signed artifacts, and dependency attestation.
+
+## Overview
+
+Build security protects against supply chain attacks and ensures artifact integrity.
+
+## SBOM Generation
+
+### CycloneDX
+```bash
+# Generate SBOM
+cyclonedx-cli generate -i . -o sbom.json
+
+# Validate
+cyclonedx-cli validate --input-file sbom.json
+```
+
+### Syft
+```bash
+# Generate from image
+syft packages myapp:latest -o cyclonedx-json > sbom.json
+
+# Multiple formats
+syft packages . -o table,json,cyclonedx
+```
+
+## Artifact Signing
+
+### GPG Signing
+```bash
+# Sign artifact
+gpg --armor --detach-sign artifact.jar
+
+# Verify
+gpg --verify artifact.jar.asc artifact.jar
+```
+
+### Cosign (Container)
+```bash
+# Sign image
+cosign sign registry.io/myapp:v1.0
+
+# Verify
+cosign verify registry.io/myapp:v1.0
+```
+
+## Dependency Attestation
+
+### SLSA Provenance
+```yaml
+# GitHub Actions
+- name: Generate provenance
+  uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v1.2.0
+```
+
+## Vulnerability Scanning
+
+### Trivy
+```bash
+# Scan image
+trivy image myapp:latest
+
+# Scan filesystem
+trivy fs .
+
+# Generate report
+trivy image --format json -o results.json myapp:latest
+```
+
+### Snyk
+```bash
+# Test dependencies
+snyk test
+
+# Monitor project
+snyk monitor
+
+# Test container
+snyk container test myapp:latest
+```
+
+## Best Practices
+
+1. **Generate SBOM** - For every release
+2. **Sign artifacts** - Cryptographic signatures
+3. **Scan dependencies** - Automated vulnerability scanning
+4. **Pin versions** - Exact dependency versions
+5. **Verify signatures** - Before deployment
+6. **Audit build process** - Regular security reviews
+7. **Least privilege** - Minimal build permissions
+8. **Secure secrets** - Never commit secrets
+9. **Provenance tracking** - Build metadata
+10. **Regular updates** - Keep dependencies current

package/.claude/skills/build-engineering/resources/build-systems.md

@@ -0,0 +1,389 @@
+# Build Systems
+
+Comprehensive comparison and guide for modern build systems including Make, Gradle, Maven, Bazel, npm/yarn/pnpm, and tool selection criteria.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Make](#make)
+- [Gradle](#gradle)
+- [Maven](#maven)
+- [Bazel](#bazel)
+- [npm/yarn/pnpm](#npmyarnpnpm)
+- [Comparison](#comparison)
+- [Tool Selection](#tool-selection)
+- [Best Practices](#best-practices)
+
+## Overview
+
+Build systems automate the process of converting source code into executable artifacts. Choosing the right build tool depends on language ecosystem, project size, team expertise, and build requirements.
+
+**Key Capabilities:**
+- Dependency management
+- Incremental compilation
+- Parallel execution
+- Build caching
+- Multi-platform support
+- Plugin ecosystem
+
+## Make
+
+Classic build tool based on file dependencies and timestamps.
+
+**Makefile:**
+```makefile
+CC = gcc
+CFLAGS = -Wall -O2
+TARGET = myapp
+SOURCES = main.c utils.c
+OBJECTS = $(SOURCES:.c=.o)
+
+.PHONY: all clean
+
+all: $(TARGET)
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(CFLAGS) -o $@ $^
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(OBJECTS) $(TARGET)
+
+install: $(TARGET)
+	install -m 755 $(TARGET) /usr/local/bin
+```
+
+**Pros:**
+- Universal, installed everywhere
+- Simple for small projects
+- Fast dependency checking
+- Language agnostic
+
+**Cons:**
+- Complex syntax for large projects
+- No built-in dependency management
+- Platform-specific makefiles
+- No standardized project structure
+
+## Gradle
+
+Flexible JVM build tool with Groovy/Kotlin DSL.
+
+**build.gradle.kts:**
+```kotlin
+plugins {
+    kotlin("jvm") version "1.9.0"
+    application
+}
+
+group = "com.example"
+version = "1.0.0"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("org.springframework.boot:spring-boot-starter-web:3.1.0")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.9.3")
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+
+application {
+    mainClass.set("com.example.MainKt")
+}
+
+// Custom task
+tasks.register("hello") {
+    doLast {
+        println("Hello from Gradle!")
+    }
+}
+
+// Parallel compilation
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+```
+
+**Multi-Module Project:**
+```kotlin
+// settings.gradle.kts
+rootProject.name = "myapp"
+include("api", "core", "web")
+
+// api/build.gradle.kts
+dependencies {
+    implementation(project(":core"))
+}
+```
+
+**Pros:**
+- Flexible and powerful
+- Excellent for multi-module projects
+- Strong caching support
+- Large plugin ecosystem
+
+**Cons:**
+- Steep learning curve
+- Build scripts can become complex
+- Slower than some alternatives
+
+## Maven
+
+Convention-over-configuration JVM build tool.
+
+**pom.xml:**
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0">
+    <modelVersion>4.0.0</modelVersion>
+    
+    <groupId>com.example</groupId>
+    <artifactId>myapp</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+    
+    <properties>
+        <java.version>17</java.version>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+    </properties>
+    
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <version>3.1.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.9.3</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+```
+
+**Multi-Module:**
+```xml
+<!-- Parent pom.xml -->
+<modules>
+    <module>api</module>
+    <module>core</module>
+    <module>web</module>
+</modules>
+
+<!-- Child module -->
+<parent>
+    <groupId>com.example</groupId>
+    <artifactId>parent</artifactId>
+    <version>1.0.0</version>
+</parent>
+```
+
+**Pros:**
+- Strong conventions
+- Standardized structure
+- Mature ecosystem
+- Great for Java projects
+
+**Cons:**
+- XML verbose
+- Less flexible than Gradle
+- Slower build times
+
+## Bazel
+
+Hermetic, reproducible build system for monorepos.
+
+**WORKSPACE:**
+```python
+workspace(name = "myapp")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "rules_jvm_external",
+    sha256 = "...",
+    url = "https://github.com/bazelbuild/rules_jvm_external/releases/download/4.5/rules_jvm_external-4.5.tar.gz",
+)
+
+load("@rules_jvm_external//:defs.bzl", "maven_install")
+
+maven_install(
+    artifacts = [
+        "com.google.guava:guava:31.1-jre",
+        "org.junit.jupiter:junit-jupiter:5.9.3",
+    ],
+    repositories = [
+        "https://repo1.maven.org/maven2",
+    ],
+)
+```
+
+**BUILD:**
+```python
+java_library(
+    name = "core",
+    srcs = glob(["src/main/java/**/*.java"]),
+    deps = [
+        "@maven//:com_google_guava_guava",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+java_binary(
+    name = "app",
+    srcs = ["Main.java"],
+    deps = [":core"],
+    main_class = "com.example.Main",
+)
+
+java_test(
+    name = "core_test",
+    srcs = glob(["src/test/java/**/*.java"]),
+    deps = [
+        ":core",
+        "@maven//:org_junit_jupiter_junit_jupiter",
+    ],
+)
+```
+
+**Pros:**
+- Truly reproducible builds
+- Excellent for monorepos
+- Multi-language support
+- Powerful caching
+
+**Cons:**
+- Steep learning curve
+- Complex configuration
+- Requires infrastructure investment
+
+## npm/yarn/pnpm
+
+JavaScript/TypeScript package managers and build tools.
+
+**package.json:**
+```json
+{
+  "name": "myapp",
+  "version": "1.0.0",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "typescript": "^5.1.6",
+    "jest": "^29.6.1"
+  }
+}
+```
+
+**pnpm Workspace:**
+```yaml
+# pnpm-workspace.yaml
+packages:
+  - 'packages/*'
+  - 'apps/*'
+```
+
+**Comparison:**
+
+| Feature | npm | yarn | pnpm |
+|---------|-----|------|------|
+| Speed | Slow | Fast | Fastest |
+| Disk Usage | High | High | Low (hard links) |
+| Workspaces | Yes | Yes | Yes |
+| Offline | No | Yes | Yes |
+
+**Pros:**
+- Native JavaScript ecosystem
+- Large package registry
+- Simple configuration
+- Fast iteration
+
+**Cons:**
+- Dependency hell without lock files
+- Security concerns
+- No type safety in package.json
+
+## Comparison
+
+| Feature | Make | Gradle | Maven | Bazel | npm |
+|---------|------|--------|-------|-------|-----|
+| Learning Curve | Low | High | Medium | Very High | Low |
+| Build Speed | Fast | Medium | Slow | Very Fast | Medium |
+| Caching | Manual | Good | Limited | Excellent | Good |
+| Incremental | Manual | Yes | Limited | Yes | Yes |
+| Multi-language | Yes | Limited | No | Yes | No |
+| Reproducibility | No | Medium | Medium | Excellent | Medium |
+| Best For | C/C++ | JVM | Java | Monorepo | JS/TS |
+
+## Tool Selection
+
+**Choose Make when:**
+- Building C/C++ projects
+- Simple build requirements
+- System-level projects
+- Maximum portability needed
+
+**Choose Gradle when:**
+- JVM projects (Java, Kotlin, Scala)
+- Need flexibility and customization
+- Multi-module projects
+- Android development
+
+**Choose Maven when:**
+- Standard Java projects
+- Prefer convention over configuration
+- Enterprise Java development
+- Team familiar with Maven
+
+**Choose Bazel when:**
+- Large monorepo
+- Need reproducible builds
+- Multi-language projects
+- Have infrastructure resources
+
+**Choose npm/yarn/pnpm when:**
+- JavaScript/TypeScript projects
+- Frontend development
+- Node.js applications
+- Need quick iteration
+
+## Best Practices
+
+1. **Use dependency locking** - Lock files for reproducibility
+2. **Enable caching** - Local and remote caching
+3. **Parallelize builds** - Use tool's parallel features
+4. **Version build tools** - Lock build tool versions
+5. **Clean separation** - Separate build from runtime
+6. **Monitor build times** - Track and optimize
+7. **Use incremental builds** - Don't rebuild unnecessarily
+8. **Document builds** - README with build instructions
+9. **Automate in CI** - Same commands local and CI
+10. **Keep it simple** - Don't over-engineer build scripts

package/.claude/skills/build-engineering/resources/compilation-optimization.md

@@ -0,0 +1,201 @@
+# Compilation Optimization
+
+Guide to optimizing compilation including compiler flags, incremental compilation, distributed builds, ccache, and parallel compilation strategies.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Compiler Flags](#compiler-flags)
+- [Incremental Compilation](#incremental-compilation)
+- [Distributed Builds](#distributed-builds)
+- [ccache](#ccache)
+- [Parallel Compilation](#parallel-compilation)
+- [Best Practices](#best-practices)
+
+## Overview
+
+Compilation optimization reduces build times through intelligent caching, parallelization, and compiler settings.
+
+**Key Techniques:**
+- Compiler optimization flags
+- Incremental compilation
+- Distributed compilation
+- Compilation caching
+- Parallel execution
+- Precompiled headers
+
+## Compiler Flags
+
+### GCC/Clang Optimization Levels
+
+```bash
+# No optimization (fast compile, slow runtime)
+gcc -O0 source.c -o app
+
+# Basic optimization
+gcc -O1 source.c -o app
+
+# Recommended for production
+gcc -O2 source.c -o app
+
+# Aggressive optimization (larger binaries)
+gcc -O3 source.c -o app
+
+# Size optimization
+gcc -Os source.c -o app
+```
+
+### Debug vs Release Flags
+
+```makefile
+# Debug build
+CFLAGS_DEBUG = -g -O0 -DDEBUG -Wall -Wextra
+
+# Release build
+CFLAGS_RELEASE = -O2 -DNDEBUG -march=native
+```
+
+### Link-Time Optimization (LTO)
+
+```bash
+# GCC LTO
+gcc -flto -O2 source.c -o app
+
+# Clang LTO
+clang -flto -O2 source.c -o app
+```
+
+## Incremental Compilation
+
+### Java Incremental Compilation
+
+```kotlin
+// build.gradle.kts
+tasks.withType<JavaCompile> {
+    options.isIncremental = true
+}
+```
+
+### TypeScript Incremental
+
+```json
+{
+  "compilerOptions": {
+    "incremental": true,
+    "composite": true,
+    "tsBuildInfoFile": "./.tsbuildinfo"
+  }
+}
+```
+
+### Rust Incremental
+
+```bash
+# Enable incremental compilation
+export CARGO_INCREMENTAL=1
+
+# Or in Cargo.toml
+[profile.dev]
+incremental = true
+```
+
+## Distributed Builds
+
+### distcc (C/C++)
+
+```bash
+# Setup distcc hosts
+export DISTCC_HOSTS="localhost/8 server1/4 server2/4"
+
+# Use with Make
+make -j16 CC="distcc gcc" CXX="distcc g++"
+
+# Monitoring
+distccmon-text 1
+```
+
+### Bazel Remote Execution
+
+```python
+# .bazelrc
+build --remote_executor=grpc://build-server:8980
+build --remote_cache=grpc://cache-server:8980
+```
+
+## ccache
+
+### Setup and Configuration
+
+```bash
+# Install
+sudo apt-get install ccache
+
+# Configure
+export CC="ccache gcc"
+export CXX="ccache g++"
+
+# Set cache size
+ccache -M 10G
+
+# Statistics
+ccache -s
+
+# Clear cache
+ccache -C
+```
+
+### CMake Integration
+
+```cmake
+find_program(CCACHE_FOUND ccache)
+if(CCACHE_FOUND)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+endif()
+```
+
+## Parallel Compilation
+
+### Make Parallel Builds
+
+```bash
+# Use all CPU cores
+make -j$(nproc)
+
+# Specific number of jobs
+make -j8
+```
+
+### Gradle Parallel
+
+```kotlin
+// gradle.properties
+org.gradle.parallel=true
+org.gradle.workers.max=8
+org.gradle.caching=true
+```
+
+### npm Parallel
+
+```json
+{
+  "scripts": {
+    "build": "npm-run-all --parallel build:*",
+    "build:client": "webpack",
+    "build:server": "tsc"
+  }
+}
+```
+
+## Best Practices
+
+1. **Use incremental compilation** - Only rebuild changed files
+2. **Enable caching** - ccache, sccache for native, gradle cache
+3. **Parallelize** - Use -j flag, parallel build options
+4. **Optimize flags** - -O2 for production, -O0 for debug
+5. **Use LTO** - Better optimization, smaller binaries
+6. **Distribute builds** - For large codebases
+7. **Monitor metrics** - Track compilation times
+8. **Precompiled headers** - For C++ projects
+9. **Clean periodically** - Remove stale artifacts
+10. **Profile builds** - Identify bottlenecks