@rune-kit/rune 2.8.0 → 2.11.0

package/extensions/devops/skills/chaos-testing.md

@@ -1,67 +1,67 @@
----
-name: "chaos-testing"
-pack: "@rune/devops"
-description: "Resilience testing — inject controlled failures to verify system behavior under degraded conditions. Validates circuit breakers, retry logic, graceful degradation, and recovery procedures."
-model: sonnet
-tools: [Read, Edit, Write, Grep, Glob, Bash]
----
-
-# chaos-testing
-
-Resilience testing — inject controlled failures to verify system behavior under degraded conditions. Validates circuit breakers, retry logic, graceful degradation, and recovery procedures.
-
-#### Workflow
-
-**Step 1 — Map failure points**
-Scan the codebase for: external API calls (HTTP clients, SDK calls), database connections, message queues, cache layers, file system operations, and third-party services. For each dependency, identify: timeout configuration, retry logic, circuit breaker presence, fallback behavior. Build a dependency map with failure modes.
-
-**Step 2 — Design chaos experiments**
-For each critical dependency, define experiments:
-- **Latency injection**: Add 2-5s delay to responses — does the UI show loading state? Do timeouts fire correctly?
-- **Error injection**: Return 500/503 from dependency — does the circuit breaker open? Does fallback activate?
-- **Partition**: Dependency becomes unreachable — does the system degrade gracefully or crash?
-- **Data corruption**: Invalid response format — does validation catch it?
-
-Each experiment has: hypothesis ("If Redis is down, the app serves stale cache for 5 minutes"), blast radius (which users/features affected), rollback procedure (how to stop the experiment).
-
-**Step 3 — Generate test harnesses**
-Emit test files that simulate each failure mode:
-- Mock-based chaos for unit/integration tests (intercept HTTP, inject errors)
-- Environment-variable-driven chaos for staging (feature flags to enable failure injection)
-- Health check validation (verify `/health` endpoint reports degraded state, not crash)
-
-Save experiment plan to `.rune/chaos/<date>-experiment.md`.
-
-#### Example
-
-```typescript
-// Chaos test: Redis connection failure
-describe('Chaos: Redis unavailable', () => {
-  beforeEach(() => {
-    // Simulate Redis connection refused
-    jest.spyOn(redisClient, 'get').mockRejectedValue(
-      new Error('ECONNREFUSED 127.0.0.1:6379')
-    );
-  });
-
-  it('falls back to database when cache is down', async () => {
-    const result = await getUserProfile('user-123');
-    expect(result).toBeDefined(); // still works
-    expect(dbClient.query).toHaveBeenCalled(); // used DB fallback
-  });
-
-  it('reports degraded health status', async () => {
-    const health = await request(app).get('/health');
-    expect(health.status).toBe(200);
-    expect(health.body.cache).toBe('degraded');
-    expect(health.body.overall).toBe('degraded'); // not 'down'
-  });
-
-  it('circuit breaker opens after 5 failures', async () => {
-    for (let i = 0; i < 5; i++) await getUserProfile(`user-${i}`);
-    // 6th call should not even attempt Redis
-    await getUserProfile('user-6');
-    expect(redisClient.get).toHaveBeenCalledTimes(5); // not 6
-  });
-});
-```
+---
+name: "chaos-testing"
+pack: "@rune/devops"
+description: "Resilience testing — inject controlled failures to verify system behavior under degraded conditions. Validates circuit breakers, retry logic, graceful degradation, and recovery procedures."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# chaos-testing
+
+Resilience testing — inject controlled failures to verify system behavior under degraded conditions. Validates circuit breakers, retry logic, graceful degradation, and recovery procedures.
+
+#### Workflow
+
+**Step 1 — Map failure points**
+Scan the codebase for: external API calls (HTTP clients, SDK calls), database connections, message queues, cache layers, file system operations, and third-party services. For each dependency, identify: timeout configuration, retry logic, circuit breaker presence, fallback behavior. Build a dependency map with failure modes.
+
+**Step 2 — Design chaos experiments**
+For each critical dependency, define experiments:
+- **Latency injection**: Add 2-5s delay to responses — does the UI show loading state? Do timeouts fire correctly?
+- **Error injection**: Return 500/503 from dependency — does the circuit breaker open? Does fallback activate?
+- **Partition**: Dependency becomes unreachable — does the system degrade gracefully or crash?
+- **Data corruption**: Invalid response format — does validation catch it?
+
+Each experiment has: hypothesis ("If Redis is down, the app serves stale cache for 5 minutes"), blast radius (which users/features affected), rollback procedure (how to stop the experiment).
+
+**Step 3 — Generate test harnesses**
+Emit test files that simulate each failure mode:
+- Mock-based chaos for unit/integration tests (intercept HTTP, inject errors)
+- Environment-variable-driven chaos for staging (feature flags to enable failure injection)
+- Health check validation (verify `/health` endpoint reports degraded state, not crash)
+
+Save experiment plan to `.rune/chaos/<date>-experiment.md`.
+
+#### Example
+
+```typescript
+// Chaos test: Redis connection failure
+describe('Chaos: Redis unavailable', () => {
+  beforeEach(() => {
+    // Simulate Redis connection refused
+    jest.spyOn(redisClient, 'get').mockRejectedValue(
+      new Error('ECONNREFUSED 127.0.0.1:6379')
+    );
+  });
+
+  it('falls back to database when cache is down', async () => {
+    const result = await getUserProfile('user-123');
+    expect(result).toBeDefined(); // still works
+    expect(dbClient.query).toHaveBeenCalled(); // used DB fallback
+  });
+
+  it('reports degraded health status', async () => {
+    const health = await request(app).get('/health');
+    expect(health.status).toBe(200);
+    expect(health.body.cache).toBe('degraded');
+    expect(health.body.overall).toBe('degraded'); // not 'down'
+  });
+
+  it('circuit breaker opens after 5 failures', async () => {
+    for (let i = 0; i < 5; i++) await getUserProfile(`user-${i}`);
+    // 6th call should not even attempt Redis
+    await getUserProfile('user-6');
+    expect(redisClient.get).toHaveBeenCalledTimes(5); // not 6
+  });
+});
+```

package/extensions/devops/skills/ci-cd.md

@@ -1,75 +1,75 @@
----
-name: "ci-cd"
-pack: "@rune/devops"
-description: "CI/CD pipeline configuration — GitHub Actions, GitLab CI, build matrices, test parallelization, deployment gates, semantic release."
-model: sonnet
-tools: [Read, Edit, Write, Grep, Glob, Bash]
----
-
-# ci-cd
-
-CI/CD pipeline configuration — GitHub Actions, GitLab CI, build matrices, test parallelization, deployment gates, semantic release.
-
-#### Workflow
-
-**Step 1 — Detect existing pipeline**
-Use Glob to find `.github/workflows/*.yml`, `.gitlab-ci.yml`, `Jenkinsfile`, `bitbucket-pipelines.yml`. Read each config to understand: triggers, jobs, caching strategy, test execution, deployment steps, and secrets usage.
-
-**Step 2 — Audit pipeline efficiency**
-Check for: no dependency caching (slow installs every run), sequential jobs that could parallelize, missing test matrix for multiple Node/Python versions, no deployment gates (staging → production), secrets referenced without environment protection, missing artifact upload for build outputs. Flag with estimated time savings.
-
-**Step 3 — Emit optimized pipeline**
-Rewrite or patch the pipeline: dependency caching (npm/pnpm/pip cache), parallel job graph (lint + typecheck + test), build matrix for LTS versions, deployment gates with manual approval for production, status checks required before merge, artifact persistence for deploy stage.
-
-#### Example
-
-```yaml
-# GitHub Actions — optimized Node.js pipeline
-name: CI/CD
-on:
-  push: { branches: [main] }
-  pull_request: { branches: [main] }
-
-jobs:
-  quality:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        check: [lint, typecheck, test]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 20, cache: 'npm' }
-      - run: npm ci
-      - run: npm run ${{ matrix.check }}
-
-  build:
-    needs: quality
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 20, cache: 'npm' }
-      - run: npm ci && npm run build
-      - uses: actions/upload-artifact@v4
-        with: { name: dist, path: dist/ }
-
-  deploy-staging:
-    needs: build
-    if: github.ref == 'refs/heads/main'
-    runs-on: ubuntu-latest
-    environment: staging
-    steps:
-      - uses: actions/download-artifact@v4
-        with: { name: dist }
-      - run: echo "Deploy to staging..."
-
-  deploy-production:
-    needs: deploy-staging
-    runs-on: ubuntu-latest
-    environment: production  # requires manual approval
-    steps:
-      - uses: actions/download-artifact@v4
-        with: { name: dist }
-      - run: echo "Deploy to production..."
-```
+---
+name: "ci-cd"
+pack: "@rune/devops"
+description: "CI/CD pipeline configuration — GitHub Actions, GitLab CI, build matrices, test parallelization, deployment gates, semantic release."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# ci-cd
+
+CI/CD pipeline configuration — GitHub Actions, GitLab CI, build matrices, test parallelization, deployment gates, semantic release.
+
+#### Workflow
+
+**Step 1 — Detect existing pipeline**
+Use Glob to find `.github/workflows/*.yml`, `.gitlab-ci.yml`, `Jenkinsfile`, `bitbucket-pipelines.yml`. Read each config to understand: triggers, jobs, caching strategy, test execution, deployment steps, and secrets usage.
+
+**Step 2 — Audit pipeline efficiency**
+Check for: no dependency caching (slow installs every run), sequential jobs that could parallelize, missing test matrix for multiple Node/Python versions, no deployment gates (staging → production), secrets referenced without environment protection, missing artifact upload for build outputs. Flag with estimated time savings.
+
+**Step 3 — Emit optimized pipeline**
+Rewrite or patch the pipeline: dependency caching (npm/pnpm/pip cache), parallel job graph (lint + typecheck + test), build matrix for LTS versions, deployment gates with manual approval for production, status checks required before merge, artifact persistence for deploy stage.
+
+#### Example
+
+```yaml
+# GitHub Actions — optimized Node.js pipeline
+name: CI/CD
+on:
+  push: { branches: [main] }
+  pull_request: { branches: [main] }
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        check: [lint, typecheck, test]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 20, cache: 'npm' }
+      - run: npm ci
+      - run: npm run ${{ matrix.check }}
+
+  build:
+    needs: quality
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 20, cache: 'npm' }
+      - run: npm ci && npm run build
+      - uses: actions/upload-artifact@v4
+        with: { name: dist, path: dist/ }
+
+  deploy-staging:
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    environment: staging
+    steps:
+      - uses: actions/download-artifact@v4
+        with: { name: dist }
+      - run: echo "Deploy to staging..."
+
+  deploy-production:
+    needs: deploy-staging
+    runs-on: ubuntu-latest
+    environment: production  # requires manual approval
+    steps:
+      - uses: actions/download-artifact@v4
+        with: { name: dist }
+      - run: echo "Deploy to production..."
+```

package/extensions/devops/skills/docker.md

@@ -1,58 +1,58 @@
----
-name: "docker"
-pack: "@rune/devops"
-description: "Dockerfile and docker-compose patterns — multi-stage builds, layer optimization, security hardening, development vs production configs."
-model: sonnet
-tools: [Read, Edit, Write, Grep, Glob, Bash]
----
-
-# docker
-
-Dockerfile and docker-compose patterns — multi-stage builds, layer optimization, security hardening, development vs production configs.
-
-#### Workflow
-
-**Step 1 — Detect container configuration**
-Use Glob to find `Dockerfile*`, `docker-compose*.yml`, `.dockerignore`. Read each file to understand: base images used, build stages, exposed ports, volume mounts, environment variables, and health checks.
-
-**Step 2 — Audit against best practices**
-Check for: non-multi-stage builds (large images), `npm install` without `--omit=dev` in production stage, missing `.dockerignore` (bloated context), running as root (security risk), `latest` tag on base images (non-reproducible), missing `HEALTHCHECK`, `COPY . .` before dependency install (cache invalidation). Flag each with severity and fix.
-
-**Step 3 — Emit optimized Dockerfile**
-Rewrite or patch the Dockerfile: multi-stage build (deps → build → production), distroless or Alpine final image, non-root user, pinned base image versions, proper layer ordering, health check, and `.dockerignore` covering `node_modules`, `.git`, `*.md`.
-
-#### Example
-
-```dockerfile
-# BEFORE: single stage, root user, no cache optimization
-FROM node:20
-WORKDIR /app
-COPY . .
-RUN npm install
-EXPOSE 3000
-CMD ["node", "server.js"]
-
-# AFTER: multi-stage, non-root, optimized layers
-FROM node:20-alpine AS deps
-WORKDIR /app
-COPY package.json package-lock.json ./
-RUN npm ci --omit=dev
-
-FROM node:20-alpine AS build
-WORKDIR /app
-COPY package.json package-lock.json ./
-RUN npm ci
-COPY . .
-RUN npm run build
-
-FROM node:20-alpine AS production
-RUN addgroup -S app && adduser -S app -G app
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
-COPY --from=build /app/dist ./dist
-COPY package.json ./
-USER app
-EXPOSE 3000
-HEALTHCHECK --interval=30s --timeout=3s CMD wget -qO- http://localhost:3000/health || exit 1
-CMD ["node", "dist/server.js"]
-```
+---
+name: "docker"
+pack: "@rune/devops"
+description: "Dockerfile and docker-compose patterns — multi-stage builds, layer optimization, security hardening, development vs production configs."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# docker
+
+Dockerfile and docker-compose patterns — multi-stage builds, layer optimization, security hardening, development vs production configs.
+
+#### Workflow
+
+**Step 1 — Detect container configuration**
+Use Glob to find `Dockerfile*`, `docker-compose*.yml`, `.dockerignore`. Read each file to understand: base images used, build stages, exposed ports, volume mounts, environment variables, and health checks.
+
+**Step 2 — Audit against best practices**
+Check for: non-multi-stage builds (large images), `npm install` without `--omit=dev` in production stage, missing `.dockerignore` (bloated context), running as root (security risk), `latest` tag on base images (non-reproducible), missing `HEALTHCHECK`, `COPY . .` before dependency install (cache invalidation). Flag each with severity and fix.
+
+**Step 3 — Emit optimized Dockerfile**
+Rewrite or patch the Dockerfile: multi-stage build (deps → build → production), distroless or Alpine final image, non-root user, pinned base image versions, proper layer ordering, health check, and `.dockerignore` covering `node_modules`, `.git`, `*.md`.
+
+#### Example
+
+```dockerfile
+# BEFORE: single stage, root user, no cache optimization
+FROM node:20
+WORKDIR /app
+COPY . .
+RUN npm install
+EXPOSE 3000
+CMD ["node", "server.js"]
+
+# AFTER: multi-stage, non-root, optimized layers
+FROM node:20-alpine AS deps
+WORKDIR /app
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev
+
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package.json package-lock.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine AS production
+RUN addgroup -S app && adduser -S app -G app
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY --from=build /app/dist ./dist
+COPY package.json ./
+USER app
+EXPOSE 3000
+HEALTHCHECK --interval=30s --timeout=3s CMD wget -qO- http://localhost:3000/health || exit 1
+CMD ["node", "dist/server.js"]
+```