@patricio0312rev/skillset 0.1.0

package/src/utils/readme.js

@@ -0,0 +1,196 @@
+const { TOOLS, DOMAINS } = require('../lib/config');
+
+/**
+ * Generate README.md content for the generated configuration
+ * @param {Object} config - Configuration object
+ * @param {Object} result - Generation result
+ * @returns {string} README content
+ */
+function generateReadme(config, result) {
+  const tool = TOOLS[config.tool];
+  const timestamp = new Date().toISOString();
+
+  return `# Development Skills Configuration
+
+> Generated with [SkillSet](https://github.com/patricio0312rev/skillset)
+
+## Overview
+
+- **Tool**: ${tool.name}
+- **Location**: \`${config.folder}/\`
+- **Domains**: ${config.domains.length}
+- **Skills**: ${result.skillsGenerated}
+- **Generated**: ${new Date().toLocaleString()}
+
+## Usage
+
+${getDetailedUsageInstructions(config.tool, config.folder)}
+
+## Structure
+
+\`\`\`
+${config.folder}/
+${generateStructureTree(config)}
+\`\`\`
+
+## Domains Included
+
+${generateDomainsList(config)}
+
+## Updating
+
+To regenerate or update your configuration:
+
+\`\`\`bash
+npx @patricio0312rev/skillset init
+\`\`\`
+
+Or if installed globally:
+
+\`\`\`bash
+skillset init
+\`\`\`
+
+## Resources
+
+- [SkillSet Documentation](https://github.com/patricio0312rev/skillset)
+- [Skills Collection](https://github.com/patricio0312rev/skills)
+- [Claude Code Documentation](https://claude.com/claude-code)
+- [Agent Skills Documentation](https://agentskills.io)
+
+## Tips
+
+- Commit these files to version control
+- Share with your team for consistent AI assistance
+- Update regularly as your project evolves
+- Customize skill instructions for your specific needs
+
+---
+
+*Generated by SkillSet v${require('../../package.json').version}*
+`;
+}
+
+function getDetailedUsageInstructions(tool, folder) {
+  const instructions = {
+    'claude-code': `### With Claude Code
+
+Skills in this folder are automatically loaded by Claude Code.
+
+\`\`\`bash
+# Skills are available in your Claude Code session
+# Reference them in your prompts
+"Use the api-endpoint-generator skill to create a REST API"
+\`\`\`
+
+### In VS Code / IDE
+
+Skills are loaded from \`${folder}/\` automatically when you open this project in an IDE with Claude Code integration.`,
+
+    'copilot': `### With GitHub Copilot (Agent Skills)
+
+Skills in this folder follow GitHub's Agent Skills format and are automatically recognized by GitHub Copilot.
+
+\`\`\`bash
+# Skills are available when working in this repository
+# GitHub Copilot will use them automatically for suggestions and code generation
+\`\`\`
+
+**Note**: GitHub also supports skills in \`.claude/skills/\` as a fallback location.`,
+
+    'cursor': `### With Cursor
+
+Skills in this folder are formatted as Project Rules for Cursor.
+
+\`\`\`
+# Use @-mentions in Cursor chat:
+@.cursor/rules/api-endpoint-generator/RULE.md
+
+# Or reference naturally in prompts:
+"Using the API endpoint generator rule, create a REST API..."
+\`\`\`
+
+Cursor automatically detects and loads rules from \`.cursor/rules/\`.`,
+
+    'other': `### With Any AI Tool
+
+Skills in this folder use a universal format compatible with most AI coding assistants.
+
+**Methods**:
+
+1. **Upload Method**: Upload relevant skill files to your AI chat
+2. **Reference**: Reference them in your prompts
+3. **Copy-Paste**: Or copy skill content directly into context
+
+Example:
+\`\`\`
+[Upload: ${folder}/api-endpoint-generator/SKILL.md]
+
+"Following the API endpoint generator skill, help me create..."
+\`\`\``
+  };
+
+  return instructions[tool] || instructions.other;
+}
+
+function generateStructureTree(config) {
+  const lines = ['├── README.md'];
+  const toolInfo = TOOLS[config.tool];
+  const fileExtension = toolInfo.fileExtension || 'SKILL.md';
+
+  // Collect all skills across all domains
+  const allSkills = [];
+  config.domains.forEach((domain) => {
+    const skills = DOMAINS[domain].skills;
+
+    // Filter skills if specific ones were selected
+    let displaySkills = skills;
+    if (config.skills && config.skills.length > 0) {
+      displaySkills = skills.filter(skill =>
+        config.skills.includes(skill) ||
+        config.skills.includes(`${domain}/${skill}`)
+      );
+    }
+
+    displaySkills.forEach(skill => {
+      allSkills.push(skill);
+    });
+  });
+
+  // Display skills directly in the target folder
+  allSkills.forEach((skill, index) => {
+    const isLast = index === allSkills.length - 1;
+    const prefix = isLast ? '└──' : '├──';
+    lines.push(`${prefix} ${skill}/`);
+    lines.push(`${isLast ? ' ' : '│'}   └── ${fileExtension}`);
+  });
+
+  return lines.join('\n');
+}
+
+function generateDomainsList(config) {
+  return config.domains.map(domain => {
+    const domainInfo = DOMAINS[domain];
+
+    // Filter skills if specific ones were selected
+    let displaySkills = domainInfo.skills;
+    if (config.skills && config.skills.length > 0) {
+      displaySkills = domainInfo.skills.filter(skill =>
+        config.skills.includes(skill) ||
+        config.skills.includes(`${domain}/${skill}`)
+      );
+    }
+
+    return `### ${domainInfo.name}
+
+${domainInfo.description}
+
+**Skills** (${displaySkills.length}):
+${displaySkills.map(skill => `- \`${skill}\``).join('\n')}
+`;
+  }).join('\n');
+}
+
+module.exports = {
+  generateReadme
+};

package/src/utils/tool-specific.js

@@ -0,0 +1,233 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { TOOLS } = require('../lib/config');
+
+/**
+ * Generate tool-specific configuration files
+ * @param {Object} config - Configuration object
+ * @param {string} targetDir - Target directory path
+ * @param {Array} skillsList - List of generated skills
+ * @returns {Promise<Array>} Array of created file paths
+ */
+async function generateToolSpecificFiles(config, targetDir, skillsList) {
+  const files = [];
+
+  switch (config.tool) {
+    case 'cursor':
+      const cursorFiles = await generateCursorFiles(config, targetDir, skillsList);
+      files.push(...cursorFiles);
+      break;
+
+    case 'copilot':
+      const copilotFiles = await generateCopilotFiles(config, targetDir, skillsList);
+      files.push(...copilotFiles);
+      break;
+
+    case 'claude-code':
+    case 'other':
+      // These use the multi-file structure as-is
+      const indexFile = await generateIndexFile(config, targetDir, skillsList);
+      if (indexFile) files.push(indexFile);
+      break;
+  }
+
+  return files;
+}
+
+/**
+ * Generate Cursor-specific files
+ */
+async function generateCursorFiles(config, targetDir, skillsList) {
+  const files = [];
+
+  // Create usage instructions file inside the target directory
+  const instructionsPath = path.join(targetDir, 'CURSOR_USAGE.md');
+  const instructions = generateCursorInstructions(config, skillsList);
+  await fs.writeFile(instructionsPath, instructions);
+  files.push(instructionsPath);
+
+  return files;
+}
+
+/**
+ * Generate GitHub Copilot configuration
+ */
+async function generateCopilotFiles(config, targetDir, skillsList) {
+  const files = [];
+
+  // Create usage instructions
+  const instructionsPath = path.join(targetDir, 'COPILOT_USAGE.md');
+  const instructions = generateCopilotInstructions(config, skillsList);
+  await fs.writeFile(instructionsPath, instructions);
+  files.push(instructionsPath);
+
+  return files;
+}
+
+/**
+ * Generate index file listing all skills
+ */
+async function generateIndexFile(config, targetDir, skillsList) {
+  const content = `# Development Skills Index
+
+## Available Skills
+
+${skillsList.map(({ domain, skill }) => {
+    return `- **${skill}** (${domain}) - [View](${skill}/${TOOLS[config.tool].fileExtension})`;
+  }).join('\n')}
+
+## Quick Reference
+
+${generateQuickReference(skillsList)}
+`;
+
+  const indexPath = path.join(targetDir, 'INDEX.md');
+  await fs.writeFile(indexPath, content);
+  return indexPath;
+}
+
+function generateQuickReference(skillsList) {
+  const byDomain = {};
+  skillsList.forEach(({ domain, skill }) => {
+    if (!byDomain[domain]) byDomain[domain] = [];
+    byDomain[domain].push(skill);
+  });
+
+  return Object.entries(byDomain).map(([domain, skills]) => {
+    return `### ${domain}\n${skills.map(s => `- ${s}`).join('\n')}`;
+  }).join('\n\n');
+}
+
+/**
+ * Generate Cursor usage instructions
+ */
+function generateCursorInstructions(config, skillsList) {
+  return `# Using Development Skills with Cursor
+
+## Setup Complete
+
+Your development skills are configured and ready to use.
+
+## How to Use
+
+### 1. @-Mentions (Primary Method)
+
+The most powerful way to use skills in Cursor:
+
+\`\`\`
+@${config.folder}/api-endpoint-generator/RULE.md
+
+Create a REST API for user management with:
+- Authentication
+- CRUD operations
+- Rate limiting
+\`\`\`
+
+### 2. Multiple Skills
+
+Combine multiple skills for complex tasks:
+
+\`\`\`
+@${config.folder}/api-endpoint-generator/RULE.md
+@${config.folder}/unit-test-generator/RULE.md
+
+Create and test a payment processing API
+\`\`\`
+
+### 3. In Composer
+
+Use skills in Cursor's Composer mode for multi-file changes:
+
+1. Open Composer (Cmd/Ctrl + I)
+2. Add skill with @-mention
+3. Describe your task
+4. Cursor will apply changes across files
+
+## Tips
+
+- **Specific Skills**: Use the most relevant skill for your task
+- **Combine Skills**: Multiple skills can collaborate on complex tasks
+- **Context**: Skills have access to your codebase context
+- **Iterations**: Refine results by providing feedback
+
+## Available Skills
+
+${skillsList.map(({ domain, skill }) => `- **${skill}** (${domain})`).join('\n')}
+
+## Troubleshooting
+
+**Skills not appearing in @-mentions?**
+- Ensure files are in \`${config.folder}/\` directory
+- Restart Cursor
+- Check Cursor settings for custom rule paths
+
+**Need different skills?**
+Run: \`skillset init\` to reconfigure
+
+---
+
+Happy coding with development skills!
+`;
+}
+
+/**
+ * Generate GitHub Copilot instructions
+ */
+function generateCopilotInstructions(config, skillsList) {
+  return `# GitHub Copilot - Development Skills
+
+This project uses specialized development skills for different aspects of engineering.
+
+## Agent Skills
+
+GitHub Copilot automatically recognizes and uses Agent Skills in this directory.
+
+${skillsList.map(({ domain, skill }) => {
+    return `### ${skill} (${domain})
+
+Specialized skill for ${domain} tasks. See detailed instructions in \`${config.folder}/${skill}/SKILL.md\`
+`;
+  }).join('\n')}
+
+## General Development Guidelines
+
+When working on this project, follow these principles:
+
+### Code Quality
+- Write clean, maintainable code
+- Follow existing patterns in the codebase
+- Add appropriate comments for complex logic
+- Ensure code is self-documenting where possible
+
+### Testing
+- Write tests for new features
+- Maintain high test coverage
+- Include edge cases in tests
+- Follow testing patterns established in the project
+
+### Documentation
+- Update documentation when adding features
+- Keep README files current
+- Document API changes
+- Add inline documentation for public APIs
+
+## Getting Skill Details
+
+For specific guidance on any aspect of development, refer to the detailed skill files:
+
+\`\`\`
+${config.folder}/
+${skillsList.map(({ domain, skill }) => `  ${skill}/SKILL.md`).join('\n')}
+\`\`\`
+
+---
+
+*Generated by SkillSet - https://github.com/patricio0312rev/skillset*
+`;
+}
+
+module.exports = {
+  generateToolSpecificFiles,
+  generateCursorFiles,
+  generateCopilotFiles
+};

package/templates/ai-engineering/agent-orchestration-planner/ SKILL.md

@@ -0,0 +1,266 @@
+---
+name: agent-orchestration-planner
+description: Designs multi-step agent workflows with tool usage, retry logic, state management, and budget controls. Provides orchestration diagrams, tool execution order, fallback strategies, and cost limits. Use for "AI agents", "agentic workflows", "multi-step AI", or "autonomous systems".
+---
+
+# Agent Orchestration Planner
+
+Design robust multi-step agent systems with tools and error handling.
+
+## Agent Architecture
+
+```
+User Query → Planning → Tool Selection → Tool Execution → Result Synthesis → Response
+              ↓            ↓                ↓                    ↓
+           Memory      Retry Logic      Validation         Cost Tracking
+```
+
+## Agent Loop Pattern
+
+```python
+from typing import List, Dict, Any
+
+class Agent:
+    def __init__(self, tools: List[Tool], max_iterations: int = 5):
+        self.tools = tools
+        self.max_iterations = max_iterations
+        self.memory = []
+        self.cost_tracker = CostTracker()
+
+    def run(self, query: str) -> str:
+        self.memory.append({"role": "user", "content": query})
+
+        for iteration in range(self.max_iterations):
+            # Decide next action
+            action = self.plan_next_action()
+
+            if action["type"] == "final_answer":
+                return action["content"]
+
+            # Execute tool
+            result = self.execute_tool(action["tool"], action["params"])
+
+            # Track cost
+            self.cost_tracker.add(result["cost"])
+
+            # Check budget
+            if self.cost_tracker.exceeds_limit():
+                return self.budget_exceeded_response()
+
+            # Add to memory
+            self.memory.append({
+                "role": "tool",
+                "tool": action["tool"],
+                "result": result["data"]
+            })
+
+        return "Max iterations reached"
+
+    def plan_next_action(self) -> Dict:
+        prompt = self.build_planning_prompt()
+        response = llm(prompt)
+        return parse_action(response)
+```
+
+## Tool Orchestration
+
+```python
+TOOL_ORDER = {
+    "search_web": 1,        # Always try search first
+    "query_database": 2,    # Then database
+    "call_api": 3,          # Then external APIs
+    "generate_content": 4,  # Finally generate
+}
+
+def select_tools(query: str, available_tools: List[Tool]) -> List[Tool]:
+    """Select and order tools based on query"""
+    # Use LLM to select relevant tools
+    tool_selection_prompt = f"""
+    Given this query: "{query}"
+
+    Which of these tools are needed? {[t.name for t in available_tools]}
+
+    Return JSON array of tool names in execution order.
+    """
+
+    selected_names = json.loads(llm(tool_selection_prompt))
+    selected_tools = [t for t in available_tools if t.name in selected_names]
+
+    # Sort by predefined order
+    selected_tools.sort(key=lambda t: TOOL_ORDER.get(t.name, 999))
+
+    return selected_tools
+```
+
+## Retry & Fallback Logic
+
+```python
+def execute_with_retry(tool: Tool, params: Dict, max_retries: int = 3):
+    """Execute tool with exponential backoff retry"""
+    for attempt in range(max_retries):
+        try:
+            result = tool.execute(params)
+            return {"success": True, "data": result}
+        except ToolError as e:
+            if attempt == max_retries - 1:
+                # Try fallback tool
+                fallback = get_fallback_tool(tool.name)
+                if fallback:
+                    return execute_with_retry(fallback, params, 1)
+
+                return {"success": False, "error": str(e)}
+
+            # Wait before retry
+            time.sleep(2 ** attempt)
+
+FALLBACK_TOOLS = {
+    "search_web": "query_database",
+    "call_api": "use_cached_data",
+}
+```
+
+## State Management
+
+```python
+class AgentState:
+    def __init__(self):
+        self.memory = []
+        self.tool_results = {}
+        self.costs = 0.0
+        self.iteration = 0
+
+    def add_message(self, role: str, content: str):
+        self.memory.append({"role": role, "content": content})
+
+    def add_tool_result(self, tool_name: str, result: Any):
+        self.tool_results[tool_name] = result
+
+    def get_context(self) -> str:
+        """Build context from memory for next LLM call"""
+        return "\n".join([
+            f"{msg['role']}: {msg['content']}"
+            for msg in self.memory[-5:]  # Last 5 messages
+        ])
+```
+
+## Budget & Cost Controls
+
+```python
+class CostTracker:
+    def __init__(self, max_cost: float = 1.0):
+        self.max_cost = max_cost
+        self.total_cost = 0.0
+        self.breakdown = {}
+
+    def add(self, cost: float, category: str = "llm"):
+        self.total_cost += cost
+        self.breakdown[category] = self.breakdown.get(category, 0) + cost
+
+    def exceeds_limit(self) -> bool:
+        return self.total_cost >= self.max_cost
+
+    def remaining(self) -> float:
+        return self.max_cost - self.total_cost
+
+# Use in agent
+if cost_tracker.exceeds_limit():
+    return f"Budget limit reached. Used ${cost_tracker.total_cost:.4f}"
+```
+
+## Orchestration Diagram
+
+```mermaid
+graph TD
+    A[User Query] --> B[Plan Action]
+    B --> C{Action Type?}
+    C -->|Tool Call| D[Execute Tool]
+    C -->|Final Answer| E[Return Response]
+    D --> F[Validate Result]
+    F -->|Success| G[Update Memory]
+    F -->|Failure| H[Retry/Fallback]
+    H --> D
+    G --> I{Budget OK?}
+    I -->|Yes| B
+    I -->|No| J[Budget Exceeded]
+    J --> E
+```
+
+## Planning Prompt
+
+```python
+def build_planning_prompt(state: AgentState) -> str:
+    return f"""
+You are an agent that can use tools to answer questions.
+
+Available tools:
+{json.dumps([t.schema for t in tools], indent=2)}
+
+Conversation history:
+{state.get_context()}
+
+Based on the conversation, decide your next action:
+1. Call a tool (specify tool name and parameters)
+2. Provide final answer
+
+If calling a tool, respond with:
+{{"action": "tool_call", "tool": "tool_name", "params": {{...}}}}
+
+If providing final answer, respond with:
+{{"action": "final_answer", "content": "your answer"}}
+
+Think step by step about what information you need.
+"""
+```
+
+## Multi-Agent Coordination
+
+```python
+class MultiAgentSystem:
+    def __init__(self):
+        self.agents = {
+            "researcher": ResearchAgent(),
+            "coder": CodeAgent(),
+            "reviewer": ReviewAgent(),
+        }
+
+    def run(self, task: str):
+        # Researcher gathers information
+        context = self.agents["researcher"].run(task)
+
+        # Coder generates solution
+        code = self.agents["coder"].run(f"{task}\nContext: {context}")
+
+        # Reviewer validates
+        review = self.agents["reviewer"].run(f"Review this code:\n{code}")
+
+        if review["approved"]:
+            return code
+        else:
+            # Iterate with feedback
+            return self.agents["coder"].run(
+                f"Fix this code based on feedback:\n{review['feedback']}"
+            )
+```
+
+## Best Practices
+
+1. **Limit iterations**: Prevent infinite loops
+2. **Budget controls**: Track and limit costs
+3. **Tool validation**: Verify tool outputs
+4. **Error handling**: Graceful fallbacks
+5. **State persistence**: Save progress
+6. **Observability**: Log all actions
+7. **Human-in-loop**: Critical decisions
+
+## Output Checklist
+
+- [ ] Agent loop implementation
+- [ ] Tool selection logic
+- [ ] Retry & fallback strategies
+- [ ] State management
+- [ ] Cost tracking
+- [ ] Budget limits
+- [ ] Orchestration diagram
+- [ ] Planning prompts
+- [ ] Error handling
+- [ ] Observability/logging