Add services, prompts, and utils modules

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