Codegen frontend fix

.windsurfrules

@@ -0,0 +1,6 @@
+You should also use the `scratchpad.md` file as a scratchpad to organize your thoughts. Especially when you receive a new task, you should first review the content of the scratchpad, clear old different task if necessary, first explain the task, and plan the steps you need to take to complete the task. You can use todo markers to indicate the progress, e.g.
+[X] Task 1
+[ ] Task 2
+Also update the progress of the task in the Scratchpad when you finish a subtask.
+Especially when you finished a milestone, it will help to improve your depth of task accomplishment to use the scratchpad to reflect and plan.
+The goal is to help you maintain a big picture as well as the progress of the task. Always refer to the Scratchpad when you plan the next step.

agentgen/README.md

@@ -0,0 +1,74 @@
+# Codegen Deep Research
+
+A code research tool that enables users to understand codebases through agentic AI analysis. The project combines a Modal-based FastAPI backend with a Next.js frontend to provide intelligent code exploration capabilities.
+
+Users submit a GitHub repository and research query through the frontend. The Modal API processes the request using an AI agent equipped with specialized code analysis tools. The agent explores the codebase using various tools (search, symbol analysis, etc.) and results are returned to the frontend for display.
+
+## How it Works
+
+### Backend (Modal API)
+
+The backend is built using [Modal](https://modal.com/) and [FastAPI](https://fastapi.tiangolo.com/), providing a serverless API endpoint for code research.
+
+There is a main API endpoint that handles code research requests. It uses the `codegen` library for codebase analysis.
+
+The agent investigates the codebase through various research tools:
+- `ViewFileTool`: Read file contents
+- `ListDirectoryTool`: Explore directory structures
+- `SearchTool`: Text-based code search
+- `SemanticSearchTool`: AI-powered semantic code search
+- `RevealSymbolTool`: Analyze code symbols and relationships
+
+```python
+tools = [
+    ViewFileTool(codebase),
+    ListDirectoryTool(codebase),
+    SearchTool(codebase),
+    SemanticSearchTool(codebase),
+    RevealSymbolTool(codebase)
+]
+
+# Initialize agent with research tools
+agent = create_agent_with_tools(
+    codebase=codebase,
+    tools=tools,
+    chat_history=[SystemMessage(content=RESEARCH_AGENT_PROMPT)],
+    verbose=True
+)
+```
+
+### Frontend (Next.js)
+
+The frontend provides an interface for users to submit a GitHub repository and research query. The components come from the [shadcn/ui](https://ui.shadcn.com/) library. This triggers the Modal API to perform the code research and returns the results to the frontend.
+
+## Getting Started
+
+1. Set up environment variables in an `.env` file:
+   ```
+   OPENAI_API_KEY=your_key_here
+   ```
+
+2. Deploy or serve the Modal API:
+   ```bash
+   modal serve backend/api.py
+   ```
+   `modal serve` runs the API locally for development, creating a temporary endpoint that's active only while the command is running.
+   ```bash
+   modal deploy backend/api.py
+   ```
+   `modal deploy` creates a persistent Modal app and deploys the FastAPI app to it, generating a permanent API endpoint.
+
+   After deployment, you'll need to update the API endpoint in the frontend configuration to point to your deployed Modal app URL.
+
+3. Run the Next.js frontend:
+   ```bash
+   cd frontend
+   npm install
+   npm run dev
+   ```
+
+## Learn More
+
+More information about the `codegen` library can be found [here](https://codegen.com/).
+
+For details on the agent implementation, check out [Deep Code Research with AI](https://docs.codegen.com/tutorials/deep-code-research) from the Codegen docs. This tutorial provides an in-depth guide on how the research agent is created.

agentgen/__init__.py

@@ -0,0 +1,7 @@
+"""
+AgentGen - Agent framework for building AI-powered applications.
+"""
+
+from agentgen.agents.chat_agent import ChatAgent as CodeAgent
+
+__version__ = "0.1.0"

agentgen/agentgen/__init__.py

@@ -0,0 +1,7 @@
+"""
+Agentgen package initialization.
+"""
+
+from agentgen.agents.code_agent import CodeAgent
+
+__all__ = ["CodeAgent"]

agentgen/agentgen/agents/chat_agent.py

@@ -0,0 +1,95 @@
+"""Chat agent implementation."""
+
+from typing import Any, Dict, List, Optional, Union
+
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+
+from agentgen.backend.extensions.langchain.agent import create_chat_agent
+
+if TYPE_CHECKING:
+    from codegen import Codebase
+
+
+class ChatAgent:
+    """Agent for interacting with a codebase."""
+
+    def __init__(self, codebase: "Codebase", model_provider: str = "anthropic", model_name: str = "claude-3-5-sonnet-latest", memory: bool = True, tools: Optional[list[BaseTool]] = None, **kwargs):
+        """Initialize a CodeAgent.
+
+        Args:
+            codebase: The codebase to operate on
+            model_provider: The model provider to use ("anthropic" or "openai")
+            model_name: Name of the model to use
+            memory: Whether to let LLM keep track of the conversation history
+            tools: Additional tools to use
+            **kwargs: Additional LLM configuration options. Supported options:
+                - temperature: Temperature parameter (0-1)
+                - top_p: Top-p sampling parameter (0-1)
+                - top_k: Top-k sampling parameter (>= 1)
+                - max_tokens: Maximum number of tokens to generate
+        """
+        self.codebase = codebase
+        self.agent = create_chat_agent(self.codebase, model_provider=model_provider, model_name=model_name, memory=memory, additional_tools=tools, **kwargs)
+
+    def run(self, prompt: str, thread_id: Optional[str] = None) -> str:
+        """Run the agent with a prompt.
+
+        Args:
+            prompt: The prompt to run
+            thread_id: Optional thread ID for message history. If None, a new thread is created.
+
+        Returns:
+            The agent's response
+        """
+        if thread_id is None:
+            thread_id = str(uuid4())
+
+        input = {"query": prompt}
+        stream = self.agent.stream(input, config={"configurable": {"thread_id": thread_id}}, stream_mode="values")
+
+        for s in stream:
+            message = s["messages"][-1]
+            if isinstance(message, tuple):
+                print(message)
+            else:
+                if isinstance(message, AIMessage) and isinstance(message.content, list) and "text" in message.content[0]:
+                    AIMessage(message.content[0]["text"]).pretty_print()
+                else:
+                    message.pretty_print()
+
+        return s["final_answer"]
+
+    def chat(self, prompt: str, thread_id: Optional[str] = None) -> tuple[str, str]:
+        """Chat with the agent, maintaining conversation history.
+
+        Args:
+            prompt: The user message
+            thread_id: Optional thread ID for message history. If None, a new thread is created.
+
+        Returns:
+            A tuple of (response_content, thread_id) to allow continued conversation
+        """
+        if thread_id is None:
+            thread_id = str(uuid4())
+            print(f"Starting new chat thread: {thread_id}")
+        else:
+            print(f"Continuing chat thread: {thread_id}")
+
+        response = self.run(prompt, thread_id=thread_id)
+        return response, thread_id
+
+    def get_chat_history(self, thread_id: str) -> list:
+        """Retrieve the chat history for a specific thread.
+
+        Args:
+            thread_id: The thread ID to retrieve history for
+
+        Returns:
+            List of messages in the conversation history
+        """
+        # Access the agent's memory to get conversation history
+        if hasattr(self.agent, "get_state"):
+            state = self.agent.get_state({"configurable": {"thread_id": thread_id}})
+            if state and "messages" in state:
+                return state["messages"]
+        return []