@nockdev/awf 6.2.0 → 6.2.2

package/.agent/skills/ai-ml/ai-agents/META.yaml

@@ -0,0 +1,127 @@
+name: ai-agents
+version: "1.1.0"
+display: AI Agent Orchestration
+category: ai-ml
+tier: 1
+priority: 1
+
+desc: "AI agent development & orchestration. LangChain/LangGraph, CrewAI, AutoGen, Google ADK. Covers multi-agent patterns, LLM API integration (OpenAI/Anthropic/Gemini), MCP built-in support, Gemini Live agents, tool use, memory, and production deployment."
+
+  ### Data Files (4 domains, ~32 patterns)
+  - orchestration-patterns.yaml: supervisor/swarm/sequential/hierarchical (8)
+  - llm-integration.yaml: OpenAI/Anthropic/Gemini API patterns, streaming (8)
+  - agent-rules.yaml: Cursor/Cline/Codex/DOMYH rule system comparison (8)
+  - memory-patterns.yaml: short-term, long-term, vector memory (8)
+
+triggers:
+  file_patterns:
+    # LangChain/LangGraph
+    - "**/agents/**"
+    - "**/chains/**"
+    - "langgraph.json"
+    # Config
+    - "AGENTS.md"
+    - ".clinerules"
+    - ".cursor/rules/**"
+  keywords:
+    # Frameworks
+    - ai agent
+    - langchain
+    - langgraph
+    - crewai
+    - autogen
+    - microsoft autogen
+    - agent framework
+    # Patterns
+    - multi-agent
+    - agent orchestration
+    - supervisor pattern
+    - swarm pattern
+    - sequential chain
+    - hierarchical agents
+    # LLM Integration
+    - tool use
+    - function calling
+    - structured output
+    - LLM integration
+    - OpenAI API
+    - Anthropic API
+    - Gemini API
+    - Claude API
+    - streaming response
+    - token optimization
+    - prompt engineering
+    # Memory
+    - agent memory
+    - conversation memory
+    - vector memory
+    - long-term memory
+    # Agent rules
+    - AGENTS.md
+    - cursor rules
+    - cline rules
+    - agent skills
+    # Observability
+    - langsmith
+    - langfuse
+    - agent traces
+    # Production
+    - human-in-the-loop
+    - HITL
+    # v1.1 — Gemini ecosystem
+    - google adk
+    - agent development kit
+    - gemini live agent
+    - MCP built-in
+    - a2a protocol
+
+caps:
+  # Frameworks
+  - LangChain Expression Language (LCEL) chains
+  - LangGraph stateful workflows (nodes/edges/state)
+  - CrewAI role-based multi-agent collaboration
+  - AutoGen conversational agents
+  # Orchestration
+  - Supervisor pattern (single orchestrator)
+  - Swarm pattern (peer-to-peer agents)
+  - Sequential pipeline (chain of agents)
+  - Hierarchical delegation (manager → workers)
+  # LLM Integration
+  - Multi-provider LLM integration (OpenAI, Anthropic, Gemini, local)
+  - Function calling / Tool use across providers
+  - Structured output (JSON mode, Pydantic models)
+  - Streaming responses (SSE, async generators)
+  - Token optimization & context window management
+  # Memory
+  - Short-term memory (conversation buffer)
+  - Long-term memory (vector store backed)
+  - Episodic memory (event-based recall)
+  # Agent Configuration
+  - Cursor Rules system (global → project → dynamic .mdc)
+  - Cline Rules (.clinerules/ folder)
+  - Codex AGENTS.md configuration
+  - DOMYH skill system (META.yaml → SKILL.md → data/)
+  # Production
+  - Human-in-the-loop (HITL) approval patterns
+  - Observability (LangSmith, Langfuse, traces/spans)
+  - Async queue architecture for long-running agents
+  - Rate limiting & cost optimization
+  - Error recovery & retry strategies
+  # v1.1
+  - Google ADK (Agent Development Kit)
+  - Gemini Live real-time agents (Pipecat, LiveKit, ADK)
+  - MCP built-in tool integration
+  - A2A (Agent-to-Agent) protocol
+
+related_skills:
+  - mcp
+  - prompt-engineering
+  - rag-patterns
+  - vector-search
+  - gemini-live
+  - gemini-media-gen
+
+hsa_adapter:
+  enabled: true
+  data_dir: "skills/ai-ml/ai-agents/data"
+  preload_data: true

package/.agent/skills/ai-ml/ai-agents/SKILL.md

@@ -0,0 +1,139 @@
+# AI Agent Orchestration — LangChain • CrewAI • AutoGen
+
+> Multi-agent systems • LLM API integration • Agent rules  
+> Tool use • Memory management • Production patterns
+
+---
+
+## Khi Nào Dùng
+
+- Xây dựng AI agents (single/multi-agent)
+- Integrate LLM APIs (OpenAI, Anthropic, Gemini)
+- Thiết kế agent orchestration patterns
+- Implement agent memory & tool use
+- Cấu hình agent rules (Cursor, Cline, AGENTS.md)
+
+## Orchestration Patterns
+
+```
+┌─────────────────────────────────────────────────────┐
+│ SUPERVISOR (recommended for complex tasks)          │
+│                                                     │
+│  ┌──────────┐                                       │
+│  │Supervisor│──┬──▶ Agent A (Research)               │
+│  │(Router)  │  ├──▶ Agent B (Code)                   │
+│  └──────────┘  └──▶ Agent C (Review)                 │
+│                                                     │
+│ SWARM (for collaborative tasks)                     │
+│  Agent A ◄──▶ Agent B ◄──▶ Agent C                   │
+│                                                     │
+│ SEQUENTIAL (for pipeline tasks)                     │
+│  Agent A ──▶ Agent B ──▶ Agent C                     │
+└─────────────────────────────────────────────────────┘
+```
+
+| Pattern          | Use Case                   | Complexity         |
+| ---------------- | -------------------------- | ------------------ |
+| **Sequential**   | ETL, simple pipelines      | ⭐ Low             |
+| **Supervisor**   | Complex tasks, routing     | ⭐⭐ Medium        |
+| **Swarm**        | Collaborative, peer review | ⭐⭐⭐ High        |
+| **Hierarchical** | Enterprise, delegation     | ⭐⭐⭐⭐ Very High |
+
+## LLM API Integration
+
+### Multi-Provider Pattern
+
+```typescript
+// Provider-agnostic interface
+interface LLMProvider {
+  chat(messages: Message[], options?: Options): Promise<Response>;
+  stream(messages: Message[], options?: Options): AsyncGenerator<Chunk>;
+}
+
+// Structured output (all providers)
+const result = await llm.chat(messages, {
+  responseFormat: { type: "json_schema", schema: userSchema },
+});
+```
+
+### Function Calling
+
+```typescript
+// Tool definition (OpenAI format, widely adopted)
+const tools = [
+  {
+    type: "function",
+    function: {
+      name: "search_database",
+      description: "Search the product database",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string" },
+          limit: { type: "number", default: 10 },
+        },
+        required: ["query"],
+      },
+    },
+  },
+];
+```
+
+### Streaming
+
+```typescript
+// SSE streaming pattern
+for await (const chunk of llm.stream(messages)) {
+  process.stdout.write(chunk.content); // real-time output
+}
+```
+
+## Agent Rules Systems
+
+| System     | Location              | Format                       | Scope            |
+| ---------- | --------------------- | ---------------------------- | ---------------- |
+| **Cursor** | `.cursor/rules/*.mdc` | MDC (frontmatter + markdown) | Dynamic per-file |
+| **Cursor** | Settings → Rules      | Plain text                   | Global user      |
+| **Cline**  | `.clinerules/`        | Markdown files               | Project          |
+| **Codex**  | `AGENTS.md`           | Markdown                     | Project          |
+| **DOMYH**  | `.agent/skills/`      | YAML + Markdown              | Hierarchical     |
+
+### Best Practices
+
+1. **Concise** — Under 500 lines per rule file
+2. **Specific** — Show patterns, not just principles
+3. **Scoped** — Use glob patterns for context-specific rules
+4. **Layered** — Global → Project → File-specific
+
+## Memory Patterns
+
+| Type         | Duration   | Storage     | Use Case              |
+| ------------ | ---------- | ----------- | --------------------- |
+| **Buffer**   | Session    | In-memory   | Chat history          |
+| **Summary**  | Session    | In-memory   | Long conversations    |
+| **Vector**   | Persistent | Vector DB   | Recall past knowledge |
+| **Episodic** | Persistent | DB + Vector | Event-based recall    |
+
+## Production Checklist
+
+- ✅ Rate limiting per provider API key
+- ✅ Retry with exponential backoff
+- ✅ Token usage tracking & cost alerts
+- ✅ Async queue for long-running agents
+- ✅ Human-in-the-loop for destructive actions
+- ✅ Observability: traces, spans, token counts
+- ✅ Fallback provider on rate limit
+
+## Common Traps
+
+| Trap                    | Fix                                            |
+| ----------------------- | ---------------------------------------------- |
+| Context window overflow | Summarize history, trim old messages           |
+| Agent loops             | Max iterations limit, break conditions         |
+| Hallucination in tools  | Validate tool outputs, constrained prompts     |
+| High costs              | Cache responses, use smaller models for triage |
+| Prompt injection        | Input sanitization, system prompt protection   |
+
+---
+
+_DOMYH Awesome Code • AI Agents Skill v1.0.0_

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",
+        }