AI代码助手：JetBrains AI Assistant

import jsonfrom collections import defaultdict  class JetBrainsAIAssistant:    """Simulate JetBrains AI Assistant behavior with PSI-based context."""     def __init__(self, ide_name="IntelliJ IDEA", model="jetbrains", language="java"):        self.ide_name = ide_name        self.model = model        self.language = language        self.psi_tree = {}        self.stats = {"completions": 0, "chats": 0, "actions": 0, "accepted": 0}     def build_psi_context(self, file_content, cursor_position):        """Build semantic context from PSI tree analysis."""        lines = file_content.split("\n")        context = {            "language": self.language,            "current_class": self._find_enclosing_class(lines, cursor_position),            "current_method": self._find_enclosing_method(lines, cursor_position),            "imports": self._extract_imports(lines),            "field_types": self._extract_field_types(lines),            "cursor_line": cursor_position[0] if isinstance(cursor_position, tuple) else cursor_position,            "prefix_code": "\n".join(lines[:cursor_position]) if isinstance(cursor_position, int) else "",            "suffix_code": "\n".join(lines[cursor_position:]) if isinstance(cursor_position, int) else ""        }        self.psi_tree = context        return context     def _find_enclosing_class(self, lines, cursor):        """Find the class enclosing the cursor position."""        cursor_line = cursor if isinstance(cursor, int) else cursor[0]        for i in range(min(cursor_line, len(lines) - 1), -1, -1):            line = lines[i].strip()            if line.startswith("class "):                return line.split("{")[0].strip()        return None     def _find_enclosing_method(self, lines, cursor):        """Find the method enclosing the cursor position."""        cursor_line = cursor if isinstance(cursor, int) else cursor[0]        for i in range(min(cursor_line, len(lines) - 1), -1, -1):            line = lines[i].strip()            if line.startswith("def ") or line.startswith("public ") or line.startswith("private "):                return line.split("{")[0].split(":")[0].strip()        return None     def _extract_imports(self, lines):        """Extract import statements from the file."""        imports = []        for line in lines:            stripped = line.strip()            if stripped.startswith("import ") or stripped.startswith("from "):                imports.append(stripped)        return imports     def _extract_field_types(self, lines):        """Extract field type information from class body."""        types = {}        for line in lines:            stripped = line.strip()            if ": " in stripped and "=" in stripped:                parts = stripped.split(": ")                if len(parts) >= 2:                    name = parts[0].strip()                    type_hint = parts[1].split("=")[0].strip()                    types[name] = type_hint        return types     def complete_code(self, file_content, cursor_position):        """Generate code completion using PSI context."""        context = self.build_psi_context(file_content, cursor_position)        suggestion = self._generate_suggestion(context)        self.stats["completions"] += 1        return {            "suggestion": suggestion,            "context_used": {                "class": context["current_class"],                "method": context["current_method"],                "imports_count": len(context["imports"]),                "types_known": len(context["field_types"])            },            "model": self.model,            "confidence": self._estimate_confidence(context)        }     def _generate_suggestion(self, context):        """Generate completion based on PSI context."""        method = context.get("current_method", "")        if method and "calculate" in method.lower():            return "    result = sum(values) / len(values)\n    return result"        elif method and "validate" in method.lower():            return "    if not data:\n        raise ValueError('Invalid data')\n    return True"        elif context.get("prefix_code", "").rstrip().endswith("="):            return " []"        return "    pass"     def _estimate_confidence(self, context):        """Estimate confidence based on context richness."""        score = 0.0        if context.get("current_class"):            score += 0.3        if context.get("current_method"):            score += 0.25        if context.get("imports"):            score += 0.2        if context.get("field_types"):            score += 0.15        return min(score + 0.1, 1.0)     def ai_chat(self, question, file_content=None, selection=None):        """Handle AI Chat conversation."""        self.stats["chats"] += 1        context = {}        if file_content:            context = self.build_psi_context(file_content, 0)        response = {            "question": question,            "answer": self._generate_chat_response(question, context, selection),            "model": self.model,            "context_elements": {                "class": context.get("current_class"),                "method": context.get("current_method"),                "has_selection": selection is not None            }        }        return response     def _generate_chat_response(self, question, context, selection):        """Generate chat response based on question and context."""        q_lower = question.lower()        if "explain" in q_lower or "what" in q_lower:            method = context.get("current_method", "this code")            return f"The method {method} processes data and returns results based on the logic."        elif "test" in q_lower:            return "I can generate unit tests covering normal paths, edge cases, and exception handling."        elif "optimize" in q_lower or "improve" in q_lower:            return "Consider using vectorized operations instead of loops for better performance."        else:            return f"Based on the context of {context.get('current_class', 'the file')}, here is my suggestion."     def ai_action(self, action_name, target_code):        """Execute an AI Action on selected code."""        self.stats["actions"] += 1        actions = {            "generate_test": self._generate_test,            "explain_code": self._explain_code,            "generate_doc": self._generate_doc,            "suggest_refactor": self._suggest_refactor        }        handler = actions.get(action_name)        if handler:            return handler(target_code)        return {"error": f"Unknown action: {action_name}"}     def _generate_test(self, code):        return {"action": "generate_test", "tests": ["test_normal_case", "test_edge_case", "test_exception"]}     def _explain_code(self, code):        return {"action": "explain_code", "explanation": "This code defines a function that processes input data."}     def _generate_doc(self, code):        return {"action": "generate_doc", "docstring": "Process the input data and return the result."}     def _suggest_refactor(self, code):        return {"action": "suggest_refactor", "suggestion": "Extract the validation logic into a separate method."}     def get_statistics(self):        """Get usage statistics."""        return dict(self.stats)  if False and __name__ == "__main__":    assistant = JetBrainsAIAssistant(ide_name="IntelliJ IDEA", model="jetbrains", language="python")    code = "class Calculator:\n    def calculate_mean(self, data):\n        "    result = assistant.complete_code(code, 2)    print("Completion:", json.dumps(result, indent=2, ensure_ascii=False))    chat = assistant.ai_chat("Explain this method", code)    print("\nChat:", json.dumps(chat, indent=2, ensure_ascii=False))    print("\nStats:", json.dumps(assistant.get_statistics(), indent=2, ensure_ascii=False))