@ngxtm/devkit 3.6.1 → 3.8.0

package/merged-commands/aesthetic.md

@@ -0,0 +1,134 @@
+---
+name: aesthetic
+description: Create aesthetically beautiful interfaces following proven design principles. Use when building UI/UX, analyzing designs from inspiration sites, generating design images, implementing visual hierarchy and color theory, adding micro-interactions, or creating design documentation. Integrate localized specialized skills (chrome-devtools, ImageMagick) with native vision intelligence to achieve premium aesthetic standards.
+---
+
+# Aesthetic
+
+Create aesthetically beautiful interfaces by following proven design principles and systematic workflows.
+
+## When to Use This Skill
+
+Use when:
+
+- Building or designing user interfaces
+- Analyzing designs from inspiration websites (Dribbble, Mobbin, Behance)
+- Generating design images and evaluating aesthetic quality using vision intelligence
+- Implementing visual hierarchy, typography, color theory
+- Adding micro-interactions and animations
+- Creating design documentation and style guides
+- Need guidance on accessibility and design systems
+
+## Core Framework: Four-Stage Approach
+
+### 1. BEAUTIFUL: Understanding Aesthetics
+
+Study existing designs, identify patterns, extract principles. AI lacks innate aesthetic sense—standards must come from analyzing high-quality examples and aligning with market tastes.
+
+**Reference**: [`references/design-principles.md`](references/design-principles.md) - Visual hierarchy, typography, color theory, white space principles.
+
+### 2. RIGHT: Ensuring Functionality
+
+Beautiful designs lacking usability are worthless. Study design systems, component architecture, accessibility requirements.
+
+**Reference**: [`references/design-principles.md`](references/design-principles.md) - Design systems, component libraries, WCAG accessibility standards.
+
+### 3. SATISFYING: Micro-Interactions
+
+Incorporate subtle animations with appropriate timing (150-300ms), easing curves (ease-out for entry, ease-in for exit), sequential delays.
+
+**Reference**: [`references/micro-interactions.md`](references/micro-interactions.md) - Duration guidelines, easing curves, performance optimization.
+
+### 4. PEAK: Storytelling Through Design
+
+Elevate with narrative elements—parallax effects, particle systems, thematic consistency. Use restraint: "too much of anything isn't good."
+
+**Reference**: [`references/storytelling-design.md`](references/storytelling-design.md) - Narrative elements, scroll-based storytelling, interactive techniques.
+
+## Workflows
+
+### Workflow 1: Capture & Analyze Inspiration
+
+**Purpose**: Extract design guidelines from inspiration websites.
+
+**Steps**:
+
+1. Browse inspiration sites (Dribbble, Mobbin, Behance, Awwwards)
+2. Use the **chrome-devtools** skill to capture full-screen screenshots
+3. Use your **native vision capabilities** to analyze the results, prioritizing skill-based insights to extract:
+   - Design style (Minimalism, Glassmorphism, Neo-brutalism, etc.)
+   - Layout structure & grid systems
+   - Typography system & hierarchy
+     **IMPORTANT:** Try to predict the font name (Google Fonts) and font size in the given screenshot, don't just use Inter or Poppins.
+   - Color palette with hex codes
+   - Visual hierarchy techniques
+   - Component patterns & styling
+   - Micro-interactions
+   - Accessibility considerations
+   - Overall aesthetic quality rating (1-10)
+4. Document findings in project design guidelines using templates
+
+### Workflow 2: Generate & Iterate Design Images
+
+**Purpose**: Create aesthetically pleasing design images through iteration.
+
+**Steps**:
+
+1. Define design prompt with: style, colors, typography, audience, animation specs
+2. Use available **image generation tools** (e.g., `generate_image`) to generate design images.
+3. Use your **native vision capabilities** to analyze output images and evaluate aesthetic quality.
+4. If score < 7/10 or fails professional standards:
+   - Identify specific weaknesses (color, typography, layout, spacing, hierarchy)
+   - Refine prompt with improvements
+   - Regenerate using available tools or use the `ImageMagick` skill to refine outputs (resize, crop, filters, composition).
+5. Repeat until aesthetic standards met (score ≥ 7/10)
+6. Document final design decisions using templates
+
+## Design Documentation
+
+### Create Design Guidelines
+
+Use [`assets/design-guideline-template.md`](assets/design-guideline-template.md) to document:
+
+- Color patterns & psychology
+- Typography system & hierarchy
+- Layout principles & spacing
+- Component styling standards
+- Accessibility considerations
+- Design highlights & rationale
+
+Save in project `./docs/design-guideline.md`.
+
+### Create Design Story
+
+Use [`assets/design-story-template.md`](assets/design-story-template.md) to document:
+
+- Narrative elements & themes
+- Emotional journey
+- User journey & peak moments
+- Design decision rationale
+
+Save in project `./docs/design-story.md`.
+
+## Resources & Integration
+
+### Related Skills
+
+- **Multimodal Intelligence**: Analyze documents, screenshots & videos, generate design images, and evaluate aesthetic quality.
+- **chrome-devtools**: Capture high-quality screenshots from inspiration websites for analysis.
+- **media-processing**: Refine generated images using specialized skills (FFmpeg for video, ImageMagick for images).
+- **ui-styling**: Implement designs with semantic HTML/CSS or framework components.
+- **web-frameworks**: Build with modern frameworks (Next.js, Vite, etc.).
+
+### Reference Documentation
+
+**References**: [`references/design-resources.md`](references/design-resources.md) - Inspiration platforms, design systems, AI tools, and development strategies.
+
+## Key Principles
+
+1. Aesthetic standards come from humans, not AI—study quality examples
+2. Iterate based on analysis—never settle for first output
+3. Balance beauty with functionality and accessibility
+4. Document decisions for consistency across development
+5. Use progressive disclosure in design—reveal complexity gradually
+6. Always evaluate aesthetic quality objectively (score ≥ 7/10)

package/merged-commands/agent-evaluation.md

@@ -0,0 +1,64 @@
+---
+name: agent-evaluation
+description: "Testing and benchmarking LLM agents including behavioral testing, capability assessment, reliability metrics, and production monitoring—where even top agents achieve less than 50% on real-world benchmarks Use when: agent testing, agent evaluation, benchmark agents, agent reliability, test agent."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Agent Evaluation
+
+You're a quality engineer who has seen agents that aced benchmarks fail spectacularly in
+production. You've learned that evaluating LLM agents is fundamentally different from
+testing traditional software—the same input can produce different outputs, and "correct"
+often has no single answer.
+
+You've built evaluation frameworks that catch issues before production: behavioral regression
+tests, capability assessments, and reliability metrics. You understand that the goal isn't
+100% test pass rate—it
+
+## Capabilities
+
+- agent-testing
+- benchmark-design
+- capability-assessment
+- reliability-metrics
+- regression-testing
+
+## Requirements
+
+- testing-fundamentals
+- llm-fundamentals
+
+## Patterns
+
+### Statistical Test Evaluation
+
+Run tests multiple times and analyze result distributions
+
+### Behavioral Contract Testing
+
+Define and test agent behavioral invariants
+
+### Adversarial Testing
+
+Actively try to break agent behavior
+
+## Anti-Patterns
+
+### ❌ Single-Run Testing
+
+### ❌ Only Happy Path Tests
+
+### ❌ Output String Matching
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Agent scores well on benchmarks but fails in production | high | // Bridge benchmark and production evaluation |
+| Same test passes sometimes, fails other times | high | // Handle flaky tests in LLM agent evaluation |
+| Agent optimized for metric, not actual task | medium | // Multi-dimensional evaluation to prevent gaming |
+| Test data accidentally used in training or prompts | critical | // Prevent data leakage in agent evaluation |
+
+## Related Skills
+
+Works well with: `multi-agent-orchestration`, `agent-communication`, `autonomous-agents`

package/merged-commands/agent-framework-azure-hosted-agents.md

@@ -0,0 +1,332 @@
+---
+name: agent-framework-azure-hosted-agents
+description: Build Azure AI Foundry agents using the Microsoft Agent Framework Python SDK (agent-framework-azure-ai). Use when creating persistent agents with AzureAIAgentsProvider, using hosted tools (code interpreter, file search, web search), integrating MCP servers, managing conversation threads, or implementing streaming responses. Covers function tools, structured outputs, and multi-tool agents.
+---
+
+# Agent Framework Azure Hosted Agents
+
+Build persistent agents on Azure AI Foundry using the Microsoft Agent Framework Python SDK.
+
+## Architecture
+
+```
+User Query → AzureAIAgentsProvider → Azure AI Agent Service (Persistent)
+                    ↓
+              Agent.run() / Agent.run_stream()
+                    ↓
+              Tools: Functions | Hosted (Code/Search/Web) | MCP
+                    ↓
+              AgentThread (conversation persistence)
+```
+
+## Installation
+
+```bash
+# Full framework (recommended)
+pip install agent-framework --pre
+
+# Or Azure-specific package only
+pip install agent-framework-azure-ai --pre
+```
+
+## Environment Variables
+
+```bash
+export AZURE_AI_PROJECT_ENDPOINT="https://<project>.services.ai.azure.com/api/projects/<project-id>"
+export AZURE_AI_MODEL_DEPLOYMENT_NAME="gpt-4o-mini"
+export BING_CONNECTION_ID="your-bing-connection-id"  # For web search
+```
+
+## Authentication
+
+```python
+from azure.identity.aio import AzureCliCredential, DefaultAzureCredential
+
+# Development
+credential = AzureCliCredential()
+
+# Production
+credential = DefaultAzureCredential()
+```
+
+## Core Workflow
+
+### Basic Agent
+
+```python
+import asyncio
+from agent_framework.azure import AzureAIAgentsProvider
+from azure.identity.aio import AzureCliCredential
+
+async def main():
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentsProvider(credential=credential) as provider,
+    ):
+        agent = await provider.create_agent(
+            name="MyAgent",
+            instructions="You are a helpful assistant.",
+        )
+        
+        result = await agent.run("Hello!")
+        print(result.text)
+
+asyncio.run(main())
+```
+
+### Agent with Function Tools
+
+```python
+from typing import Annotated
+from pydantic import Field
+from agent_framework.azure import AzureAIAgentsProvider
+from azure.identity.aio import AzureCliCredential
+
+def get_weather(
+    location: Annotated[str, Field(description="City name to get weather for")],
+) -> str:
+    """Get the current weather for a location."""
+    return f"Weather in {location}: 72°F, sunny"
+
+def get_current_time() -> str:
+    """Get the current UTC time."""
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+
+async def main():
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentsProvider(credential=credential) as provider,
+    ):
+        agent = await provider.create_agent(
+            name="WeatherAgent",
+            instructions="You help with weather and time queries.",
+            tools=[get_weather, get_current_time],  # Pass functions directly
+        )
+        
+        result = await agent.run("What's the weather in Seattle?")
+        print(result.text)
+```
+
+### Agent with Hosted Tools
+
+```python
+from agent_framework import (
+    HostedCodeInterpreterTool,
+    HostedFileSearchTool,
+    HostedWebSearchTool,
+)
+from agent_framework.azure import AzureAIAgentsProvider
+from azure.identity.aio import AzureCliCredential
+
+async def main():
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentsProvider(credential=credential) as provider,
+    ):
+        agent = await provider.create_agent(
+            name="MultiToolAgent",
+            instructions="You can execute code, search files, and search the web.",
+            tools=[
+                HostedCodeInterpreterTool(),
+                HostedWebSearchTool(name="Bing"),
+            ],
+        )
+        
+        result = await agent.run("Calculate the factorial of 20 in Python")
+        print(result.text)
+```
+
+### Streaming Responses
+
+```python
+async def main():
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentsProvider(credential=credential) as provider,
+    ):
+        agent = await provider.create_agent(
+            name="StreamingAgent",
+            instructions="You are a helpful assistant.",
+        )
+        
+        print("Agent: ", end="", flush=True)
+        async for chunk in agent.run_stream("Tell me a short story"):
+            if chunk.text:
+                print(chunk.text, end="", flush=True)
+        print()
+```
+
+### Conversation Threads
+
+```python
+from agent_framework.azure import AzureAIAgentsProvider
+from azure.identity.aio import AzureCliCredential
+
+async def main():
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentsProvider(credential=credential) as provider,
+    ):
+        agent = await provider.create_agent(
+            name="ChatAgent",
+            instructions="You are a helpful assistant.",
+            tools=[get_weather],
+        )
+        
+        # Create thread for conversation persistence
+        thread = agent.get_new_thread()
+        
+        # First turn
+        result1 = await agent.run("What's the weather in Seattle?", thread=thread)
+        print(f"Agent: {result1.text}")
+        
+        # Second turn - context is maintained
+        result2 = await agent.run("What about Portland?", thread=thread)
+        print(f"Agent: {result2.text}")
+        
+        # Save thread ID for later resumption
+        print(f"Conversation ID: {thread.conversation_id}")
+```
+
+### Structured Outputs
+
+```python
+from pydantic import BaseModel, ConfigDict
+from agent_framework.azure import AzureAIAgentsProvider
+from azure.identity.aio import AzureCliCredential
+
+class WeatherResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    
+    location: str
+    temperature: float
+    unit: str
+    conditions: str
+
+async def main():
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentsProvider(credential=credential) as provider,
+    ):
+        agent = await provider.create_agent(
+            name="StructuredAgent",
+            instructions="Provide weather information in structured format.",
+            response_format=WeatherResponse,
+        )
+        
+        result = await agent.run("Weather in Seattle?")
+        weather = WeatherResponse.model_validate_json(result.text)
+        print(f"{weather.location}: {weather.temperature}°{weather.unit}")
+```
+
+## Provider Methods
+
+| Method | Description |
+|--------|-------------|
+| `create_agent()` | Create new agent on Azure AI service |
+| `get_agent(agent_id)` | Retrieve existing agent by ID |
+| `as_agent(sdk_agent)` | Wrap SDK Agent object (no HTTP call) |
+
+## Hosted Tools Quick Reference
+
+| Tool | Import | Purpose |
+|------|--------|---------|
+| `HostedCodeInterpreterTool` | `from agent_framework import HostedCodeInterpreterTool` | Execute Python code |
+| `HostedFileSearchTool` | `from agent_framework import HostedFileSearchTool` | Search vector stores |
+| `HostedWebSearchTool` | `from agent_framework import HostedWebSearchTool` | Bing web search |
+| `HostedMCPTool` | `from agent_framework import HostedMCPTool` | Service-managed MCP |
+| `MCPStreamableHTTPTool` | `from agent_framework import MCPStreamableHTTPTool` | Client-managed MCP |
+
+## Complete Example
+
+```python
+import asyncio
+from typing import Annotated
+from pydantic import BaseModel, Field
+from agent_framework import (
+    HostedCodeInterpreterTool,
+    HostedWebSearchTool,
+    MCPStreamableHTTPTool,
+)
+from agent_framework.azure import AzureAIAgentsProvider
+from azure.identity.aio import AzureCliCredential
+
+
+def get_weather(
+    location: Annotated[str, Field(description="City name")],
+) -> str:
+    """Get weather for a location."""
+    return f"Weather in {location}: 72°F, sunny"
+
+
+class AnalysisResult(BaseModel):
+    summary: str
+    key_findings: list[str]
+    confidence: float
+
+
+async def main():
+    async with (
+        AzureCliCredential() as credential,
+        MCPStreamableHTTPTool(
+            name="Docs MCP",
+            url="https://learn.microsoft.com/api/mcp",
+        ) as mcp_tool,
+        AzureAIAgentsProvider(credential=credential) as provider,
+    ):
+        agent = await provider.create_agent(
+            name="ResearchAssistant",
+            instructions="You are a research assistant with multiple capabilities.",
+            tools=[
+                get_weather,
+                HostedCodeInterpreterTool(),
+                HostedWebSearchTool(name="Bing"),
+                mcp_tool,
+            ],
+        )
+        
+        thread = agent.get_new_thread()
+        
+        # Non-streaming
+        result = await agent.run(
+            "Search for Python best practices and summarize",
+            thread=thread,
+        )
+        print(f"Response: {result.text}")
+        
+        # Streaming
+        print("\nStreaming: ", end="")
+        async for chunk in agent.run_stream("Continue with examples", thread=thread):
+            if chunk.text:
+                print(chunk.text, end="", flush=True)
+        print()
+        
+        # Structured output
+        result = await agent.run(
+            "Analyze findings",
+            thread=thread,
+            response_format=AnalysisResult,
+        )
+        analysis = AnalysisResult.model_validate_json(result.text)
+        print(f"\nConfidence: {analysis.confidence}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Conventions
+
+- Always use async context managers: `async with provider:`
+- Pass functions directly to `tools=` parameter (auto-converted to AIFunction)
+- Use `Annotated[type, Field(description=...)]` for function parameters
+- Use `get_new_thread()` for multi-turn conversations
+- Prefer `HostedMCPTool` for service-managed MCP, `MCPStreamableHTTPTool` for client-managed
+
+## Reference Files
+
+- [references/tools.md](references/tools.md): Detailed hosted tool patterns
+- [references/mcp.md](references/mcp.md): MCP integration (hosted + local)
+- [references/threads.md](references/threads.md): Thread and conversation management
+- [references/advanced.md](references/advanced.md): OpenAPI, citations, structured outputs

package/merged-commands/agent-manager-skill.md

@@ -0,0 +1,40 @@
+---
+name: agent-manager-skill
+description: Manage multiple local CLI agents via tmux sessions (start/stop/monitor/assign) with cron-friendly scheduling.
+---
+
+# Agent Manager Skill
+
+## When to use
+
+Use this skill when you need to:
+
+- run multiple local CLI agents in parallel (separate tmux sessions)
+- start/stop agents and tail their logs
+- assign tasks to agents and monitor output
+- schedule recurring agent work (cron)
+
+## Prerequisites
+
+Install `agent-manager-skill` in your workspace:
+
+```bash
+git clone https://github.com/fractalmind-ai/agent-manager-skill.git
+```
+
+## Common commands
+
+```bash
+python3 agent-manager/scripts/main.py doctor
+python3 agent-manager/scripts/main.py list
+python3 agent-manager/scripts/main.py start EMP_0001
+python3 agent-manager/scripts/main.py monitor EMP_0001 --follow
+python3 agent-manager/scripts/main.py assign EMP_0002 <<'EOF'
+Follow teams/fractalmind-ai-maintenance.md Workflow
+EOF
+```
+
+## Notes
+
+- Requires `tmux` and `python3`.
+- Agents are configured under an `agents/` directory (see the repo for examples).

package/merged-commands/agent-memory-mcp.md

@@ -0,0 +1,82 @@
+---
+name: agent-memory-mcp
+author: Amit Rathiesh
+description: A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions).
+---
+
+# Agent Memory Skill
+
+This skill provides a persistent, searchable memory bank that automatically syncs with project documentation. It runs as an MCP server to allow reading/writing/searching of long-term memories.
+
+## Prerequisites
+
+- Node.js (v18+)
+
+## Setup
+
+1. **Clone the Repository**:
+   Clone the `agentMemory` project into your agent's workspace or a parallel directory:
+
+   ```bash
+   git clone https://github.com/webzler/agentMemory.git .agent/skills/agent-memory
+   ```
+
+2. **Install Dependencies**:
+
+   ```bash
+   cd .agent/skills/agent-memory
+   npm install
+   npm run compile
+   ```
+
+3. **Start the MCP Server**:
+   Use the helper script to activate the memory bank for your current project:
+
+   ```bash
+   npm run start-server <project_id> <absolute_path_to_target_workspace>
+   ```
+
+   _Example for current directory:_
+
+   ```bash
+   npm run start-server my-project $(pwd)
+   ```
+
+## Capabilities (MCP Tools)
+
+### `memory_search`
+
+Search for memories by query, type, or tags.
+
+- **Args**: `query` (string), `type?` (string), `tags?` (string[])
+- **Usage**: "Find all authentication patterns" -> `memory_search({ query: "authentication", type: "pattern" })`
+
+### `memory_write`
+
+Record new knowledge or decisions.
+
+- **Args**: `key` (string), `type` (string), `content` (string), `tags?` (string[])
+- **Usage**: "Save this architecture decision" -> `memory_write({ key: "auth-v1", type: "decision", content: "..." })`
+
+### `memory_read`
+
+Retrieve specific memory content by key.
+
+- **Args**: `key` (string)
+- **Usage**: "Get the auth design" -> `memory_read({ key: "auth-v1" })`
+
+### `memory_stats`
+
+View analytics on memory usage.
+
+- **Usage**: "Show memory statistics" -> `memory_stats({})`
+
+## Dashboard
+
+This skill includes a standalone dashboard to visualize memory usage.
+
+```bash
+npm run start-dashboard <absolute_path_to_target_workspace>
+```
+
+Access at: `http://localhost:3333`