blockmine 1.23.4 → 1.25.0

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

@@ -1,95 +0,0 @@
-# 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

@@ -1,389 +0,0 @@
-# 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

@@ -1,201 +0,0 @@
-# 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