@nockdev/awf 6.2.0 → 6.2.1

package/.agent/skills/ai-ml/ai-agents/data/agent-rules.yaml

@@ -0,0 +1,120 @@
+# Agent Rules Systems - HSA AI Agents Skill
+# Updated: 2026-02-12
+
+metadata:
+  skill: ai-agents
+  domain: agent-rules
+  version: "1.0.0"
+  updated: "2026-02-12"
+  patterns_count: 8
+
+patterns:
+  - id: rules001
+    name: cursor_rules
+    category: rules
+    description: Cursor IDE rule system (3-level hierarchy)
+    text: cursor rules mdc global project dynamic file scope
+    hierarchy:
+      global: "Cursor Settings → Rules for AI (plain text, all projects)"
+      project: ".cursor/index.mdc (project overview, tech stack)"
+      dynamic: ".cursor/rules/*.mdc (glob-scoped, activate on context)"
+    example: |
+      ---
+      description: React component guidelines
+      globs: ["src/components/**/*.tsx"]
+      ---
+      - Use functional components with TypeScript
+      - Use React.memo for expensive renders
+    best_practices:
+      - "Keep under 500 lines per rule file"
+      - "Use descriptive names for .mdc files"
+      - "Reference files instead of copying content"
+
+  - id: rules002
+    name: cline_rules
+    category: rules
+    description: Cline Rules for persistent coding standards
+    text: cline rules clinerules folder markdown project workspace
+    locations:
+      folder: ".clinerules/*.md (multiple files)"
+      file: ".clinerules (single file)"
+      agents: "AGENTS.md (alternative)"
+    scope: "Workspace rules override global rules"
+    content_types:
+      - "Code standards (formatting, naming)"
+      - "Documentation requirements"
+      - "Architectural decisions"
+      - "Technology constraints (required/banned)"
+
+  - id: rules003
+    name: codex_agents_md
+    category: rules
+    description: OpenAI Codex AGENTS.md configuration
+    text: codex agents md configuration testing commands code style
+    example: |
+      # AGENTS.md
+      ## Testing
+      Run `npm test` to verify changes.
+      ## Code Style
+      - Use TypeScript strict mode
+      - Follow existing patterns
+      ## Structure
+      - Components in src/components/
+      - API routes in src/api/
+
+  - id: rules004
+    name: domyh_skill_system
+    category: rules
+    description: DOMYH hierarchical skill system (META→SKILL→data)
+    text: domyh skill system meta yaml skill md data progressive disclosure
+    hierarchy:
+      T1_META: "~100 tokens — triggers, keywords, caps (always loaded)"
+      T2_SKILL: "~1500 tokens — patterns, examples, traps (on-demand)"
+      T3_DATA: "YAML domain files (HSA adapter, reference only)"
+
+  - id: rules005
+    name: rule_design_principles
+    category: best-practices
+    description: Best practices for designing agent rules
+    text: rule design principles concise specific scoped layered
+    principles:
+      concise: "Under 500 lines per rule file"
+      specific: "Show patterns and examples, not just principles"
+      scoped: "Use glob patterns for context-specific activation"
+      layered: "Global → Project → File-specific (override order)"
+      outcome_focused: "Describe desired outcomes, not just constraints"
+      conditional: "Use if/when conditions for context-dependent rules"
+
+  - id: rules006
+    name: rule_content_types
+    category: best-practices
+    description: Common content types for agent rules
+    text: rule content types standards conventions patterns frameworks
+    types:
+      - "Code standards: formatting, naming, imports"
+      - "Architecture: patterns, module boundaries, dependencies"
+      - "Security: banned APIs, input validation requirements"
+      - "Testing: coverage thresholds, test patterns"
+      - "Documentation: comment style, README template"
+      - "Git: commit message format, branch naming"
+
+  - id: rules007
+    name: vercel_agent_skills
+    category: reference
+    description: Vercel agent-skills open standard (Anthropic 2025)
+    text: vercel agent skills open standard anthropic markdown code
+    note: "Anthropic open-sourced agent skills in late 2025"
+    format: "Markdown + optional code snippets"
+    example: "Skills packaged as npm modules with domain knowledge"
+
+  - id: rules008
+    name: rule_anti_patterns
+    category: best-practices
+    description: Common anti-patterns in agent rules
+    text: anti-patterns rules mistakes avoid
+    anti_patterns:
+      - "Too generic: 'Write good code' → Be specific"
+      - "Too long: 1000+ line rule files → Split into focused files"
+      - "Stale references: Copying file contents → Reference files instead"
+      - "Contradictory: Conflicting rules → Clear priority/override order"
+      - "Missing context: No examples → Always include code examples"

package/.agent/skills/ai-ml/ai-agents/data/llm-integration.yaml

@@ -0,0 +1,129 @@
+# LLM Integration Patterns - HSA AI Agents Skill
+# Updated: 2026-02-12
+
+metadata:
+  skill: ai-agents
+  domain: llm-integration
+  version: "1.0.0"
+  updated: "2026-02-12"
+  patterns_count: 8
+
+patterns:
+  - id: llm001
+    name: multi_provider
+    category: integration
+    description: Provider-agnostic LLM interface
+    text: multi provider openai anthropic gemini abstraction unified
+    example: |
+      // Unified interface
+      const llm = createLLM({ provider: "openai", model: "gpt-4o" });
+      const result = await llm.chat([{ role: "user", content: "Hello" }]);
+
+  - id: llm002
+    name: function_calling
+    category: integration
+    description: Tool/function calling across LLM providers
+    text: function calling tool use openai anthropic gemini tools
+    example: |
+      // OpenAI format (widely adopted)
+      const tools = [{ type: "function", function: {
+        name: "search", description: "Search the web",
+        parameters: { type: "object", properties: { query: { type: "string" } } }
+      }}];
+      const response = await openai.chat.completions.create({ model, messages, tools });
+
+  - id: llm003
+    name: structured_output
+    category: integration
+    description: Force LLM to output structured JSON
+    text: structured output json schema pydantic response format
+    example: |
+      // OpenAI JSON mode
+      { response_format: { type: "json_schema", json_schema: { schema: userSchema } } }
+      // Anthropic tool-based extraction
+      { tools: [{ name: "extract", input_schema: userSchema }], tool_choice: { type: "tool", name: "extract" } }
+
+  - id: llm004
+    name: streaming
+    category: integration
+    description: Streaming LLM responses (SSE pattern)
+    text: streaming sse server-sent events real-time incremental
+    example: |
+      const stream = await openai.chat.completions.create({ model, messages, stream: true });
+      for await (const chunk of stream) {
+        process.stdout.write(chunk.choices[0]?.delta?.content || "");
+      }
+
+  - id: llm005
+    name: retry_fallback
+    category: production
+    description: Retry with fallback to alternate provider/model
+    text: retry fallback exponential backoff rate limit alternate model
+    example: |
+      async function llmCall(messages, options) {
+        try { return await primaryModel.chat(messages, options); }
+        catch (e) {
+          if (e.status === 429) { // Rate limited
+            await sleep(exponentialBackoff(retryCount));
+            return await fallbackModel.chat(messages, options);
+          }
+          throw e;
+        }
+      }
+
+  - id: llm006
+    name: token_optimization
+    category: production
+    description: Token usage optimization and cost management
+    text: token optimization context window cost management trim
+    strategies:
+      - "Summarize old messages to reduce context"
+      - "Use smaller models for triage/routing"
+      - "Cache identical prompts"
+      - "Trim system prompts to essentials"
+      - "Track token usage per request"
+
+  - id: llm007
+    name: prompt_caching
+    category: production
+    description: Anthropic/OpenAI prompt caching for cost reduction
+    text: prompt caching cache_control ephemeral cost reduction
+    example: |
+      // Anthropic prompt caching
+      { role: "user", content: [
+        { type: "text", text: longDocument, cache_control: { type: "ephemeral" } }
+      ]}
+
+  - id: llm008
+    name: provider_comparison
+    category: reference
+    description: LLM provider feature comparison matrix
+    text: provider comparison openai anthropic gemini features
+    comparison:
+      openai:
+        {
+          streaming: true,
+          function_calling: true,
+          json_mode: true,
+          vision: true,
+        }
+      anthropic:
+        {
+          streaming: true,
+          function_calling: true,
+          json_mode: "via tools",
+          vision: true,
+        }
+      gemini:
+        {
+          streaming: true,
+          function_calling: true,
+          json_mode: true,
+          vision: true,
+        }
+      local_ollama:
+        {
+          streaming: true,
+          function_calling: "model dependent",
+          json_mode: "model dependent",
+        }

package/.agent/skills/ai-ml/ai-agents/data/memory-patterns.yaml

@@ -0,0 +1,123 @@
+# Memory Patterns - HSA AI Agents Skill
+# Updated: 2026-02-12
+
+metadata:
+  skill: ai-agents
+  domain: memory
+  version: "1.0.0"
+  updated: "2026-02-12"
+  patterns_count: 8
+
+patterns:
+  - id: mem001
+    name: buffer_memory
+    category: short-term
+    description: Simple conversation buffer (in-memory)
+    text: buffer memory conversation history chat in-memory session
+    example: |
+      const memory = new BufferMemory({ returnMessages: true });
+      await memory.saveContext({ input: "Hello" }, { output: "Hi there!" });
+
+  - id: mem002
+    name: summary_memory
+    category: short-term
+    description: Summarize old messages to save context window
+    text: summary memory compress context window token save
+    example: |
+      const memory = new ConversationSummaryMemory({
+        llm: new ChatOpenAI({ model: "gpt-4o-mini" }),
+        returnMessages: true
+      });
+    best_for: "Long conversations that exceed context window"
+
+  - id: mem003
+    name: vector_memory
+    category: long-term
+    description: Vector store for persistent semantic recall
+    text: vector memory embedding persistent recall search semantic
+    example: |
+      const memory = new VectorStoreRetrieverMemory({
+        vectorStore: await Chroma.fromDocuments(docs, embeddings),
+        memoryKey: "relevant_history"
+      });
+
+  - id: mem004
+    name: entity_memory
+    category: long-term
+    description: Track entities mentioned in conversations
+    text: entity memory track people places things mentioned
+    example: |
+      const memory = new EntityMemory({
+        llm: new ChatOpenAI(),
+        entityStore: new InMemoryEntityStore()
+      });
+
+  - id: mem005
+    name: knowledge_graph_memory
+    category: long-term
+    description: Knowledge graph for structured relationships
+    text: knowledge graph memory relationships entities structured
+    note: "Used by MCP Memory Server for persistent knowledge"
+
+  - id: mem006
+    name: window_memory
+    category: short-term
+    description: Sliding window of last K messages
+    text: window memory sliding last k messages buffer limit
+    example: |
+      const memory = new BufferWindowMemory({ k: 10, returnMessages: true });
+    best_for: "Fixed context budget, recent context focus"
+
+  - id: mem007
+    name: checkpoint_persistence
+    category: production
+    description: Checkpoint agent state for resume/replay
+    text: checkpoint persistence save resume replay state recovery
+    example: |
+      // LangGraph checkpointer
+      const checkpointer = new SqliteSaver("checkpoints.db");
+      const graph = workflow.compile({ checkpointer });
+      // Resume from checkpoint
+      await graph.invoke(null, { configurable: { thread_id: "abc" } });
+
+  - id: mem008
+    name: memory_strategy_selection
+    category: reference
+    description: Decision matrix for choosing memory type
+    text: memory strategy selection guide choose type
+    decision_matrix:
+      buffer:
+        {
+          duration: "Session",
+          storage: "RAM",
+          tokens: "High",
+          best_for: "Short chats",
+        }
+      summary:
+        {
+          duration: "Session",
+          storage: "RAM",
+          tokens: "Low",
+          best_for: "Long chats",
+        }
+      window:
+        {
+          duration: "Session",
+          storage: "RAM",
+          tokens: "Medium",
+          best_for: "Recent context",
+        }
+      vector:
+        {
+          duration: "Persistent",
+          storage: "Vector DB",
+          tokens: "Low",
+          best_for: "Knowledge recall",
+        }
+      entity:
+        {
+          duration: "Persistent",
+          storage: "DB",
+          tokens: "Medium",
+          best_for: "Entity tracking",
+        }

package/.agent/skills/ai-ml/ai-agents/data/orchestration-patterns.yaml

@@ -0,0 +1,101 @@
+# AI Agent Orchestration Patterns - HSA AI Agents Skill
+# Updated: 2026-02-12
+
+metadata:
+  skill: ai-agents
+  domain: orchestration
+  version: "1.0.0"
+  updated: "2026-02-12"
+  patterns_count: 8
+
+patterns:
+  - id: orch001
+    name: supervisor
+    category: orchestration
+    description: Single supervisor routes tasks to specialized agents
+    text: supervisor orchestrator router delegate specialized agent
+    example: |
+      // LangGraph supervisor
+      const graph = new StateGraph({ channels: { messages, next } })
+        .addNode("supervisor", supervisorAgent)
+        .addNode("researcher", researchAgent)
+        .addNode("coder", codingAgent)
+        .addEdge("supervisor", routeToAgent)
+        .compile();
+    best_for: "Complex tasks with clear sub-task boundaries"
+
+  - id: orch002
+    name: swarm
+    category: orchestration
+    description: Peer-to-peer agents collaborate without central control
+    text: swarm peer collaborative decentralized agents handoff
+    example: |
+      // OpenAI Swarm pattern
+      const triage = new Agent({ name: "Triage", handoffs: [sales, support] });
+      const sales = new Agent({ name: "Sales", tools: [createQuote] });
+    best_for: "Customer service, collaborative workflows"
+
+  - id: orch003
+    name: sequential
+    category: orchestration
+    description: Linear pipeline of agents, output feeds next input
+    text: sequential pipeline chain linear flow step by step
+    example: |
+      const pipeline = research.pipe(draft).pipe(review).pipe(publish);
+      const result = await pipeline.invoke({ topic: "MCP best practices" });
+    best_for: "Content creation, ETL, simple workflows"
+
+  - id: orch004
+    name: hierarchical
+    category: orchestration
+    description: Manager agents delegate to worker agents recursively
+    text: hierarchical manager worker delegation tree recursive
+    best_for: "Enterprise workflows, complex project management"
+
+  - id: orch005
+    name: langgraph_setup
+    category: framework
+    description: LangGraph state machine for agent workflows
+    text: langgraph state graph node edge checkpoint persistence
+    example: |
+      const graph = new StateGraph(AgentState)
+        .addNode("agent", callModel)
+        .addNode("tools", toolNode)
+        .addEdge(START, "agent")
+        .addConditionalEdges("agent", shouldContinue, { continue: "tools", end: END })
+        .addEdge("tools", "agent")
+        .compile({ checkpointer: new MemorySaver() });
+
+  - id: orch006
+    name: crewai_setup
+    category: framework
+    description: CrewAI role-based multi-agent collaboration
+    text: crewai crew agent task role goal backstory
+    example: |
+      researcher = Agent(role="Researcher", goal="Find information", tools=[search])
+      writer = Agent(role="Writer", goal="Write content")
+      crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])
+
+  - id: orch007
+    name: hitl
+    category: production
+    description: Human-in-the-loop approval for critical actions
+    text: human in the loop approval review critical destructive confirm
+    example: |
+      // LangGraph interrupt pattern
+      .addNode("approval", async (state) => {
+        return { needsApproval: true, action: state.proposedAction };
+        // Graph pauses here until human approves
+      })
+
+  - id: orch008
+    name: error_recovery
+    category: production
+    description: Agent error recovery and retry strategies
+    text: error recovery retry fallback checkpoint resume
+    example: |
+      const config = {
+        maxRetries: 3,
+        fallbackModel: "gpt-4o-mini",
+        checkpointOnSuccess: true
+      };

package/.agent/skills/ai-ml/gemini-live/META.yaml

@@ -0,0 +1,55 @@
+name: gemini-live
+version: "1.0.0"
+display: Gemini Live & Advanced APIs
+category: ai-ml
+tier: 1
+priority: 4
+
+desc: "Advanced Gemini APIs: Live API (real-time voice/video streaming via WebSocket), Context Caching (implicit + explicit TTL), Code Execution (Python sandbox, 30+ libs), Grounding with Google Search (citations). 28+ patterns."
+
+triggers:
+  file_patterns: []
+  keywords:
+    - live api
+    - real-time ai
+    - gemini live
+    - context caching
+    - code execution
+    - gemini sandbox
+    - grounding
+    - google search grounding
+    - implicit caching
+    - explicit caching
+    - voice activity detection
+    - session management
+    - ephemeral token
+    - websocket ai
+    - streaming ai
+  intents:
+    - build real-time AI app
+    - cache context for LLM
+    - execute code with gemini
+    - ground responses with search
+    - stream audio/video to AI
+
+caps:
+  - Live API (WebSocket, audio/video streaming)
+  - Voice Activity Detection (VAD)
+  - Context Caching (implicit + explicit TTL, cost savings)
+  - Code Execution (Python sandbox, 30+ libs including TensorFlow)
+  - Grounding with Google Search (real-time citations)
+  - Multi-tool combinations (Search + Code + Functions)
+  - Session management for long conversations
+  - Ephemeral tokens (client-side auth)
+  - Partner integrations (Pipecat, LiveKit, ADK)
+
+related_skills:
+  - ai-agents
+  - prompt-engineering
+  - gemini-media-gen
+
+data_files:
+  - data/live-api.yaml
+  - data/context-caching.yaml
+  - data/code-execution.yaml
+  - data/grounding.yaml

package/.agent/skills/ai-ml/gemini-live/SKILL.md

@@ -0,0 +1,155 @@
+# Gemini Live & Advanced APIs
+
+> 🔴 **Real-time streaming + Advanced Gemini capabilities**
+> **APIs**: Live API + Context Caching + Code Execution + Grounding | **Patterns**: 28+
+
+---
+
+## Quick Reference
+
+| What You Need                  | Data File              | Patterns |
+| ------------------------------ | ---------------------- | -------- |
+| Live API (WebSocket streaming) | `live-api.yaml`        | 8        |
+| Context Caching                | `context-caching.yaml` | 6        |
+| Code Execution (sandbox)       | `code-execution.yaml`  | 8        |
+| Grounding with Google Search   | `grounding.yaml`       | 6        |
+
+---
+
+## Live API Overview
+
+```
+┌──────────────────────────────────────────┐
+│  Client (Audio/Video/Text)               │
+│    ↓ WebSocket                           │
+│  Gemini Live API                         │
+│    ↓ Real-time processing                │
+│  Response (Audio/Text)                   │
+│    + Voice Activity Detection            │
+│    + Tool calling                        │
+│    + Session management                  │
+└──────────────────────────────────────────┘
+```
+
+### Implementation Approaches
+
+| Approach             | Description                  | Use Case                      |
+| -------------------- | ---------------------------- | ----------------------------- |
+| **Server-to-server** | Backend connects to Live API | Secure, full control          |
+| **Client-to-server** | Frontend connects directly   | Low latency, ephemeral tokens |
+
+### Partner Integrations
+
+| Partner                        | Description                       |
+| ------------------------------ | --------------------------------- |
+| **Pipecat** (Daily)            | Real-time AI chatbot framework    |
+| **LiveKit**                    | Agents with Gemini Live           |
+| **Fishjam** (Software Mansion) | Live video/audio streaming        |
+| **ADK** (Google)               | Agent Development Kit             |
+| **Vision Agents** (Stream)     | Real-time voice/video AI          |
+| **Voximplant**                 | Inbound/outbound call integration |
+
+---
+
+## Context Caching
+
+| Type         | Description                   | Cost                |
+| ------------ | ----------------------------- | ------------------- |
+| **Implicit** | Auto-enabled, no code changes | Free (auto savings) |
+| **Explicit** | Manual cache with TTL control | Reduced input cost  |
+
+### When to Use Explicit Caching
+
+- Chatbots with extensive system instructions
+- Repetitive analysis of lengthy video files
+- Recurring queries against large document sets
+- Frequent code repository analysis
+
+### Implicit Caching Tips
+
+- Put large, common content at beginning of prompt
+- Send similar-prefix requests close together in time
+- Check `usage_metadata.cached_content_token_count`
+
+---
+
+## Code Execution
+
+**Python sandbox with 30+ libraries** — model writes, runs, and iterates on code.
+
+### Key Libraries Available
+
+| Category          | Libraries                                   |
+| ----------------- | ------------------------------------------- |
+| **Data Science**  | numpy, pandas, scipy, scikit-learn          |
+| **Visualization** | matplotlib, seaborn                         |
+| **Image**         | pillow, opencv-python, imageio              |
+| **Documents**     | PyPDF2, python-docx, python-pptx, reportlab |
+| **ML**            | tensorflow                                  |
+| **Math**          | sympy, mpmath                               |
+
+### Gemini 3 — Code Execution with Images
+
+New in Gemini 3: model can manipulate and inspect images via code:
+
+- **Zoom and inspect**: Auto-crops to examine small details
+- **Visual math**: Multi-step calculations from image data
+- **Image annotation**: Draws arrows and labels on images
+
+### Billing
+
+- No extra charge for code execution
+- Billed at standard input/output token rates
+- Generated code + results count as output tokens
+
+---
+
+## Grounding with Google Search
+
+```
+User Prompt → Model → Google Search → Synthesized Response + Citations
+```
+
+### Response Structure
+
+```json
+{
+  "groundingMetadata": {
+    "webSearchQueries": ["search terms used"],
+    "groundingChunks": [{ "web": { "uri": "...", "title": "..." } }],
+    "groundingSupports": [
+      { "segment": { "text": "claim..." }, "groundingChunkIndices": [0, 1] }
+    ]
+  }
+}
+```
+
+### Building Citations
+
+- `groundingChunks` → source URLs and titles
+- `groundingSupports` → maps text segments to sources
+- `searchEntryPoint` → HTML/CSS for search widget (required by ToS)
+
+---
+
+## Multi-Tool Combinations
+
+| Combo              | Use Case                        |
+| ------------------ | ------------------------------- |
+| Search + Functions | Real-time data + custom actions |
+| Code + Functions   | Compute + external data         |
+| Search + Code      | Research + data analysis        |
+| All + MCP          | Complex agentic workflows       |
+
+Live API supports ALL tool combinations simultaneously.
+
+---
+
+## HSA Integration
+
+| Domain | Query Examples                               |
+| ------ | -------------------------------------------- |
+| Live   | "WebSocket streaming real-time audio VAD"    |
+| Cache  | "context caching TTL cost savings implicit"  |
+| Code   | "sandbox Python execution tensorflow pandas" |
+| Ground | "Google Search grounding citations metadata" |