@nockdev/awf 6.2.0

package/.agent/skills/languages/javascript/data/modern.yaml

@@ -0,0 +1,269 @@
+# =============================================================================
+# JavaScript Modern Patterns (Feb 2026)
+# Version: ES2025/ES2026
+# =============================================================================
+
+metadata:
+  skill: javascript
+  domain: modern
+  version: "ES2026"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: js201
+    name: ESM Modules
+    category: modules
+    version: "ES2015+"
+    description: |
+      ECMAScript Modules best practices.
+      Named exports, dynamic import, top-level await.
+    text: esm modules import export dynamic import default
+    example: |
+      // ✅ Named exports (preferred)
+      // math.js
+      export function add(a, b) { return a + b; }
+      export function subtract(a, b) { return a - b; }
+      export const PI = 3.14159;
+
+      // ✅ Import named exports
+      import { add, subtract, PI } from './math.js';
+
+      // ✅ Import all as namespace
+      import * as math from './math.js';
+      math.add(1, 2);
+
+      // ✅ Re-export pattern (barrel file)
+      // utils/index.js
+      export { add, subtract } from './math.js';
+      export { formatDate } from './date.js';
+      export { validate } from './validation.js';
+
+      // ✅ Dynamic import (code splitting)
+      async function loadModule() {
+        const { heavyFunction } = await import('./heavy-module.js');
+        return heavyFunction();
+      }
+
+      // ✅ Top-level await (ES2022)
+      // Only in ESM modules
+      const config = await fetch('/config.json').then(r => r.json());
+      const db = await connectDatabase(config.dbUrl);
+
+      export { db, config };
+
+      // ✅ Import assertions (ES2025)
+      import data from './data.json' with { type: 'json' };
+      import styles from './styles.css' with { type: 'css' };
+
+      // ✅ package.json for ESM
+      // {
+      //   "type": "module",
+      //   "exports": {
+      //     ".": "./dist/index.js",
+      //     "./utils": "./dist/utils.js"
+      //   }
+      // }
+    severity: HIGH
+    docs_url: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules
+
+  - id: js202
+    name: Decorators (ES2025)
+    category: metaprogramming
+    version: "ES2025"
+    description: |
+      Native JavaScript decorators.
+      Class, method, field, accessor decorators.
+    text: decorator class method field accessor metadata
+    example: |
+      // ✅ Method decorator
+      function logged(originalMethod, context) {
+        const methodName = context.name;
+        
+        return function (...args) {
+          console.log(`Calling ${methodName} with`, args);
+          const result = originalMethod.call(this, ...args);
+          console.log(`${methodName} returned`, result);
+          return result;
+        };
+      }
+
+      class Calculator {
+        @logged
+        add(a, b) {
+          return a + b;
+        }
+      }
+
+      // ✅ Class decorator
+      function sealed(target, context) {
+        Object.seal(target);
+        Object.seal(target.prototype);
+      }
+
+      @sealed
+      class User {
+        name = '';
+      }
+
+      // ✅ Field decorator
+      function readonly(_, context) {
+        return function (initialValue) {
+          return {
+            get() { return initialValue; },
+            set() { throw new Error(`${context.name} is readonly`); }
+          };
+        };
+      }
+
+      class Config {
+        @readonly
+        version = '1.0.0';
+      }
+
+      // ✅ Accessor decorator
+      function validate(validator) {
+        return function (accessor, context) {
+          return {
+            get() {
+              return accessor.get.call(this);
+            },
+            set(value) {
+              if (!validator(value)) {
+                throw new Error(`Invalid value for ${context.name}`);
+              }
+              accessor.set.call(this, value);
+            }
+          };
+        };
+      }
+
+      class Form {
+        @validate(v => v.length > 0)
+        accessor name = '';
+        
+        @validate(v => v.includes('@'))
+        accessor email = '';
+      }
+    severity: MEDIUM
+    docs_url: https://github.com/tc39/proposal-decorators
+
+  - id: js203
+    name: Temporal API
+    category: datetime
+    version: "ES2026 (Stage 3)"
+    description: |
+      Modern date/time API replacing Date.
+      Immutable, time zone aware, precise.
+    text: temporal date time duration timezone instant
+    example: |
+      // ✅ Temporal.Now - Current time
+      const now = Temporal.Now.instant();
+      const today = Temporal.Now.plainDateISO();
+      const currentTime = Temporal.Now.plainTimeISO();
+      const zonedNow = Temporal.Now.zonedDateTimeISO('America/New_York');
+
+      // ✅ PlainDate - Date without time/timezone
+      const date = Temporal.PlainDate.from('2026-02-05');
+      const nextWeek = date.add({ days: 7 });
+      const diff = nextWeek.since(date); // P7D
+
+      // ✅ PlainTime - Time without date/timezone
+      const time = Temporal.PlainTime.from('14:30:00');
+      const later = time.add({ hours: 2, minutes: 30 }); // 17:00:00
+
+      // ✅ ZonedDateTime - Full datetime with timezone
+      const meeting = Temporal.ZonedDateTime.from({
+        year: 2026,
+        month: 2,
+        day: 5,
+        hour: 14,
+        timeZone: 'America/New_York'
+      });
+
+      // Convert timezone
+      const inTokyo = meeting.withTimeZone('Asia/Tokyo');
+
+      // ✅ Duration - Time periods
+      const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });
+      const totalMinutes = duration.total('minutes'); // 150
+
+      // ✅ Comparison (immutable operations)
+      if (Temporal.PlainDate.compare(date1, date2) > 0) {
+        console.log('date1 is after date2');
+      }
+
+      // ✅ Formatting
+      const formatted = date.toLocaleString('en-US', {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric'
+      });
+
+      // ✅ Parsing with validation
+      try {
+        const parsed = Temporal.PlainDate.from('2026-02-30'); // Throws!
+      } catch (e) {
+        console.log('Invalid date');
+      }
+    severity: MEDIUM
+    docs_url: https://tc39.es/proposal-temporal/docs/
+
+  - id: js204
+    name: Record and Tuple (Stage 2)
+    category: data-structures
+    version: "Future (Stage 2)"
+    description: |
+      Immutable primitive data structures.
+      Deep equality by value, hashable.
+    text: record tuple immutable primitive value equality
+    example: |
+      // ✅ Record - immutable object-like
+      // Note: Stage 2 proposal, syntax may change
+      const point = #{ x: 1, y: 2 };
+      const point2 = #{ x: 1, y: 2 };
+
+      // Value equality
+      console.log(point === point2); // true (unlike objects)
+
+      // Immutable - creates new record
+      const moved = #{ ...point, x: point.x + 1 }; // #{ x: 2, y: 2 }
+
+      // ✅ Tuple - immutable array-like
+      const coords = #[1, 2, 3];
+      const coords2 = #[1, 2, 3];
+
+      console.log(coords === coords2); // true
+
+      // Immutable operations
+      const extended = #[...coords, 4]; // #[1, 2, 3, 4]
+
+      // ✅ Nested records and tuples
+      const user = #{
+        name: 'Alice',
+        tags: #['admin', 'active'],
+        address: #{ city: 'NYC', zip: '10001' }
+      };
+
+      // ✅ Use as Map/Set keys (value equality)
+      const cache = new Map();
+      cache.set(#{ x: 1, y: 2 }, 'result');
+      cache.get(#{ x: 1, y: 2 }); // 'result' (works! unlike objects)
+
+      // ✅ Pattern matching (future)
+      // Works well with pattern matching proposal
+      function process(data) {
+        switch (data) {
+          case #{ type: 'point', x: _, y: _ }:
+            return 'It's a point';
+          case #{ type: 'circle', r: _ }:
+            return 'It's a circle';
+        }
+      }
+
+      // ✅ Current workaround with Object.freeze
+      const immutable = Object.freeze({ x: 1, y: 2 });
+      // But no value equality: {} !== {}
+    severity: LOW
+    docs_url: https://github.com/tc39/proposal-record-tuple

package/.agent/skills/languages/julia/META.yaml

@@ -0,0 +1,13 @@
+name: julia
+version: "6.2.0"
+category: scientific
+tier: 3
+
+domains:
+  core: 5
+
+desc: "Julia development patterns for Julia 1.10+. Covers scientific computing, ML, data analysis, high performance."
+
+related_skills:
+  - python
+  - r

package/.agent/skills/languages/julia/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: julia
+detect: ["*.jl", "Project.toml", "Manifest.toml"]
+version: "6.1.2"
+category: scientific
+tier: 2
+---
+
+# Julia Patterns — DOMYH Awesome Code
+
+> **Version**: Julia 1.10+ (2025-2026)
+> **Focus**: Scientific computing, ML, high performance
+> **Philosophy**: Fast as C, easy as Python
+
+---
+
+## 🎯 When to Use This Skill
+
+Use for: Numerical computing, ML, simulations, scientific research.
+**NOT for**: Web apps (→ python/go), mobile (→ flutter).
+
+---
+
+## 📦 Why Julia?
+
+| Feature | Julia      | Python  | R       |
+| ------- | ---------- | ------- | ------- |
+| Speed   | C-like 🏆  | Slow    | Slow    |
+| Syntax  | Easy 🏆    | Easy    | Easy    |
+| ML      | Flux/MLJ   | PyTorch | Limited |
+| Interop | Python/C/R | C       | C       |
+
+---
+
+## 🔧 Project Setup
+
+```julia
+# Create project
+julia> ] generate MyProject
+julia> cd MyProject
+julia> ] activate .
+
+# Add packages
+julia> ] add DataFrames, Plots, Flux
+```
+
+### Project Structure
+
+```
+MyProject/
+├── Project.toml
+├── Manifest.toml
+├── src/
+│   └── MyProject.jl
+└── test/
+    └── runtests.jl
+```
+
+---
+
+## 🔄 Core Patterns
+
+### Multiple Dispatch
+
+```julia
+# ✅ Define methods for different types
+function process(x::Int)
+    println("Integer: $x")
+end
+
+function process(x::Float64)
+    println("Float: $x")
+end
+
+function process(x::String)
+    println("String: $x")
+end
+
+# ✅ Custom types
+struct User
+    name::String
+    age::Int
+end
+
+function greet(u::User)
+    println("Hello, $(u.name)!")
+end
+```
+
+### Broadcasting
+
+```julia
+# ✅ Dot syntax for element-wise
+a = [1, 2, 3]
+b = [4, 5, 6]
+
+c = a .+ b        # [5, 7, 9]
+d = sin.(a)       # Apply sin to each
+e = a .^ 2        # Square each
+
+# ✅ Custom function broadcasting
+double(x) = x * 2
+double.(a)        # [2, 4, 6]
+```
+
+---
+
+## 📊 DataFrames
+
+```julia
+using DataFrames, CSV
+
+# ✅ Create DataFrame
+df = DataFrame(
+    name = ["Alice", "Bob", "Carol"],
+    age = [25, 30, 35],
+    salary = [50000, 60000, 70000]
+)
+
+# ✅ Filter and transform
+result = df |>
+    x -> filter(row -> row.age > 25, x) |>
+    x -> select(x, :name, :salary) |>
+    x -> transform(x, :salary => (s -> s .* 1.1) => :new_salary)
+
+# ✅ Group and aggregate
+grouped = combine(
+    groupby(df, :age),
+    :salary => mean => :avg_salary,
+    nrow => :count
+)
+```
+
+---
+
+## 🤖 ML with Flux
+
+```julia
+using Flux
+
+# ✅ Define model
+model = Chain(
+    Dense(784, 128, relu),
+    Dropout(0.2),
+    Dense(128, 64, relu),
+    Dense(64, 10),
+    softmax
+)
+
+# ✅ Loss and optimizer
+loss(x, y) = Flux.crossentropy(model(x), y)
+opt = Adam(0.001)
+
+# ✅ Training loop
+for epoch in 1:10
+    for (x, y) in train_loader
+        gs = gradient(() -> loss(x, y), params(model))
+        Flux.update!(opt, params(model), gs)
+    end
+end
+```
+
+---
+
+## ✅ Production Checklist
+
+- [ ] Type annotations for performance
+- [ ] Tests with `@testset`
+- [ ] JuliaFormatter applied
+- [ ] Package documented
+
+---
+
+_DOMYH Awesome Code • Julia 1.10+_