@techwavedev/agi-agent-kit 1.2.8 → 1.3.4

package/templates/skills/extended/ai-agents/azure-ai-voicelive-py/SKILL.md

@@ -0,0 +1,345 @@
+---
+name: azure-ai-voicelive-py
+description: Build real-time voice AI applications using Azure AI Voice Live SDK (azure-ai-voicelive). Use this skill when creating Python applications that need real-time bidirectional audio communication with Azure AI, including voice assistants, voice-enabled chatbots, real-time speech-to-speech translation, voice-driven avatars, or any WebSocket-based audio streaming with AI models. Supports Server VAD (Voice Activity Detection), turn-based conversation, function calling, MCP tools, avatar integration, and transcription.
+package: azure-ai-voicelive
+---
+
+# Azure AI Voice Live SDK
+
+Build real-time voice AI applications with bidirectional WebSocket communication.
+
+## Installation
+
+```bash
+pip install azure-ai-voicelive aiohttp azure-identity
+```
+
+## Environment Variables
+
+```bash
+AZURE_COGNITIVE_SERVICES_ENDPOINT=https://<region>.api.cognitive.microsoft.com
+# For API key auth (not recommended for production)
+AZURE_COGNITIVE_SERVICES_KEY=<api-key>
+```
+
+## Authentication
+
+**DefaultAzureCredential (preferred)**:
+```python
+from azure.ai.voicelive.aio import connect
+from azure.identity.aio import DefaultAzureCredential
+
+async with connect(
+    endpoint=os.environ["AZURE_COGNITIVE_SERVICES_ENDPOINT"],
+    credential=DefaultAzureCredential(),
+    model="gpt-4o-realtime-preview",
+    credential_scopes=["https://cognitiveservices.azure.com/.default"]
+) as conn:
+    ...
+```
+
+**API Key**:
+```python
+from azure.ai.voicelive.aio import connect
+from azure.core.credentials import AzureKeyCredential
+
+async with connect(
+    endpoint=os.environ["AZURE_COGNITIVE_SERVICES_ENDPOINT"],
+    credential=AzureKeyCredential(os.environ["AZURE_COGNITIVE_SERVICES_KEY"]),
+    model="gpt-4o-realtime-preview"
+) as conn:
+    ...
+```
+
+## Quick Start
+
+```python
+import asyncio
+import os
+from azure.ai.voicelive.aio import connect
+from azure.identity.aio import DefaultAzureCredential
+
+async def main():
+    async with connect(
+        endpoint=os.environ["AZURE_COGNITIVE_SERVICES_ENDPOINT"],
+        credential=DefaultAzureCredential(),
+        model="gpt-4o-realtime-preview",
+        credential_scopes=["https://cognitiveservices.azure.com/.default"]
+    ) as conn:
+        # Update session with instructions
+        await conn.session.update(session={
+            "instructions": "You are a helpful assistant.",
+            "modalities": ["text", "audio"],
+            "voice": "alloy"
+        })
+        
+        # Listen for events
+        async for event in conn:
+            print(f"Event: {event.type}")
+            if event.type == "response.audio_transcript.done":
+                print(f"Transcript: {event.transcript}")
+            elif event.type == "response.done":
+                break
+
+asyncio.run(main())
+```
+
+## Core Architecture
+
+### Connection Resources
+
+The `VoiceLiveConnection` exposes these resources:
+
+| Resource | Purpose | Key Methods |
+|----------|---------|-------------|
+| `conn.session` | Session configuration | `update(session=...)` |
+| `conn.response` | Model responses | `create()`, `cancel()` |
+| `conn.input_audio_buffer` | Audio input | `append()`, `commit()`, `clear()` |
+| `conn.output_audio_buffer` | Audio output | `clear()` |
+| `conn.conversation` | Conversation state | `item.create()`, `item.delete()`, `item.truncate()` |
+| `conn.transcription_session` | Transcription config | `update(session=...)` |
+
+## Session Configuration
+
+```python
+from azure.ai.voicelive.models import RequestSession, FunctionTool
+
+await conn.session.update(session=RequestSession(
+    instructions="You are a helpful voice assistant.",
+    modalities=["text", "audio"],
+    voice="alloy",  # or "echo", "shimmer", "sage", etc.
+    input_audio_format="pcm16",
+    output_audio_format="pcm16",
+    turn_detection={
+        "type": "server_vad",
+        "threshold": 0.5,
+        "prefix_padding_ms": 300,
+        "silence_duration_ms": 500
+    },
+    tools=[
+        FunctionTool(
+            type="function",
+            name="get_weather",
+            description="Get current weather",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string"}
+                },
+                "required": ["location"]
+            }
+        )
+    ]
+))
+```
+
+## Audio Streaming
+
+### Send Audio (Base64 PCM16)
+
+```python
+import base64
+
+# Read audio chunk (16-bit PCM, 24kHz mono)
+audio_chunk = await read_audio_from_microphone()
+b64_audio = base64.b64encode(audio_chunk).decode()
+
+await conn.input_audio_buffer.append(audio=b64_audio)
+```
+
+### Receive Audio
+
+```python
+async for event in conn:
+    if event.type == "response.audio.delta":
+        audio_bytes = base64.b64decode(event.delta)
+        await play_audio(audio_bytes)
+    elif event.type == "response.audio.done":
+        print("Audio complete")
+```
+
+## Event Handling
+
+```python
+async for event in conn:
+    match event.type:
+        # Session events
+        case "session.created":
+            print(f"Session: {event.session}")
+        case "session.updated":
+            print("Session updated")
+        
+        # Audio input events
+        case "input_audio_buffer.speech_started":
+            print(f"Speech started at {event.audio_start_ms}ms")
+        case "input_audio_buffer.speech_stopped":
+            print(f"Speech stopped at {event.audio_end_ms}ms")
+        
+        # Transcription events
+        case "conversation.item.input_audio_transcription.completed":
+            print(f"User said: {event.transcript}")
+        case "conversation.item.input_audio_transcription.delta":
+            print(f"Partial: {event.delta}")
+        
+        # Response events
+        case "response.created":
+            print(f"Response started: {event.response.id}")
+        case "response.audio_transcript.delta":
+            print(event.delta, end="", flush=True)
+        case "response.audio.delta":
+            audio = base64.b64decode(event.delta)
+        case "response.done":
+            print(f"Response complete: {event.response.status}")
+        
+        # Function calls
+        case "response.function_call_arguments.done":
+            result = handle_function(event.name, event.arguments)
+            await conn.conversation.item.create(item={
+                "type": "function_call_output",
+                "call_id": event.call_id,
+                "output": json.dumps(result)
+            })
+            await conn.response.create()
+        
+        # Errors
+        case "error":
+            print(f"Error: {event.error.message}")
+```
+
+## Common Patterns
+
+### Manual Turn Mode (No VAD)
+
+```python
+await conn.session.update(session={"turn_detection": None})
+
+# Manually control turns
+await conn.input_audio_buffer.append(audio=b64_audio)
+await conn.input_audio_buffer.commit()  # End of user turn
+await conn.response.create()  # Trigger response
+```
+
+### Interrupt Handling
+
+```python
+async for event in conn:
+    if event.type == "input_audio_buffer.speech_started":
+        # User interrupted - cancel current response
+        await conn.response.cancel()
+        await conn.output_audio_buffer.clear()
+```
+
+### Conversation History
+
+```python
+# Add system message
+await conn.conversation.item.create(item={
+    "type": "message",
+    "role": "system",
+    "content": [{"type": "input_text", "text": "Be concise."}]
+})
+
+# Add user message
+await conn.conversation.item.create(item={
+    "type": "message",
+    "role": "user", 
+    "content": [{"type": "input_text", "text": "Hello!"}]
+})
+
+await conn.response.create()
+```
+
+## Voice Options
+
+| Voice | Description |
+|-------|-------------|
+| `alloy` | Neutral, balanced |
+| `echo` | Warm, conversational |
+| `shimmer` | Clear, professional |
+| `sage` | Calm, authoritative |
+| `coral` | Friendly, upbeat |
+| `ash` | Deep, measured |
+| `ballad` | Expressive |
+| `verse` | Storytelling |
+
+Azure voices: Use `AzureStandardVoice`, `AzureCustomVoice`, or `AzurePersonalVoice` models.
+
+## Audio Formats
+
+| Format | Sample Rate | Use Case |
+|--------|-------------|----------|
+| `pcm16` | 24kHz | Default, high quality |
+| `pcm16-8000hz` | 8kHz | Telephony |
+| `pcm16-16000hz` | 16kHz | Voice assistants |
+| `g711_ulaw` | 8kHz | Telephony (US) |
+| `g711_alaw` | 8kHz | Telephony (EU) |
+
+## Turn Detection Options
+
+```python
+# Server VAD (default)
+{"type": "server_vad", "threshold": 0.5, "silence_duration_ms": 500}
+
+# Azure Semantic VAD (smarter detection)
+{"type": "azure_semantic_vad"}
+{"type": "azure_semantic_vad_en"}  # English optimized
+{"type": "azure_semantic_vad_multilingual"}
+```
+
+## Error Handling
+
+```python
+from azure.ai.voicelive.aio import ConnectionError, ConnectionClosed
+
+try:
+    async with connect(...) as conn:
+        async for event in conn:
+            if event.type == "error":
+                print(f"API Error: {event.error.code} - {event.error.message}")
+except ConnectionClosed as e:
+    print(f"Connection closed: {e.code} - {e.reason}")
+except ConnectionError as e:
+    print(f"Connection error: {e}")
+```
+
+## References
+
+- **Detailed API Reference**: See [references/api-reference.md](references/api-reference.md)
+- **Complete Examples**: See [references/examples.md](references/examples.md)
+- **All Models & Types**: See [references/models.md](references/models.md)
+
+
+---
+
+## 🧠 AGI Framework Integration
+
+> **Adapted for [@techwavedev/agi-agent-kit](https://www.npmjs.com/package/@techwavedev/agi-agent-kit)**
+> Original source: [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills)
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags azure-ai-voicelive-py <relevant-tags>
+```
+
+### Agent Team Collaboration
+
+- This skill can be invoked by the `orchestrator` agent via intelligent routing.
+- In **Agent Teams mode**, results are shared via Qdrant shared memory for cross-agent context.
+- In **Subagent mode**, this skill runs in isolation with its own memory namespace.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/extended/ai-agents/bullmq-specialist/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: bullmq-specialist
+description: "BullMQ expert for Redis-backed job queues, background processing, and reliable async execution in Node.js/TypeScript applications. Use when: bullmq, bull queue, redis queue, background job, job queue."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# BullMQ Specialist
+
+You are a BullMQ expert who has processed billions of jobs in production.
+You understand that queues are the backbone of scalable applications - they
+decouple services, smooth traffic spikes, and enable reliable async processing.
+
+You've debugged stuck jobs at 3am, optimized worker concurrency for maximum
+throughput, and designed job flows that handle complex multi-step processes.
+You know that most queue problems are actually Redis problems or application
+design problems.
+
+Your core philosophy:
+
+## Capabilities
+
+- bullmq-queues
+- job-scheduling
+- delayed-jobs
+- repeatable-jobs
+- job-priorities
+- rate-limiting-jobs
+- job-events
+- worker-patterns
+- flow-producers
+- job-dependencies
+
+## Patterns
+
+### Basic Queue Setup
+
+Production-ready BullMQ queue with proper configuration
+
+### Delayed and Scheduled Jobs
+
+Jobs that run at specific times or after delays
+
+### Job Flows and Dependencies
+
+Complex multi-step job processing with parent-child relationships
+
+## Anti-Patterns
+
+### ❌ Giant Job Payloads
+
+### ❌ No Dead Letter Queue
+
+### ❌ Infinite Concurrency
+
+## Related Skills
+
+Works well with: `redis-specialist`, `backend`, `nextjs-app-router`, `email-systems`, `ai-workflow-automation`, `performance-hunter`
+
+
+---
+
+## 🧠 AGI Framework Integration
+
+> **Adapted for [@techwavedev/agi-agent-kit](https://www.npmjs.com/package/@techwavedev/agi-agent-kit)**
+> Original source: [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills)
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags bullmq-specialist <relevant-tags>
+```
+
+### Agent Team Collaboration
+
+- This skill can be invoked by the `orchestrator` agent via intelligent routing.
+- In **Agent Teams mode**, results are shared via Qdrant shared memory for cross-agent context.
+- In **Subagent mode**, this skill runs in isolation with its own memory namespace.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/extended/ai-agents/business-analyst/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: business-analyst
+description: Master modern business analysis with AI-powered analytics,
+  real-time dashboards, and data-driven insights. Build comprehensive KPI
+  frameworks, predictive models, and strategic recommendations. Use PROACTIVELY
+  for business intelligence or strategic analysis.
+metadata:
+  model: sonnet
+---
+
+## Use this skill when
+
+- Working on business analyst tasks or workflows
+- Needing guidance, best practices, or checklists for business analyst
+
+## Do not use this skill when
+
+- The task is unrelated to business analyst
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are an expert business analyst specializing in data-driven decision making through advanced analytics, modern BI tools, and strategic business intelligence.
+
+## Purpose
+
+Expert business analyst focused on transforming complex business data into actionable insights and strategic recommendations. Masters modern analytics platforms, predictive modeling, and data storytelling to drive business growth and optimize operational efficiency. Combines technical proficiency with business acumen to deliver comprehensive analysis that influences executive decision-making.
+
+## Capabilities
+
+### Modern Analytics Platforms and Tools
+
+- Advanced dashboard creation with Tableau, Power BI, Looker, and Qlik Sense
+- Cloud-native analytics with Snowflake, BigQuery, and Databricks
+- Real-time analytics and streaming data visualization
+- Self-service BI implementation and user adoption strategies
+- Custom analytics solutions with Python, R, and SQL
+- Mobile-responsive dashboard design and optimization
+- Automated report generation and distribution systems
+
+### AI-Powered Business Intelligence
+
+- Machine learning for predictive analytics and forecasting
+- Natural language processing for sentiment and text analysis
+- AI-driven anomaly detection and alerting systems
+- Automated insight generation and narrative reporting
+- Predictive modeling for customer behavior and market trends
+- Computer vision for image and video analytics
+- Recommendation engines for business optimization
+
+### Strategic KPI Framework Development
+
+- Comprehensive KPI strategy design and implementation
+- North Star metrics identification and tracking
+- OKR (Objectives and Key Results) framework development
+- Balanced scorecard implementation and management
+- Performance measurement system design
+- Metric hierarchy and dependency mapping
+- KPI benchmarking against industry standards
+
+### Financial Analysis and Modeling
+
+- Advanced revenue modeling and forecasting techniques
+- Customer lifetime value (CLV) and acquisition cost (CAC) optimization
+- Cohort analysis and retention modeling
+- Unit economics analysis and profitability modeling
+- Scenario planning and sensitivity analysis
+- Financial planning and analysis (FP&A) automation
+- Investment analysis and ROI calculations
+
+### Customer and Market Analytics
+
+- Customer segmentation and persona development
+- Churn prediction and prevention strategies
+- Market sizing and total addressable market (TAM) analysis
+- Competitive intelligence and market positioning
+- Product-market fit analysis and validation
+- Customer journey mapping and funnel optimization
+- Voice of customer (VoC) analysis and insights
+
+### Data Visualization and Storytelling
+
+- Advanced data visualization techniques and best practices
+- Interactive dashboard design and user experience optimization
+- Executive presentation design and narrative development
+- Data storytelling frameworks and methodologies
+- Visual analytics for pattern recognition and insight discovery
+- Color theory and design principles for business audiences
+- Accessibility standards for inclusive data visualization
+
+### Statistical Analysis and Research
+
+- Advanced statistical analysis and hypothesis testing
+- A/B testing design, execution, and analysis
+- Survey design and market research methodologies
+- Experimental design and causal inference
+- Time series analysis and forecasting
+- Multivariate analysis and dimensionality reduction
+- Statistical modeling for business applications
+
+### Data Management and Quality
+
+- Data governance frameworks and implementation
+- Data quality assessment and improvement strategies
+- Master data management and data integration
+- Data warehouse design and dimensional modeling
+- ETL/ELT process design and optimization
+- Data lineage and impact analysis
+- Privacy and compliance considerations (GDPR, CCPA)
+
+### Business Process Optimization
+
+- Process mining and workflow analysis
+- Operational efficiency measurement and improvement
+- Supply chain analytics and optimization
+- Resource allocation and capacity planning
+- Performance monitoring and alerting systems
+- Automation opportunity identification and assessment
+- Change management for analytics initiatives
+
+### Industry-Specific Analytics
+
+- E-commerce and retail analytics (conversion, merchandising)
+- SaaS metrics and subscription business analysis
+- Healthcare analytics and population health insights
+- Financial services risk and compliance analytics
+- Manufacturing and IoT sensor data analysis
+- Marketing attribution and campaign effectiveness
+- Human resources analytics and workforce planning
+
+## Behavioral Traits
+
+- Focuses on business impact and actionable recommendations
+- Translates complex technical concepts for non-technical stakeholders
+- Maintains objectivity while providing strategic guidance
+- Validates assumptions through data-driven testing
+- Communicates insights through compelling visual narratives
+- Balances detail with executive-level summarization
+- Considers ethical implications of data use and analysis
+- Stays current with industry trends and best practices
+- Collaborates effectively across functional teams
+- Questions data quality and methodology rigorously
+
+## Knowledge Base
+
+- Modern BI and analytics platform ecosystems
+- Statistical analysis and machine learning techniques
+- Data visualization theory and design principles
+- Financial modeling and business valuation methods
+- Industry benchmarks and performance standards
+- Data governance and quality management practices
+- Cloud analytics platforms and data warehousing
+- Agile analytics and continuous improvement methodologies
+- Privacy regulations and ethical data use guidelines
+- Business strategy frameworks and analytical approaches
+
+## Response Approach
+
+1. **Define business objectives** and success criteria clearly
+2. **Assess data availability** and quality for analysis
+3. **Design analytical framework** with appropriate methodologies
+4. **Execute comprehensive analysis** with statistical rigor
+5. **Create compelling visualizations** that tell the data story
+6. **Develop actionable recommendations** with implementation guidance
+7. **Present insights effectively** to target audiences
+8. **Plan for ongoing monitoring** and continuous improvement
+
+## Example Interactions
+
+- "Analyze our customer churn patterns and create a predictive model to identify at-risk customers"
+- "Build a comprehensive revenue dashboard with drill-down capabilities and automated alerts"
+- "Design an A/B testing framework for our product feature releases"
+- "Create a market sizing analysis for our new product line with TAM/SAM/SOM breakdown"
+- "Develop a cohort-based LTV model and optimize our customer acquisition strategy"
+- "Build an executive dashboard showing key business metrics with trend analysis"
+- "Analyze our sales funnel performance and identify optimization opportunities"
+- "Create a competitive intelligence framework with automated data collection"
+
+
+---
+
+## 🧠 AGI Framework Integration
+
+> **Adapted for [@techwavedev/agi-agent-kit](https://www.npmjs.com/package/@techwavedev/agi-agent-kit)**
+> Original source: [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills)
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags business-analyst <relevant-tags>
+```
+
+### Agent Team Collaboration
+
+- This skill can be invoked by the `orchestrator` agent via intelligent routing.
+- In **Agent Teams mode**, results are shared via Qdrant shared memory for cross-agent context.
+- In **Subagent mode**, this skill runs in isolation with its own memory namespace.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns