mem.attribution(
    entity_id="developer_123",        # Who is using the copilot?
    process_id="coding_copilot"       # Which copilot is this?
)

from memori import Memori
from anthropic import Anthropic

class WritingCopilot:
    def __init__(self, writer_id: str):
        self.client = Anthropic()
        self.mem = Memori().llm.register(self.client)
        self.mem.attribution(
            entity_id=writer_id,
            process_id="writing_copilot"
        )
    
    def assist(self, request: str) -> str:
        """Provide writing assistance."""
        response = self.client.messages.create(
            model="claude-sonnet-4-5-20250929",
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": f"You are a writing copilot. Learn the writer's style, "
                                    f"tone, and preferences. Provide personalized assistance.\n\n"
                                    f"{request}"
                        }
                    ]
                }
            ]
        )
        return response.content[0].text

# Usage
copilot = WritingCopilot("writer_john")

# Establish writing style
response1 = copilot.assist(
    "Help me write the introduction for a blog post about AI memory systems. "
    "I prefer a conversational tone with technical depth, similar to how Stripe "
    "writes their docs — friendly but precise."
)
print(response1)

copilot.mem.augmentation.wait()

# Later: Copilot adapts to learned style
response2 = copilot.assist(
    "Write a conclusion for the AI memory blog post."
)
print(response2)
# Copilot recalls: Conversational tone, technical depth, Stripe-style docs

from memori import Memori
from openai import OpenAI

class ProjectCopilot:
    def __init__(self, user_id: str, project_id: str):
        self.client = OpenAI()
        self.mem = Memori().llm.register(self.client)
        
        # Use project_id in entity to share context across the project
        self.mem.attribution(
            entity_id=f"{user_id}_{project_id}",
            process_id="project_copilot"
        )
    
    def assist(self, request: str, stage: str) -> str:
        """Provide project assistance for different stages."""
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "system",
                    "content": f"You are a project copilot in the {stage} stage. "
                               f"Maintain context across all project phases. Reference "
                               f"decisions and context from previous stages."
                },
                {"role": "user", "content": request}
            ]
        )
        return response.choices[0].message.content

# Usage across project lifecycle
copilot = ProjectCopilot("dev_mike", "ecommerce_platform")

# Planning stage
print("=== Planning Stage ===")
planning = copilot.assist(
    "Plan the architecture for an e-commerce platform. Requirements: "
    "Support 10k concurrent users, integrate with Stripe, use microservices.",
    stage="planning"
)
print(planning)

copilot.mem.augmentation.wait()

# Development stage
print("\n=== Development Stage ===")
dev = copilot.assist(
    "Help me implement the payment service.",
    stage="development"
)
print(dev)
# Recalls: Stripe integration, microservices architecture

# Testing stage
print("\n=== Testing Stage ===")
testing = copilot.assist(
    "Create integration tests for the payment flow.",
    stage="testing"
)
print(testing)
# Recalls: Payment service implementation, Stripe integration

# Deployment stage
print("\n=== Deployment Stage ===")
deploy = copilot.assist(
    "Plan the deployment strategy.",
    stage="deployment"
)
print(deploy)
# Recalls: Microservices architecture, 10k concurrent users requirement

from memori import Memori
from openai import OpenAI

class CodeSuggestionCopilot:
    def __init__(self, developer_id: str, repo_id: str):
        self.client = OpenAI()
        self.mem = Memori().llm.register(self.client)
        self.mem.attribution(
            entity_id=f"{developer_id}_{repo_id}",
            process_id="code_suggestions"
        )
    
    def suggest(self, context: str, task: str) -> str:
        """Provide context-aware code suggestions."""
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "system",
                    "content": "You are a code suggestion copilot. Learn the codebase patterns, "
                               "conventions, and tech stack. Provide suggestions that match "
                               "the project's style and architecture."
                },
                {
                    "role": "user",
                    "content": f"Context: {context}\n\nTask: {task}"
                }
            ]
        )
        return response.choices[0].message.content
    
    def learn_convention(self, convention: str):
        """Teach the copilot a project convention."""
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "user",
                    "content": f"Remember this project convention: {convention}"
                }
            ]
        )
        return response.choices[0].message.content

# Usage
copilot = CodeSuggestionCopilot("dev_alice", "api_service")

# Teach conventions
copilot.learn_convention(
    "All API endpoints use dependency injection for database sessions. "
    "Pattern: def endpoint(db: Session = Depends(get_db))"
)

copilot.learn_convention(
    "Error handling uses custom exception classes that inherit from APIException. "
    "All exceptions include error_code, message, and status_code."
)

copilot.mem.augmentation.wait()

# Get suggestions based on learned conventions
suggestion = copilot.suggest(
    context="Creating a new endpoint to fetch user profile",
    task="Write the endpoint function with proper error handling"
)
print(suggestion)
# Copilot applies dependency injection and custom exception patterns