handycode 2.2.1__tar.gz → 2.3.0__tar.gz

{handycode-2.2.1 → handycode-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: handycode
-Version: 2.2.1
+Version: 2.3.0
 Summary: AI Code Assistant for DeepSeek
 Home-page: https://github.com/AuraTechno/HandyCode
 Author: AuraTechno

{handycode-2.2.1 → handycode-2.3.0}/handycode/__init__.py

@@ -3,7 +3,7 @@ HandyCode - AI Ассистент для разработки
 Аналог Claude Code для командной строки
 """
 
-__version__ = "2.2.1"
+__version__ = "2.3.0"
 __author__ = "AURA Tec."
 __license__ = "MIT"
 

{handycode-2.2.1 → handycode-2.3.0}/handycode/assistant.py

@@ -1,5 +1,5 @@
 """
-Основной класс ассистента HandyCode с интерактивным меню
+Основной класс ассистента HandyCode
 """
 
 import os
@@ -34,43 +34,33 @@ from handycode.security import SecurityChecker
 from handycode.utils import (
     Colors, Theme, colorize, print_colored, print_header, print_success,
     print_error, print_warning, print_info, print_logo,
-    print_divider, print_file_action, print_status, print_section, print_box
+    print_divider, print_file_action, print_status, print_section, print_box,
+    Spinner, print_package_status
 )
 
 
 def interactive_confirm(commands):
-    """
-    Интерактивное меню выбора команд.
-    Управление: ↑/↓ для навигации, ПРОБЕЛ для выбора, ENTER для подтверждения.
-    Возвращает список выбранных команд.
-    """
+    """Интерактивное меню выбора команд"""
     if not commands:
         return []
 
-    # Настройка для Windows
     if os.name == 'nt':
         import msvcrt
-
         def get_key():
             key = msvcrt.getch()
-            if key == b'\xe0':  # стрелки
+            if key == b'\xe0':
                 key = msvcrt.getch()
                 if key == b'H': return 'up'
                 if key == b'P': return 'down'
             if key == b'\r': return 'enter'
             if key == b' ': return 'space'
-            if key == b'a': return 'a'
-            if key == b'A': return 'A'
-            if key == b's': return 's'
-            if key == b'S': return 'S'
-            if key == b'c': return 'c'
-            if key == b'C': return 'C'
+            if key in [b'a', b'A']: return 'a'
+            if key in [b's', b'S']: return 's'
+            if key in [b'c', b'C']: return 'c'
             if key == b'\x1b': return 'escape'
             return key.decode('utf-8', errors='ignore')
     else:
-        import tty
-        import termios
-
+        import tty, termios
         def get_key():
             fd = sys.stdin.fileno()
             old = termios.tcgetattr(fd)
@@ -88,51 +78,28 @@ def interactive_confirm(commands):
             finally:
                 termios.tcsetattr(fd, termios.TCSADRAIN, old)
 
-    selected = [True] * len(commands)  # все выбраны по умолчанию
+    selected = [True] * len(commands)
     current = 0
 
     def render():
-        # Очищаем предыдущий вывод
         print(f"\033[{len(commands) + 4}A\033[J", end="")
-
         print()
         print(colorize("  ⚡ Команды для выполнения:", Theme.HIGHLIGHT + Colors.BOLD))
         print(colorize("  ─────────────────────────────────────────────────", Theme.MUTED))
-
         for i, cmd in enumerate(commands):
-            if i == current:
-                prefix = colorize("  ›", Theme.PRIMARY + Colors.BOLD)
-            else:
-                prefix = "   "
-
-            if selected[i]:
-                checkbox = colorize("◉", Theme.SUCCESS)
-                cmd_color = Theme.SUCCESS
-            else:
-                checkbox = colorize("○", Theme.MUTED)
-                cmd_color = Theme.MUTED
-
+            prefix = colorize("  ›", Theme.PRIMARY + Colors.BOLD) if i == current else "   "
+            checkbox = colorize("◉", Theme.SUCCESS) if selected[i] else colorize("○", Theme.MUTED)
+            cmd_color = Theme.SUCCESS if selected[i] else Theme.MUTED
             print(f"{prefix} {checkbox} {colorize(cmd, cmd_color)}")
-
-        print()
-        print(colorize("  Управление:", Theme.MUTED))
-        print(colorize("  ↑↓ Навигация  ПРОБЕЛ Выбрать  A Все  S Пропустить  ENTER Подтвердить", Theme.MUTED))
-
-    # Рендерим первый раз
-    print()
-    print()
-    print()
-    print()
-    print()
-    print()
-    for _ in range(len(commands) + 4):
         print()
+        print(colorize("  ↑↓ Навигация  ПРОБЕЛ Выбрать  A Все  S Пропустить  ENTER Подтвердить  C Отмена", Theme.MUTED))
 
+    for _ in range(len(commands) + 5):
+        print()
     render()
 
     while True:
         key = get_key()
-
         if key == 'up':
             current = (current - 1) % len(commands)
             render()
@@ -168,7 +135,12 @@ class HandyCode:
         self.model_settings = get_model_settings(self.current_model)
         self.file_manager = FileManager(self.project_path)
         self.security = SecurityChecker(self.project_path)
+
+        # Получаем список установленных пакетов
+        self.installed_packages = self.file_manager.get_installed_packages()
+
         project_context = self._build_project_context()
+
         self.conversation_history = [
             {"role": "system", "content": self._get_system_prompt() + project_context}
         ]
@@ -179,12 +151,21 @@ class HandyCode:
         }
         self.stream_buffer = ""
         self.pending_commands = []
+        self.command_results = []  # Результаты выполнения команд
         self._setup_readline()
         signal.signal(signal.SIGINT, self._signal_handler)
         self._interrupt_count = 0
 
     def _build_project_context(self):
         context = f"\n\n=== CURRENT PROJECT ===\nDirectory: {self.project_path}\n"
+        context += f"\n=== INSTALLED PACKAGES ===\n"
+        if self.installed_packages:
+            context += ", ".join(self.installed_packages[:50])
+            if len(self.installed_packages) > 50:
+                context += f"\n... and {len(self.installed_packages) - 50} more"
+        else:
+            context += "No packages detected"
+
         try:
             all_files = []
             for ext in self.file_manager.allowed_extensions:
@@ -199,13 +180,26 @@ class HandyCode:
                         if not any(rel.startswith(ex) for ex in self.file_manager.excluded_dirs):
                             files.append(f)
                             seen.add(f)
-            context += f"\nFiles ({len(files)}):\n"
+            context += f"\n\n=== PROJECT FILES ({len(files)}) ===\n"
             for file in files:
                 try:
                     rel_path = file.relative_to(self.project_path)
                     size = file.stat().st_size
                     context += f"  {rel_path} ({self._format_size(size)})\n"
                 except: pass
+
+            context += f"\n=== FILE CONTENTS ===\n"
+            total = 0
+            for file in files:
+                if total > 50000: break
+                try:
+                    content = file.read_text(encoding='utf-8', errors='ignore')
+                    if len(content) > 3000:
+                        content = content[:3000] + "\n... (truncated)"
+                    rel_path = file.relative_to(self.project_path)
+                    context += f"\n=== {rel_path} ===\n{content}\n"
+                    total += len(content)
+                except: pass
         except: pass
         return context
 
@@ -216,22 +210,50 @@ class HandyCode:
         return f"{size:.1f}TB"
 
     def _get_system_prompt(self):
-        return """You are HandyCode - AI coding assistant. Create/modify/delete files and run commands.
-FORMAT:
-[[CREATE:path/file]]
+        return """You are HandyCode - AI coding assistant.
+
+CAPABILITIES:
+- Create, modify, delete files
+- Run shell commands
+- Install Python packages via pip
+- Analyze code and errors
+- See installed packages and project files
+
+PACKAGE MANAGEMENT:
+- Check INSTALLED PACKAGES section before suggesting imports
+- If a package is needed but not installed, use [[INSTALL:package_name]]
+- Example: [[INSTALL:fastapi]] [[INSTALL:uvicorn]]
+
+FILE FORMAT:
+[[CREATE:path/file.py]]
 code here
 [[END]]
-[[MODIFY:path/file]]
+
+[[MODIFY:path/file.py]]
 new code here
 [[END]]
+
+[[DELETE:path/file.py]]
+[[READ:path/file.py]]
+[[LIST:directory/]]
 [[EXEC:command]]
-RULES:
-1. CREATE + EXEC in ONE response
-2. Use [[END]] after file content
-3. NO comments inside [[CREATE]]...[[END]]
-4. Explanations BEFORE [[CREATE]] blocks
-5. Files create automatically, commands need confirmation
-Speak Russian. Write code in English."""
+[[INSTALL:package_name]]
+
+CRITICAL RULES:
+1. ALWAYS check if required packages are installed before using them
+2. Install missing packages with [[INSTALL:...]]
+3. CREATE files + INSTALL packages + EXEC commands in ONE response
+4. Use [[END]] to close file blocks
+5. NO comments or explanations inside [[CREATE]]...[[END]] - ONLY CODE
+6. Put ALL explanations BEFORE [[CREATE]] blocks
+7. After EXEC, I will show you any errors
+
+ERROR HANDLING:
+- After running commands, I'll show you the output
+- If there are errors, I'll show them to you
+- You can then fix the files and re-run
+
+Speak Russian. Write code in English. Code ONLY inside [[CREATE]]...[[END]]."""
 
     def _setup_readline(self):
         if not HAS_READLINE: return
@@ -254,6 +276,8 @@ Speak Russian. Write code in English."""
 
     def _process_stream_chunk(self, chunk):
         self.stream_buffer += chunk
+
+        # CREATE с анимацией
         while True:
             match = re.search(r'\[\[CREATE:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
             if match:
@@ -262,11 +286,15 @@ Speak Russian. Write code in English."""
                 content = re.sub(r'^```[\w]*\n', '', content)
                 content = re.sub(r'\n```$', '', content)
                 if content and self.security.is_safe_path(path):
+                    spinner = Spinner(f"Создание {path}")
+                    spinner.start()
                     self.file_manager.create_file(path, content)
+                    spinner.stop(f"  ✔ {path} ({content.count(chr(10))+1} строк)")
                     self.stats["files_created"].append(path)
-                    print_file_action('create', path, f"({content.count(chr(10))+1} lines)")
                 self.stream_buffer = self.stream_buffer[match.end():]
             else: break
+
+        # MODIFY
         while True:
             match = re.search(r'\[\[MODIFY:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
             if match:
@@ -275,11 +303,25 @@ Speak Russian. Write code in English."""
                 content = re.sub(r'^```[\w]*\n', '', content)
                 content = re.sub(r'\n```$', '', content)
                 if content and self.security.is_safe_path(path):
+                    spinner = Spinner(f"Изменение {path}")
+                    spinner.start()
                     self.file_manager.modify_file(path, content)
+                    spinner.stop(f"  ✎ {path} ({content.count(chr(10))+1} строк)")
                     self.stats["files_modified"].append(path)
-                    print_file_action('modify', path, f"({content.count(chr(10))+1} lines)")
                 self.stream_buffer = self.stream_buffer[match.end():]
             else: break
+
+        # INSTALL
+        while True:
+            match = re.search(r'\[\[INSTALL:(.+?)\]\]', self.stream_buffer)
+            if match:
+                package = match.group(1).strip()
+                print_status(f"Установка пакета: {package}")
+                self.file_manager.install_package(package)
+                self.stream_buffer = self.stream_buffer[match.end():]
+            else: break
+
+        # EXEC
         while True:
             match = re.search(r'\[\[EXEC:(.+?)\]\]', self.stream_buffer)
             if match:
@@ -322,7 +364,7 @@ Speak Russian. Write code in English."""
                                     if '[[END]]' in content:
                                         in_code = False
                                     if not in_code:
-                                        clean = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '').replace(']]', '')
+                                        clean = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '').replace('[[INSTALL:', '').replace(']]', '')
                                         if clean.strip():
                                             print(clean, end="", flush=True)
                                     self._process_stream_chunk(content)
@@ -360,7 +402,7 @@ Speak Russian. Write code in English."""
                                     if '[[END]]' in content:
                                         in_code = False
                                     if not in_code:
-                                        clean = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '').replace(']]', '')
+                                        clean = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '').replace('[[INSTALL:', '').replace(']]', '')
                                         if clean.strip():
                                             print(clean, end="", flush=True)
                                     self._process_stream_chunk(content)
@@ -409,8 +451,26 @@ Speak Russian. Write code in English."""
                         for cmd in selected_commands:
                             if self.security.is_safe_command(cmd):
                                 print_status(f"Выполняется: {cmd}")
-                                self.file_manager.execute_command(cmd)
+                                success, output = self.file_manager.execute_command(cmd)
                                 self.stats["commands_executed"].append(cmd)
+                                self.command_results.append({
+                                    "command": cmd,
+                                    "success": success,
+                                    "output": output
+                                })
+
+                        # Показываем ошибки
+                        errors = [r for r in self.command_results if not r['success']]
+                        if errors:
+                            print()
+                            print_section("❌ Обнаружены ошибки", [])
+                            for err in errors:
+                                print(colorize(f"  Команда: {err['command']}", Theme.ERROR))
+                                if err['output']:
+                                    for line in err['output'].strip().split('\n')[:5]:
+                                        print(colorize(f"    {line}", Theme.MUTED))
+                            print()
+                            print_info("Вы можете попросить меня исправить ошибки")
                     else:
                         print_warning("Команды пропущены")
 
@@ -426,6 +486,7 @@ Speak Russian. Write code in English."""
             print_box([
                 "/help      Справка",
                 "/scan      Показать проект",
+                "/packages  Показать установленные пакеты",
                 "/models    Модели",
                 "/model N   Сменить модель",
                 "/clear     Очистить историю",
@@ -435,6 +496,11 @@ Speak Russian. Write code in English."""
             ], Theme.PRIMARY)
         elif cmd in ['/scan', '/s']:
             print(self.file_manager.scan_project())
+        elif cmd in ['/packages', '/pkg']:
+            packages = self.file_manager.get_installed_packages()
+            print_section("📦 Установленные пакеты", packages[:20])
+            if len(packages) > 20:
+                print(colorize(f"  ... и ещё {len(packages) - 20}", Theme.MUTED))
         elif cmd in ['/models', '/m']:
             lines = []
             for name, mid in MODELS.items():
@@ -449,14 +515,18 @@ Speak Russian. Write code in English."""
                 print_success(f"Модель изменена на {name}")
         elif cmd in ['/clear', '/c']:
             self.conversation_history = [self.conversation_history[0]]
+            self.command_results = []
             print_success("История очищена")
+        elif cmd in ['/save']:
+            self.file_manager.save_session(self.conversation_history, self.current_model, self.stats)
         elif cmd in ['/stats']:
             print_box([
                 f"Сообщений: {self.stats['messages_sent']}",
                 f"Создано файлов: {len(self.stats['files_created'])}",
                 f"Изменено: {len(self.stats['files_modified'])}",
                 f"Удалено: {len(self.stats['files_deleted'])}",
-                f"Команд выполнено: {len(self.stats['commands_executed'])}"
+                f"Команд выполнено: {len(self.stats['commands_executed'])}",
+                f"Пакетов установлено: {len(self.installed_packages)}"
             ], Theme.SECONDARY)
         elif cmd in ['/exit', '/q']:
             print_success("До свидания!")
@@ -471,6 +541,7 @@ Speak Russian. Write code in English."""
         print_divider("─", 60, Theme.MUTED)
         print(colorize(f"  📁 Проект: {self.project_path}", Theme.TEXT))
         print(colorize(f"  🤖 Модель: {self.current_model}", Theme.TEXT))
+        print(colorize(f"  📦 Пакетов: {len(self.installed_packages)}", Theme.TEXT))
         print(colorize(f"  {Theme.MUTED}/help для команд{Colors.RESET}", Theme.MUTED))
         print_divider("─", 60, Theme.MUTED)
         print()

handycode-2.3.0/handycode/file_manager.py

@@ -0,0 +1,228 @@
+"""
+Управление файлами для HandyCode
+"""
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Dict, Optional
+from datetime import datetime
+
+from handycode.utils import (
+    print_success, print_error, print_warning, print_info,
+    print_status, print_package_status, print_command_result, Spinner
+)
+
+
+class FileManager:
+    def __init__(self, project_root: Path):
+        self.project_root = Path(project_root).resolve()
+        self.allowed_extensions = {
+            '.html', '.css', '.scss', '.sass', '.less',
+            '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
+            '.vue', '.svelte', '.astro',
+            '.py', '.pyi', '.pyx', '.pxd',
+            '.json', '.yaml', '.yml', '.toml', '.ini', '.cfg',
+            '.xml', '.env', '.gitignore', '.dockerignore',
+            '.md', '.mdx', '.rst', '.txt', '.log',
+            '.sql', '.sh', '.bash', '.zsh', '.bat', '.ps1',
+            '.java', '.kt', '.scala',
+            '.cpp', '.c', '.h', '.hpp', '.cs',
+            '.rs', '.go', '.rb', '.php', '.swift',
+            '.dart', '.r', '.jl', '.lua',
+            '.dockerfile', '.makefile', '.cmake',
+        }
+        self.excluded_dirs = {
+            'node_modules', '__pycache__', '.git', '.svn',
+            'venv', '.venv', 'env', '.env',
+            'dist', 'build', '.next', '.nuxt',
+            'target', 'out', '.idea', '.vscode',
+            '.DS_Store', 'Thumbs.db',
+        }
+
+    def scan_project(self) -> str:
+        if not self.project_root.exists():
+            return ""
+        try:
+            lines = [f"📁 Проект: {self.project_root.name}"]
+            all_files = []
+            for ext in self.allowed_extensions:
+                all_files.extend(self.project_root.rglob(f"*{ext}"))
+            all_files.extend(self.project_root.rglob("*"))
+            seen = set()
+            files = []
+            for f in sorted(all_files):
+                if f.is_file() and f not in seen:
+                    rel = str(f.relative_to(self.project_root))
+                    if not any(ex in f.parts for ex in self.excluded_dirs):
+                        if not any(rel.startswith(ex) for ex in self.excluded_dirs):
+                            files.append(f)
+                            seen.add(f)
+            lines.append(f"📄 Файлов: {len(files)}")
+            if files:
+                lines.append("\n📂 Структура:")
+                for file in files:
+                    try:
+                        rel_path = file.relative_to(self.project_root)
+                        size = file.stat().st_size
+                        lines.append(f"  {rel_path} ({self._format_size(size)})")
+                    except:
+                        pass
+            return '\n'.join(lines)
+        except Exception as e:
+            return f"Ошибка: {e}"
+
+    def _format_size(self, size):
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size < 1024: return f"{size:.1f}{unit}"
+            size /= 1024
+        return f"{size:.1f}TB"
+
+    def create_file(self, path: str, content: str) -> bool:
+        try:
+            full_path = self.project_root / path
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            if full_path.exists():
+                backup = full_path.with_suffix(full_path.suffix + '.bak')
+                shutil.copy2(full_path, backup)
+            full_path.write_text(content, encoding='utf-8')
+            return True
+        except Exception as e:
+            print_error(f"Ошибка создания {path}: {e}")
+            return False
+
+    def modify_file(self, path: str, content: str) -> bool:
+        try:
+            full_path = self.project_root / path
+            if not full_path.exists():
+                return self.create_file(path, content)
+            backup = full_path.with_suffix(full_path.suffix + '.bak')
+            shutil.copy2(full_path, backup)
+            full_path.write_text(content, encoding='utf-8')
+            return True
+        except Exception as e:
+            print_error(f"Ошибка изменения {path}: {e}")
+            return False
+
+    def delete_file(self, path: str) -> bool:
+        try:
+            full_path = self.project_root / path
+            if not full_path.exists():
+                return False
+            backup = full_path.with_suffix(full_path.suffix + '.bak')
+            shutil.copy2(full_path, backup)
+            full_path.unlink()
+            print_success(f"Удалён: {path}")
+            return True
+        except Exception as e:
+            print_error(f"Ошибка удаления {path}: {e}")
+            return False
+
+    def read_file(self, path: str) -> bool:
+        try:
+            full_path = self.project_root / path
+            if not full_path.exists():
+                return False
+            content = full_path.read_text(encoding='utf-8', errors='ignore')
+            print(f"\n=== {path} ===\n{content}")
+            return True
+        except Exception as e:
+            print_error(f"Ошибка чтения {path}: {e}")
+            return False
+
+    def list_directory(self, path: str = ".") -> bool:
+        try:
+            full_path = self.project_root / path
+            if not full_path.exists():
+                return False
+            items = list(full_path.iterdir())
+            print(f"\n=== {path or '.'} ({len(items)} элементов) ===")
+            for item in sorted(items):
+                if item.is_dir():
+                    print(f"  📁 {item.name}/")
+                else:
+                    size = item.stat().st_size
+                    print(f"  📄 {item.name} ({self._format_size(size)})")
+            return True
+        except Exception as e:
+            print_error(f"Ошибка: {e}")
+            return False
+
+    def execute_command(self, command: str, timeout: int = 300) -> tuple[bool, str]:
+        """Выполняет команду и возвращает (успех, вывод)"""
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=self.project_root,
+                capture_output=True,
+                text=True,
+                timeout=timeout
+            )
+            output = result.stdout + result.stderr
+            success = result.returncode == 0
+            print_command_result(command, success, output if not success else None)
+            return success, output
+        except subprocess.TimeoutExpired:
+            print_command_result(command, False, "Таймаут выполнения")
+            return False, "Таймаут выполнения"
+        except Exception as e:
+            print_command_result(command, False, str(e))
+            return False, str(e)
+
+    def install_package(self, package: str) -> bool:
+        """Устанавливает пакет через pip"""
+        spinner = Spinner(f"Установка {package}")
+        spinner.start()
+        try:
+            result = subprocess.run(
+                f"pip install {package}",
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=120
+            )
+            spinner.stop()
+            success = result.returncode == 0
+            print_package_status(package, "установлен", success)
+            if not success:
+                print_error(result.stderr[:200])
+            return success
+        except:
+            spinner.stop()
+            print_package_status(package, "ошибка", False)
+            return False
+
+    def get_installed_packages(self) -> List[str]:
+        """Получает список установленных pip-пакетов"""
+        try:
+            result = subprocess.run(
+                "pip list --format=freeze",
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            if result.returncode == 0:
+                return [line.split('==')[0].lower() for line in result.stdout.strip().split('\n') if '==' in line]
+        except:
+            pass
+        return []
+
+    def save_session(self, history: List[Dict], model: str, stats: Dict) -> str:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"handycode_session_{timestamp}.md"
+        try:
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(f"# HandyCode Session\n\n")
+                f.write(f"Date: {datetime.now()}\n")
+                f.write(f"Model: {model}\n\n---\n\n")
+                for msg in history[1:]:
+                    if msg['role'] == 'user':
+                        f.write(f"## User\n\n{msg['content']}\n\n")
+                    else:
+                        f.write(f"## Assistant\n\n{msg['content']}\n\n---\n\n")
+            return print_success(f"Сессия сохранена: {filename}")
+        except Exception as e:
+            return print_error(f"Ошибка сохранения: {e}")

{handycode-2.2.1 → handycode-2.3.0}/handycode/utils.py

@@ -4,16 +4,15 @@
 
 import sys
 import os
+import time
+import threading
 
 class Colors:
-    # Базовые
     RESET = '\033[0m'
     BOLD = '\033[1m'
     DIM = '\033[2m'
     ITALIC = '\033[3m'
-    UNDERLINE = '\033[4m'
 
-    # Стандартные мягкие тона (не яркие)
     BLACK = '\033[30m'
     RED = '\033[31m'
     GREEN = '\033[32m'
@@ -23,7 +22,6 @@ class Colors:
     CYAN = '\033[36m'
     WHITE = '\033[37m'
 
-    # Яркие (для акцентов)
     BRIGHT_BLACK = '\033[90m'
     BRIGHT_RED = '\033[91m'
     BRIGHT_GREEN = '\033[92m'
@@ -33,16 +31,15 @@ class Colors:
     BRIGHT_CYAN = '\033[96m'
     BRIGHT_WHITE = '\033[97m'
 
-# Тема HandyCode (премиальная пастель)
 class Theme:
-    PRIMARY = Colors.CYAN          # мягкий циан
-    SECONDARY = Colors.BLUE        # спокойный синий
-    ACCENT = Colors.MAGENTA        # акцент
+    PRIMARY = Colors.CYAN
+    SECONDARY = Colors.BLUE
+    ACCENT = Colors.MAGENTA
     SUCCESS = Colors.GREEN
     WARNING = Colors.YELLOW
     ERROR = Colors.RED
     TEXT = Colors.WHITE
-    MUTED = Colors.BRIGHT_BLACK    # серый для подписей
+    MUTED = Colors.BRIGHT_BLACK
     HIGHLIGHT = Colors.BRIGHT_WHITE
 
 def supports_color():
@@ -84,27 +81,10 @@ def print_logo():
     from .logo import get_logo
     print(get_logo())
 
-def print_install_logo():
-    from .logo import get_install_logo
-    print(get_install_logo())
-
-def truncate(text, max_length=100):
-    if len(text) <= max_length:
-        return text
-    return text[:max_length-3] + "..."
-
-def format_size(size_bytes):
-    for unit in ['B', 'KB', 'MB', 'GB']:
-        if size_bytes < 1024:
-            return f"{size_bytes:.1f} {unit}"
-        size_bytes /= 1024
-    return f"{size_bytes:.1f} TB"
-
 def print_divider(char="─", width=60, color=Theme.MUTED):
     print(colorize(char * width, color))
 
 def print_box(lines, color=Theme.PRIMARY):
-    """Рамка вокруг списка строк"""
     max_len = max((len(line) for line in lines), default=0) + 2
     top = "┌" + "─" * max_len + "┐"
     bottom = "└" + "─" * max_len + "┘"
@@ -114,7 +94,6 @@ def print_box(lines, color=Theme.PRIMARY):
     print(colorize(bottom, color))
 
 def print_section(title, content_lines):
-    """Секция с заголовком и содержимым"""
     print_divider("─", 50, Theme.MUTED)
     print(colorize(f"  {title}", Theme.HIGHLIGHT + Colors.BOLD))
     for line in content_lines:
@@ -137,4 +116,50 @@ def print_file_action(action, path, details=""):
     msg = f"  {icon} {path}"
     if details:
         msg += f" {colorize(details, Theme.MUTED)}"
-    print(colorize(msg, color))
+    print(colorize(msg, color))
+
+class Spinner:
+    """Анимированный спиннер"""
+    def __init__(self, message="Загрузка"):
+        self.message = message
+        self.running = False
+        self.thread = None
+        self.chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+    def start(self):
+        self.running = True
+        self.thread = threading.Thread(target=self._spin)
+        self.thread.start()
+
+    def stop(self, final_message=None):
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        sys.stdout.write('\r' + ' ' * (len(self.message) + 10) + '\r')
+        sys.stdout.flush()
+        if final_message:
+            print(final_message)
+
+    def _spin(self):
+        i = 0
+        while self.running:
+            char = self.chars[i % len(self.chars)]
+            sys.stdout.write(f'\r  {char} {self.message}...')
+            sys.stdout.flush()
+            time.sleep(0.1)
+            i += 1
+
+def print_package_status(package, action, success=True):
+    """Красивое отображение установки пакета"""
+    icon = '✔' if success else '✘'
+    color = Theme.SUCCESS if success else Theme.ERROR
+    print(colorize(f"    {icon} {package}", color))
+
+def print_command_result(command, success, output=None):
+    """Отображение результата команды"""
+    icon = '✔' if success else '✘'
+    color = Theme.SUCCESS if success else Theme.ERROR
+    print(colorize(f"  {icon} {command[:60]}", color))
+    if output and not success:
+        for line in output.strip().split('\n')[:5]:
+            print(colorize(f"    {line}", Theme.MUTED))

{handycode-2.2.1 → handycode-2.3.0}/handycode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: handycode
-Version: 2.2.1
+Version: 2.3.0
 Summary: AI Code Assistant for DeepSeek
 Home-page: https://github.com/AuraTechno/HandyCode
 Author: AuraTechno

{handycode-2.2.1 → handycode-2.3.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="handycode",
-    version="2.2.1",
+    version="2.3.0",
     author="AuraTechno",
     description="AI Code Assistant for DeepSeek",
     long_description="HandyCode - AI Code Assistant",

handycode-2.2.1/handycode/file_manager.py

@@ -1,238 +0,0 @@
-"""
-Управление файлами для HandyCode
-"""
-
-import os
-import shutil
-import subprocess
-from pathlib import Path
-from typing import List, Dict, Optional
-from datetime import datetime
-
-from handycode.utils import print_success, print_error, print_warning, print_info
-
-
-class FileManager:
-    """Управляет файловыми операциями HandyCode"""
-
-    def __init__(self, project_root: Path):
-        """Инициализация файлового менеджера"""
-        self.project_root = Path(project_root).resolve()
-        self.allowed_extensions = {
-            '.html', '.css', '.scss', '.sass', '.less',
-            '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
-            '.vue', '.svelte', '.astro',
-            '.py', '.pyi', '.pyx', '.pxd',
-            '.json', '.yaml', '.yml', '.toml', '.ini', '.cfg',
-            '.xml', '.env', '.gitignore', '.dockerignore',
-            '.md', '.mdx', '.rst', '.txt', '.log',
-            '.sql', '.sh', '.bash', '.zsh', '.bat', '.ps1',
-            '.java', '.kt', '.scala',
-            '.cpp', '.c', '.h', '.hpp', '.cs',
-            '.rs', '.go', '.rb', '.php', '.swift',
-            '.dart', '.r', '.jl', '.lua',
-            '.dockerfile', '.makefile', '.cmake',
-        }
-
-        self.excluded_dirs = {
-            'node_modules', '__pycache__', '.git', '.svn',
-            'venv', '.venv', 'env', '.env',
-            'dist', 'build', '.next', '.nuxt',
-            'target', 'out', '.idea', '.vscode',
-            '.DS_Store', 'Thumbs.db',
-        }
-
-    def scan_project(self) -> str:
-        """Сканирует проект и возвращает структуру"""
-        if not self.project_root.exists():
-            return ""
-
-        try:
-            lines = [f"📁 Проект: {self.project_root.name}"]
-
-            # Собираем все файлы
-            all_files = []
-            for ext in self.allowed_extensions:
-                all_files.extend(self.project_root.rglob(f"*{ext}"))
-
-            # Фильтруем исключённые
-            files = [
-                f for f in all_files
-                if f.is_file() and not any(ex in f.parts for ex in self.excluded_dirs)
-            ]
-
-            lines.append(f"📄 Файлов: {len(files)}")
-
-            # Строим дерево
-            if files:
-                lines.append("\n📂 Структура:")
-                tree = self._build_tree(files)
-                lines.extend(self._print_tree(tree))
-
-            # Ключевые файлы
-            key_files = [
-                'package.json', 'requirements.txt', 'Dockerfile',
-                'README.md', 'setup.py', 'pyproject.toml',
-                'tsconfig.json', '.gitignore', 'docker-compose.yml',
-                'main.py', 'app.py', 'index.js', 'server.js'
-            ]
-
-            for file in files:
-                if file.name in key_files:
-                    try:
-                        content = file.read_text(encoding='utf-8')
-                        if len(content) < 5000:
-                            lines.append(f"\n{'=' * 40}")
-                            lines.append(f"📄 {file.relative_to(self.project_root)}")
-                            lines.append('=' * 40)
-                            lines.append(content)
-                    except:
-                        pass
-
-            return '\n'.join(lines)
-        except Exception as e:
-            return f"Ошибка сканирования: {e}"
-
-    def _build_tree(self, files: List[Path]) -> dict:
-        """Строит дерево директорий"""
-        tree = {}
-        for file in files:
-            try:
-                relative = file.relative_to(self.project_root)
-                parts = relative.parts
-                current = tree
-                for part in parts[:-1]:
-                    if part not in current:
-                        current[part] = {}
-                    current = current[part]
-
-                if '__files__' not in current:
-                    current['__files__'] = []
-                current['__files__'].append(parts[-1])
-            except:
-                pass
-        return tree
-
-    def _print_tree(self, node: dict, indent: str = "") -> List[str]:
-        """Выводит дерево директорий"""
-        result = []
-        # Сначала директории
-        dirs = sorted([k for k in node if k != '__files__'])
-        for d in dirs:
-            result.append(f"{indent}📁 {d}/")
-            result.extend(self._print_tree(node[d], indent + "  "))
-        # Потом файлы
-        if '__files__' in node:
-            for f in sorted(node['__files__']):
-                result.append(f"{indent}📄 {f}")
-        return result
-
-    def create_file(self, path: str, content: str) -> bool:
-        """Создаёт файл"""
-        try:
-            full_path = self.project_root / path
-
-            # Создаём директории
-            full_path.parent.mkdir(parents=True, exist_ok=True)
-
-            # Резервная копия если файл существует
-            if full_path.exists():
-                backup = full_path.with_suffix(full_path.suffix + '.bak')
-                shutil.copy2(full_path, backup)
-                print_warning(f"📦 Резервная копия: {backup.name}")
-
-            # Записываем файл
-            full_path.write_text(content, encoding='utf-8')
-
-            lines = content.count('\n') + 1
-            size = len(content)
-            print_success(f"✅ Создан: {path} ({lines} строк, {size} байт)")
-
-            return True
-        except Exception as e:
-            print_error(f"Ошибка создания {path}: {e}")
-            return False
-
-    def modify_file(self, path: str, content: str) -> bool:
-        """Изменяет файл"""
-        try:
-            full_path = self.project_root / path
-
-            if not full_path.exists():
-                print_warning(f"Файл не существует, создаём: {path}")
-                return self.create_file(path, content)
-
-            # Резервная копия
-            backup = full_path.with_suffix(full_path.suffix + '.bak')
-            shutil.copy2(full_path, backup)
-            print_warning(f"📦 Резервная копия: {backup.name}")
-
-            # Записываем новое содержимое
-            full_path.write_text(content, encoding='utf-8')
-
-            lines = content.count('\n') + 1
-            print_success(f"✅ Изменён: {path} ({lines} строк)")
-
-            return True
-        except Exception as e:
-            print_error(f"Ошибка изменения {path}: {e}")
-            return False
-
-    def execute_command(self, command: str, timeout: int = 300) -> bool:
-        """Выполняет команду"""
-        try:
-            print_warning(f"\n⚡ Выполнение: {command}")
-
-            result = subprocess.run(
-                command,
-                shell=True,
-                cwd=self.project_root,
-                capture_output=True,
-                text=True,
-                timeout=timeout
-            )
-
-            if result.stdout:
-                print(result.stdout)
-
-            if result.returncode != 0:
-                if result.stderr:
-                    print_error(result.stderr)
-                print_error(f"Команда завершилась с ошибкой (код {result.returncode})")
-                return False
-
-            print_success("✅ Команда выполнена успешно")
-            return True
-
-        except subprocess.TimeoutExpired:
-            print_error(f"Таймаут выполнения ({timeout}с)")
-            return False
-        except Exception as e:
-            print_error(f"Ошибка выполнения: {e}")
-            return False
-
-    def save_session(self, history: List[Dict], model: str, stats: Dict) -> str:
-        """Сохраняет сессию в файл"""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"handycode_сессия_{timestamp}.md"
-
-        try:
-            with open(filename, 'w', encoding='utf-8') as f:
-                f.write(f"# Сессия HandyCode\n\n")
-                f.write(f"**Дата:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-                f.write(f"**Модель:** {model}\n")
-                f.write(f"**Сообщений:** {stats.get('messages_sent', 0)}\n\n")
-                f.write("---\n\n")
-
-                for msg in history[1:]:  # Пропускаем системный промпт
-                    if msg['role'] == 'user':
-                        f.write(f"## 👤 Пользователь\n\n{msg['content']}\n\n")
-                    else:
-                        clean = msg['content']
-                        # Убираем маркеры действий для читаемости
-                        clean = clean.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[EXEC:', '')
-                        f.write(f"## 🤖 Ассистент\n\n{clean}\n\n---\n\n")
-
-            return print_success(f"✅ Сессия сохранена: {filename}")
-        except Exception as e:
-            return print_error(f"Ошибка сохранения: {e}")