codegraph-cli 2.0.0__py3-none-any.whl

codegraph_cli/chat_agent.py

@@ -0,0 +1,352 @@
+"""Chat agent for interactive conversational coding assistance."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from .chat_session import SessionManager
+from .codegen_agent import CodeGenAgent
+from .context_manager import assemble_context_for_llm, detect_intent
+from .llm import LocalLLM
+from .models_v2 import ChatSession, CodeProposal
+from .orchestrator import MCPOrchestrator
+from .rag import RAGRetriever
+from .refactor_agent import RefactorAgent
+from .storage import GraphStore
+
+
+SYSTEM_PROMPT = """You are an AI coding assistant integrated with CodeGraph CLI.
+
+You have access to a semantic code graph of the user's project and can:
+- Search for code semantically
+- Analyze impact of changes
+- Generate new code
+- Refactor existing code
+- Explain code functionality
+
+When the user asks you to make changes:
+1. Use the provided code context to understand existing patterns
+2. Generate code that follows the project's style
+3. Explain what you're doing
+4. Create a proposal that the user can review before applying
+
+Be concise, helpful, and always explain your reasoning.
+"""
+
+
+class ChatAgent:
+    """Orchestrates interactive chat with RAG-based context management and real file access."""
+    
+    def __init__(
+        self,
+        context: ProjectContext,
+        llm: LocalLLM,
+        orchestrator: MCPOrchestrator,
+        rag_retriever: RAGRetriever
+    ):
+        """Initialize chat agent.
+        
+        Args:
+            context: ProjectContext for real file access
+            llm: LLM for generating responses
+            orchestrator: Orchestrator for accessing other agents
+            rag_retriever: RAG retriever for semantic search
+        """
+        self.context = context
+        self.llm = llm
+        self.orchestrator = orchestrator
+        self.rag_retriever = rag_retriever
+        self.session_manager = SessionManager()
+        
+        # Initialize specialized agents
+        from .codegen_agent import CodeGenAgent
+        from .refactor_agent import RefactorAgent
+        self.codegen_agent = CodeGenAgent(context.store, llm, project_context=context)
+        self.refactor_agent = RefactorAgent(context.store)
+    
+    def process_message(
+        self,
+        user_message: str,
+        session: ChatSession
+    ) -> str:
+        """Process user message and generate response.
+        
+        Args:
+            user_message: User's message
+            session: Current chat session
+            
+        Returns:
+            Assistant's response
+        """
+        # Add user message to session
+        timestamp = datetime.now().isoformat()
+        session.add_message("user", user_message, timestamp)
+        
+        # Detect intent
+        intent = detect_intent(user_message)
+        
+        # Handle special intents with existing agents
+        if intent == "read":
+            response = self._handle_read(user_message)
+        elif intent == "list":
+            response = self._handle_list()
+        elif intent == "search":
+            response = self._handle_search(user_message)
+        elif intent == "impact":
+            response = self._handle_impact(user_message)
+        elif intent == "generate":
+            response = self._handle_generate(user_message, session)
+        elif intent == "refactor":
+            response = self._handle_refactor(user_message, session)
+        else:
+            # General chat - use LLM with RAG context
+            response = self._handle_chat(user_message, session)
+        
+        # Add assistant response to session
+        session.add_message("assistant", response, datetime.now().isoformat())
+        
+        # Save session
+        self.session_manager.save_session(session)
+        
+        return response
+    
+    def _handle_list(self) -> str:
+        """Handle list files intent - show actual project files."""
+        if not self.context.has_source_access:
+            return (
+                "❌ Source directory not available for this project.\n"
+                "Re-index the project to enable file access: cg index <path> --name <project>"
+            )
+        
+        try:
+            items = self.context.list_directory(".")
+            
+            if not items:
+                return "📁 Project directory is empty."
+            
+            # Separate files and directories
+            dirs = [item for item in items if item["type"] == "dir"]
+            files = [item for item in items if item["type"] == "file"]
+            
+            response_parts = [f"📁 Project: {self.context.project_name}"]
+            response_parts.append(f"📂 Location: {self.context.source_path}\n")
+            
+            # Show directories
+            if dirs:
+                response_parts.append(f"Directories ({len(dirs)}):")
+                for d in dirs[:10]:  # Limit to 10
+                    response_parts.append(f"  📂 {d['name']}/")
+                if len(dirs) > 10:
+                    response_parts.append(f"  ... and {len(dirs) - 10} more")
+                response_parts.append("")
+            
+            # Show files
+            if files:
+                response_parts.append(f"Files ({len(files)}):")
+                for f in files[:15]:  # Limit to 15
+                    size_kb = f['size'] / 1024 if f['size'] else 0
+                    response_parts.append(f"  📄 {f['name']} ({size_kb:.1f} KB)")
+                if len(files) > 15:
+                    response_parts.append(f"  ... and {len(files) - 15} more")
+            
+            # Show indexed files info
+            indexed_files = self.context.get_indexed_files()
+            response_parts.append(f"\n✅ Indexed: {len(indexed_files)} Python file(s)")
+            
+            return "\n".join(response_parts)
+            
+        except Exception as e:
+            return f"❌ Error listing directory: {str(e)}"
+    
+    def _handle_read(self, message: str) -> str:
+        """Handle read file intent - show file contents."""
+        if not self.context.has_source_access:
+            return (
+                "❌ Source directory not available for this project.\n"
+                "Re-index the project to enable file access: cg index <path> --name <project>"
+            )
+        
+        # Extract filename from message
+        import re
+        # Look for common file extensions
+        file_pattern = r'([\w/.-]+\.(?:py|txt|md|json|yaml|yml|toml|cfg|ini|sh|js|ts|html|css))'
+        matches = re.findall(file_pattern, message, re.IGNORECASE)
+        
+        if not matches:
+            return "❌ Please specify a file to read (e.g., 'show me basic.py')"
+        
+        filename = matches[0]
+        
+        try:
+            content = self.context.read_file(filename)
+            
+            # Detect language for syntax highlighting
+            ext = filename.split('.')[-1]
+            lang_map = {
+                'py': 'python', 'js': 'javascript', 'ts': 'typescript',
+                'md': 'markdown', 'json': 'json', 'yaml': 'yaml', 'yml': 'yaml',
+                'sh': 'bash', 'html': 'html', 'css': 'css'
+            }
+            lang = lang_map.get(ext, '')
+            
+            response_parts = [f"📄 {filename}\n"]
+            response_parts.append(f"```{lang}")
+            response_parts.append(content)
+            response_parts.append("```")
+            
+            # Add file info
+            file_info = self.context.get_file_info(filename)
+            if file_info:
+                size_kb = file_info['size'] / 1024 if file_info['size'] else 0
+                response_parts.append(f"\n📊 Size: {size_kb:.1f} KB | Modified: {file_info['modified'][:10]}")
+            
+            return "\n".join(response_parts)
+            
+        except FileNotFoundError:
+            return f"❌ File not found: {filename}\nAvailable files: {', '.join([f['name'] for f in self.context.list_directory('.') if f['type'] == 'file'][:5])}"
+        except Exception as e:
+            return f"❌ Error reading file: {str(e)}"
+    
+    def _handle_search(self, message: str) -> str:
+        """Handle search intent."""
+        # Extract query (remove search keywords)
+        query = message.lower()
+        for kw in ["find", "search", "where is", "show me", "locate"]:
+            query = query.replace(kw, "").strip()
+        
+        # Use RAG agent
+        results = self.rag_retriever.search(query, top_k=5)
+        
+        if not results:
+            return "I couldn't find any matching code. Try a different search query."
+        
+        # Format results
+        response_parts = [f"Found {len(results)} results:\n"]
+        for i, result in enumerate(results, 1):
+            response_parts.append(
+                f"{i}. [{result.node_type}] {result.qualname}\n"
+                f"   Location: {result.file_path}:{result.start_line}\n"
+                f"   Relevance: {result.score:.2f}\n"
+            )
+        
+        return "\n".join(response_parts)
+    
+    def _handle_impact(self, message: str) -> str:
+        """Handle impact analysis intent."""
+        # Extract symbol name
+        import re
+        symbols = re.findall(r'\b[A-Z][a-zA-Z0-9_]*\b|\b[a-z_][a-z0-9_]*\b', message)
+        
+        if not symbols:
+            return "Please specify a function or class name to analyze impact."
+        
+        symbol = symbols[0]
+        
+        # Use summarization agent for impact analysis
+        try:
+            report = self.orchestrator.summarization_agent.impact_analysis(symbol, hops=2)
+            return f"**Impact Analysis for {symbol}:**\n\n{report.explanation}"
+        except Exception as e:
+            return f"Couldn't analyze impact: {str(e)}"
+    
+    def _handle_generate(self, message: str, session: ChatSession) -> str:
+        """Handle code generation intent."""
+        try:
+            # Use codegen agent
+            proposal = self.codegen_agent.generate(
+                prompt=message,
+                max_files=3
+            )
+            
+            # Add to pending proposals
+            session.pending_proposals.append(proposal)
+            
+            # Format response
+            response_parts = [
+                f"I've created a code proposal: {proposal.description}\n",
+                f"Files to change: {proposal.num_files_changed}",
+                f"  - New files: {proposal.num_files_created}",
+                f"  - Modified files: {proposal.num_files_modified}\n",
+                "To apply these changes, say 'apply' or '/apply'.",
+                "To see the diff, say 'show diff' or '/preview'."
+            ]
+            
+            return "\n".join(response_parts)
+        except Exception as e:
+            return f"I encountered an error generating code: {str(e)}\n\nCould you provide more details?"
+    
+    def _handle_refactor(self, message: str, session: ChatSession) -> str:
+        """Handle refactoring intent."""
+        # For now, provide guidance
+        return (
+            "I can help with refactoring! Here are some operations I support:\n\n"
+            "- Rename a symbol: 'Rename process_payment to handle_payment'\n"
+            "- Extract function: 'Extract lines 45-60 into a new function'\n"
+            "- Extract service: 'Move payment functions to a new service'\n\n"
+            "What would you like to refactor?"
+        )
+    
+    def _handle_chat(self, message: str, session: ChatSession) -> str:
+        """Handle general chat with LLM and RAG context."""
+        # Assemble context using smart RAG strategy
+        context_messages = assemble_context_for_llm(
+            user_message=message,
+            session=session,
+            rag_retriever=self.rag_retriever,
+            system_prompt=SYSTEM_PROMPT,
+            max_tokens=8000
+        )
+        
+        # Call LLM
+        response = self.llm.chat_completion(
+            messages=context_messages,
+            max_tokens=1000,
+            temperature=0.7
+        )
+        
+        if response:
+            return response
+        
+        # Fallback if LLM fails
+        return (
+            "I'm having trouble connecting to the LLM. "
+            "Try asking me to search for code, analyze impact, or generate code."
+        )
+    
+    def apply_pending_proposal(self, session: ChatSession, proposal_index: int = 0) -> str:
+        """Apply a pending proposal.
+        
+        Args:
+            session: Chat session
+            proposal_index: Index of proposal to apply (default: most recent)
+            
+        Returns:
+            Result message
+        """
+        if not session.pending_proposals:
+            return "No pending proposals to apply."
+        
+        if proposal_index >= len(session.pending_proposals):
+            return f"Invalid proposal index. You have {len(session.pending_proposals)} pending proposal(s)."
+        
+        proposal = session.pending_proposals[proposal_index]
+        
+        try:
+            # Apply using codegen agent
+            result = self.codegen_agent.apply_changes(proposal, backup=True)
+            
+            if result.success:
+                # Remove from pending
+                session.pending_proposals.pop(proposal_index)
+                self.session_manager.save_session(session)
+                
+                return (
+                    f"✅ Successfully applied changes to {len(result.files_changed)} file(s).\n"
+                    f"Backup ID: {result.backup_id}\n"
+                    f"You can rollback with: cg v2 rollback {result.backup_id}"
+                )
+            else:
+                return f"❌ Failed to apply changes: {result.error}"
+        except Exception as e:
+            return f"❌ Error applying changes: {str(e)}"

codegraph_cli/chat_session.py

@@ -0,0 +1,220 @@
+"""Chat session management with persistence."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from .models_v2 import ChatMessage, ChatSession, CodeProposal
+
+
+class SessionManager:
+    """Manages chat session persistence and loading."""
+    
+    def __init__(self, sessions_dir: Optional[Path] = None):
+        """Initialize session manager.
+        
+        Args:
+            sessions_dir: Directory to store sessions (default: ~/.codegraph/chat_sessions/)
+        """
+        if sessions_dir is None:
+            home = Path.home()
+            sessions_dir = home / ".codegraph" / "chat_sessions"
+        
+        self.sessions_dir = sessions_dir
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+    
+    def create_session(self, project_name: str) -> ChatSession:
+        """Create a new chat session.
+        
+        Args:
+            project_name: Name of the project this session is for
+            
+        Returns:
+            New ChatSession instance
+        """
+        session_id = str(uuid.uuid4())
+        timestamp = datetime.now().isoformat()
+        
+        session = ChatSession(
+            id=session_id,
+            project_name=project_name,
+            created_at=timestamp,
+            updated_at=timestamp
+        )
+        
+        return session
+    
+    def save_session(self, session: ChatSession) -> None:
+        """Save session to disk.
+        
+        Args:
+            session: Session to save
+        """
+        session_file = self.sessions_dir / f"{session.id}.json"
+        
+        # Convert to dict
+        data = {
+            "id": session.id,
+            "project_name": session.project_name,
+            "created_at": session.created_at,
+            "updated_at": session.updated_at,
+            "messages": [
+                {
+                    "role": msg.role,
+                    "content": msg.content,
+                    "timestamp": msg.timestamp,
+                    "metadata": msg.metadata
+                }
+                for msg in session.messages
+            ],
+            "pending_proposals": [
+                {
+                    "id": p.id,
+                    "description": p.description,
+                    "impact_summary": p.impact_summary,
+                    "metadata": p.metadata,
+                    "changes": [
+                        {
+                            "file_path": c.file_path,
+                            "change_type": c.change_type,
+                            "original_content": c.original_content,
+                            "new_content": c.new_content,
+                            "diff": c.diff
+                        }
+                        for c in p.changes
+                    ]
+                }
+                for p in session.pending_proposals
+            ]
+        }
+        
+        session_file.write_text(json.dumps(data, indent=2))
+    
+    def load_session(self, session_id: str) -> Optional[ChatSession]:
+        """Load session from disk.
+        
+        Args:
+            session_id: ID of session to load
+            
+        Returns:
+            ChatSession if found, None otherwise
+        """
+        session_file = self.sessions_dir / f"{session_id}.json"
+        
+        if not session_file.exists():
+            return None
+        
+        data = json.loads(session_file.read_text())
+        
+        # Reconstruct session
+        session = ChatSession(
+            id=data["id"],
+            project_name=data["project_name"],
+            created_at=data["created_at"],
+            updated_at=data["updated_at"]
+        )
+        
+        # Reconstruct messages
+        for msg_data in data["messages"]:
+            session.messages.append(ChatMessage(
+                role=msg_data["role"],
+                content=msg_data["content"],
+                timestamp=msg_data["timestamp"],
+                metadata=msg_data.get("metadata", {})
+            ))
+        
+        # Reconstruct pending proposals
+        from .models_v2 import FileChange
+        for prop_data in data.get("pending_proposals", []):
+            changes = [
+                FileChange(
+                    file_path=c["file_path"],
+                    change_type=c["change_type"],
+                    original_content=c.get("original_content"),
+                    new_content=c.get("new_content"),
+                    diff=c.get("diff", "")
+                )
+                for c in prop_data["changes"]
+            ]
+            
+            session.pending_proposals.append(CodeProposal(
+                id=prop_data["id"],
+                description=prop_data["description"],
+                changes=changes,
+                impact_summary=prop_data.get("impact_summary", ""),
+                metadata=prop_data.get("metadata", {})
+            ))
+        
+        return session
+    
+    def list_sessions(self, project_name: Optional[str] = None) -> List[dict]:
+        """List all saved sessions.
+        
+        Args:
+            project_name: Optional filter by project name
+            
+        Returns:
+            List of session metadata dicts
+        """
+        sessions = []
+        
+        for session_file in self.sessions_dir.glob("*.json"):
+            try:
+                data = json.loads(session_file.read_text())
+                
+                # Filter by project if specified
+                if project_name and data.get("project_name") != project_name:
+                    continue
+                
+                sessions.append({
+                    "id": data["id"],
+                    "project_name": data["project_name"],
+                    "created_at": data["created_at"],
+                    "updated_at": data["updated_at"],
+                    "message_count": len(data.get("messages", []))
+                })
+            except Exception:
+                # Skip corrupted files
+                continue
+        
+        # Sort by updated_at (most recent first)
+        sessions.sort(key=lambda s: s["updated_at"], reverse=True)
+        
+        return sessions
+    
+    def get_latest_session(self, project_name: str) -> Optional[str]:
+        """Get the most recent session ID for a project.
+        
+        Args:
+            project_name: Project to find session for
+            
+        Returns:
+            Session ID if found, None otherwise
+        """
+        sessions = self.list_sessions(project_name=project_name)
+        
+        if sessions:
+            return sessions[0]["id"]
+        
+        return None
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session.
+        
+        Args:
+            session_id: ID of session to delete
+            
+        Returns:
+            True if deleted, False if not found
+        """
+        session_file = self.sessions_dir / f"{session_id}.json"
+        
+        if session_file.exists():
+            session_file.unlink()
+            return True
+        
+        return False