| |
| """ |
| DeepSeek API Helper Script for ATOM Project |
| Provides integration with DeepSeek API for AI-assisted development |
| """ |
|
|
| import json |
| import os |
| from pathlib import Path |
| from typing import Dict, List, Optional |
|
|
| import requests |
|
|
|
|
| class DeepSeekHelper: |
| """Helper class for DeepSeek API integration""" |
|
|
| def __init__(self, api_key: Optional[str] = None): |
| self.api_key = api_key or os.getenv("DEEPSEEK_API_KEY") |
| self.base_url = "https://api.deepseek.com/chat/completions" |
| self.headers = { |
| "Content-Type": "application/json", |
| "Authorization": f"Bearer {self.api_key}", |
| } |
|
|
| def chat_completion( |
| self, |
| messages: List[Dict[str, str]], |
| model: str = "deepseek-chat", |
| temperature: float = 0.7, |
| max_tokens: int = 4000, |
| ) -> Optional[str]: |
| """ |
| Send chat completion request to DeepSeek API |
| |
| Args: |
| messages: List of message dictionaries with 'role' and 'content' |
| model: DeepSeek model to use |
| temperature: Sampling temperature |
| max_tokens: Maximum tokens in response |
| |
| Returns: |
| Response content or None if error |
| """ |
| if not self.api_key: |
| print("❌ DEEPSEEK_API_KEY environment variable not set") |
| return None |
|
|
| payload = { |
| "model": model, |
| "messages": messages, |
| "temperature": temperature, |
| "max_tokens": max_tokens, |
| "stream": False, |
| } |
|
|
| try: |
| response = requests.post(self.base_url, headers=self.headers, json=payload) |
| response.raise_for_status() |
|
|
| result = response.json() |
| return result["choices"][0]["message"]["content"] |
|
|
| except requests.exceptions.RequestException as e: |
| print(f"❌ API request failed: {e}") |
| return None |
| except KeyError as e: |
| print(f"❌ Unexpected API response format: {e}") |
| return None |
|
|
| def get_organization_prompt(self) -> str: |
| """Get the organization prompt for maintaining project structure""" |
| return """ |
| You are assisting with the ATOM project development. Follow these organization rules: |
| |
| PROJECT STRUCTURE: |
| - Root directory should only contain: README.md, .charm |
| - Python files → backend/ |
| - TypeScript/React files → frontend-nextjs/ |
| - Rust files → desktop-tauri/src-tauri/ |
| - Documentation → docs/ |
| - Scripts → scripts/ |
| - Tests → tests/ |
| - Configuration → config/ |
| - Deployment → deployment/ |
| |
| ORGANIZATION RULES: |
| 1. Prefer existing directories for file placement |
| 2. Create new folders only when necessary for logical organization of new features |
| 3. Use kebab-case for folder names |
| 4. Run organization validation before committing |
| 5. Never create files in root directory |
| |
| EXISTING DIRECTORIES: |
| - backend/ - Python backend services and APIs |
| - frontend-nextjs/ - Next.js web application |
| - desktop-tauri/ - Tauri desktop application |
| - docs/ - Documentation and guides |
| - scripts/ - Automation and utility scripts |
| - tests/ - Test files and test results |
| - config/ - Configuration files |
| - deployment/ - Deployment configurations |
| - data/ - Database schemas and data files |
| |
| When creating new files, always place them in the appropriate existing directory. |
| Only create new folders when absolutely necessary for major new features. |
| """ |
|
|
| def code_assistance( |
| self, task: str, context_files: List[str] = None, language: str = "python" |
| ) -> Optional[str]: |
| """ |
| Get AI assistance for coding tasks with project context |
| |
| Args: |
| task: Description of the coding task |
| context_files: List of file paths to include as context |
| language: Programming language for the task |
| |
| Returns: |
| AI-generated code or assistance |
| """ |
| system_prompt = self.get_organization_prompt() |
|
|
| |
| context = "" |
| if context_files: |
| for file_path in context_files: |
| if Path(file_path).exists(): |
| with open(file_path, "r") as f: |
| content = f.read() |
| context += f"\n\n--- {file_path} ---\n{content}" |
|
|
| user_message = f""" |
| Task: {task} |
| Language: {language} |
| {context} |
| |
| Please provide code that follows the project organization rules. |
| Place files in appropriate directories and maintain clean structure. |
| """ |
|
|
| messages = [ |
| {"role": "system", "content": system_prompt}, |
| {"role": "user", "content": user_message}, |
| ] |
|
|
| return self.chat_completion(messages) |
|
|
| def organize_suggestion(self, file_path: str) -> Optional[str]: |
| """ |
| Get suggestion for organizing a specific file |
| |
| Args: |
| file_path: Path to the file that needs organization |
| |
| Returns: |
| Suggestion for where to move the file |
| """ |
| if not Path(file_path).exists(): |
| print(f"❌ File not found: {file_path}") |
| return None |
|
|
| system_prompt = self.get_organization_prompt() |
|
|
| user_message = f""" |
| I have a file at path: {file_path} |
| Based on the ATOM project organization rules, where should this file be placed? |
| Please suggest the appropriate directory and explain why. |
| """ |
|
|
| messages = [ |
| {"role": "system", "content": system_prompt}, |
| {"role": "user", "content": user_message}, |
| ] |
|
|
| return self.chat_completion(messages) |
|
|
|
|
| def main(): |
| """Command line interface for DeepSeek helper""" |
| import argparse |
|
|
| parser = argparse.ArgumentParser(description="DeepSeek API Helper for ATOM Project") |
| parser.add_argument("--task", help="Coding task description") |
| parser.add_argument("--organize", help="Get organization suggestion for file") |
| parser.add_argument("--context", nargs="+", help="Context files to include") |
| parser.add_argument("--language", default="python", help="Programming language") |
|
|
| args = parser.parse_args() |
|
|
| helper = DeepSeekHelper() |
|
|
| if args.organize: |
| print(f"🔍 Getting organization suggestion for: {args.organize}") |
| suggestion = helper.organize_suggestion(args.organize) |
| if suggestion: |
| print("💡 Organization Suggestion:") |
| print(suggestion) |
| else: |
| print("❌ Failed to get organization suggestion") |
|
|
| elif args.task: |
| print(f"🤖 Getting AI assistance for: {args.task}") |
| result = helper.code_assistance(args.task, args.context, args.language) |
| if result: |
| print("💻 AI Assistance:") |
| print(result) |
| else: |
| print("❌ Failed to get AI assistance") |
|
|
| else: |
| parser.print_help() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
