From 496449174b6d3a79e5cceb001108b349d0455323 Mon Sep 17 00:00:00 2001 From: 7000pctAUTO Date: Sat, 31 Jan 2026 15:30:17 +0000 Subject: [PATCH] Add services, prompts, and utils modules --- local_code_assistant/prompts/templates.py | 428 ++++++++++++++++++++++ 1 file changed, 428 insertions(+) create mode 100644 local_code_assistant/prompts/templates.py diff --git a/local_code_assistant/prompts/templates.py b/local_code_assistant/prompts/templates.py new file mode 100644 index 0000000..844bf21 --- /dev/null +++ b/local_code_assistant/prompts/templates.py @@ -0,0 +1,428 @@ +"""Prompt templates for Local Code Assistant.""" + +from typing import Optional + + +class PromptTemplates: + """Collection of prompt templates for different operations.""" + + SYSTEM_PROMPT = """You are an expert AI coding assistant helping developers write better code. +Your role is to: +1. Generate clean, well-documented code +2. Explain code clearly and concisely +3. Refactor code for better performance and readability +4. Write comprehensive tests + +Always: +- Provide complete, working code +- Include comments for complex logic +- Follow best practices for the specific language +- Consider edge cases and error handling +- Keep responses focused and practical + +Never: +- Include any external API calls or network requests in generated code +- Use placeholder comments without actual implementation +- Generate code that could be harmful or insecure""" + + CODE_GENERATION = """Generate {language} code that accomplishes the following task: + +{user_prompt} + +Requirements: +- Write clean, readable {language} code +- Include appropriate comments +- Handle potential errors +- Follow {language} best practices + +{files_context} + +Return only the code, no explanations.""" + + CODE_EXPLANATION = """Explain the following {language} code in detail: + +```{language} +{code} +``` + +Provide: +1. Overall purpose of the code +2. Key functions/classes and their roles +3. Important logic flows +4. Any potential issues or improvements +5. Usage examples if applicable""" + + CODE_REFACTOR = """Refactor the following {language} code: + +```{language} +{code} +``` + +{files_context} + +Focus on: +{refactor_focus} + +Return the refactored code with brief explanation of changes made.""" + + CODE_REFACTOR_SAFE = """Perform safe refactoring of the following {language} code: + +```{language} +{code} +``` + +{files_context} + +Safe refactoring means: +- No changing external APIs or interfaces +- No modifying business logic behavior +- Only improving code structure and readability +- Better variable names +- Extracting reusable functions +- Reducing duplication + +Return the refactored code with brief explanation of changes.""" + + CODE_REFACTOR_OPTIMIZE = """Optimize the following {language} code for better performance: + +```{language} +{code} +``` + +{files_context} + +Consider: +- Algorithm complexity improvements +- Memory usage optimization +- Reducing unnecessary operations +- Better data structures +- Caching where appropriate + +Return the optimized code with explanation of performance improvements.""" + + TEST_GENERATION = """Write comprehensive tests for the following {language} code: + +```{language} +{code} +``` + +{files_context} + +Requirements: +- Use appropriate testing framework for {language} +- Cover main functionality +- Include edge cases +- Use descriptive test names +- Keep tests independent + +Supported testing frameworks: +- Python: pytest, unittest +- JavaScript/TypeScript: jest, mocha +- Go: testing package +- Rust: test module + +Return the test code only, no explanations.""" + + DOCSTRING_GENERATION = """Generate documentation for the following {language} function: + +```{language} +{code} +``` + +Provide: +1. Docstring following {language} conventions +2. Parameter descriptions +3. Return value description +4. Example usage + +Return the function with added docstring.""" + + BUG_FIX = """Identify and fix bugs in the following {language} code: + +```{language} +{code} +``` + +{files_context} + +Expected behavior: {expected_behavior} + +Identify issues and provide fixed code.""" + + CONTEXT_TEMPLATE = """Related project files for context: +{files} +""" + + @classmethod + def code_generation( + cls, + language: str, + user_prompt: str, + files_context: Optional[str] = None + ) -> str: + """Generate code generation prompt. + + Args: + language: Programming language. + user_prompt: User's request. + files_context: Optional project context. + + Returns: + Complete prompt string. + """ + context = files_context or "" + return cls.CODE_GENERATION.format( + language=language, + user_prompt=user_prompt, + files_context=context + ) + + @classmethod + def code_explanation( + cls, + language: str, + code: str + ) -> str: + """Generate code explanation prompt. + + Args: + language: Programming language. + code: Code to explain. + + Returns: + Complete prompt string. + """ + return cls.CODE_EXPLANATION.format( + language=language, + code=code + ) + + @classmethod + def code_refactor( + cls, + language: str, + code: str, + focus: list[str], + files_context: Optional[str] = None + ) -> str: + """Generate refactoring prompt. + + Args: + language: Programming language. + code: Code to refactor. + focus: List of focus areas. + files_context: Optional project context. + + Returns: + Complete prompt string. + """ + context = files_context or "" + focus_text = "\n".join(f"- {item}" for item in focus) + + return cls.CODE_REFACTOR.format( + language=language, + code=code, + files_context=context, + refactor_focus=focus_text + ) + + @classmethod + def code_refactor_safe( + cls, + language: str, + code: str, + files_context: Optional[str] = None + ) -> str: + """Generate safe refactoring prompt. + + Args: + language: Programming language. + code: Code to refactor. + files_context: Optional project context. + + Returns: + Complete prompt string. + """ + context = files_context or "" + return cls.CODE_REFACTOR_SAFE.format( + language=language, + code=code, + files_context=context + ) + + @classmethod + def code_refactor_optimize( + cls, + language: str, + code: str, + files_context: Optional[str] = None + ) -> str: + """Generate optimization prompt. + + Args: + language: Programming language. + code: Code to optimize. + files_context: Optional project context. + + Returns: + Complete prompt string. + """ + context = files_context or "" + return cls.CODE_REFACTOR_OPTIMIZE.format( + language=language, + code=code, + files_context=context + ) + + @classmethod + def test_generation( + cls, + language: str, + code: str, + files_context: Optional[str] = None + ) -> str: + """Generate test creation prompt. + + Args: + language: Programming language. + code: Code to test. + files_context: Optional project context. + + Returns: + Complete prompt string. + """ + context = files_context or "" + return cls.TEST_GENERATION.format( + language=language, + code=code, + files_context=context + ) + + @classmethod + def build_system_prompt(cls, extra_context: Optional[str] = None) -> str: + """Build system prompt with optional extra context. + + Args: + extra_context: Additional context to include. + + Returns: + Complete system prompt. + """ + if extra_context: + return f"{cls.SYSTEM_PROMPT}\n\nAdditional context:\n{extra_context}" + return cls.SYSTEM_PROMPT + + +class LanguageConfig: + """Configuration for supported programming languages.""" + + class _Settings: + """Internal settings class.""" + def __init__( + self, + extension: str, + comment: str, + testing_framework: str, + file_patterns: list[str], + ): + self.extension = extension + self.comment = comment + self.testing_framework = testing_framework + self.file_patterns = file_patterns + + SUPPORTED_LANGUAGES = { + "python": _Settings( + extension=".py", + comment="#", + testing_framework="pytest", + file_patterns=["*.py", "*.pyw"] + ), + "javascript": _Settings( + extension=".js", + comment="//", + testing_framework="jest", + file_patterns=["*.js", "*.mjs"] + ), + "typescript": _Settings( + extension=".ts", + comment="//", + testing_framework="jest", + file_patterns=["*.ts", "*.tsx"] + ), + "go": _Settings( + extension=".go", + comment="//", + testing_framework="testing", + file_patterns=["*.go"] + ), + "rust": _Settings( + extension=".rs", + comment="//", + testing_framework="test", + file_patterns=["*.rs"] + ) + } + + @classmethod + def get_config(cls, language: str) -> _Settings: + """Get configuration for a language. + + Args: + language: Language name. + + Returns: + Language configuration object. + """ + return cls.SUPPORTED_LANGUAGES.get(language, cls._Settings( + extension=".txt", + comment="#", + testing_framework="pytest", + file_patterns=["*"] + )) + + @classmethod + def is_supported(cls, language: str) -> bool: + """Check if language is supported. + + Args: + language: Language name. + + Returns: + True if supported, False otherwise. + """ + return language.lower() in cls.SUPPORTED_LANGUAGES + + @classmethod + def get_supported_languages(cls) -> list[str]: + """Get list of supported languages. + + Returns: + List of language names. + """ + return list(cls.SUPPORTED_LANGUAGES.keys()) + + @classmethod + def get_extension(cls, language: str) -> str: + """Get file extension for language. + + Args: + language: Language name. + + Returns: + File extension with dot. + """ + config = cls.get_config(language) + return config.extension + + @classmethod + def get_comment_style(cls, language: str) -> str: + """Get comment style for language. + + Args: + language: Language name. + + Returns: + Comment prefix. + """ + config = cls.get_config(language) + return config.comment \ No newline at end of file