docs: Add example skill files

- code-reviewer: SKILL.md + tests.yml
- git-commit: SKILL.md + tests.yml
- api-documenter: SKILL.md + STYLE_GUIDE.md (composite skill)
- data-analyst: SKILL.md with full metadata

Update .gitignore to allow examples/skills/

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lhassa8

.gitignore

@@ -52,7 +52,8 @@ Thumbs.db
 .env
 .env.local
 api_key.txt
-skills/
+/skills/
+!examples/skills/
 *.zip
 
 # Claude Code settings (may contain sensitive data)

examples/skills/api-documenter/SKILL.md

@@ -0,0 +1,133 @@
+---
+schema_version: "1.0"
+name: api-documenter
+description: Use when asked to generate API documentation. Creates comprehensive docs with endpoints, parameters, and examples.
+version: 1.0.0
+min_skillforge_version: 1.0.0
+tags:
+  - documentation
+  - api
+includes:
+  - ./STYLE_GUIDE.md
+---
+
+# API Documentation Generator
+
+Generate comprehensive API documentation from code, specifications, or descriptions.
+
+## Documentation Structure
+
+Every API endpoint should include:
+
+1. **Endpoint**: HTTP method and path
+2. **Description**: What the endpoint does
+3. **Authentication**: Required auth (if any)
+4. **Parameters**: Path, query, and body parameters
+5. **Response**: Success and error responses
+6. **Examples**: Request/response examples
+
+## Output Format
+
+```markdown
+## Endpoint Name
+
+Brief description.
+
+### Request
+
+`METHOD /path/:param`
+
+**Authentication**: Bearer token / API key / None
+
+**Parameters**:
+| Name | Type | In | Required | Description |
+|------|------|-----|----------|-------------|
+| id | string | path | Yes | Resource ID |
+
+**Body**:
+```json
+{
+  "field": "value"
+}
+```
+
+### Response
+
+**Success (200)**:
+```json
+{
+  "data": {}
+}
+```
+
+**Error (4xx)**:
+```json
+{
+  "error": "message"
+}
+```
+
+### Example
+
+```bash
+curl -X METHOD https://api.example.com/path \
+  -H "Authorization: Bearer token" \
+  -d '{"field": "value"}'
+```
+```
+
+## Examples
+
+### Example 1: REST Endpoint
+
+**User**: Document this endpoint:
+```python
+@app.get("/users/{user_id}")
+def get_user(user_id: int, include_posts: bool = False):
+    """Get user by ID."""
+    ...
+```
+
+**Response**:
+
+## Get User
+
+Retrieve a user by their unique identifier.
+
+### Request
+
+`GET /users/:user_id`
+
+**Authentication**: Bearer token
+
+**Parameters**:
+| Name | Type | In | Required | Description |
+|------|------|-----|----------|-------------|
+| user_id | integer | path | Yes | Unique user identifier |
+| include_posts | boolean | query | No | Include user's posts (default: false) |
+
+### Response
+
+**Success (200)**:
+```json
+{
+  "id": 123,
+  "name": "John Doe",
+  "email": "john@example.com",
+  "posts": []
+}
+```
+
+**Error (404)**:
+```json
+{
+  "error": "User not found"
+}
+```
+
+### Example
+
+```bash
+curl https://api.example.com/users/123?include_posts=true \
+  -H "Authorization: Bearer your-token"
+```

examples/skills/api-documenter/STYLE_GUIDE.md

@@ -0,0 +1,31 @@
+# Documentation Style Guide
+
+This reference document defines the style conventions for API documentation.
+
+## Writing Style
+
+- Use **active voice**: "Returns the user" not "The user is returned"
+- Use **present tense**: "Creates a resource" not "Will create"
+- Be **concise**: Avoid unnecessary words
+- Use **consistent terminology**: Pick one term and stick with it
+
+## Code Examples
+
+- Always include working curl examples
+- Show both request and response
+- Use realistic but safe example data
+- Include error examples for common cases
+
+## Parameter Descriptions
+
+- Start with a verb or noun
+- Include valid values for enums
+- Note default values
+- Mention constraints (min/max, format)
+
+## Response Documentation
+
+- Document all possible status codes
+- Show full response structure
+- Include pagination details if applicable
+- Document rate limit headers

examples/skills/code-reviewer/SKILL.md

@@ -0,0 +1,109 @@
+---
+schema_version: "1.0"
+name: code-reviewer
+description: Use when asked to review code for bugs, security issues, performance problems, or style improvements. Provides structured feedback with severity levels.
+version: 1.0.0
+min_skillforge_version: 1.0.0
+tags:
+  - code-quality
+  - review
+  - security
+---
+
+# Code Reviewer
+
+You are an expert code reviewer. Analyze code for bugs, security vulnerabilities, performance issues, and style improvements.
+
+## Instructions
+
+When reviewing code:
+
+1. **Read the code** carefully and understand its purpose
+2. **Identify issues** categorized by severity:
+   - **Critical**: Security vulnerabilities, data loss risks
+   - **High**: Bugs that will cause failures
+   - **Medium**: Performance issues, code smells
+   - **Low**: Style issues, minor improvements
+3. **Provide fixes** with corrected code snippets
+4. **Suggest improvements** for maintainability
+
+## Response Format
+
+Structure your review as:
+
+```
+## Summary
+One-line overview of the code quality.
+
+## Issues Found
+
+### [Severity] Issue Title
+- **Location**: file:line or function name
+- **Problem**: What's wrong
+- **Fix**: How to fix it with code example
+
+## Recommendations
+Prioritized list of improvements.
+```
+
+## Examples
+
+### Example 1: SQL Injection
+
+**User**: Review this code
+```python
+def get_user(user_id):
+    query = f"SELECT * FROM users WHERE id = {user_id}"
+    return db.execute(query)
+```
+
+**Response**:
+## Summary
+Critical security vulnerability found - SQL injection risk.
+
+## Issues Found
+
+### [Critical] SQL Injection Vulnerability
+- **Location**: `get_user` function
+- **Problem**: User input is directly interpolated into SQL query, allowing attackers to execute arbitrary SQL.
+- **Fix**: Use parameterized queries:
+```python
+def get_user(user_id: int):
+    query = "SELECT * FROM users WHERE id = %s"
+    return db.execute(query, (user_id,))
+```
+
+## Recommendations
+1. Use an ORM like SQLAlchemy for safer database operations
+2. Add input validation for user_id
+3. Add type hints for better code clarity
+
+### Example 2: Clean Code
+
+**User**: Review this function
+```python
+def calculate_total(items: list[dict]) -> float:
+    return sum(item['price'] * item['quantity'] for item in items)
+```
+
+**Response**:
+## Summary
+Clean, well-written code with minor improvement suggestions.
+
+## Issues Found
+No critical or high-severity issues found.
+
+## Recommendations
+1. Consider adding error handling for missing keys
+2. Add docstring explaining expected item format
+3. Consider using a dataclass for type safety:
+```python
+@dataclass
+class Item:
+    price: float
+    quantity: int
+
+def calculate_total(items: list[Item]) -> float:
+    """Calculate total price for a list of items."""
+    return sum(item.price * item.quantity for item in items)
+```

examples/skills/code-reviewer/tests.yml

@@ -0,0 +1,83 @@
+version: "1.0"
+
+defaults:
+  timeout: 30
+
+tests:
+  - name: "detects_sql_injection"
+    description: "Should identify SQL injection vulnerabilities"
+    input: |
+      Review this code:
+      ```python
+      def get_user(id):
+          query = f"SELECT * FROM users WHERE id = {id}"
+          return db.execute(query)
+      ```
+    assertions:
+      - type: contains
+        value: "SQL injection"
+        case_sensitive: false
+      - type: contains
+        value: "Critical"
+        case_sensitive: false
+      - type: regex
+        pattern: "parameterized|prepared|placeholder"
+    mock:
+      response: |
+        ## Summary
+        Critical security vulnerability found - SQL injection risk.
+
+        ## Issues Found
+
+        ### [Critical] SQL Injection Vulnerability
+        - **Problem**: User input directly in query
+        - **Fix**: Use parameterized queries
+    tags: ["security", "critical"]
+
+  - name: "provides_structured_feedback"
+    description: "Should use the defined response format"
+    input: "Review this function: def add(a, b): return a + b"
+    assertions:
+      - type: contains
+        value: "Summary"
+      - type: regex
+        pattern: "(Issues|Recommendations)"
+    mock:
+      response: |
+        ## Summary
+        Simple, clean function.
+
+        ## Issues Found
+        None.
+
+        ## Recommendations
+        - Add type hints
+        - Add docstring
+    tags: ["format"]
+
+  - name: "handles_clean_code"
+    description: "Should acknowledge good code"
+    input: |
+      Review this:
+      ```python
+      def calculate_total(items: list[dict]) -> float:
+          """Calculate total price."""
+          return sum(item['price'] * item['quantity'] for item in items)
+      ```
+    assertions:
+      - type: not_contains
+        value: "Critical"
+      - type: regex
+        pattern: "(clean|good|well)"
+        case_sensitive: false
+    mock:
+      response: |
+        ## Summary
+        Clean, well-written code with good practices.
+
+        ## Issues Found
+        No critical issues.
+
+        ## Recommendations
+        Consider using dataclasses for type safety.
+    tags: ["positive"]