@nockdev/awf 6.2.0 → 6.2.2

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

@@ -7,7 +7,7 @@ detect:
     "@tailwind",
     '@import "tailwindcss"',
   ]
-version: "6.1.2"
+version: "6.2.2"
 category: styling
 tier: 1
 ---
@@ -326,18 +326,20 @@ Use for: Utility-first CSS, rapid UI development, design systems.
 
 ## 🔌 HSA Integration
 
-```python
-from .agent.scripts.hsa.adapters import (
-    search_tailwind_patterns,
-    get_tailwind_utility,
-)
+Data files available in `data/` directory (indexed by HSA engine):
 
-# Search patterns
-results = search_tailwind_patterns("text shadow glow")
+| File              | Content                            |
+| ----------------- | ---------------------------------- |
+| `config.yaml`     | CSS-first @theme configuration     |
+| `utilities.yaml`  | Utility class patterns             |
+| `variants.yaml`   | New v4 variants (not-\*, starting) |
+| `responsive.yaml` | Breakpoints, container queries     |
+| `states.yaml`     | Hover, focus, active patterns      |
+| `theme.yaml`      | Design token structure             |
+| `build.yaml`      | Build optimization, @source        |
+| `migration.yaml`  | v3 → v4 migration guide            |
 
-# Get utility info
-util = get_tailwind_utility("mask-linear-to-b")
-```
+Agent reads these YAML files directly for pattern lookup.
 
 ---
 

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

@@ -0,0 +1,75 @@
+name: tauri
+version: "1.0.0"
+display: Tauri Desktop & Mobile
+category: cross-cutting
+tier: 1
+priority: 5
+
+desc: "Tauri 2.0 desktop & mobile app development. Rust core, system WebView, capability-based security, IPC bridge, plugin system, and cross-platform bundling."
+
+  ### Data Files (3 domains, ~21 patterns)
+  - security.yaml: capability permissions, IPC safety, CSP (7)
+  - plugins.yaml: official + custom plugin patterns (7)
+  - build.yaml: bundler config, cross-compilation, CI/CD (7)
+
+triggers:
+  file_patterns:
+    - "tauri.conf.json"
+    - "tauri.conf.json5"
+    - "Cargo.toml"
+    - "src-tauri/**"
+    - "src-tauri/src/main.rs"
+    - "src-tauri/src/lib.rs"
+    - "capabilities/*.json"
+    - "src-tauri/capabilities/**"
+  keywords:
+    - tauri
+    - tauri app
+    - tauri 2
+    - tauri 2.0
+    - tauri desktop
+    - tauri mobile
+    - invoke command
+    - IPC bridge
+    - system webview
+    - capability permissions
+    - tauri plugin
+    - tauri-cli
+    - src-tauri
+    - webview window
+    - "@tauri-apps/api"
+    - "@tauri-apps/cli"
+
+caps:
+  # Architecture
+  - Tauri 2.0 architecture (Rust core + system WebView frontend)
+  - IPC bridge (invoke/listen/emit between JS ↔ Rust)
+  - Multi-window management
+  - Tray icons & system integration
+  # Security
+  - Capability-based security model (fine-grained permissions)
+  - Content Security Policy (CSP) for WebView
+  - No direct Node.js access (secure by default)
+  # Plugins
+  - Official plugins (fs, shell, http, dialog, notification, clipboard)
+  - Custom Rust plugin development
+  # Cross-platform
+  - Desktop: Windows (WebView2), macOS (WebKit), Linux (WebKitGTK)
+  - Mobile: iOS + Android (Tauri 2.0)
+  # Build & Distribution
+  - tauri-cli bundler (MSI, DMG, AppImage, DEB, Android APK, iOS IPA)
+  - Auto-updater integration
+  - Code signing (Windows, macOS)
+  - CI/CD build matrix
+
+related_skills:
+  - electron
+  - rust
+  - react
+  - vue
+  - svelte
+
+hsa_adapter:
+  enabled: true
+  data_dir: "skills/cross-cutting/tauri/data"
+  preload_data: true

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

@@ -0,0 +1,127 @@
+# Tauri 2.0 — Desktop & Mobile Apps
+
+> Rust core • System WebView • Capability-based Security  
+> Cross-platform: Windows, macOS, Linux, iOS, Android
+
+---
+
+## Khi Nào Dùng
+
+- Build desktop app với frontend framework (React/Vue/Svelte/Solid)
+- Cần app size nhỏ (~3-10MB vs Electron ~150MB+)
+- Cần security mạnh (capability-based, no Node.js)
+- Cần support cả mobile (iOS/Android) via Tauri 2.0
+
+## Tauri vs Electron
+
+| Feature         | Tauri 2.0                | Electron         |
+| --------------- | ------------------------ | ---------------- |
+| **Bundle size** | ~3-10MB                  | ~150-300MB       |
+| **Memory**      | ~30-80MB                 | ~100-400MB       |
+| **Backend**     | Rust                     | Node.js          |
+| **WebView**     | System (WebView2/WebKit) | Bundled Chromium |
+| **Security**    | Capability-based         | Manual CSP       |
+| **Mobile**      | ✅ iOS + Android         | ❌ Desktop only  |
+| **Maturity**    | Growing (2.0)            | Mature           |
+
+## Architecture
+
+```
+┌──────────────────────────────────────┐
+│         Frontend (WebView)           │
+│    React / Vue / Svelte / Solid      │
+│         @tauri-apps/api              │
+└───────────┬──────────────────────────┘
+            │ IPC (invoke/listen/emit)
+┌───────────▼──────────────────────────┐
+│         Rust Core (src-tauri/)       │
+│    Commands • Plugins • State        │
+│    File System • Shell • HTTP        │
+└──────────────────────────────────────┘
+```
+
+## Core Patterns
+
+### IPC: Frontend ↔ Rust
+
+```typescript
+// Frontend: invoke Rust command
+import { invoke } from "@tauri-apps/api/core";
+const result = await invoke("greet", { name: "World" });
+
+// Frontend: listen to events
+import { listen } from "@tauri-apps/api/event";
+await listen("file-changed", (event) => console.log(event.payload));
+```
+
+```rust
+// Rust: define command
+#[tauri::command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+// Rust: emit event
+app.emit("file-changed", payload)?;
+
+fn main() {
+    tauri::Builder::default()
+        .invoke_handler(tauri::generate_handler![greet])
+        .run(tauri::generate_context!())
+        .expect("error running tauri app");
+}
+```
+
+### Capability-based Security
+
+```json
+// src-tauri/capabilities/main.json
+{
+  "identifier": "main-capability",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "fs:allow-read-text-file",
+    "dialog:allow-open"
+  ]
+}
+```
+
+**Rules**:
+
+- ✅ Grant minimal permissions per window
+- ✅ Use scoped access (specific directories)
+- ❌ Never use `fs:default` (grants all fs access)
+
+### Plugins
+
+```rust
+// Using official plugin
+tauri::Builder::default()
+    .plugin(tauri_plugin_fs::init())
+    .plugin(tauri_plugin_dialog::init())
+    .plugin(tauri_plugin_shell::init())
+```
+
+| Plugin         | Purpose              |
+| -------------- | -------------------- |
+| `fs`           | File system access   |
+| `dialog`       | Open/save dialogs    |
+| `shell`        | Run system commands  |
+| `http`         | HTTP requests        |
+| `notification` | System notifications |
+| `clipboard`    | Clipboard access     |
+| `updater`      | Auto-updates         |
+
+## Common Traps
+
+| Trap                | Fix                                                  |
+| ------------------- | ---------------------------------------------------- |
+| WebView differences | Test on all platforms (WebView2, WebKit)             |
+| Large binary        | Use `cargo build --release`, strip debug symbols     |
+| IPC serialization   | Use `serde` correctly, avoid large payloads          |
+| Permissions denied  | Check capabilities/\*.json, add required permissions |
+
+---
+
+_DOMYH Awesome Code • Tauri Skill v1.0.0_

package/.agent/skills/cross-cutting/tauri/data/build.yaml

@@ -0,0 +1,141 @@
+# Tauri Build & Distribution — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: TAURI-BLD-001
+    name: Project Configuration
+    category: config
+    description: tauri.conf.json core configuration.
+    example: |
+      {
+        "productName": "My App",
+        "version": "1.0.0",
+        "identifier": "com.mycompany.myapp",
+        "build": { "frontendDist": "../dist" },
+        "app": {
+          "windows": [
+            { "title": "My App", "width": 1200, "height": 800,
+              "resizable": true, "fullscreen": false }
+          ],
+          "security": {
+            "csp": "default-src 'self'; script-src 'self'"
+          }
+        },
+        "bundle": {
+          "active": true,
+          "targets": "all",
+          "icon": ["icons/32x32.png", "icons/128x128.png", "icons/icon.icns"]
+        }
+      }
+
+  - id: TAURI-BLD-002
+    name: Bundle Targets
+    category: distribution
+    description: |
+      Platform-specific bundle formats.
+    text: |
+      | Platform | Format | Notes |
+      |----------|--------|-------|
+      | Windows | MSI, NSIS | MSI for enterprise, NSIS for consumer |
+      | macOS | DMG, App Bundle | Requires code signing for notarization |
+      | Linux | AppImage, DEB, RPM | AppImage for universal, DEB for Debian |
+      | iOS | IPA | Requires Xcode + Apple Developer |
+      | Android | APK, AAB | Requires Android Studio + SDK |
+
+  - id: TAURI-BLD-003
+    name: Code Signing
+    category: distribution
+    description: |
+      Platform-specific code signing for distribution.
+    text: |
+      Windows: EV code signing certificate (avoid SmartScreen warnings)
+      macOS: Apple Developer certificate + notarization
+
+      Env variables:
+      TAURI_SIGNING_PRIVATE_KEY — For updater signatures
+      APPLE_SIGNING_IDENTITY — macOS code signing
+      APPLE_ID — For notarization
+
+  - id: TAURI-BLD-004
+    name: CI/CD Build Matrix
+    category: ci-cd
+    description: |
+      GitHub Actions build matrix for all platforms.
+    example: |
+      # .github/workflows/release.yml
+      jobs:
+        release:
+          strategy:
+            matrix:
+              include:
+                - platform: ubuntu-22.04
+                  args: ""
+                - platform: windows-latest
+                  args: ""
+                - platform: macos-latest
+                  args: "--target aarch64-apple-darwin"
+                - platform: macos-latest
+                  args: "--target x86_64-apple-darwin"
+          runs-on: ${{ matrix.platform }}
+          steps:
+            - uses: actions/checkout@v4
+            - uses: dtolnay/rust-toolchain@stable
+            - uses: tauri-apps/tauri-action@v0
+              with:
+                tagName: v__VERSION__
+                releaseName: "v__VERSION__"
+                args: ${{ matrix.args }}
+
+  - id: TAURI-BLD-005
+    name: Auto-updater Setup
+    category: distribution
+    description: |
+      Configure Tauri auto-updater.
+    text: |
+      1. Generate signing keys: cargo tauri signer generate
+      2. Configure update endpoints in tauri.conf.json
+      3. Host update manifest (JSON) at endpoint
+      4. Updater checks version on app start
+    example: |
+      // Update manifest (hosted at endpoint)
+      {
+        "version": "1.1.0",
+        "notes": "Bug fixes and improvements",
+        "pub_date": "2026-02-12T00:00:00Z",
+        "platforms": {
+          "windows-x86_64": {
+            "signature": "...",
+            "url": "https://releases.myapp.com/v1.1.0/myapp_1.1.0_x64-setup.nsis.zip"
+          }
+        }
+      }
+
+  - id: TAURI-BLD-006
+    name: Development Workflow
+    category: development
+    description: |
+      Tauri development commands.
+    text: |
+      cargo tauri dev       — Run in development mode (hot reload)
+      cargo tauri build     — Build production bundle
+      cargo tauri icon      — Generate icons from source image
+      cargo tauri signer    — Generate update signing keys
+      cargo tauri info      — Show environment info
+      cargo tauri init      — Initialize Tauri in existing project
+
+  - id: TAURI-BLD-007
+    name: Optimization
+    category: performance
+    description: |
+      Reduce binary size and improve performance.
+    text: |
+      Cargo.toml:
+      [profile.release]
+      panic = "abort"
+      codegen-units = 1
+      lto = true
+      strip = true
+      opt-level = "s"
+
+      Results: ~3-10MB binary (vs Electron ~150MB+)
+      Additional: Use UPX compression for further reduction

package/.agent/skills/cross-cutting/tauri/data/plugins.yaml

@@ -0,0 +1,157 @@
+# Tauri Plugin Patterns — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: TAURI-PLG-001
+    name: Official Plugins
+    category: plugins
+    description: |
+      Tauri 2.0 official plugin ecosystem.
+    text: |
+      | Plugin | Crate | Purpose |
+      |--------|-------|---------|
+      | fs | tauri-plugin-fs | File system read/write |
+      | dialog | tauri-plugin-dialog | Open/save dialogs |
+      | shell | tauri-plugin-shell | Run system commands |
+      | http | tauri-plugin-http | HTTP requests |
+      | notification | tauri-plugin-notification | System notifications |
+      | clipboard | tauri-plugin-clipboard-manager | Clipboard access |
+      | updater | tauri-plugin-updater | Auto-updates |
+      | store | tauri-plugin-store | Key-value storage |
+      | sql | tauri-plugin-sql | SQLite/MySQL/PostgreSQL |
+      | log | tauri-plugin-log | Structured logging |
+      | process | tauri-plugin-process | Process management |
+      | os | tauri-plugin-os | OS information |
+    example: |
+      // Cargo.toml
+      [dependencies]
+      tauri-plugin-fs = "2"
+      tauri-plugin-dialog = "2"
+
+      // main.rs
+      tauri::Builder::default()
+        .plugin(tauri_plugin_fs::init())
+        .plugin(tauri_plugin_dialog::init())
+        .run(tauri::generate_context!())
+        .expect("error");
+
+  - id: TAURI-PLG-002
+    name: Custom Plugin Development
+    category: plugins
+    description: |
+      Create custom Tauri plugins.
+    text: |
+      Plugin structure:
+      1. Define commands in Rust
+      2. Create TypeScript API bindings
+      3. Register with Builder::plugin()
+    example: |
+      // Rust plugin
+      use tauri::plugin::{Builder, TauriPlugin};
+      use tauri::Runtime;
+
+      #[tauri::command]
+      fn my_command(input: String) -> Result<String, String> {
+        Ok(format!("Processed: {}", input))
+      }
+
+      pub fn init<R: Runtime>() -> TauriPlugin<R> {
+        Builder::new("my-plugin")
+          .invoke_handler(tauri::generate_handler![my_command])
+          .build()
+      }
+
+  - id: TAURI-PLG-003
+    name: Plugin State Management
+    category: plugins
+    description: |
+      Share state between plugin commands.
+    text: |
+      Use tauri::State<T> to inject managed state.
+      State must be Send + Sync + 'static.
+    example: |
+      use std::sync::Mutex;
+      struct AppState { counter: Mutex<i32> }
+
+      #[tauri::command]
+      fn increment(state: tauri::State<AppState>) -> i32 {
+        let mut counter = state.counter.lock().unwrap();
+        *counter += 1;
+        *counter
+      }
+
+      tauri::Builder::default()
+        .manage(AppState { counter: Mutex::new(0) })
+
+  - id: TAURI-PLG-004
+    name: Frontend Plugin API
+    category: plugins
+    description: |
+      TypeScript bindings for plugin commands.
+    example: |
+      // @tauri-apps/api usage
+      import { invoke } from "@tauri-apps/api/core";
+
+      // Plugin namespace
+      import { open } from "@tauri-apps/plugin-dialog";
+      import { readTextFile } from "@tauri-apps/plugin-fs";
+
+      const file = await open({ filters: [{ name: "Text", extensions: ["txt"] }] });
+      if (file) {
+        const content = await readTextFile(file.path);
+      }
+
+  - id: TAURI-PLG-005
+    name: Event System
+    category: communication
+    description: |
+      Emit and listen events between frontend and Rust.
+    text: |
+      Types:
+      - Global events: app-wide
+      - Window events: per-window
+      - Webview events: per-webview
+    example: |
+      // Rust → Frontend
+      app.emit("download-progress", ProgressPayload { percent: 50 })?;
+
+      // Frontend → Rust  
+      import { emit, listen } from "@tauri-apps/api/event";
+      const unlisten = await listen("download-progress", (event) => {
+        console.log(`Progress: ${event.payload.percent}%`);
+      });
+
+  - id: TAURI-PLG-006
+    name: Tray Icon Plugin
+    category: system
+    description: |
+      System tray icon with menu.
+    example: |
+      use tauri::tray::{TrayIconBuilder, MouseButton, MouseButtonState};
+
+      TrayIconBuilder::new()
+        .icon(app.default_window_icon().unwrap().clone())
+        .menu(&menu)
+        .on_menu_event(|app, event| {
+          match event.id.as_ref() {
+            "quit" => app.exit(0),
+            "show" => { /* show window */ },
+            _ => {}
+          }
+        })
+        .build(app)?;
+
+  - id: TAURI-PLG-007
+    name: Multi-window Plugin
+    category: system
+    description: |
+      Create and manage multiple windows.
+    example: |
+      // Create new window from Rust
+      let _new_window = tauri::WebviewWindowBuilder::new(
+        app, "settings",
+        tauri::WebviewUrl::App("settings.html".into())
+      )
+      .title("Settings")
+      .inner_size(600.0, 400.0)
+      .build()?;

package/.agent/skills/cross-cutting/tauri/data/security.yaml

@@ -0,0 +1,134 @@
+# Tauri Security Patterns — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: TAURI-SEC-001
+    name: Capability-based Permissions
+    category: security
+    description: |
+      Tauri 2.0 uses capability-based security model.
+      Each window gets explicit permissions via capabilities/*.json.
+    text: |
+      Principles:
+      - Default deny: no permissions unless explicitly granted
+      - Per-window: different windows can have different permissions
+      - Scoped: restrict to specific directories/URLs
+      - Auditable: all permissions in JSON files
+    example: |
+      // src-tauri/capabilities/main.json
+      {
+        "identifier": "main-window",
+        "description": "Main window permissions",
+        "windows": ["main"],
+        "permissions": [
+          "core:default",
+          "fs:allow-read-text-file",
+          "fs:allow-write-text-file",
+          { "identifier": "fs:scope",
+            "allow": [{ "path": "$APPDATA/**" }] },
+          "dialog:allow-open",
+          "dialog:allow-save",
+          "shell:allow-open"
+        ]
+      }
+
+  - id: TAURI-SEC-002
+    name: Content Security Policy
+    category: security
+    description: CSP configuration for WebView.
+    text: |
+      Default CSP (tauri.conf.json):
+      "security": {
+        "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'"
+      }
+      Rules:
+      - Never use 'unsafe-eval' in production
+      - Whitelist specific CDN domains if needed
+      - Use nonces for inline scripts when required
+
+  - id: TAURI-SEC-003
+    name: IPC Safety
+    category: security
+    description: |
+      Secure IPC communication between frontend and Rust.
+    text: |
+      Best practices:
+      - Validate all input in Rust commands (never trust frontend)
+      - Use typed parameters with serde deserialization
+      - Return Result<T, E> to handle errors properly
+      - Never expose raw file paths from frontend
+    example: |
+      #[tauri::command]
+      fn read_config(path: &str) -> Result<String, String> {
+        // Validate path is within allowed scope
+        let canonical = std::fs::canonicalize(path)
+          .map_err(|e| e.to_string())?;
+        if !canonical.starts_with(app_data_dir()) {
+          return Err("Access denied: path outside allowed scope".into());
+        }
+        std::fs::read_to_string(canonical).map_err(|e| e.to_string())
+      }
+
+  - id: TAURI-SEC-004
+    name: Scoped File Access
+    category: security
+    description: |
+      Restrict file system access to specific directories.
+    text: |
+      Scope variables:
+      $APPDATA — App-specific data directory
+      $APPCONFIG — App config directory
+      $DESKTOP — User desktop
+      $DOCUMENT — User documents
+      $HOME — User home directory
+    example: |
+      // Only allow reading from app data
+      { "identifier": "fs:scope",
+        "allow": [
+          { "path": "$APPDATA/**" },
+          { "path": "$DOCUMENT/*.md" }
+        ],
+        "deny": [
+          { "path": "$HOME/.ssh/**" }
+        ]
+      }
+
+  - id: TAURI-SEC-005
+    name: Update Security
+    category: security
+    description: |
+      Secure auto-update with signature verification.
+    text: |
+      Tauri updater verifies Ed25519 signatures.
+      Configure update endpoints with HTTPS only.
+      Use tauri-cli signer to generate key pairs.
+    example: |
+      // tauri.conf.json
+      "plugins": {
+        "updater": {
+          "endpoints": ["https://releases.myapp.com/{{target}}/{{arch}}/{{current_version}}"],
+          "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ..."
+        }
+      }
+
+  - id: TAURI-SEC-006
+    name: Window-level Isolation
+    category: security
+    description: |
+      Different windows can have different permission sets.
+    text: |
+      Use case: Settings window needs more permissions than main window.
+      Create separate capability files per window.
+
+  - id: TAURI-SEC-007
+    name: No Node.js Advantage
+    category: security
+    description: |
+      Unlike Electron, Tauri has no Node.js in renderer.
+    text: |
+      Security advantages:
+      - No require() or import of Node.js modules in frontend
+      - No child_process access from frontend
+      - No fs module directly accessible
+      - All system access must go through IPC → Rust commands
+      - Prevents supply chain attacks via npm in renderer