claude-flow-novice 2.18.5 → 2.18.7

package/.claude/skills/cfn-cerebras-coordinator/pattern-examples.md

@@ -0,0 +1,317 @@
+# TDD Pattern Examples - What "Patterns" Means in Practice
+
+These are actual examples of patterns that get stored in RuVector and reused. They're not just code snippets - they're successful approaches with context.
+
+## Example 1: Rust API Handler Pattern
+
+**Stored in RuVector after successful generation:**
+
+```json
+{
+  "type": "tdd_pattern",
+  "agent_id": "backend-developer-123",
+  "file_type": "rust",
+  "feature": "User authentication API endpoint",
+  "success": true,
+  "confidence": 0.95,
+  "pattern": {
+    "test_first": true,
+    "structure": "Given/When/Then",
+    "key_elements": [
+      "Write tests for HTTP status codes",
+      "Test error cases explicitly",
+      "Use mock dependencies",
+      "Test with invalid JSON",
+      "Include authentication edge cases"
+    ]
+  }
+}
+```
+
+**When queried for "rust API handler", the system provides:**
+
+```rust
+// Successful Pattern: User Authentication Handler
+// Tests that worked well:
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum_test::TestServer;
+    use serde_json::json;
+
+    #[tokio::test]
+    async fn test_login_success() {
+        // Given
+        let app = create_app().await;
+        let server = TestServer::new(app).unwrap();
+        let payload = json!({
+            "email": "test@example.com",
+            "password": "password123"
+        });
+
+        // When
+        let response = server
+            .post("/api/auth/login")
+            .json(&payload)
+            .await;
+
+        // Then
+        assert_eq!(response.status_code(), 200);
+        let body: serde_json::Value = response.json();
+        assert!(body["token"].is_string());
+    }
+
+    #[tokio::test]
+    async fn test_login_invalid_credentials() {
+        // Given
+        let app = create_app().await;
+        let server = TestServer::new(app).unwrap();
+        let payload = json!({
+            "email": "test@example.com",
+            "password": "wrongpassword"
+        });
+
+        // When
+        let response = server
+            .post("/api/auth/login")
+            .json(&payload)
+            .await;
+
+        // Then
+        assert_eq!(response.status_code(), 401);
+    }
+}
+```
+
+## Example 2: TypeScript React Component Pattern
+
+**Pattern metadata:**
+```json
+{
+  "type": "success_pattern",
+  "file_type": "tsx",
+  "framework": "React",
+  "success_rate": 0.92,
+  "common_elements": [
+    "TypeScript interfaces for props",
+    "useEffect for data fetching",
+    "Loading and error states",
+    "Responsive design with Tailwind",
+    "Jest + Testing Library tests"
+  ]
+}
+```
+
+**Reusable test pattern provided:**
+```tsx
+// Pattern: Data Fetching Component with Tests
+// This approach consistently worked for React components
+
+import React, { useState, useEffect } from 'react';
+import { User } from '../types/User';
+
+interface UserProfileProps {
+  userId: string;
+  onUpdate?: (user: User) => void;
+}
+
+export const UserProfile: React.FC<UserProfileProps> = ({ userId, onUpdate }) => {
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    fetchUser();
+  }, [userId]);
+
+  const fetchUser = async () => {
+    try {
+      setLoading(true);
+      const response = await fetch(`/api/users/${userId}`);
+      if (!response.ok) throw new Error('Failed to fetch user');
+      const userData = await response.json();
+      setUser(userData);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Unknown error');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  if (loading) return <div className="loading">Loading...</div>;
+  if (error) return <div className="error">{error}</div>;
+  if (!user) return <div className="no-data">No user found</div>;
+
+  return (
+    <div className="user-profile">
+      <h2>{user.name}</h2>
+      <p>{user.email}</p>
+    </div>
+  );
+};
+
+// Tests that consistently passed:
+import { render, screen, waitFor } from '@testing-library/react';
+import { UserProfile } from './UserProfile';
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
+
+const server = setupServer(
+  rest.get('/api/users/1', (req, res, ctx) => {
+    return res(ctx.json({ id: '1', name: 'John Doe', email: 'john@example.com' }));
+  })
+);
+
+describe('UserProfile', () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  it('displays user data when loaded', async () => {
+    render(<UserProfile userId="1" />);
+
+    await waitFor(() => {
+      expect(screen.getByText('John Doe')).toBeInTheDocument();
+      expect(screen.getByText('john@example.com')).toBeInTheDocument();
+    });
+  });
+
+  it('shows loading state initially', () => {
+    render(<UserProfile userId="1" />);
+    expect(screen.getByText('Loading...')).toBeInTheDocument();
+  });
+
+  it('handles API errors gracefully', async () => {
+    server.use(
+      rest.get('/api/users/1', (req, res, ctx) => {
+        return res(ctx.status(500));
+      })
+    );
+
+    render(<UserProfile userId="1" />);
+
+    await waitFor(() => {
+      expect(screen.getByText(/Unknown error/)).toBeInTheDocument();
+    });
+  });
+});
+```
+
+## Example 3: Python Service Layer Pattern
+
+**Pattern tracked in RuVector:**
+```python
+# Successful Pattern: Service Layer with Business Logic
+# Key elements that made this successful:
+
+class UserService:
+    """
+    Service layer for user operations.
+    Follows business rules, not just CRUD.
+    """
+
+    def __init__(self, user_repo: UserRepository, email_service: EmailService):
+        self._user_repo = user_repo
+        self._email_service = email_service
+
+    async def create_user(self, user_data: CreateUserRequest) -> User:
+        """Create user with business validation."""
+        # Business rule: Email must be unique
+        existing = await self._user_repo.find_by_email(user_data.email)
+        if existing:
+            raise DuplicateEmailError(user_data.email)
+
+        # Business rule: Password strength
+        if not self._is_strong_password(user_data.password):
+            raise WeakPasswordError()
+
+        # Create user
+        user = await self._user_repo.save(user_data)
+
+        # Send welcome email
+        await self._email_service.send_welcome(user)
+
+        return user
+
+    def _is_strong_password(self, password: str) -> bool:
+        """Business rule for password strength."""
+        return (
+            len(password) >= 8 and
+            any(c.isupper() for c in password) and
+            any(c.islower() for c in password) and
+            any(c.isdigit() for c in password)
+        )
+
+# Tests that validated business logic:
+class TestUserService:
+    def test_create_user_success(self):
+        # Given
+        mock_repo = Mock()
+        mock_email = Mock()
+        service = UserService(mock_repo, mock_email)
+        user_data = CreateUserRequest(
+            email="test@example.com",
+            password="StrongPass123"
+        )
+
+        # When
+        result = service.create_user(user_data)
+
+        # Then
+        assert result.email == "test@example.com"
+        mock_email.send_welcome.assert_called_once_with(result)
+
+    def test_create_user_duplicate_email(self):
+        # Given
+        mock_repo = Mock()
+        mock_repo.find_by_email.return_value = User(email="test@example.com")
+        service = UserService(mock_repo, Mock())
+
+        # When/Then
+        with pytest.raises(DuplicateEmailError):
+            service.create_user(CreateUserRequest(email="test@example.com"))
+```
+
+## What Makes These "Patterns"?
+
+1. **Context-Aware**: Not just code, but WHY it worked
+   - Agent ID (who succeeded with this)
+   - File type and framework context
+   - Success rate and confidence
+   - Common pitfalls that were avoided
+
+2. **Structured Approach**:
+   - Test-first methodology
+   - Clear Given/When/Then structure
+   - Specific assertion patterns
+   - Error handling approaches
+
+3. **Reusable Elements**:
+   - Test setup patterns
+   - Mocking strategies
+   - Data validation approaches
+   - Error response formats
+
+4. **Learning Metadata**:
+   - What failed initially
+   - How it was fixed
+   - Performance characteristics
+   - Dependencies that mattered
+
+## How Patterns Are Used
+
+When an agent requests similar functionality:
+
+```bash
+./query-patterns.sh --file-type rs --pattern "authentication API"
+```
+
+The system returns:
+1. **Successful test structures** that passed consistently
+2. **Implementation approaches** that worked well
+3. **Common pitfalls** to avoid
+4. **Context files** that helped (types, mocks, etc.)
+5. **Agent-specific tips** - what worked for your agent type
+
+This isn't just copying code - it's learning from experience what approaches consistently succeed for each language, framework, and agent type.

package/.claude/skills/cfn-cerebras-coordinator/query-patterns.sh

@@ -0,0 +1,182 @@
+#!/bin/bash
+set -euo pipefail
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DB_PATH="${COORDINATION_DB_PATH:-$SCRIPT_DIR/generations.db}"
+RUVECTOR_INDEX="${RUVECTOR_INDEX_PATH:-./.claude/skills/cfn-ruvector-codebase-index/data}"
+
+# Parse arguments
+FILE_TYPE=""
+PATTERN=""
+AGENT_ID=""
+SUCCESS_RATE_THRESHOLD=""
+LIMIT="10"
+FORMAT="table"
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --file-type) FILE_TYPE="$2"; shift 2 ;;
+        --pattern) PATTERN="$2"; shift 2 ;;
+        --agent-id) AGENT_ID="$2"; shift 2 ;;
+        --success-rate-threshold) SUCCESS_RATE_THRESHOLD="$2"; shift 2 ;;
+        --limit) LIMIT="$2"; shift 2 ;;
+        --format) FORMAT="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+# Query successful patterns from database
+query_db_patterns() {
+    local where_clause="WHERE success = 1"
+
+    [[ -n "$FILE_TYPE" ]] && where_clause="$where_clause AND file_type = '$FILE_TYPE'"
+    [[ -n "$AGENT_ID" ]] && where_clause="$where_clause AND agent_id LIKE '%$AGENT_ID%'"
+    [[ -n "$SUCCESS_RATE_THRESHOLD" ]] && where_clause="$where_clause AND confidence_score >= $SUCCESS_RATE_THRESHOLD"
+
+    sqlite3 "$DB_PATH" <<EOF
+SELECT
+    agent_id,
+    file_type,
+    prompt,
+    confidence_score,
+    created_at,
+    model
+FROM generations
+$where_clause
+ORDER BY confidence_score DESC, created_at DESC
+LIMIT $LIMIT;
+EOF
+}
+
+# Query patterns from RuVector
+query_ruvector_patterns() {
+    local query=""
+
+    [[ -n "$FILE_TYPE" ]] && query="$query $FILE_TYPE"
+    [[ -n "$PATTERN" ]] && query="$query $PATTERN"
+
+    if [[ -z "$query" ]]; then
+        echo "No query specified for RuVector search"
+        return 1
+    fi
+
+    if [[ -f "$RUVECTOR_INDEX/search.sh" ]]; then
+        echo "Querying RuVector for: $query"
+        "$RUVECTOR_INDEX/search.sh" "$query" --top "$LIMIT" 2>/dev/null || \
+        echo "RuVector search failed"
+    else
+        echo "RuVector not found at $RUVECTOR_INDEX"
+    fi
+}
+
+# Format output
+format_table() {
+    echo "📊 Successful Code Generation Patterns"
+    echo "======================================"
+    echo
+
+    if command -v column >/dev/null 2>&1; then
+        # Use column for pretty formatting
+        query_db_patterns | \
+        awk 'NR>1 {printf "%-15s %-8s %-50s %-8s %s\n", $1, $2, substr($3, 1, 50), $4, $5}' | \
+        column -t -s " " -N "Agent,Type,Prompt,Confidence,Created"
+    else
+        # Simple formatting
+        echo "Agent         | Type   | Prompt Preview                                    | Confidence | Created"
+        echo "--------------|--------|--------------------------------------------------|------------|---------"
+        query_db_patterns | \
+        awk 'NR>1 {printf "%-13s | %-6s | %-48s | %-10s | %s\n", $1, $2, substr($3, 1, 48), $4, $5}'
+    fi
+}
+
+format_json() {
+    echo "{"
+    echo "  \"patterns\": ["
+    local first=true
+    query_db_patterns | while IFS='|' read -r agent_id file_type prompt confidence created_at model; do
+        if [[ "$first" == "false" ]]; then
+            echo ","
+        fi
+        echo "    {"
+        echo "      \"agent_id\": \"$agent_id\","
+        echo "      \"file_type\": \"$file_type\","
+        echo "      \"prompt\": $(echo "$prompt" | jq -Rs .),"
+        echo "      \"confidence_score\": $confidence,"
+        echo "      \"created_at\": \"$created_at\","
+        echo "      \"model\": \"$model\""
+        echo -n "    }"
+        first=false
+    done
+    echo ""
+    echo "  ]"
+    echo "}"
+}
+
+format_prompt() {
+    echo "# Top Prompts for $FILE_TYPE files"
+    echo
+    query_db_patterns | while IFS='|' read -r agent_id file_type prompt confidence created_at model; do
+        echo "## Prompt (Confidence: $confidence)"
+        echo
+        echo "$prompt"
+        echo
+        echo "---"
+        echo
+    done
+}
+
+# Get statistics
+get_statistics() {
+    echo "📈 Pattern Statistics"
+    echo "===================="
+    echo
+
+    sqlite3 "$DB_PATH" <<'EOF'
+SELECT
+    'Total Generations:' as metric,
+    COUNT(*) as value
+FROM generations
+UNION ALL
+SELECT
+    'Success Rate:',
+    ROUND(COUNT(CASE WHEN success = 1 THEN 1 END) * 100.0 / COUNT(*), 2) || '%'
+FROM generations
+UNION ALL
+SELECT
+    'Avg Confidence:',
+    ROUND(AVG(confidence_score), 2)
+FROM generations
+WHERE success = 1
+UNION ALL
+SELECT
+    'Top Agent:',
+    agent_id
+FROM generations
+GROUP BY agent_id
+ORDER BY COUNT(*) DESC
+LIMIT 1;
+EOF
+}
+
+# Main execution
+echo "🔍 Querying Code Generation Patterns"
+echo "=================================="
+echo
+
+if [[ "$FORMAT" == "json" ]]; then
+    format_json
+elif [[ "$FORMAT" == "prompt" ]]; then
+    format_prompt
+else
+    get_statistics
+    echo
+    format_table
+fi
+
+echo
+echo "💡 Tips:"
+echo "  - Use --agent-id to find patterns specific to an agent"
+echo "  - Use --file-type to filter by file extension (rs, ts, py, etc.)"
+echo "  - Use --success-rate-threshold to find high-confidence patterns"
+echo "  - Use --format json for machine-readable output"