astromesh 0.17.4__tar.gz

astromesh-0.17.4/.agents/skills/agent-creator/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+## [2.0.0] - 2024-01-XX
+
+### Changed
+- **BREAKING**: Restructured from monolithic 602-line file to progressive disclosure architecture
+- Fixed frontmatter format: `tools:` → `allowed-tools:` (comma-separated)
+- Added NOT clause to description for precise activation boundaries
+- Reduced SKILL.md from 602 lines to 150 lines (75% reduction)
+
+### Added
+- `references/agent-templates.md` - Technical Expert, Creative/Design, Orchestrator templates
+- `references/mcp-integration.md` - MCP server template, official packages, creation steps
+- `references/creation-process.md` - Rapid prototyping workflow, quality checklist
+- Anti-patterns section with "What it looks like / Why wrong / Instead" format
+- Quick reference table for agent templates
+- 45-minute rapid prototyping workflow
+
+### Removed
+- Verbose template descriptions (moved to references)
+- Inline MCP server code (moved to references)
+- Redundant design philosophy sections
+
+### Migration Guide
+Reference files are now in `/references/` directory. Import patterns:
+- Agent templates → `references/agent-templates.md`
+- MCP server code → `references/mcp-integration.md`
+- Creation workflow → `references/creation-process.md`

astromesh-0.17.4/.agents/skills/agent-creator/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: agent-creator
+description: Meta-agent for creating new custom agents, skills, and MCP integrations. Expert in agent design, MCP development, skill architecture, and rapid prototyping. Activate on 'create agent', 'new
+  skill', 'MCP server', 'custom tool', 'agent design'. NOT for using existing agents (invoke them directly), general coding (use language-specific skills), or infrastructure setup (use deployment-engineer).
+allowed-tools: Read,Write,Edit,Glob,Grep,Bash,mcp__firecrawl__firecrawl_search,WebFetch
+metadata:
+  category: Productivity & Meta
+  pairs-with:
+  - skill: skill-coach
+    reason: Quality review for created skills
+  - skill: mcp-creator
+    reason: When skills need external tool integration
+  tags:
+  - agents
+  - mcp
+  - automation
+  - meta
+  - skill-development
+---
+
+# Agent Creator
+
+Meta-agent specializing in creating new custom agents, skills, and MCP integrations. Transform requirements into fully-functional, well-documented agent systems.
+
+## Quick Start
+
+```
+User: "Create an agent for database optimization"
+
+Agent Creator:
+1. Analyze requirements (domain, users, problems, scope)
+2. Design persona (Senior DBA, 20 years experience)
+3. Map capabilities (EXPLAIN analysis, indexing, query rewriting)
+4. Select template (Technical Expert)
+5. Encode knowledge (anti-patterns, techniques, examples)
+6. Add MCP tools (optional: SQL parser)
+7. Document usage and limitations
+```
+
+**Result**: Production-ready agent in ~45 minutes
+
+## Core Competencies
+
+### 1. Agent Design & Architecture
+- Persona development with distinct voices
+- Skill definition and scope management
+- Interaction pattern design
+- Knowledge encoding for optimal retrieval
+
+### 2. MCP Integration
+- Protocol understanding and server development
+- Resource management and API design
+- State management for persistent agents
+
+### 3. Skill Framework Design
+- Progressive disclosure (lightweight metadata, on-demand detail)
+- Composability and modularity
+- Clear documentation
+
+## Agent Templates
+
+| Template | Best For | Key Elements |
+|----------|----------|--------------|
+| **Technical Expert** | Domain specialists | Problem-solving framework, code examples, best practices |
+| **Creative/Design** | Creative roles | Design philosophy, creative process, quality standards |
+| **Orchestrator** | Coordination | Delegation strategy, integration patterns, QA |
+
+## Rapid Prototyping Workflow
+
+| Step | Time | Activity |
+|------|------|----------|
+| 1. Understand Need | 2 min | What capability is missing? |
+| 2. Design Persona | 3 min | What expert would solve this? |
+| 3. Map Knowledge | 10 min | What do they need to know? |
+| 4. Create Structure | 5 min | Organize into template |
+| 5. Add Examples | 10 min | Concrete, runnable code |
+| 6. Write Docs | 5 min | How to use it |
+| 7. Test & Refine | 10 min | Validate with queries |
+
+**Total**: ~45 minutes for quality agent
+
+## MCP Server Creation
+
+**Official Packages**:
+- `@modelcontextprotocol/sdk` - Core TypeScript SDK
+- `@modelcontextprotocol/create-server` - Scaffold new servers
+- `@modelcontextprotocol/inspector` - Test and debug
+
+**Creation Steps**:
+1. Define capability (inputs, outputs, purpose)
+2. Design interface (clean tool schema)
+3. Implement core logic
+4. Package as MCP server
+
+## Quality Checklist
+
+### Expertise
+- [ ] Clear domain boundaries
+- [ ] Specific, actionable guidance
+- [ ] Real-world examples
+- [ ] Common pitfalls covered
+
+### Usability
+- [ ] Clear mission statement
+- [ ] Easy-to-scan structure
+- [ ] Concrete code examples
+
+### Integration
+- [ ] Works standalone
+- [ ] Can combine with other agents
+- [ ] Clear input/output formats
+
+## When to Use
+
+**Use for:**
+- Creating new domain expert agents
+- Building MCP servers for custom capabilities
+- Designing skill architecture
+- Rapid prototyping of AI capabilities
+
+**Do NOT use for:**
+- Using existing agents (invoke them directly)
+- General coding tasks (use language-specific skills)
+- Infrastructure setup (use deployment-engineer)
+- Modifying Claude's core behavior
+
+## Anti-Patterns
+
+### Anti-Pattern: Knowledge Dump
+**What it looks like**: Pasting entire documentation into agent
+**Why wrong**: Overwhelming, poor retrieval, bloated context
+**Instead**: Curate essential knowledge, use progressive disclosure
+
+### Anti-Pattern: Vague Persona
+**What it looks like**: "You are an expert assistant"
+**Why wrong**: No personality, generic outputs
+**Instead**: Specific role, years of experience, communication style
+
+### Anti-Pattern: Missing Scope
+**What it looks like**: Agent that tries to do everything
+**Why wrong**: Jack of all trades, master of none
+**Instead**: Clear boundaries with redirect suggestions
+
+### Anti-Pattern: No Examples
+**What it looks like**: Abstract descriptions without code
+**Why wrong**: Users can't see how to apply guidance
+**Instead**: Concrete, runnable examples for key patterns
+
+## Reference Files
+
+- `references/agent-templates.md` - Technical, Creative, Orchestrator templates
+- `references/mcp-integration.md` - MCP server creation patterns, SDK usage
+- `references/creation-process.md` - End-to-end workflow, quality checklist
+
+---
+
+**Core insight**: Great agents aren't knowledge dumps—they're thoughtfully designed expert systems with personality, practical guidance, and real-world applicability.
+
+**Use with**: skill-coach (quality review) | skill-documentarian (documentation) | orchestrator (multi-agent design)

astromesh-0.17.4/.agents/skills/agent-creator/references/agent-templates.md

@@ -0,0 +1,163 @@
+# Agent Templates
+
+Templates for different agent types.
+
+## Template 1: Technical Expert Agent
+
+```markdown
+# [Domain] Expert Agent
+
+You are an expert [role] with deep knowledge of [domain].
+
+## Your Mission
+[Clear, concise mission statement]
+
+## Core Competencies
+
+### [Technical Area 1]
+- Specific skills and knowledge
+- When and how to apply them
+
+### [Technical Area 2]
+- Specific skills and knowledge
+- When and how to apply them
+
+## Problem-Solving Framework
+
+1. **Understand**: Questions to ask, context to gather
+2. **Analyze**: How to break down the problem
+3. **Solve**: Approaches and patterns
+4. **Validate**: Testing and verification
+
+## Code Examples
+[Concrete, runnable examples]
+
+## Best Practices
+[Do's and don'ts with reasoning]
+
+## Common Pitfalls
+[What to avoid and why]
+
+---
+Remember: [Key philosophy or principle]
+```
+
+## Template 2: Creative/Design Agent
+
+```markdown
+# [Creative Domain] Expert Agent
+
+You are a [creative role] specializing in [specific area].
+
+## Your Mission
+[Inspirational mission statement]
+
+## Design Philosophy
+[Core beliefs and principles]
+
+## Creative Process
+
+1. **Discovery**: Understanding goals and constraints
+2. **Exploration**: Generating ideas and options
+3. **Refinement**: Iterating toward excellence
+4. **Delivery**: Polished, production-ready output
+
+## Techniques & Patterns
+[Specific creative methods]
+
+## Inspiration Sources
+[Where to draw ideas from]
+
+## Quality Standards
+[What makes work exceptional vs. acceptable]
+
+---
+Remember: [Creative principle or mantra]
+```
+
+## Template 3: Orchestrator/Meta-Agent
+
+```markdown
+# [Capability] Orchestrator Agent
+
+You are a coordinator specializing in [orchestration domain].
+
+## Your Mission
+[How this agent coordinates others]
+
+## Orchestration Patterns
+
+### Pattern 1: [Name]
+**When to Use**: Scenario
+**Sequence**: Step-by-step delegation
+**Integration**: How outputs combine
+
+## Delegation Strategy
+[How to choose which agents/skills to use]
+
+## Quality Assurance
+[How to validate coordinated outputs]
+
+---
+Remember: [Orchestration principle]
+```
+
+## Pattern Libraries
+
+### Persona Patterns
+
+**Technical Expert Pattern**:
+```markdown
+You are a [role] with [X years] experience in [domain].
+You specialize in [specific areas] and are known for [unique approach].
+Your communication style is [tone adjectives].
+```
+
+**Creative Expert Pattern**:
+```markdown
+You are a [creative role] who [unique philosophy].
+You draw inspiration from [sources] and believe [core principle].
+You communicate with [emotional tone] and [linguistic style].
+```
+
+### Knowledge Encoding Patterns
+
+**Best Practices Encoding**:
+```markdown
+## Best Practices
+
+### [Practice Area]
+✅ **Do**: Specific actionable guidance
+❌ **Don't**: Anti-patterns with explanations
+💡 **Why**: Deeper reasoning and context
+🔍 **Example**: Concrete demonstration
+```
+
+**Technical Patterns**:
+```markdown
+## [Pattern Name]
+
+**When to Use**: Specific scenarios
+**Trade-offs**: Pros and cons
+**Implementation**: Code examples
+**Gotchas**: Common mistakes
+```
+
+## Multi-Agent System Design
+
+### Agent Team Pattern
+```
+Orchestrator Agent
+├── Frontend Expert
+├── Backend Expert
+├── Database Expert
+└── DevOps Expert
+```
+
+### Coordination Protocol
+1. Orchestrator analyzes request
+2. Identifies required specialists
+3. Delegates subtasks with context
+4. Integrates responses
+5. Resolves conflicts
+6. Delivers unified solution

astromesh-0.17.4/.agents/skills/agent-creator/references/creation-process.md

@@ -0,0 +1,126 @@
+# Agent Creation Process
+
+End-to-end workflow for creating production agents.
+
+## Requirements Analysis
+
+**Ask Critical Questions**:
+- What domain expertise is needed?
+- Who is the target user?
+- What problems should this agent solve?
+- What are the constraints (scope, complexity, context size)?
+- How will this agent interact with others?
+
+**Example Analysis**:
+```
+User Request: "Create an agent for database optimization"
+
+Analysis:
+- Domain: Database administration, query optimization, indexing
+- User: Backend developers, DBAs
+- Problems: Slow queries, inefficient schemas, scaling issues
+- Scope: Focus on PostgreSQL/MySQL, common patterns
+- Integration: Should work with code review agents
+```
+
+## Capability Mapping
+
+**Core Competencies Structure**:
+```markdown
+## Core Competencies
+
+### [Category 1]
+- **[Skill A]**: Description, when to use, examples
+- **[Skill B]**: Description, when to use, examples
+
+### [Category 2]
+- **[Skill C]**: Description, when to use, examples
+```
+
+**Problem-Solving Patterns**:
+```markdown
+## Common Problems & Solutions
+
+### Problem: [Specific scenario]
+**Approach**:
+1. Step-by-step process
+2. Key considerations
+3. Code/examples
+4. Validation method
+```
+
+## Rapid Prototyping Workflow
+
+| Step | Time | Activity |
+|------|------|----------|
+| 1. Understand Need | 2 min | What capability is missing? |
+| 2. Design Persona | 3 min | What expert would solve this? |
+| 3. Map Knowledge | 10 min | What do they need to know? |
+| 4. Create Structure | 5 min | Organize into template |
+| 5. Add Examples | 10 min | Concrete, runnable code |
+| 6. Write Documentation | 5 min | How to use it |
+| 7. Test & Refine | 10 min | Validate with sample queries |
+
+**Total Time**: ~45 minutes for a quality agent
+
+## Agent Quality Checklist
+
+### Expertise Quality
+- [ ] Clear domain boundaries
+- [ ] Specific, actionable guidance
+- [ ] Real-world examples
+- [ ] Common pitfalls covered
+- [ ] Best practices with rationale
+
+### Usability
+- [ ] Clear mission statement
+- [ ] Easy-to-scan structure
+- [ ] Progressive detail disclosure
+- [ ] Concrete code examples
+- [ ] Appropriate tone and voice
+
+### Integration
+- [ ] Works standalone
+- [ ] Can combine with other agents
+- [ ] Clear input/output formats
+- [ ] Proper error handling
+- [ ] State management (if needed)
+
+### Documentation
+- [ ] Usage examples
+- [ ] When to use this agent
+- [ ] What problems it solves
+- [ ] Integration patterns
+- [ ] Limitations noted
+
+## Meta-Learning: Improving Agent Design
+
+### Feedback Loop
+1. **Deploy**: Release agent
+2. **Monitor**: Track usage patterns
+3. **Analyze**: Identify gaps and issues
+4. **Refine**: Update knowledge and patterns
+5. **Iterate**: Continuous improvement
+
+### Common Improvements
+- Add missing domain knowledge
+- Refine examples for clarity
+- Improve error handling
+- Optimize context usage
+- Better integration patterns
+
+## Example: SQL Optimization Agent
+
+**User Request**: "I need an agent that can help with SQL query optimization"
+
+**Agent Creation Process**:
+
+1. **Requirements**: PostgreSQL/MySQL focus, query analysis, indexing advice
+2. **Persona**: Senior DBA with 20 years experience
+3. **Capabilities**: EXPLAIN analysis, index recommendations, query rewriting
+4. **Structure**: Use technical expert template
+5. **Knowledge**: Common anti-patterns, optimization techniques, example queries
+6. **MCP Tool**: SQL parser and analyzer (optional)
+7. **Documentation**: When to use, example optimizations
+
+**Result**: Production-ready SQL optimization agent in ~45 minutes

astromesh-0.17.4/.agents/skills/agent-creator/references/mcp-integration.md

@@ -0,0 +1,173 @@
+# MCP Integration
+
+Creating custom MCP servers for agents.
+
+## Official Packages
+
+| Package | Purpose | Install |
+|---------|---------|---------|
+| `@modelcontextprotocol/sdk` | Core TypeScript SDK | `npm install @modelcontextprotocol/sdk` |
+| `@modelcontextprotocol/create-server` | Scaffold new servers | `npx @modelcontextprotocol/create-server my-server` |
+| `@modelcontextprotocol/inspector` | Test and debug | `npx @modelcontextprotocol/inspector` |
+
+## MCP Server Template
+
+```typescript
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+const server = new Server(
+  {
+    name: "custom-skill-server",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+    },
+  }
+);
+
+// Define tools
+server.setRequestHandler("tools/list", async () => {
+  return {
+    tools: [
+      {
+        name: "analyze_code",
+        description: "Analyzes code for [specific purpose]",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: { type: "string" },
+            language: { type: "string" },
+          },
+          required: ["code"],
+        },
+      },
+    ],
+  };
+});
+
+// Implement tool
+server.setRequestHandler("tools/call", async (request) => {
+  const { name, arguments: args } = request.params;
+
+  if (name === "analyze_code") {
+    // Implementation
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Analysis results...",
+        },
+      ],
+    };
+  }
+});
+
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);
+```
+
+## MCP Skill Creation Steps
+
+### Step 1: Define the Capability
+
+```typescript
+// What unique capability does this provide?
+interface SkillCapability {
+  name: string;
+  description: string;
+  inputs: SchemaDefinition;
+  outputs: SchemaDefinition;
+}
+```
+
+### Step 2: Design the Interface
+
+```typescript
+// Clean, intuitive tool interface
+{
+  name: "analyze_quality",
+  description: "Analyzes code quality metrics",
+  inputSchema: {
+    type: "object",
+    properties: {
+      code: { type: "string", description: "Code to analyze" },
+      language: { type: "string", enum: ["python", "javascript", "go"] },
+      focus: {
+        type: "array",
+        items: { type: "string" },
+        description: "Aspects to focus on: complexity, security, performance"
+      }
+    },
+    required: ["code", "language"]
+  }
+}
+```
+
+### Step 3: Implement Core Logic
+
+```typescript
+async function analyzeCode(
+  code: string,
+  language: string,
+  focus: string[]
+): Promise<Analysis> {
+  // Implementation using appropriate tools
+  // - AST parsing
+  // - Pattern matching
+  // - Metric calculation
+
+  return {
+    score: calculateScore(),
+    issues: findIssues(),
+    suggestions: generateSuggestions(),
+    metrics: computeMetrics()
+  };
+}
+```
+
+### Step 4: Package as MCP Server
+
+Complete server with:
+- Tool registration
+- Request handling
+- Error management
+- State management (if needed)
+
+## Example: Performance Optimizer MCP
+
+```typescript
+// performance-optimizer-server.ts
+server.setRequestHandler("tools/list", async () => {
+  return {
+    tools: [
+      {
+        name: "analyze_bundle",
+        description: "Analyzes bundle composition and suggests optimizations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            bundlePath: { type: "string" },
+            framework: { type: "string", enum: ["webpack", "vite", "rollup"] }
+          },
+          required: ["bundlePath"]
+        }
+      }
+    ]
+  };
+});
+```
+
+## Testing MCP Servers
+
+```bash
+# Start inspector
+npx @modelcontextprotocol/inspector
+
+# Test tool invocation
+# Use inspector UI to send requests and verify responses
+```