opencode-skills-collection 4.0.53 → 4.0.55

package/bundled-skills/deployment-validation-config-validate/references/detailed-guide.md

@@ -0,0 +1,484 @@
+# Configuration Validation - Detailed Guide
+
+> This file contains the detailed procedure and reference material extracted from `SKILL.md` for focused loading. The root skill defines activation, examples, safety constraints, and limitations.
+
+## Context
+The user needs to validate configuration files, implement configuration schemas, ensure consistency across environments, and prevent configuration-related errors. Focus on creating robust validation rules, type safety, security checks, and automated validation processes.
+
+
+## Requirements
+$ARGUMENTS
+
+
+## Instructions
+
+### 1. Configuration Analysis
+
+Analyze existing configuration structure and identify validation needs:
+
+```python
+import os
+import yaml
+import json
+from pathlib import Path
+from typing import Dict, List, Any
+
+class ConfigurationAnalyzer:
+    def analyze_project(self, project_path: str) -> Dict[str, Any]:
+        analysis = {
+            'config_files': self._find_config_files(project_path),
+            'security_issues': self._check_security_issues(project_path),
+            'consistency_issues': self._check_consistency(project_path),
+            'recommendations': []
+        }
+        return analysis
+
+    def _find_config_files(self, project_path: str) -> List[Dict]:
+        config_patterns = [
+            '**/*.json', '**/*.yaml', '**/*.yml', '**/*.toml',
+            '**/*.ini', '**/*.env*', '**/config.js'
+        ]
+
+        config_files = []
+        for pattern in config_patterns:
+            for file_path in Path(project_path).glob(pattern):
+                if not self._should_ignore(file_path):
+                    config_files.append({
+                        'path': str(file_path),
+                        'type': self._detect_config_type(file_path),
+                        'environment': self._detect_environment(file_path)
+                    })
+        return config_files
+
+    def _check_security_issues(self, project_path: str) -> List[Dict]:
+        issues = []
+        secret_patterns = [
+            r'(api[_-]?key|apikey)',
+            r'(secret|password|passwd)',
+            r'(token|auth)',
+            r'(aws[_-]?access)'
+        ]
+
+        for config_file in self._find_config_files(project_path):
+            content = Path(config_file['path']).read_text()
+            for pattern in secret_patterns:
+                if re.search(pattern, content, re.IGNORECASE):
+                    if self._looks_like_real_secret(content, pattern):
+                        issues.append({
+                            'file': config_file['path'],
+                            'type': 'potential_secret',
+                            'severity': 'high'
+                        })
+        return issues
+```
+
+### 2. Schema Validation
+
+Implement configuration schema validation with JSON Schema:
+
+```typescript
+import Ajv from 'ajv';
+import ajvFormats from 'ajv-formats';
+import { JSONSchema7 } from 'json-schema';
+
+interface ValidationResult {
+  valid: boolean;
+  errors?: Array<{
+    path: string;
+    message: string;
+    keyword: string;
+  }>;
+}
+
+export class ConfigValidator {
+  private ajv: Ajv;
+
+  constructor() {
+    this.ajv = new Ajv({
+      allErrors: true,
+      strict: false,
+      coerceTypes: true
+    });
+    ajvFormats(this.ajv);
+    this.addCustomFormats();
+  }
+
+  private addCustomFormats() {
+    this.ajv.addFormat('url-https', {
+      type: 'string',
+      validate: (data: string) => {
+        try {
+          return new URL(data).protocol === 'https:';
+        } catch { return false; }
+      }
+    });
+
+    this.ajv.addFormat('port', {
+      type: 'number',
+      validate: (data: number) => data >= 1 && data <= 65535
+    });
+
+    this.ajv.addFormat('duration', {
+      type: 'string',
+      validate: /^\d+[smhd]$/
+    });
+  }
+
+  validate(configData: any, schemaName: string): ValidationResult {
+    const validate = this.ajv.getSchema(schemaName);
+    if (!validate) throw new Error(`Schema '${schemaName}' not found`);
+
+    const valid = validate(configData);
+
+    if (!valid && validate.errors) {
+      return {
+        valid: false,
+        errors: validate.errors.map(error => ({
+          path: error.instancePath || '/',
+          message: error.message || 'Validation error',
+          keyword: error.keyword
+        }))
+      };
+    }
+    return { valid: true };
+  }
+}
+
+// Example schema
+export const schemas = {
+  database: {
+    type: 'object',
+    properties: {
+      host: { type: 'string', format: 'hostname' },
+      port: { type: 'integer', format: 'port' },
+      database: { type: 'string', minLength: 1 },
+      user: { type: 'string', minLength: 1 },
+      password: { type: 'string', minLength: 8 },
+      ssl: {
+        type: 'object',
+        properties: {
+          enabled: { type: 'boolean' }
+        },
+        required: ['enabled']
+      }
+    },
+    required: ['host', 'port', 'database', 'user', 'password']
+  }
+};
+```
+
+### 3. Environment-Specific Validation
+
+```python
+from typing import Dict, List, Any
+
+class EnvironmentValidator:
+    def __init__(self):
+        self.environments = ['development', 'staging', 'production']
+        self.environment_rules = {
+            'development': {
+                'allow_debug': True,
+                'require_https': False,
+                'min_password_length': 8
+            },
+            'production': {
+                'allow_debug': False,
+                'require_https': True,
+                'min_password_length': 16,
+                'require_encryption': True
+            }
+        }
+
+    def validate_config(self, config: Dict, environment: str) -> List[Dict]:
+        if environment not in self.environment_rules:
+            raise ValueError(f"Unknown environment: {environment}")
+
+        rules = self.environment_rules[environment]
+        violations = []
+
+        if not rules['allow_debug'] and config.get('debug', False):
+            violations.append({
+                'rule': 'no_debug_in_production',
+                'message': 'Debug mode not allowed in production',
+                'severity': 'critical'
+            })
+
+        if rules['require_https']:
+            urls = self._extract_urls(config)
+            for url_path, url in urls:
+                if url.startswith('http://') and 'localhost' not in url:
+                    violations.append({
+                        'rule': 'require_https',
+                        'message': f'HTTPS required for {url_path}',
+                        'severity': 'high'
+                    })
+
+        return violations
+```
+
+### 4. Configuration Testing
+
+```typescript
+import { describe, it, expect } from '@jest/globals';
+import { ConfigValidator } from './config-validator';
+
+describe('Configuration Validation', () => {
+  let validator: ConfigValidator;
+
+  beforeEach(() => {
+    validator = new ConfigValidator();
+  });
+
+  it('should validate database config', () => {
+    const config = {
+      host: 'localhost',
+      port: 5432,
+      database: 'myapp',
+      user: 'dbuser',
+      password: 'securepass123'
+    };
+
+    const result = validator.validate(config, 'database');
+    expect(result.valid).toBe(true);
+  });
+
+  it('should reject invalid port', () => {
+    const config = {
+      host: 'localhost',
+      port: 70000,
+      database: 'myapp',
+      user: 'dbuser',
+      password: 'securepass123'
+    };
+
+    const result = validator.validate(config, 'database');
+    expect(result.valid).toBe(false);
+  });
+});
+```
+
+### 5. Runtime Validation
+
+```typescript
+import { EventEmitter } from 'events';
+import * as chokidar from 'chokidar';
+
+export class RuntimeConfigValidator extends EventEmitter {
+  private validator: ConfigValidator;
+  private currentConfig: any;
+
+  async initialize(configPath: string): Promise<void> {
+    this.currentConfig = await this.loadAndValidate(configPath);
+    this.watchConfig(configPath);
+  }
+
+  private async loadAndValidate(configPath: string): Promise<any> {
+    const config = await this.loadConfig(configPath);
+
+    const validationResult = this.validator.validate(
+      config,
+      this.detectEnvironment()
+    );
+
+    if (!validationResult.valid) {
+      this.emit('validation:error', {
+        path: configPath,
+        errors: validationResult.errors
+      });
+
+      if (!this.isDevelopment()) {
+        throw new Error('Configuration validation failed');
+      }
+    }
+
+    return config;
+  }
+
+  private watchConfig(configPath: string): void {
+    const watcher = chokidar.watch(configPath, {
+      persistent: true,
+      ignoreInitial: true
+    });
+
+    watcher.on('change', async () => {
+      try {
+        const newConfig = await this.loadAndValidate(configPath);
+
+        if (JSON.stringify(newConfig) !== JSON.stringify(this.currentConfig)) {
+          this.emit('config:changed', {
+            oldConfig: this.currentConfig,
+            newConfig
+          });
+          this.currentConfig = newConfig;
+        }
+      } catch (error) {
+        this.emit('config:error', { error });
+      }
+    });
+  }
+}
+```
+
+### 6. Configuration Migration
+
+```python
+from typing import Dict
+from abc import ABC, abstractmethod
+import semver
+
+class ConfigMigration(ABC):
+    @property
+    @abstractmethod
+    def version(self) -> str:
+        pass
+
+    @abstractmethod
+    def up(self, config: Dict) -> Dict:
+        pass
+
+    @abstractmethod
+    def down(self, config: Dict) -> Dict:
+        pass
+
+class ConfigMigrator:
+    def __init__(self):
+        self.migrations: List[ConfigMigration] = []
+
+    def migrate(self, config: Dict, target_version: str) -> Dict:
+        current_version = config.get('_version', '0.0.0')
+
+        if semver.compare(current_version, target_version) == 0:
+            return config
+
+        result = config.copy()
+        for migration in self.migrations:
+            if (semver.compare(migration.version, current_version) > 0 and
+                semver.compare(migration.version, target_version) <= 0):
+                result = migration.up(result)
+                result['_version'] = migration.version
+
+        return result
+```
+
+### 7. Secure Configuration
+
+```typescript
+import * as crypto from 'crypto';
+
+interface EncryptedValue {
+  encrypted: true;
+  value: string;
+  algorithm: string;
+  iv: string;
+  authTag?: string;
+}
+
+export class SecureConfigManager {
+  private encryptionKey: Buffer;
+
+  constructor(masterKey: string) {
+    this.encryptionKey = crypto.pbkdf2Sync(masterKey, 'config-salt', 100000, 32, 'sha256');
+  }
+
+  encrypt(value: any): EncryptedValue {
+    const algorithm = 'aes-256-gcm';
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(algorithm, this.encryptionKey, iv);
+
+    let encrypted = cipher.update(JSON.stringify(value), 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+
+    return {
+      encrypted: true,
+      value: encrypted,
+      algorithm,
+      iv: iv.toString('hex'),
+      authTag: cipher.getAuthTag().toString('hex')
+    };
+  }
+
+  decrypt(encryptedValue: EncryptedValue): any {
+    const decipher = crypto.createDecipheriv(
+      encryptedValue.algorithm,
+      this.encryptionKey,
+      Buffer.from(encryptedValue.iv, 'hex')
+    );
+
+    if (encryptedValue.authTag) {
+      decipher.setAuthTag(Buffer.from(encryptedValue.authTag, 'hex'));
+    }
+
+    let decrypted = decipher.update(encryptedValue.value, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+
+    return JSON.parse(decrypted);
+  }
+
+  async processConfig(config: any): Promise<any> {
+    const processed = {};
+
+    for (const [key, value] of Object.entries(config)) {
+      if (this.isEncryptedValue(value)) {
+        processed[key] = this.decrypt(value as EncryptedValue);
+      } else if (typeof value === 'object' && value !== null) {
+        processed[key] = await this.processConfig(value);
+      } else {
+        processed[key] = value;
+      }
+    }
+
+    return processed;
+  }
+}
+```
+
+### 8. Documentation Generation
+
+```python
+from typing import Dict, List
+import yaml
+
+class ConfigDocGenerator:
+    def generate_docs(self, schema: Dict, examples: Dict) -> str:
+        docs = ["# Configuration Reference\n"]
+
+        docs.append("## Configuration Options\n")
+        sections = self._generate_sections(schema.get('properties', {}), examples)
+        docs.extend(sections)
+
+        return '\n'.join(docs)
+
+    def _generate_sections(self, properties: Dict, examples: Dict, level: int = 3) -> List[str]:
+        sections = []
+
+        for prop_name, prop_schema in properties.items():
+            sections.append(f"{'#' * level} {prop_name}\n")
+
+            if 'description' in prop_schema:
+                sections.append(f"{prop_schema['description']}\n")
+
+            sections.append(f"**Type:** `{prop_schema.get('type', 'any')}`\n")
+
+            if 'default' in prop_schema:
+                sections.append(f"**Default:** `{prop_schema['default']}`\n")
+
+            if prop_name in examples:
+                sections.append("**Example:**\n```yaml")
+                sections.append(yaml.dump({prop_name: examples[prop_name]}))
+                sections.append("```\n")
+
+        return sections
+```
+
+
+## Output Format
+
+1. **Configuration Analysis**: Current configuration assessment
+2. **Validation Schemas**: JSON Schema definitions
+3. **Environment Rules**: Environment-specific validation
+4. **Test Suite**: Configuration tests
+5. **Migration Scripts**: Version migrations
+6. **Security Report**: Issues and recommendations
+7. **Documentation**: Auto-generated reference
+
+Focus on preventing configuration errors, ensuring consistency, and maintaining security best practices.

package/bundled-skills/design-it/SKILL.md

@@ -163,6 +163,12 @@ To use a style, you MUST read its file at `<style-folder>/SKILL.md` relative to
 - **Web (React/Vue/HTML)**: Use CSS variables natively. Prioritize CSS grid/flexbox for layout. Use CSS transitions for hover states.
 - **App (React Native/Flutter/SwiftUI)**: Map the palettes to the framework's theme engine. Use platform-specific shadows (elevation) and animations instead of CSS transitions. Maintain the core visual principles while adapting to mobile constraints.
 
+## Example
+
+**User request:**
+
+> Review this interface with @design-it, identify the highest-impact design problems, and propose an implementation-ready improvement.
+
 ## Limitations
 
 - This skill does not replace environment-specific validation, testing, or expert review.

package/bundled-skills/design-orchestration/SKILL.md

@@ -168,6 +168,12 @@ This meta-skill exists to enforce the former.
 ## When to Use
 This skill is applicable to execute the workflow or actions described in the overview.
 
+## Example
+
+**User request:**
+
+> Review this interface with @design-orchestration, identify the highest-impact design problems, and propose an implementation-ready improvement.
+
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

package/bundled-skills/design-spells/SKILL.md

@@ -35,6 +35,12 @@ Trigger this skill when:
 - **Delight, Don't Distract**: The detail must be additive to the experience, not a usability barrier. It should feel expensive and highly crafted.
 - **Quality Execution**: A broken or janky "spell" is worse than none. Ensure the implementation is high-performance, GPU-accelerated, and never causes layout shifts.
 
+## Example
+
+**User request:**
+
+> Polish a finished feature to actively add a "wow" factor.
+
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

package/bundled-skills/design-system/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: design-system
-description: "Mechanical implementation invariants for frontend design: token architecture, typography hierarchy, loading order, FOUT prevention, chrome stability, motion timing, color semantics. Use with design when building components, pages, or design systems. (Aesthetic direction lives in..."
+description: "Mechanical implementation invariants for frontend design: token architecture, typography hierarchy, loading order, FOUT prevention, chrome stability, motion timing, color semantics. Use with design when building components, pages, or design systems."
 risk: critical
 source: https://github.com/connerkward/ckw-design-skill/tree/main/design-system
 source_repo: connerkward/ckw-design-skill
@@ -133,6 +133,12 @@ Avoiding the generic/trend look (Inter, purple-on-white, the same dark-glass car
 
 Atmosphere over flat fills — but matched to the chosen aesthetic, not a default. The reflexive gradient-mesh / noise / grain "premium" treatment is itself the designer-trend mean (design-spatial §2); reach for it only when the direction genuinely calls for it, never as decoration for its own sake.
 
+## Example
+
+**User request:**
+
+> Review this interface with @design-system, identify the highest-impact design problems, and propose an implementation-ready improvement.
+
 ## Limitations
 
 - Use this skill only when the task clearly matches its upstream source and local project context.

package/bundled-skills/design-taste-frontend/SKILL.md

@@ -19,6 +19,12 @@ tools: [claude, cursor, codex, antigravity]
 - Use when React, Next.js, Tailwind, motion, component states, typography, spacing, color, or responsive behavior need senior-level design judgment.
 - Use when the output must override common LLM UI biases such as centered heroes, purple gradients, card overuse, poor states, and fragile layouts.
 
+## Example
+
+**User request:**
+
+> Review this interface with @design-taste-frontend, identify the highest-impact design problems, and propose an implementation-ready improvement.
+
 ## Limitations
 
 - This skill provides frontend design and implementation guidance; it does not replace project-specific product requirements, accessibility review, or user testing.

package/bundled-skills/design-thinking/SKILL.md

@@ -102,6 +102,12 @@ When defining direction, choose which disciplines fit the product and apply 2–
 - **Product personality**: One clear character (friendly, serious, playful, premium); consistent across the UI.
 - **Simplify**: Remove until it breaks; "best part is no part" for UI clutter.
 
+## Example
+
+**User request:**
+
+> Review this interface with @design-thinking, identify the highest-impact design problems, and propose an implementation-ready improvement.
+
 ## Limitations
 
 - Use this skill only when the task clearly matches its upstream source and local project context.

package/bundled-skills/design-ux/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: design-ux
-description: UX / usability audit — heuristic evaluation of INTERACTIVE UIs (not just visual polish). Load with design when a UI "feels off", "sucks to use", is hard to learn, needs an instruction wall, or before shipping an interactive tool/editor/app. Scores the RENDERED UI against Nielsen's 10 +...
+description: "UX / usability audit — heuristic evaluation of INTERACTIVE UIs (not just visual polish). Load with design when a UI \"feels off\", \"sucks to use\", is hard to learn, needs an instruction wall, or before shipping an interactive tool/editor/app."
 risk: critical
 source: https://github.com/connerkward/ckw-design-skill/tree/main/deterministic-design/design-ux
 source_repo: connerkward/ckw-design-skill
@@ -68,6 +68,12 @@ A scored table — `Heuristic | Finding (located) | Severity | Fix` — then a p
 - **design-thinking** owns the UX *principles* (goals/tasks, IA, feedback, accessibility, progressive disclosure); this skill turns them into a *scored audit + fix loop*.
 - Run a usability audit **before** declaring an interactive UI "done" — alongside the visual critique, not instead of it.
 
+## Example
+
+**User request:**
+
+> Review this interface with @design-ux, identify the highest-impact design problems, and propose an implementation-ready improvement.
+
 ## Limitations
 
 - Use this skill only when the task clearly matches its upstream source and local project context.

package/bundled-skills/deterministic-design/SKILL.md

@@ -49,6 +49,12 @@ In central this lives as a subdir of ckw-design; it **publishes separately** as
 `deterministic-design-skill` (its own distribution) via publish-skill. One of the two
 flagship narratives — the *determinism* one; its sibling is human-in-the-loop (lookdev).
 
+## Example
+
+**User request:**
+
+> Review this interface with @deterministic-design, identify the highest-impact design problems, and propose an implementation-ready improvement.
+
 ## Limitations
 
 - Layout metrics and vision-judged audits catch many spatial and usability failures, but they are not a substitute for product judgment or user testing.

package/bundled-skills/developer-advocacy/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: developer-advocacy
-description: When the user wants to do developer advocacy activities including conference talks, live coding, podcasts, and building in public. Trigger phrases include "developer advocacy," "devrel," "conference talk," "CFP," "call for papers," "live coding," "podcast," "building in public,"...
+description: "When the user wants to do developer advocacy activities including conference talks, live coding, podcasts, and building in public."
 risk: critical
 source: https://github.com/jonathimer/devmarketing-skills/tree/main/skills/developer-advocacy
 source_repo: jonathimer/devmarketing-skills

package/bundled-skills/developer-audience-context/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: developer-audience-context
-description: When the user wants to establish or update their developer audience context. Also use when starting any other developer marketing skill to ensure foundational context is loaded. Trigger phrases include "developer persona," "target developers," "who are our developers," "developer...
+description: "When the user wants to establish or update their developer audience context. Also use when starting any other developer marketing skill to ensure foundational context is loaded."
 risk: critical
 source: https://github.com/jonathimer/devmarketing-skills/tree/main/skills/developer-audience-context
 source_repo: jonathimer/devmarketing-skills