@nockdev/awf 6.2.0 → 6.2.2

package/.agent/skills/cross-cutting/wasm/META.yaml

@@ -0,0 +1,47 @@
+name: wasm
+version: "1.0.0"
+display: WebAssembly
+category: cross-cutting
+tier: 1
+priority: 8
+
+desc: "WebAssembly: Component Model, WASI 0.2+, WIT interfaces, browser WASM (wasm-bindgen), and server-side WASM (Spin, wasmCloud)."
+
+triggers:
+  file_patterns:
+    - "*.wasm"
+    - "*.wat"
+    - "*.wit"
+    - "Cargo.toml"
+  keywords:
+    - wasm
+    - webassembly
+    - WASI
+    - component model
+    - WIT interface
+    - wasm-bindgen
+    - wasm-pack
+    - wasmtime
+    - wasmer
+    - wasm-tools
+    - spin framework
+    - wasmcloud
+
+caps:
+  - Component Model architecture
+  - WIT interface definitions
+  - WASI 0.2+ (I/O, networking, filesystem)
+  - Browser WASM (wasm-bindgen, wasm-pack)
+  - Server-side WASM (Spin, wasmCloud, Fermyon)
+  - Language toolchains (Rust/Go/Python → WASM)
+  - Performance optimization (SIMD, memory)
+
+related_skills:
+  - rust
+  - javascript
+  - go
+
+hsa_adapter:
+  enabled: true
+  data_dir: "skills/cross-cutting/wasm/data"
+  preload_data: false

package/.agent/skills/cross-cutting/wasm/SKILL.md

@@ -0,0 +1,88 @@
+# WebAssembly — WASM • WASI • Component Model
+
+> Browser WASM • Server-side WASM • Near-native performance
+
+---
+
+## Khi Nào Dùng
+
+- Chạy compute-intensive code trong browser (image/video processing, games)
+- Server-side WASM cho lightweight serverless functions
+- Port native code (Rust/C++) sang web platform
+- Cross-language component sharing via WIT
+
+## Architecture
+
+```
+┌─────────────────────────────────┐
+│     Browser / Server Runtime    │
+│  ┌───────────────────────────┐ │
+│  │    WASM Runtime           │ │
+│  │  (V8, wasmtime, wasmer)   │ │
+│  │  ┌─────────────────────┐  │ │
+│  │  │   WASM Module       │  │ │
+│  │  │  (compiled Rust/Go) │  │ │
+│  │  └─────────────────────┘  │ │
+│  └───────────────────────────┘ │
+│        ↕ WASI System Interface │
+└─────────────────────────────────┘
+```
+
+## Browser WASM (wasm-bindgen)
+
+```rust
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn add(a: i32, b: i32) -> i32 { a + b }
+
+// Build: wasm-pack build --target web
+```
+
+```javascript
+import init, { add } from "./pkg/my_wasm.js";
+await init();
+console.log(add(2, 3)); // 5
+```
+
+## Server-side WASM (Spin)
+
+```rust
+use spin_sdk::http::{Request, Response};
+
+#[spin_sdk::http_component]
+fn handle_request(req: Request) -> Response {
+    Response::builder()
+        .status(200)
+        .body("Hello from WASM!")
+        .build()
+}
+```
+
+## WIT Interface (Component Model)
+
+```wit
+package example:calculator;
+
+interface operations {
+    add: func(a: f64, b: f64) -> f64;
+    multiply: func(a: f64, b: f64) -> f64;
+}
+
+world calculator {
+    export operations;
+}
+```
+
+## Common Traps
+
+| Trap            | Fix                               |
+| --------------- | --------------------------------- |
+| Large WASM file | Use wasm-opt, tree shaking        |
+| DOM access      | Use wasm-bindgen JS interop       |
+| Threading       | SharedArrayBuffer + Web Workers   |
+| Debugging       | Use DWARF debug info, source maps |
+
+---
+
+_DOMYH Awesome Code • WebAssembly Skill v1.0.0_

package/.agent/skills/cross-cutting/wasm/data/browser-patterns.yaml

@@ -0,0 +1,106 @@
+# Browser WASM Patterns — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: WASM-BR-001
+    name: wasm-bindgen Setup
+    category: setup
+    description: |
+      Rust → Browser WASM with wasm-bindgen.
+    example: |
+      // Cargo.toml
+      [lib]
+      crate-type = ["cdylib"]
+
+      [dependencies]
+      wasm-bindgen = "0.2"
+      web-sys = { version = "0.3", features = ["console", "Document", "Element"] }
+      js-sys = "0.3"
+
+      // lib.rs
+      use wasm_bindgen::prelude::*;
+
+      #[wasm_bindgen]
+      pub fn greet(name: &str) -> String {
+        format!("Hello, {}!", name)
+      }
+
+      #[wasm_bindgen]
+      pub fn fibonacci(n: u32) -> u32 {
+        match n { 0 => 0, 1 => 1, _ => fibonacci(n-1) + fibonacci(n-2) }
+      }
+
+  - id: WASM-BR-002
+    name: wasm-pack Build
+    category: build
+    description: |
+      Build, test, and publish WASM packages.
+    text: |
+      wasm-pack build --target web      → ES modules (recommended)
+      wasm-pack build --target bundler  → For webpack/vite
+      wasm-pack build --target nodejs   → For Node.js
+      wasm-pack test --chrome           → Browser tests
+
+  - id: WASM-BR-003
+    name: JavaScript Interop
+    category: interop
+    description: |
+      Call JS from Rust and Rust from JS.
+    example: |
+      // Rust: Call JS functions
+      #[wasm_bindgen]
+      extern "C" {
+        #[wasm_bindgen(js_namespace = console)]
+        fn log(s: &str);
+        
+        fn alert(s: &str);
+      }
+
+      // Rust: Export to JS
+      #[wasm_bindgen]
+      pub struct ImageProcessor { /* ... */ }
+
+      #[wasm_bindgen]
+      impl ImageProcessor {
+        #[wasm_bindgen(constructor)]
+        pub fn new(width: u32, height: u32) -> Self { /* ... */ }
+        pub fn apply_blur(&mut self, radius: f32) { /* ... */ }
+        pub fn get_result(&self) -> Vec<u8> { /* ... */ }
+      }
+
+      // JavaScript usage
+      import init, { ImageProcessor } from './pkg/my_wasm.js';
+      await init();
+      const proc = new ImageProcessor(800, 600);
+      proc.apply_blur(2.0);
+      const result = proc.get_result();
+
+  - id: WASM-BR-004
+    name: Web Workers + WASM
+    category: threading
+    description: |
+      Run WASM in Web Workers for off-main-thread compute.
+    example: |
+      // worker.js
+      import init, { heavyComputation } from './pkg/my_wasm.js';
+
+      self.onmessage = async (e) => {
+        await init();
+        const result = heavyComputation(e.data);
+        self.postMessage(result);
+      };
+
+      // main.js
+      const worker = new Worker("worker.js", { type: "module" });
+      worker.postMessage(inputData);
+      worker.onmessage = (e) => updateUI(e.data);
+
+  - id: WASM-BR-005
+    name: Memory Management
+    category: performance
+    description: |
+      Efficient memory sharing between JS and WASM.
+    text: |
+      WASM uses linear memory (ArrayBuffer).
+      Pass large data via shared memory views, not copying.
+      Use wasm-bindgen's Uint8Array conversions for binary data.

package/.agent/skills/cross-cutting/wasm/data/component-model.yaml

@@ -0,0 +1,85 @@
+# WASM Component Model — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: WASM-CM-001
+    name: WIT Interface Definition
+    category: interface
+    description: |
+      WebAssembly Interface Types (WIT) for component interop.
+    example: |
+      // my-component.wit
+      package example:calculator@1.0.0;
+
+      interface operations {
+        add: func(a: f64, b: f64) -> f64;
+        subtract: func(a: f64, b: f64) -> f64;
+        multiply: func(a: f64, b: f64) -> f64;
+        divide: func(a: f64, b: f64) -> result<f64, string>;
+      }
+
+      world calculator {
+        export operations;
+      }
+
+  - id: WASM-CM-002
+    name: Component Composition
+    category: architecture
+    description: |
+      Compose multiple WASM components together.
+    text: |
+      Components can import/export interfaces.
+      Composition creates a linked component graph.
+      Tools: wasm-tools compose, wac (WebAssembly Composition)
+    example: |
+      # Compose two components
+      wasm-tools compose frontend.wasm -d calculator.wasm -o composed.wasm
+
+  - id: WASM-CM-003
+    name: WASI 0.2 Interfaces
+    category: system
+    description: |
+      WebAssembly System Interface standard interfaces.
+    text: |
+      Core interfaces:
+      - wasi:io/streams — I/O streams
+      - wasi:filesystem/types — File system access
+      - wasi:sockets/tcp — TCP networking
+      - wasi:http/incoming-handler — HTTP server handler
+      - wasi:cli/run — CLI program entry point
+      - wasi:random/random — Random number generation
+      - wasi:clocks/wall-clock — System clock access
+
+  - id: WASM-CM-004
+    name: Rust to Component
+    category: toolchain
+    description: |
+      Build Rust code as WASM component.
+    example: |
+      # Cargo.toml
+      [lib]
+      crate-type = ["cdylib"]
+
+      [dependencies]
+      wit-bindgen = "0.25"
+
+      # Build
+      cargo component build --release
+
+  - id: WASM-CM-005
+    name: Resource Types
+    category: interface
+    description: |
+      WIT resource types for handle-based APIs.
+    example: |
+      interface database {
+        resource connection {
+          constructor(url: string);
+          query: func(sql: string) -> list<row>;
+          close: func();
+        }
+        record row {
+          columns: list<string>,
+          values: list<string>,
+        }
+      }

package/.agent/skills/cross-cutting/wasm/data/server-patterns.yaml

@@ -0,0 +1,89 @@
+# Server-side WASM Patterns — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: WASM-SRV-001
+    name: Spin Framework
+    category: serverless
+    description: |
+      Fermyon Spin: serverless WASM microservices.
+    example: |
+      // Rust with Spin SDK
+      use spin_sdk::http::{IntoResponse, Request, Response};
+      use spin_sdk::http_component;
+
+      #[http_component]
+      fn handle_request(req: Request) -> anyhow::Result<impl IntoResponse> {
+        Ok(Response::builder()
+          .status(200)
+          .header("content-type", "application/json")
+          .body(r#"{"message": "Hello from WASM!"}"#)
+          .build())
+      }
+
+      // spin.toml
+      // [[trigger.http]]
+      // route = "/api/hello"
+      // component = "hello"
+
+      // Run: spin build && spin up
+
+  - id: WASM-SRV-002
+    name: wasmCloud
+    category: distributed
+    description: |
+      Distributed WASM platform with capability-based security.
+    text: |
+      Architecture:
+      - Actors: WASM components (business logic)
+      - Capability Providers: Infrastructure (HTTP, KV, messaging)
+      - Lattice: Distributed mesh of wasmCloud hosts
+
+      Benefits: Portable, deny-by-default security, hot-swappable
+
+  - id: WASM-SRV-003
+    name: wasmtime Runtime
+    category: runtime
+    description: |
+      Standalone WASM runtime by Bytecode Alliance.
+    example: |
+      // Embed WASM in Rust application
+      use wasmtime::*;
+
+      let engine = Engine::default();
+      let module = Module::from_file(&engine, "component.wasm")?;
+      let mut store = Store::new(&engine, ());
+      let instance = Instance::new(&mut store, &module, &[])?;
+
+      let add = instance.get_typed_func::<(i32, i32), i32>(&mut store, "add")?;
+      let result = add.call(&mut store, (2, 3))?;
+      assert_eq!(result, 5);
+
+  - id: WASM-SRV-004
+    name: WASM vs Containers
+    category: comparison
+    description: |
+      When to use WASM vs Docker containers.
+    text: |
+      | Feature | WASM | Containers |
+      |---------|------|-----------|
+      | Startup | ~1ms | ~100ms+ |
+      | Size | ~1-10MB | ~50-500MB |
+      | Isolation | Sandbox | Namespace |
+      | Portability | Any arch | Same arch |
+      | Ecosystem | Growing | Mature |
+      | Use case | Edge, plugins | Services |
+
+  - id: WASM-SRV-005
+    name: Plugin System with WASM
+    category: architecture
+    description: |
+      Use WASM for safe, sandboxed plugin execution.
+    text: |
+      Benefits:
+      - Language-agnostic plugins (Rust, Go, Python, JS)
+      - Sandboxed execution (no file/network access by default)
+      - Deterministic (same input → same output)
+      - Fast startup (~1ms)
+
+      Examples: Envoy filters, Shopify Functions, Grafana plugins

package/.agent/skills/cross-cutting/web-perf/META.yaml

@@ -1,5 +1,5 @@
-name: web-perf
-version: "6.2.0"
+name: web-perf
+version: "6.2.2"
 category: support
 tier: 3
 
@@ -14,12 +14,6 @@ patterns:
     cls-optimization: 6
     measurement: 6
 
-hsa:
-  enabled: true
-  adapter: webperf_yaml_adapter.py
-
-triggers:
-  file_patterns:
     - "*.html"
     - "lighthouse.json"
     - "web-vitals.*"
@@ -86,7 +80,7 @@ related_skills:
   - nextjs
   - vue
   - tailwind
-  - ui-ux-pro-max
+  - domyh-design
 
 prevent_confusion_with:
   - testing: "web-perf audits performance, testing verifies correctness"

package/.agent/skills/cross-cutting/web-perf/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: web-perf
 detect: ["lighthouse.json", "web-vitals.*", ".lighthouserc.js"]
-version: "6.1.2"
+version: "6.2.2"
 category: support
 tier: 1
 ---
@@ -156,25 +156,16 @@ medium:
 
 ## 🔌 HSA Integration
 
-This skill is powered by HSA adapter for semantic search across 4 performance domains:
+Data powered by HSA BM25 search engine:
 
-```python
-from .agent.scripts.hsa.adapters import (
-    search_webperf_patterns,
-    get_cwv_thresholds,
-    get_optimization_for,
-    get_framework_config,
-)
+| Domain    | Query Examples                 |
+| --------- | ------------------------------ |
+| CWV       | "LCP optimization preload"     |
+| Network   | "render blocking CSS defer"    |
+| Framework | "Next.js image optimization"   |
+| Audit     | "Lighthouse performance score" |
 
-# Get Core Web Vitals thresholds
-thresholds = get_cwv_thresholds()
-# → {"LCP": {"good": "< 2.5s", "poor": "> 4.0s"}, ...}
-
-# Get optimizations for specific metric
-optimizations = get_optimization_for("LCP")
-```
-
-**Available Functions**: `search_webperf_patterns`, `get_cwv_thresholds`, `get_optimization_for`, `get_framework_config`, `get_audit_checklist`
+**Data domains**: `cwv`, `network`, `framework`, `audit`
 
 ---
 

package/.agent/skills/devops/aws/META.yaml

@@ -1,84 +1,69 @@
 name: aws
-display: AWS Cloud Development
-category: cloud
-priority: 1
-version: "6.2.0"
+version: "6.2.2"
+category: infrastructure
+tier: 3
 
-desc: "AWS serverless, containers, IaC patterns for Lambda, DynamoDB, S3, ECS, CDK, SAM (2025-2026)"
+desc: "AWS cloud services patterns for serverless, containers, and AI/ML. Covers Lambda, S3, ECS, EKS, Bedrock, and SageMaker."
 
-triggers:
-  file_patterns:
+patterns:
+  total: 25
+  domains:
+    compute: 6
+    storage: 5
+    kubernetes: 5
+    ai-ml: 5
+    serverless: 4
+
+    - "*.tf"
     - "serverless.yml"
-    - "serverless.ts"
     - "sam.yaml"
-    - "template.yaml"
-    - "samconfig.toml"
     - "cdk.json"
+    - "template.yaml"
   keywords:
-    # Core services
+    # Services
     - aws
-    - amazon web services
     - lambda
-    - dynamodb
     - s3
-    - api gateway
     - ecs
-    - fargate
-    - rds
-    - aurora
-    - sqs
-    - sns
-    - eventbridge
-    - step functions
-    # IaC
-    - cdk
-    - aws cdk
-    - sam
+    - eks
+    - bedrock
+    - sagemaker
+    - dynamodb
+    - api gateway
+    - cloudfront
+    # Lambda
+    - lambda function
     - serverless
-    - cloudformation
-    - terraform aws
-    # SDK
-    - aws-sdk
-    - boto3
-    - sdk v3
-    # Patterns
-    - event-driven
-    - microservices
-    - fan-out
-    - single-table design
-    # Operations
-    - cloudwatch
-    - x-ray
-    - secrets manager
-    - parameter store
-    - iam
-    - vpc
-    # Cost
-    - graviton
-    - fargate spot
-    - savings plans
-    - cost optimization
+    - event bridge
+    - lambda layer
+    - lambda durable
+    # S3
+    - s3 vectors
+    - s3 tables
+    - s3 metadata
+    - iceberg
+    # ECS/EKS
+    - fargate
+    - ecs managed instances
+    - pod identity
+    - eks capabilities
+    # AI/ML
+    - bedrock
+    - sagemaker
+    - mlflow
+    - model training
   intents:
     - deploy aws
     - create lambda
     - setup s3
     - configure eks
-    - cdk project
-
-caps:
-  - Lambda function patterns (TypeScript/Python)
-  - DynamoDB single-table design
-  - S3 presigned URLs and events
-  - API Gateway REST/HTTP APIs
-  - Event-driven (EventBridge, SQS, SNS, Step Functions)
-  - ECS/Fargate container patterns
-  - CDK infrastructure as code
-  - SAM serverless templates
-  - Security (IAM, Secrets Manager, VPC)
-  - Cost optimization (Graviton, Spot, Savings Plans)
-  - Lambda Powertools observability
+    - train model
 
 related_skills:
-  - typescript
   - docker
+  - kubernetes
+  - ci-cd
   - security
+
+prevent_confusion_with:
+  - kubernetes: "aws covers EKS specifically, kubernetes is general k8s patterns"