Virtual software company with real memory

from chatdev.company import Company
from chatdev.phase import Phase
import httpx
import os

class ProjectMemory:
    """Persistent memory for the ChatDev company."""

    def __init__(self, project_name: str):
        self.project = project_name
        self.url = "https://mcp.stompy.ai/sse"
        self.headers = {"Authorization": f"Bearer {os.environ['STOMPY_TOKEN']}"}

    async def recall_codebase(self) -> str:
        """Recall existing code structure."""
        async with httpx.AsyncClient() as client:
            response = await client.post(self.url, headers=self.headers,
                json={"tool": "recall_context", "topic": f"{self.project}_codebase"})
            return response.json().get("content", "")

    async def recall_decisions(self) -> str:
        """Recall design decisions from past sessions."""
        async with httpx.AsyncClient() as client:
            response = await client.post(self.url, headers=self.headers,
                json={"tool": "recall_context", "topic": f"{self.project}_decisions"})
            return response.json().get("content", "")

    async def save_outcome(self, phase: str, content: str):
        """Save important outcomes from each phase."""
        async with httpx.AsyncClient() as client:
            await client.post(self.url, headers=self.headers,
                json={"tool": "lock_context",
                      "topic": f"{self.project}_{phase}",
                      "content": content,
                      "priority": "important"})

memory = ProjectMemory("my_app")

class MemoryEnabledCompany(Company):
    """ChatDev company with persistent project memory."""

    def __init__(self, project_name: str, **kwargs):
        super().__init__(**kwargs)
        self.memory = ProjectMemory(project_name)

    async def run_phase(self, phase: Phase, *args, **kwargs):
        # Inject project context before each phase
        existing_code = await self.memory.recall_codebase()
        past_decisions = await self.memory.recall_decisions()

        phase.context = f"""
PROJECT HISTORY:
This is an existing project with the following codebase:
{existing_code}

Past design decisions:
{past_decisions}

Build on existing code. Don't recreate what exists. Maintain consistency with past decisions.
"""

        # Run the phase
        result = await super().run_phase(phase, *args, **kwargs)

        # Save important outcomes
        if phase.name in ["coding", "designing", "reviewing"]:
            await self.memory.save_outcome(phase.name, result.summary)

        return result

async def develop_feature(project_name: str, feature_request: str):
    """Develop a feature with full project memory."""

    company = MemoryEnabledCompany(project_name)

    # The company now knows everything from previous sessions
    result = await company.chat(feature_request)

    # Save the complete session outcome
    await company.memory.save_outcome(
        "session",
        f"""Feature: {feature_request}
Files created/modified: {result.files}
Key decisions: {result.design_summary}
Tests added: {result.test_summary}"""
    )

    # Save updated codebase structure
    await company.memory.save_outcome(
        "codebase",
        f"""Current codebase structure:
{result.file_tree}

Key components:
{result.component_summary}"""
    )

    return result

# Iterative development - each builds on the last
await develop_feature("todo_app", "Build a basic todo list with React")
await develop_feature("todo_app", "Add user authentication with JWT")
await develop_feature("todo_app", "Integrate Stripe for premium features")
# Each session knows about all previous work!