Download src/core/agent.py from amkyawdev/burme-coder-max: direct link, hf CLI and curl.
- Browser
- Download file 5.76 kB
-
https://huggingface.co/datasets/amkyawdev/burme-coder-max/resolve/main/src/core/agent.py
- Command line
-
hf download hf://datasets/amkyawdev/burme-coder-max/src/core/agent.py
-
curl -L -o agent.py https://huggingface.co/datasets/amkyawdev/burme-coder-max/resolve/main/src/core/agent.py
5.76 kB
| """Coder Agent - Main AI Brain for Myanmar Coding Assistant""" | |
| import json | |
| import time | |
| from typing import Dict, List, Optional, Any | |
| from pathlib import Path | |
| class CoderAgent: | |
| """Expert Myanmar AI coding agent with advanced knowledge""" | |
| SYSTEM_PROMPTS = [ | |
| "You are an expert programmer with advanced knowledge in: Python, JavaScript, TypeScript, Java, C++, Go, Rust, etc.", | |
| "You are a senior security reviewer. Analyze code for vulnerabilities and provide secure version with Myanmar explanation.", | |
| "You are a testing expert. Generate comprehensive unit tests for the given function using pytest.", | |
| "You are a GUI and game development expert. Provide complete, runnable code with Myanmar explanations.", | |
| "You are an expert Myanmar AI coding agent. Answer in Myanmar language and provide code examples when needed.", | |
| ] | |
| def __init__( | |
| self, | |
| model: str = "gpt-4", | |
| temperature: float = 0.7, | |
| max_tokens: int = 2048, | |
| knowledge_dir: Optional[str] = None, | |
| ): | |
| self.model = model | |
| self.temperature = temperature | |
| self.max_tokens = max_tokens | |
| self.knowledge_dir = Path(knowledge_dir) if knowledge_dir else None | |
| self.conversation_history: List[Dict[str, str]] = [] | |
| self.session_id = self._generate_session_id() | |
| def _generate_session_id(self) -> str: | |
| """Generate unique session ID""" | |
| return f"session_{int(time.time())}_{id(self)}" | |
| def set_system_prompt(self, prompt: str) -> None: | |
| """Set custom system prompt""" | |
| self.system_prompt = prompt | |
| def generate_response( | |
| self, instruction: str, context: Optional[Dict[str, Any]] = None | |
| ) -> Dict[str, Any]: | |
| """Generate code response for the given instruction""" | |
| self.conversation_history.append({"role": "user", "content": instruction}) | |
| response = { | |
| "session_id": self.session_id, | |
| "instruction": instruction, | |
| "response": self._generate_code_response(instruction, context), | |
| "timestamp": time.time(), | |
| "model": self.model, | |
| } | |
| self.conversation_history.append( | |
| {"role": "assistant", "content": response["response"]} | |
| ) | |
| return response | |
| def _generate_code_response( | |
| self, instruction: str, context: Optional[Dict[str, Any]] | |
| ) -> str: | |
| """Internal method to generate code response""" | |
| if self.knowledge_dir: | |
| knowledge_content = self._check_knowledge_base(instruction) | |
| if knowledge_content: | |
| return knowledge_content | |
| return self._get_fallback_response(instruction) | |
| def _check_knowledge_base(self, instruction: str) -> Optional[str]: | |
| """Check local knowledge base for relevant content""" | |
| if not self.knowledge_dir: | |
| return None | |
| keywords = self._extract_keywords(instruction) | |
| for keyword in keywords: | |
| kb_file = self.knowledge_dir / f"{keyword}_skills.md" | |
| if kb_file.exists(): | |
| return self._parse_markdown_file(kb_file) | |
| return None | |
| def _extract_keywords(self, text: str) -> List[str]: | |
| """Extract keywords from instruction""" | |
| common_langs = ["python", "javascript", "typescript", "java", "go", "rust", "sql"] | |
| return [w for w in common_langs if w in text.lower()] | |
| def _parse_markdown_file(self, file_path: Path) -> str: | |
| """Parse markdown file and extract content""" | |
| content = file_path.read_text(encoding="utf-8") | |
| lines = content.split("\n") | |
| return "\n".join(lines[:20]) | |
| def _get_fallback_response(self, instruction: str) -> str: | |
| """Get fallback response based on instruction""" | |
| instruction_lower = instruction.lower() | |
| if "python" in instruction_lower: | |
| return self._get_python_response(instruction) | |
| elif "javascript" in instruction_lower or "js" in instruction_lower: | |
| return self._get_javascript_response(instruction) | |
| elif "sql" in instruction_lower: | |
| return self._get_sql_response(instruction) | |
| else: | |
| return self._get_general_response(instruction) | |
| def _get_python_response(self, instruction: str) -> str: | |
| """Generate Python response""" | |
| return "# Python Code\n# TODO: Implement based on instruction" | |
| def _get_javascript_response(self, instruction: str) -> str: | |
| """Generate JavaScript response""" | |
| return "// JavaScript Code\n// TODO: Implement based on instruction" | |
| def _get_sql_response(self, instruction: str) -> str: | |
| """Generate SQL response""" | |
| return "-- SQL Query\n-- TODO: Implement based on instruction" | |
| def _get_general_response(self, instruction: str) -> str: | |
| """Generate general response""" | |
| return "# Code\n# TODO: Implement based on instruction" | |
| def get_trajectory(self) -> Dict[str, Any]: | |
| """Get conversation trajectory for training""" | |
| return { | |
| "session_id": self.session_id, | |
| "history": self.conversation_history, | |
| "timestamp": time.time(), | |
| } | |
| def save_trajectory(self, path: str) -> None: | |
| """Save conversation trajectory to file""" | |
| trajectory = self.get_trajectory() | |
| file_path = Path(path) / f"session_{int(time.time())}.jsonl" | |
| file_path.parent.mkdir(parents=True, exist_ok=True) | |
| with open(file_path, "w", encoding="utf-8") as f: | |
| f.write(json.dumps(trajectory, ensure_ascii=False) + "\n") | |
| def reset(self) -> None: | |
| """Reset agent state""" | |
| self.conversation_history = [] | |
| self.session_id = self._generate_session_id() | |