# Load entire standards (~150,000 tokens)
with open('docs/standards/UNIFIED_STANDARDS.md') as f:
    standards = f.read()

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"{standards}\n\nImplement user authentication"
    }]
)
# Token cost: ~150,000 input tokens
# Context overload: Claude sees too much irrelevant content

# Load only what's needed (1,755 tokens for Level 1)
skills = load_skills(['coding-standards', 'security-practices', 'testing', 'nist-compliance'], level=1)

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"{skills}\n\nImplement user authentication"
    }]
)
# Token cost: ~1,755 input tokens (98.8% reduction compared to loading all standards)
# Better context: Claude sees only relevant guidance

import anthropic
from pathlib import Path

# Initialize client
client = anthropic.Anthropic(api_key="your-api-key")

# Load skills
def load_skills(skill_names: list[str], level: int = 1) -> str:
    """Load skills from the standards repository."""
    skills_content = []

    for skill in skill_names:
        skill_path = Path(f"skills/{skill}/SKILL.md")
        if skill_path.exists():
            content = skill_path.read_text()

            # Extract specified level
            if level == 1:
                # Extract Level 1 content only
                match = re.search(
                    r"## Level 1: Quick Start.*?(?=## Level 2:|$)",
                    content,
                    re.DOTALL
                )
            elif level == 2:
                # Extract Level 1 + 2
                match = re.search(
                    r"## Level 1: Quick Start.*?(?=## Level 3:|$)",
                    content,
                    re.DOTALL
                )
            else:
                # Full content (all levels)
                match = re.search(r"---\n\n# .*", content, re.DOTALL)

            if match:
                skills_content.append(match.group(0))

    return "\n\n".join(skills_content)

# Use in API call
skills = load_skills(['coding-standards', 'security-practices', 'testing'], level=1)

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    system=f"""You are a senior software engineer.

Follow these standards:

{skills}
""",
    messages=[{
        "role": "user",
        "content": "Implement user authentication with password hashing"
    }]
)

print(response.content[0].text)

import anthropic
import subprocess
import json
from pathlib import Path

class ClaudeWithSkills:
    def __init__(self, api_key: str, project_path: str = "./"):
        self.client = anthropic.Anthropic(api_key=api_key)
        self.project_path = project_path

    def get_skill_recommendations(self) -> list[dict]:
        """Get skill recommendations for the project."""
        result = subprocess.run(
            ["python3", "scripts/skill-loader.py", "recommend", self.project_path, "--format", "json"],
            capture_output=True,
            text=True
        )

        if result.returncode == 0:
            return json.loads(result.stdout)

        return []

    def load_skills(self, skill_names: list[str], level: int = 1) -> str:
        """Load skills at specified level."""
        # Use skill-loader tool
        skills_str = "+".join([f"skill:{s}" for s in skill_names])
        result = subprocess.run(
            ["python3", "scripts/skill-loader.py", "load", skills_str, "--level", str(level)],
            capture_output=True,
            text=True
        )

        return result.stdout if result.returncode == 0 else ""

    def create_message_with_skills(
        self,
        user_message: str,
        skills: list[str] = None,
        level: int = 1,
        auto_recommend: bool = False
    ):
        """Create message with skills context."""

        # Auto-recommend if requested
        if auto_recommend and not skills:
            recommendations = self.get_skill_recommendations()
            skills = [rec['skill'] for rec in recommendations if rec['priority'] in ['high', 'critical']]

        # Load skills
        skills_content = self.load_skills(skills, level) if skills else ""

        # Create message
        return self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=4096,
            system=f"""You are a senior software engineer.

Follow these standards:

{skills_content}
""",
            messages=[{
                "role": "user",
                "content": user_message
            }]
        )

# Usage
claude = ClaudeWithSkills(api_key="your-api-key", project_path="./")

# With auto-recommendations
response = claude.create_message_with_skills(
    "Implement user authentication",
    auto_recommend=True,
    level=1
)

# With specific skills
response = claude.create_message_with_skills(
    "Review this code for security issues",
    skills=['security-practices', 'nist-compliance'],
    level=2
)

# Print response
print(response.content[0].text)

# Start with Level 1
skills_l1 = load_skills(['coding-standards'], level=1)
# Fast, high-level guidance

# Scale to Level 2 when implementing
skills_l2 = load_skills(['coding-standards'], level=2)
# Detailed patterns and examples

# Use Level 3 for deep dives
skills_l3 = load_skills(['coding-standards'], level=3)
# Comprehensive resources

# Load based on task
def load_skills_for_task(task_type: str):
    if task_type == 'authentication':
        return load_skills(['security-practices', 'nist-compliance'], level=2)
    elif task_type == 'testing':
        return load_skills(['testing'], level=2)
    elif task_type == 'code-review':
        return load_skills(['coding-standards', 'security-practices'], level=1)
    else:
        return load_skills(['coding-standards'], level=1)

from functools import lru_cache

@lru_cache(maxsize=10)
def load_skills_cached(skill_tuple: tuple[str, ...], level: int) -> str:
    """Load and cache skills."""
    return load_skills(list(skill_tuple), level)

# Usage
skills = load_skills_cached(('coding-standards', 'testing'), level=1)
# Subsequent calls use cache

# Calculate token budget
MAX_SKILLS_TOKENS = 5000  # Reserve for skills
MAX_CODE_TOKENS = 10000   # Reserve for code context
MAX_OUTPUT_TOKENS = 4096  # Claude output

# Load skills within budget
def load_skills_with_budget(skills: list[str], max_tokens: int = MAX_SKILLS_TOKENS):
    level = 1
    content = load_skills(skills, level)

    # Estimate tokens (rough: 4 chars per token)
    estimated_tokens = len(content) / 4

    if estimated_tokens > max_tokens and level > 1:
        # Try lower level
        content = load_skills(skills, level=1)

    return content

# Batch multiple files with same skills
skills = load_skills(['coding-standards', 'security-practices'], level=1)

files_to_review = ['src/auth.py', 'src/users.py', 'src/api.py']

for file_path in files_to_review:
    with open(file_path) as f:
        code = f.read()

    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        system=f"Follow these standards:\n\n{skills}",
        messages=[{
            "role": "user",
            "content": f"Review this code:\n\n```python\n{code}\n```"
        }]
    )

    # Process response
    print(f"Review for {file_path}:")
    print(response.content[0].text)

# Check token estimates
from skill_loader import estimate_tokens

skills = load_skills(['coding-standards'], level=2)
tokens = estimate_tokens(skills)
print(f"Estimated tokens: {tokens}")

# If too high, use Level 1
skills = load_skills(['coding-standards'], level=1)

# Be explicit in prompt
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    system=f"""You MUST follow these standards strictly:

{skills}

Do not deviate from these standards under any circumstances.""",
    messages=[...]
)

skills = load_skills(['coding-standards', 'security-practices', 'testing'], level=2)

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    system=f"""You are a senior software engineer.

Follow these standards strictly:

{skills}""",
    messages=[{
        "role": "user",
        "content": """Implement a user authentication system with:
- Password hashing (bcrypt)
- JWT token generation
- Rate limiting
- NIST control tagging
- Comprehensive tests
"""
    }]
)

print(response.content[0].text)

skills = load_skills(['coding-standards', 'security-practices', 'nist-compliance'], level=1)

with open('src/auth.py') as f:
    code = f.read()

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    system=f"""You are a code reviewer.

Review against these standards:

{skills}

Provide specific, actionable feedback.""",
    messages=[{
        "role": "user",
        "content": f"""Review this code:

```python
{code}