18 KiB
18 KiB
name, description, delegates-to
| name | description | delegates-to |
|---|---|---|
| learn:clone | Clone and learn features from external repos to implement in current project | autonomous-agent:dev-orchestrator |
Learn-Clone Command
Command: /learn:clone
Feature cloning through learning - Analyzes features and capabilities in external GitHub/GitLab repositories, understands their implementation, and helps implement similar or equivalent functionality in the current project while respecting licenses and best practices.
🔄 Intelligent Feature Cloning:
- Feature Analysis: Deep understanding of how features work
- Implementation Extraction: Learn implementation patterns
- Adaptation: Adapt features to current project context
- License Compliance: Respect and comply with source licenses
- Best Practice Integration: Implement using current project standards
- Testing Strategy: Learn and adapt testing approaches
How It Works
- Feature Identification: Analyzes target repository for specific features
- Implementation Study: Studies how features are implemented
- Pattern Extraction: Extracts implementation patterns and approaches
- Adaptation Planning: Plans how to adapt to current project
- Implementation: Implements similar functionality (with attribution)
- Testing: Adapts testing strategies from source
- Documentation: Documents learnings and implementation
Usage
Basic Usage
# Clone specific feature from repository
/learn:clone https://github.com/user/repo --feature "JWT authentication"
# Clone multiple features
/learn:clone https://github.com/user/repo --features "auth,caching,rate-limiting"
# Learn implementation approach
/learn:clone https://github.com/user/repo --feature "real-time notifications" --learn-only
With Implementation
# Clone and implement immediately
/learn:clone https://github.com/user/repo --feature "JWT auth" --implement
# Clone with adaptation
/learn:clone https://github.com/user/repo --feature "caching" --adapt-to-current
# Clone with testing
/learn:clone https://github.com/user/repo --feature "API validation" --include-tests
Advanced Options
# Deep learning mode (understands internals)
/learn:clone https://github.com/user/repo --feature "auth" --deep-learning
# Compare implementations
/learn:clone https://github.com/user/repo --feature "caching" --compare-approaches
# Extract patterns only (no implementation)
/learn:clone https://github.com/user/repo --feature "queue" --extract-patterns
# With license attribution
/learn:clone https://github.com/user/repo --feature "parser" --add-attribution
Output Format
Terminal Output
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔄 FEATURE LEARNING COMPLETE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Feature: JWT Authentication
Source: fastapi/fastapi (MIT License)
Complexity: Medium | Adaptation Required: Yes
Key Components Identified:
* Token generation with configurable expiry
* Dependency injection for auth validation
* Refresh token mechanism
Implementation Strategy:
1. Add python-jose dependency
2. Create auth utility module
3. Implement token generation/validation
4. Add authentication middleware
📄 Full analysis: .claude/data/reports/learn-clone-jwt-auth-2025-10-29.md
⏱ Analysis completed in 2.8 minutes
Next: Review analysis, then use /dev:auto to implement
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Detailed Report
=======================================================
FEATURE LEARNING REPORT
=======================================================
Feature: JWT Authentication
Source: https://github.com/fastapi/fastapi
License: MIT (attribution required)
Analysis Date: 2025-10-29
+- Feature Overview -----------------------------------+
| Feature Name: JWT Authentication System |
| Location: fastapi/security/oauth2.py |
| Complexity: Medium |
| Dependencies: python-jose, passlib |
| |
| Core Capabilities: |
| * Access token generation with expiry |
| * Refresh token support |
| * Dependency injection for validation |
| * Multiple authentication schemes |
| * Token revocation support |
+-------------------------------------------------------+
+- Implementation Analysis ----------------------------+
| Key Files Analyzed: |
| * fastapi/security/oauth2.py (core logic) |
| * fastapi/security/utils.py (helpers) |
| * tests/test_security_oauth2.py (tests) |
| |
| Architecture: |
| +- Token Generation Layer |
| | * Uses python-jose for JWT encoding |
| | * Configurable algorithms (HS256, RS256) |
| | * Expiry and claims management |
| | |
| +- Validation Layer |
| | * Dependency injection pattern |
| | * Automatic token extraction from headers |
| | * Validation with error handling |
| | |
| +- Integration Layer |
| * Middleware for route protection |
| * Flexible authentication schemes |
| * OAuth2 PasswordBearer support |
+-------------------------------------------------------+
+- Code Patterns Extracted ----------------------------+
| Pattern 1: Token Generation |
| ```python |
| from jose import jwt |
| from datetime import datetime, timedelta |
| |
| def create_token(data: dict, expires_delta: timedelta):|
| to_encode = data.copy() |
| expire = datetime.utcnow() + expires_delta |
| to_encode.update({"exp": expire}) |
| return jwt.encode(to_encode, SECRET_KEY, ALGO) |
| ``` |
| |
| Pattern 2: Dependency Injection for Auth |
| ```python |
| from fastapi import Depends, HTTPException |
| from fastapi.security import OAuth2PasswordBearer |
| |
| oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")|
| |
| async def get_current_user(token: str = Depends(oauth2_scheme)):|
| credentials_exception = HTTPException(...) |
| try: |
| payload = jwt.decode(token, SECRET, ALGO) |
| username = payload.get("sub") |
| if username is None: |
| raise credentials_exception |
| return username |
| except JWTError: |
| raise credentials_exception |
| ``` |
| |
| Pattern 3: Route Protection |
| ```python |
| @app.get("/users/me") |
| async def read_users_me(current_user: User = Depends(get_current_user)):|
| return current_user |
| ``` |
+-------------------------------------------------------+
+- Adaptation Strategy for Current Project ------------+
| Current Project Context: |
| * Type: Claude Code Plugin |
| * Language: Python + Markdown config |
| * Architecture: Agent-based with skills |
| |
| Adaptation Required: |
| 1. Simplify for plugin context |
| * May not need OAuth2PasswordBearer |
| * Focus on token generation/validation |
| * Adapt for agent communication |
| |
| 2. Integration points |
| * Add to orchestrator for secure agent calls |
| * Protect sensitive agent operations |
| * Add authentication skill |
| |
| 3. Dependencies |
| * Add: python-jose[cryptography] |
| * Add: passlib[bcrypt] |
| * Keep: Lightweight, minimal deps |
+-------------------------------------------------------+
+- Implementation Roadmap ------------------------------+
| Phase 1: Core Implementation (2-3 hours) |
| Step 1: Add Dependencies |
| +- Add python-jose to requirements |
| +- Add passlib for password hashing |
| +- Update lock file |
| |
| Step 2: Create Auth Skill |
| +- Create skills/authentication/SKILL.md |
| +- Add JWT token generation patterns |
| +- Add validation best practices |
| +- Add security considerations |
| |
| Step 3: Implement Token Utilities |
| +- Create lib/auth_utils.py |
| +- Implement create_token() |
| +- Implement validate_token() |
| +- Add error handling |
| |
| Phase 2: Integration (1-2 hours) |
| Step 4: Agent Authentication |
| +- Add auth to sensitive agent operations |
| +- Implement token validation middleware |
| +- Add authentication examples |
| |
| Step 3: Testing (1 hour) |
| +- Write unit tests for token utils |
| +- Write integration tests |
| +- Add security tests |
| |
| Phase 3: Documentation (30 min) |
| +- Document auth skill usage |
| +- Add examples to README |
| +- Add security best practices |
| +- Include attribution to FastAPI |
+-------------------------------------------------------+
+- Testing Strategy Learned ---------------------------+
| From Source Repository Tests: |
| |
| Test Categories: |
| 1. Token Generation Tests |
| * Valid token creation |
| * Token expiry handling |
| * Custom claims inclusion |
| |
| 2. Token Validation Tests |
| * Valid token validation |
| * Expired token rejection |
| * Invalid signature detection |
| * Malformed token handling |
| |
| 3. Integration Tests |
| * Protected route access with valid token |
| * Protected route rejection without token |
| * Token refresh flow |
| |
| Test Implementation Example: |
| ```python |
| def test_create_access_token(): |
| data = {"sub": "user@example.com"} |
| token = create_access_token(data) |
| assert token is not None |
| payload = jwt.decode(token, SECRET, ALGO) |
| assert payload["sub"] == "user@example.com" |
| assert "exp" in payload |
| ``` |
+-------------------------------------------------------+
+- License Compliance ----------------------------------+
| Source License: MIT License |
| |
| Requirements: |
| ✅ Include original license notice |
| ✅ Include attribution in documentation |
| ✅ Do not claim original authorship |
| |
| Attribution Text (add to README and code files): |
| |
| """ |
| JWT Authentication implementation learned from: |
| FastAPI (https://github.com/tiangolo/fastapi) |
| Copyright (c) 2018 Sebastián Ramírez |
| MIT License |
| |
| Adapted for Claude Code Plugin with modifications. |
| """ |
+-------------------------------------------------------+
+- Learned Patterns to Store --------------------------+
| Pattern: Dependency Injection for Security |
| * Effectiveness: 95/100 |
| * Reusability: High |
| * Complexity: Medium |
| * Store in: .claude-patterns/security-patterns.json |
| |
| Pattern: Token-Based Authentication |
| * Effectiveness: 92/100 |
| * Reusability: High |
| * Complexity: Medium |
| * Store in: .claude-patterns/auth-patterns.json |
+-------------------------------------------------------+
=======================================================
NEXT STEPS
=======================================================
Ready to Implement?
* Review implementation roadmap above
* Check license compliance requirements
* Use: /dev:auto "implement JWT authentication based on learned patterns"
Need More Analysis?
* Analyze alternative implementations
* Compare with other auth approaches
* Deep-dive into security considerations
=======================================================
Analysis Time: 2.8 minutes
Feature Complexity: Medium
Implementation Estimate: 4-6 hours
License: MIT (attribution required)
Learned patterns stored in database for future reference.
Integration with Learning System
Stores learned feature patterns:
{
"feature_clone_patterns": {
"feature_name": "jwt_authentication",
"source_repo": "fastapi/fastapi",
"source_license": "MIT",
"patterns_extracted": 3,
"adaptation_required": true,
"implemented": false,
"implementation_approach": "adapted_for_plugin",
"attribution_added": true
}
}
Agent Delegation
- dev-orchestrator: Coordinates learning and implementation
- code-analyzer: Analyzes source implementation
- pattern-learning: Extracts and stores patterns
- security-auditor: Ensures secure implementation
Skills Integration
- code-analysis: For understanding source code
- pattern-learning: For pattern extraction
- security-patterns: For secure implementation
- documentation-best-practices: For proper attribution
Use Cases
Learning Authentication
/learn:clone https://github.com/fastapi/fastapi --feature "JWT auth"
Learning Caching Strategies
/learn:clone https://github.com/django/django --feature "caching"
Learning Testing Approaches
/learn:clone https://github.com/pytest-dev/pytest --feature "test fixtures"
Best Practices
License Compliance
- Always check and respect source licenses
- Add proper attribution in code and documentation
- Do not copy code verbatim - learn and adapt
- Understand license restrictions before cloning
Feature Selection
- Choose features that fit project needs
- Consider maintenance burden
- Evaluate complexity vs value
- Check for dependencies
Implementation
- Adapt to project conventions
- Don't blindly copy - understand first
- Write tests for cloned features
- Document learnings and adaptations
Version: 1.0.0 Integration: Uses dev-orchestrator, code-analyzer agents Skills: code-analysis, pattern-learning, security-patterns Platform: Cross-platform Scope: Learn and adapt features from external repositories License: Enforces proper attribution and compliance