Initial commit

skills/pi-pathfinder/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: skill-adapter
+description: |
+  Analyzes existing plugins to extract their capabilities, then adapts and applies those skills to the current task. Acts as a universal skill chameleon that learns from other plugins. Activates when you request "skill adapter" functionality.
+allowed-tools: Read, Grep, Glob, Bash
+version: 1.0.0
+---
+
+# Skill Adapter - Universal Plugin Capability Extractor
+
+## Purpose
+Analyzes plugins in the claude-code-plugins marketplace to understand their capabilities, extracts the core patterns and approaches, then adapts those skills to solve the current user's task. Acts as a "skill chameleon" that can adopt any plugin's capabilities.
+
+## How It Works
+
+### 1. Task Analysis
+When user presents a task:
+- Identify the core capability needed (e.g., "analyze code quality", "generate documentation", "automate deployment")
+- Determine the domain (security, devops, testing, etc.)
+- Extract key requirements and constraints
+
+### 2. Plugin Discovery
+Search existing plugins for relevant capabilities:
+
+```bash
+# Find plugins in relevant category
+ls plugins/community/ plugins/packages/ plugins/examples/
+
+# Search for keywords in plugin descriptions
+grep -r "keyword" --include="plugin.json" plugins/
+
+# Find similar commands/agents
+grep -r "capability-name" --include="*.md" plugins/
+```
+
+### 3. Capability Extraction
+
+For each relevant plugin found, analyze:
+
+**Commands (commands/*.md):**
+- Read the markdown content
+- Extract the approach/methodology
+- Identify input/output patterns
+- Note any scripts or tools used
+
+**Agents (agents/*.md):**
+- Understand the agent's role
+- Extract problem-solving approach
+- Note decision-making patterns
+- Identify expertise areas
+
+**Skills (skills/*/SKILL.md):**
+- Read the skill instructions
+- Extract core capability
+- Note trigger conditions
+- Understand tool usage patterns
+
+**Scripts (scripts/*.sh, *.py):**
+- Analyze script logic
+- Extract reusable patterns
+- Identify best practices
+- Note error handling approaches
+
+### 4. Pattern Synthesis
+
+Combine learned patterns:
+- Merge multiple approaches if beneficial
+- Adapt to current context and constraints
+- Simplify or enhance based on user needs
+- Ensure compatibility with current environment
+
+### 5. Skill Application
+
+Apply the adapted skill:
+- Use the learned approach
+- Follow the extracted patterns
+- Apply best practices discovered
+- Adapt syntax/tools to current context
+
+## Example Workflows
+
+### Example 1: Learning Code Analysis from Security Plugins
+
+**User task:** "Analyze this codebase for issues"
+
+**Process:**
+1. Search for security and code-analysis plugins
+2. Find: `owasp-top-10-scanner`, `code-quality-enforcer`, `security-audit-agent`
+3. Extract patterns:
+   - OWASP scanner checks for: SQL injection, XSS, CSRF, auth issues
+   - Quality enforcer looks at: complexity, duplication, standards
+   - Audit agent examines: dependencies, secrets, permissions
+4. Synthesize approach:
+   - Run multi-layer analysis
+   - Check security patterns first
+   - Then code quality metrics
+   - Then dependency issues
+5. Apply to user's codebase with adapted checks
+
+### Example 2: Adopting Documentation Skills
+
+**User task:** "Generate API documentation"
+
+**Process:**
+1. Find documentation plugins
+2. Discover: `api-documenter`, `openapi-generator`, `readme-builder`
+3. Extract approaches:
+   - API documenter: parses code, generates OpenAPI spec
+   - OpenAPI generator: creates interactive docs
+   - README builder: structures documentation hierarchically
+4. Synthesize:
+   - Parse code for endpoints
+   - Generate OpenAPI/Swagger spec
+   - Create interactive documentation
+   - Build comprehensive README
+5. Apply combined approach to user's API
+
+### Example 3: Learning Automation from DevOps Plugins
+
+**User task:** "Automate deployment process"
+
+**Process:**
+1. Search DevOps category
+2. Find: `deployment-automation`, `ci-cd-pipeline`, `docker-compose-generator`
+3. Extract patterns:
+   - Deployment automation: build → test → deploy → verify
+   - CI/CD pipeline: trigger conditions, parallel jobs, rollback
+   - Docker compose: service orchestration, environment management
+4. Synthesize deployment workflow
+5. Apply to user's specific tech stack
+
+## Reasoning Process
+
+### When to Use Skill Adapter
+
+Trigger when:
+- User needs capability that might exist in marketplace
+- Task could benefit from existing plugin patterns
+- User asks: "Is there a plugin for this?"
+- Similar problems have been solved before
+- Multiple approaches could be combined
+
+### Plugin Selection Criteria
+
+Choose plugins based on:
+1. **Relevance**: Matches task domain/requirements
+2. **Quality**: Well-documented, clear approach
+3. **Simplicity**: Not overly complex for the task
+4. **Recency**: Updated plugins preferred
+5. **Popularity**: Featured or well-maintained plugins
+
+### Adaptation Strategy
+
+When adapting skills:
+- **Keep**: Core logic and proven patterns
+- **Adapt**: Syntax, tool names, specific commands
+- **Enhance**: Add error handling, user feedback
+- **Simplify**: Remove unnecessary complexity
+- **Contextualize**: Adjust to user's environment
+
+## Limitations and Boundaries
+
+### What Skill Adapter CAN Do:
+✅ Read and analyze plugin source code
+✅ Extract patterns and approaches
+✅ Adapt methodologies to new contexts
+✅ Combine multiple plugin capabilities
+✅ Apply learned skills with reasoning
+
+### What Skill Adapter CANNOT Do:
+❌ Execute compiled code (MCP servers)
+❌ Access external APIs without credentials
+❌ Modify original plugins
+❌ Guarantee exact plugin behavior replication
+❌ Use plugins that require specific environment setup
+
+## Success Criteria
+
+Skill adaptation is successful when:
+1. User's task is completed effectively
+2. Approach borrowed makes logical sense
+3. Adapted skill is properly contextualized
+4. User understands where the approach came from
+5. Result quality matches or exceeds original plugin
+
+## Transparency
+
+Always inform user:
+- Which plugins were analyzed
+- What patterns were extracted
+- How the skill was adapted
+- Why this approach was chosen
+- Any limitations of the adaptation
+
+## Example Usage
+
+```
+User: "I need to validate JSON schemas in my project"
+
+Skill Adapter Process:
+1. Searches plugins for JSON validation
+2. Finds: schema-validator, json-lint-enforcer
+3. Extracts: ajv library usage, error formatting patterns
+4. Adapts: Uses available tools (jq, node, python)
+5. Applies: Validates user's schemas with detailed errors
+6. Reports: "I adapted the schema-validator approach using jq
+   for validation and added custom error formatting"
+```
+
+## Meta-Learning
+
+Skill Adapter improves by:
+- Tracking which plugins solve which tasks best
+- Learning which patterns are most reusable
+- Noting which adaptations work well
+- Building a mental model of the marketplace
+- Understanding plugin ecosystem relationships
+
+---
+
+**In essence:** Skill Adapter is a meta-skill that makes the entire plugin marketplace available as a learning resource, extracting and applying capabilities on-demand to solve user tasks efficiently.