handycode 2.1.5__tar.gz → 2.2.0__tar.gz

{handycode-2.1.5 → handycode-2.2.0}/PKG-INFO

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

{handycode-2.1.5 → handycode-2.2.0}/handycode/__init__.py

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

{handycode-2.1.5 → handycode-2.2.0}/handycode/assistant.py

@@ -1,13 +1,8 @@
 """
-Основной класс ассистента HandyCode
+Основной класс ассистента HandyCode с премиальным интерфейсом
 """
 
-import os
-import re
-import json
-import sys
-import atexit
-import signal
+import os, re, json, sys, atexit, signal
 from pathlib import Path
 from typing import List, Dict, Optional
 from datetime import datetime
@@ -23,71 +18,53 @@ try:
     HAS_REQUESTS = True
 except ImportError:
     HAS_REQUESTS = False
-    import urllib.request
-    import urllib.error
-    import ssl
+    import urllib.request, urllib.error, ssl
 
 from handycode.config import Config
 from handycode.models import MODELS, get_model_settings
 from handycode.file_manager import FileManager
 from handycode.security import SecurityChecker
 from handycode.utils import (
-    print_colored, print_header, print_success,
-    print_error, print_warning, print_info, print_logo
+    Colors, Theme, colorize, print_colored, print_header, print_success,
+    print_error, print_warning, print_info, print_logo, print_install_logo,
+    print_divider, print_file_action, print_status, print_section, print_box
 )
 
-
 class HandyCode:
     def __init__(self, project_path, model="deepseek", auto_approve=False, config=None):
         self.project_path = project_path
         self.auto_approve = auto_approve
         self.config = config or Config()
-
         self.api_key = self.config.get_api_key()
         if not self.api_key:
             raise ValueError("API key not found")
-
         self.api_url = "https://openrouter.ai/api/v1/chat/completions"
         self.current_model = MODELS.get(model, MODELS["deepseek"])
         self.model_settings = get_model_settings(self.current_model)
-
         self.file_manager = FileManager(self.project_path)
         self.security = SecurityChecker(self.project_path)
-
         project_context = self._build_project_context()
-
         self.conversation_history = [
             {"role": "system", "content": self._get_system_prompt() + project_context}
         ]
-
         self.stats = {
-            "messages_sent": 0,
-            "files_created": [],
-            "files_modified": [],
-            "files_deleted": [],
-            "files_read": [],
-            "commands_executed": [],
+            "messages_sent": 0, "files_created": [], "files_modified": [],
+            "files_deleted": [], "files_read": [], "commands_executed": [],
             "start_time": datetime.now()
         }
-
-        # Буфер для потокового создания файлов
         self.stream_buffer = ""
-        self.current_file_action = None
-
+        self.pending_commands = []
         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 ===\n"
-        context += f"Directory: {self.project_path}\n"
-
+        context = f"\n\n=== CURRENT PROJECT ===\nDirectory: {self.project_path}\n"
         try:
             all_files = []
             for ext in self.file_manager.allowed_extensions:
                 all_files.extend(self.project_path.rglob(f"*{ext}"))
             all_files.extend(self.project_path.rglob("*"))
-
             seen = set()
             files = []
             for f in sorted(all_files):
@@ -97,153 +74,98 @@ 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"
             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"\nFile 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 Exception as e:
-            context += f"\nError: {e}\n"
-
+                except: pass
+        except: pass
         return context
 
     def _format_size(self, size):
         for unit in ['B', 'KB', 'MB', 'GB']:
-            if size < 1024:
-                return f"{size:.1f}{unit}"
+            if size < 1024: return f"{size:.1f}{unit}"
             size /= 1024
         return f"{size:.1f}TB"
 
     def _get_system_prompt(self):
-        return """You are HandyCode - an AI assistant for coding. You can create, modify, delete files and run commands.
-
-CRITICAL: You MUST complete ALL actions in ONE response. If user asks to create AND run a project, do BOTH in the same response.
-
-FILE FORMAT - use EXACTLY:
-[[CREATE:filename]]
+        return """You are HandyCode - AI coding assistant. Create/modify/delete files and run commands.
+FORMAT:
+[[CREATE:path/file]]
 code here
 [[END]]
-
-[[MODIFY:filename]]
+[[MODIFY:path/file]]
 new code here
 [[END]]
-
-[[DELETE:filename]]
-[[READ:filename]]
-[[LIST:directory/]]
 [[EXEC:command]]
-
 RULES:
-1. CREATE and EXEC in SAME response - create files AND run them together
-2. Always use [[END]] to close files
-3. NEVER put comments inside [[CREATE]]...[[END]] blocks
-4. Put explanations BEFORE [[CREATE]] blocks, not inside
-5. When user asks to create and run - do both immediately
-6. Files create automatically, commands need confirmation
-
+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."""
 
     def _setup_readline(self):
-        if not HAS_READLINE:
-            return
+        if not HAS_READLINE: return
         try:
             histfile = os.path.join(os.path.expanduser("~"), ".handycode", "history")
             os.makedirs(os.path.dirname(histfile), exist_ok=True)
             readline.read_history_file(histfile)
             readline.set_history_length(1000)
             atexit.register(readline.write_history_file, histfile)
-        except:
-            pass
+        except: pass
 
     def _signal_handler(self, sig, frame):
         self._interrupt_count += 1
         if self._interrupt_count == 1:
-            print("\n\nPress Ctrl+C again to exit")
+            print("\n\n  ⚠ Нажмите Ctrl+C ещё раз для выхода")
         else:
             os._exit(0)
 
-    def reset_interrupt(self):
-        self._interrupt_count = 0
+    def reset_interrupt(self): self._interrupt_count = 0
 
+    # Потоковая обработка
     def _process_stream_chunk(self, chunk):
-        """Обрабатывает кусок потокового ответа, создавая файлы на лету"""
         self.stream_buffer += chunk
-
-        # Ищем [[CREATE:...]]...[[END]]
         while True:
-            # Ищем начало CREATE
-            create_match = re.search(r'\[\[CREATE:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
-            if create_match:
-                path = create_match.group(1).strip()
-                content = create_match.group(2).strip()
+            match = re.search(r'\[\[CREATE:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
+            if match:
+                path = match.group(1).strip()
+                content = match.group(2).strip()
                 content = re.sub(r'^```[\w]*\n', '', content)
                 content = re.sub(r'\n```$', '', content)
-
                 if content and self.security.is_safe_path(path):
                     self.file_manager.create_file(path, content)
                     self.stats["files_created"].append(path)
-                    lines = content.count('\n') + 1
-                    print(f"\n  ✅ Created: {path} ({lines} lines)")
-
-                # Удаляем обработанный блок из буфера
-                self.stream_buffer = self.stream_buffer[create_match.end():]
-            else:
-                break
-
-        # Ищем [[MODIFY:...]]...[[END]]
+                    print_file_action('create', path, f"({content.count(chr(10))+1} lines)")
+                self.stream_buffer = self.stream_buffer[match.end():]
+            else: break
         while True:
-            modify_match = re.search(r'\[\[MODIFY:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
-            if modify_match:
-                path = modify_match.group(1).strip()
-                content = modify_match.group(2).strip()
+            match = re.search(r'\[\[MODIFY:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
+            if match:
+                path = match.group(1).strip()
+                content = match.group(2).strip()
                 content = re.sub(r'^```[\w]*\n', '', content)
                 content = re.sub(r'\n```$', '', content)
-
                 if content and self.security.is_safe_path(path):
                     self.file_manager.modify_file(path, content)
                     self.stats["files_modified"].append(path)
-                    lines = content.count('\n') + 1
-                    print(f"\n  ✏️ Modified: {path} ({lines} lines)")
-
-                self.stream_buffer = self.stream_buffer[modify_match.end():]
-            else:
-                break
-
-        # Ищем [[EXEC:...]]
+                    print_file_action('modify', path, f"({content.count(chr(10))+1} lines)")
+                self.stream_buffer = self.stream_buffer[match.end():]
+            else: break
         while True:
-            exec_match = re.search(r'\[\[EXEC:(.+?)\]\]', self.stream_buffer)
-            if exec_match:
-                command = exec_match.group(1).strip()
-                self.pending_commands.append(command)
-                self.stream_buffer = self.stream_buffer[exec_match.end():]
-            else:
-                break
+            match = re.search(r'\[\[EXEC:(.+?)\]\]', self.stream_buffer)
+            if match:
+                self.pending_commands.append(match.group(1).strip())
+                self.stream_buffer = self.stream_buffer[match.end():]
+            else: break
 
     def _make_request_streaming(self, data):
-        """Потоковый запрос с обработкой файлов в реальном времени"""
         self.stream_buffer = ""
         self.pending_commands = []
-
         if HAS_REQUESTS:
             return self._stream_requests(data)
         else:
@@ -251,28 +173,19 @@ Speak Russian. Write code in English."""
 
     def _stream_requests(self, data):
         try:
-            response = requests.post(
-                self.api_url,
-                headers={
-                    "Authorization": f"Bearer {self.api_key}",
-                    "Content-Type": "application/json"
-                },
-                json={**data, "stream": True},
-                timeout=120,
-                stream=True
-            )
+            response = requests.post(self.api_url,
+                headers={"Authorization": f"Bearer {self.api_key}",
+                         "Content-Type": "application/json"},
+                json={**data, "stream": True}, timeout=120, stream=True)
             response.raise_for_status()
-
             full_response = ""
-            in_code_block = False
-
+            in_code = False
             for line in response.iter_lines():
                 if line:
                     line = line.decode('utf-8')
                     if line.startswith('data: '):
                         data_str = line[6:]
-                        if data_str.strip() == '[DONE]':
-                            break
+                        if data_str.strip() == '[DONE]': break
                         try:
                             chunk = json.loads(data_str)
                             if 'choices' in chunk and chunk['choices']:
@@ -280,26 +193,16 @@ Speak Russian. Write code in English."""
                                 content = delta.get('content', '')
                                 if content:
                                     full_response += content
-
-                                    # Определяем, нужно ли показывать
-                                    if '[[CREATE:' in full_response[-100:] or '[[MODIFY:' in full_response[-100:]:
-                                        in_code_block = True
-
-                                    if '[[END]]' in full_response[-20:]:
-                                        in_code_block = False
-
-                                    # Показываем только текст вне кодовых блоков
-                                    if not in_code_block:
-                                        # Не показываем маркеры
-                                        display = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '')
-                                        if display.strip():
-                                            print(display, end="", flush=True)
-
-                                    # Обрабатываем буфер для создания файлов
+                                    if '[[CREATE:' in content or '[[MODIFY:' in content:
+                                        in_code = True
+                                    if '[[END]]' in content:
+                                        in_code = False
+                                    if not in_code:
+                                        clean = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '').replace(']]', '')
+                                        if clean.strip():
+                                            print(clean, end="", flush=True)
                                     self._process_stream_chunk(content)
-                        except:
-                            continue
-
+                        except: continue
             print()
             return full_response
         except Exception as e:
@@ -309,27 +212,18 @@ Speak Russian. Write code in English."""
     def _stream_urllib(self, data):
         try:
             json_data = json.dumps({**data, "stream": True}).encode('utf-8')
-            req = urllib.request.Request(
-                self.api_url,
-                data=json_data,
-                headers={
-                    "Authorization": f"Bearer {self.api_key}",
-                    "Content-Type": "application/json"
-                },
-                method='POST'
-            )
+            req = urllib.request.Request(self.api_url, data=json_data,
+                headers={"Authorization": f"Bearer {self.api_key}",
+                         "Content-Type": "application/json"}, method='POST')
             ctx = ssl.create_default_context()
-
             full_response = ""
-            in_code_block = False
-
-            with urllib.request.urlopen(req, context=ctx, timeout=120) as response:
-                for line in response:
+            in_code = False
+            with urllib.request.urlopen(req, context=ctx, timeout=120) as resp:
+                for line in resp:
                     line = line.decode('utf-8').strip()
                     if line.startswith('data: '):
                         data_str = line[6:]
-                        if data_str == '[DONE]':
-                            break
+                        if data_str == '[DONE]': break
                         try:
                             chunk = json.loads(data_str)
                             if 'choices' in chunk and chunk['choices']:
@@ -337,21 +231,16 @@ Speak Russian. Write code in English."""
                                 content = delta.get('content', '')
                                 if content:
                                     full_response += content
-
-                                    if '[[CREATE:' in full_response[-100:] or '[[MODIFY:' in full_response[-100:]:
-                                        in_code_block = True
-
-                                    if '[[END]]' in full_response[-20:]:
-                                        in_code_block = False
-
-                                    if not in_code_block:
-                                        display = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '')
-                                        if display.strip():
-                                            print(display, end="", flush=True)
-
+                                    if '[[CREATE:' in content or '[[MODIFY:' in content:
+                                        in_code = True
+                                    if '[[END]]' in content:
+                                        in_code = False
+                                    if not in_code:
+                                        clean = content.replace('[[CREATE:', '').replace('[[MODIFY:', '').replace('[[END]]', '').replace('[[EXEC:', '').replace(']]', '')
+                                        if clean.strip():
+                                            print(clean, end="", flush=True)
                                     self._process_stream_chunk(content)
-                        except:
-                            continue
+                        except: continue
                 print()
                 return full_response
         except Exception as e:
@@ -363,7 +252,6 @@ Speak Russian. Write code in English."""
             return self._handle_command(user_input)
 
         self.conversation_history.append({"role": "user", "content": user_input})
-
         if len(self.conversation_history) > 20:
             self.conversation_history = [self.conversation_history[0]] + self.conversation_history[-19:]
 
@@ -375,32 +263,33 @@ Speak Russian. Write code in English."""
         }
 
         try:
-            print_info(f"\nDEEPSEEK:")
+            # Заголовок ответа
+            print_divider("─", 60, Theme.MUTED)
+            print(colorize("  HandyCode", Theme.PRIMARY + Colors.BOLD), end="")
+            print(colorize("  ●  ответ", Theme.MUTED))
+            print_divider("─", 60, Theme.MUTED)
+
             response = self._make_request_streaming(payload)
 
             if response:
                 self.conversation_history.append({"role": "assistant", "content": response})
 
-                # Выполняем оставшиеся команды
+                # Команды
                 if self.pending_commands:
-                    print_header("\nCOMMANDS")
-                    for i, cmd in enumerate(self.pending_commands, 1):
-                        print(f"  {i}. {cmd}")
-
+                    print()
+                    print_section("⚡ Команды (требуют подтверждения)",
+                                  [colorize(cmd, Theme.WARNING) for cmd in self.pending_commands])
                     if self.auto_approve:
                         choice = 'A'
                     else:
-                        print("\n[A] Execute all  [S] Skip  [C] Cancel")
-                        choice = input("> ").strip().upper()
-
+                        print(colorize("  [A] Выполнить все  [S] Пропустить  [C] Отмена", Theme.MUTED))
+                        choice = input(colorize("  > ", Theme.HIGHLIGHT)).strip().upper()
                     if choice == 'A':
                         for cmd in self.pending_commands:
                             if self.security.is_safe_command(cmd):
+                                print_status(f"Выполняется: {cmd}")
                                 self.file_manager.execute_command(cmd)
                                 self.stats["commands_executed"].append(cmd)
-                    elif choice == 'S':
-                        print_warning("Skipped")
-
                 self.stats["messages_sent"] += 1
                 return response
         except Exception as e:
@@ -409,40 +298,44 @@ Speak Russian. Write code in English."""
     def _handle_command(self, user_input):
         parts = user_input.split()
         cmd = parts[0].lower()
-
         if cmd in ['/help', '/h']:
-            print("""
-COMMANDS:
-  /help          Show help
-  /scan          Scan project
-  /models        List models
-  /model NAME    Switch model
-  /clear         Clear history
-  /save          Save session
-  /stats         Statistics
-  /exit          Exit
-            """)
+            print_box([
+                "/help      Справка",
+                "/scan      Показать проект",
+                "/models    Модели",
+                "/model N   Сменить модель",
+                "/clear     Очистить историю",
+                "/save      Сохранить сессию",
+                "/stats     Статистика",
+                "/exit      Выход"
+            ], Theme.PRIMARY)
         elif cmd in ['/scan', '/s']:
-            print(self.file_manager.scan_project())
+            print_section("📁 Проект", self.file_manager.scan_project().split('\n'))
         elif cmd in ['/models', '/m']:
-            for name in MODELS:
-                print(f"  {name}")
+            lines = []
+            for name, mid in MODELS.items():
+                mark = " (текущая)" if mid == self.current_model else ""
+                lines.append(f"{name}{mark}")
+            print_section("🤖 Модели", lines)
         elif cmd in ['/model'] and len(parts) > 1:
-            model_name = parts[1]
-            if model_name in MODELS:
-                self.current_model = MODELS[model_name]
+            name = parts[1]
+            if name in MODELS:
+                self.current_model = MODELS[name]
                 self.model_settings = get_model_settings(self.current_model)
-                print_success(f"Switched to: {model_name}")
+                print_success(f"Модель изменена на {name}")
         elif cmd in ['/clear', '/c']:
             self.conversation_history = [self.conversation_history[0]]
-            print_success("Cleared")
+            print_success("История очищена")
         elif cmd in ['/stats']:
-            print(f"Messages: {self.stats['messages_sent']}")
-            print(f"Created: {len(self.stats['files_created'])}")
-            print(f"Modified: {len(self.stats['files_modified'])}")
-            print(f"Deleted: {len(self.stats['files_deleted'])}")
-            print(f"Commands: {len(self.stats['commands_executed'])}")
+            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'])}"
+            ], Theme.SECONDARY)
         elif cmd in ['/exit', '/q']:
+            print_success("До свидания!")
             os._exit(0)
         return ""
 
@@ -451,16 +344,16 @@ COMMANDS:
 
     def run(self):
         print_logo()
+        print_divider("─", 60, Theme.MUTED)
+        print(colorize(f"  📁 Проект: {self.project_path}", Theme.TEXT))
+        print(colorize(f"  🤖 Модель: {self.current_model}", Theme.TEXT))
+        print(colorize(f"  {Theme.MUTED}/help для команд{Colors.RESET}", Theme.MUTED))
+        print_divider("─", 60, Theme.MUTED)
         print()
-        print_info(f"Project: {self.project_path}")
-        print_info(f"Model: {self.current_model}")
-        print_info("Files: auto-create in real-time | Commands: confirmation required")
-        print_info("/help for commands\n")
-
         while True:
             try:
                 self.reset_interrupt()
-                user_input = input("> ").strip()
+                user_input = input(colorize("  ❯ ", Theme.PRIMARY + Colors.BOLD)).strip()
                 if user_input:
                     self.send_message(user_input)
             except KeyboardInterrupt:

{handycode-2.1.5 → handycode-2.2.0}/handycode/logo.py

@@ -5,15 +5,13 @@
 import sys
 from .utils import Colors, supports_color
 
-
 def get_logo() -> str:
-    """Возвращает ASCII логотип HandyCode"""
     if not supports_color():
         return get_logo_plain()
 
     C = Colors
     logo = f"""
-{C.CYAN}{C.BOLD}╔═════════════════════════════════════════════════════════════════════════════════════════════════╗
+{C.CYAN}╔═════════════════════════════════════════════════════════════════════════════════════════════════╗
 ║                                                                                                 ║
 ║  {C.YELLOW}██╗  ██╗{C.CYAN}  {C.GREEN}█████╗{C.CYAN}    {C.BLUE}███╗   ██╗{C.CYAN}  {C.MAGENTA}██████╗{C.CYAN}   {C.RED}██╗   ██╗{C.CYAN}    {C.WHITE}██████╗{C.CYAN}   {C.GREEN}███████╗{C.CYAN}  {C.BLUE}██████╗{C.CYAN}    {C.MAGENTA}███████╗{C.CYAN} ║
 ║  {C.YELLOW}██║  ██║{C.CYAN}  {C.GREEN}██╔══██╗{C.CYAN}  {C.BLUE}████╗  ██║{C.CYAN}  {C.MAGENTA}██╔══██╗{C.CYAN}  {C.RED}╚██╗ ██╔╝{C.CYAN}    {C.WHITE}██╔════╝{C.CYAN} {C.GREEN}██╔════██╗{C.CYAN}  {C.BLUE}██╔══██╗{C.CYAN}  {C.MAGENTA}██╔════╝{C.CYAN} ║
@@ -29,64 +27,46 @@ def get_logo() -> str:
 """
     return logo
 
-
 def get_logo_plain() -> str:
-    """Возвращает простой ASCII логотип без цветов"""
-    logo = r"""
-╔══════════════════════════════════════════════════════════════╗
-║                                                              ║
-║  ██╗  ██╗  █████╗  ███╗   ██╗  ██████╗  ██╗   ██╗            ║
-║  ██║  ██║  ██╔══██╗ ████╗  ██║  ██╔══██╗ ╚██╗ ██╔╝           ║
-║  ███████║  ███████║ ██╔██╗ ██║  ██║  ██║  ╚████╔╝            ║
-║  ██╔══██║  ██╔══██║ ██║╚██╗██║  ██║  ██║   ╚██╔╝             ║
-║  ██║  ██║  ██║  ██║ ██║ ╚████║  ██████╔╝    ██║              ║
-║  ╚═╝  ╚═╝  ╚═╝  ╚═╝ ╚═╝  ╚═══╝  ╚═════╝     ╚═╝              ║
-║                                                              ║
-║           ██████╗   ███████╗   ██████╗  ███████╗             ║
-║          ██╔════╝  ██╔════██╗  ██╔══██╗ ██╔════╝             ║
-║          ██║      ██║      ██║ ██║  ██║ █████╗               ║
-║          ██║       ██║    ██║  ██║  ██║ ██╔══╝               ║
-║          ╚██████╗   ███████╔╝  ██████╔╝ ███████╗             ║
-║           ╚═════╝    ╚═════╝   ╚═════╝  ╚══════╝             ║
-║                                                              ║
-║              AI Ассистент для разработки                     ║
-║                    Prod. by AURA Tec.                        ║
-║                         2.1.2                                ║
-║                                                              ║
-╚══════════════════════════════════════════════════════════════╝
+    return r"""
+╔═════════════════════════════════════════════════════════════════════════════════════════════════╗
+║                                                                                                 ║
+║  ██╗  ██╗  █████╗  ███╗   ██╗  ██████╗  ██╗   ██╗     ██████╗  ███████╗  ██████╗  ███████╗ ║
+║  ██║  ██║  ██╔══██╗ ████╗  ██║  ██╔══██╗ ╚██╗ ██╔╝     ██╔════╝  ██╔════██╗ ██╔══██╗ ██╔════╝ ║
+║  ███████║  ███████║ ██╔██╗ ██║  ██║  ██║  ╚████╔╝      ██║       ██║      ██║ ██║  ██║ █████╗   ║
+║  ██╔══██║  ██╔══██║ ██║╚██╗██║  ██║  ██║   ╚██╔╝       ██║       ██║    ██║  ██║  ██║ ██╔══╝   ║
+║  ██║  ██║  ██║  ██║ ██║ ╚████║  ██████╔╝    ██║        ╚██████╗  ███████╔╝  ██████╔╝ ███████╗ ║
+║  ╚═╝  ╚═╝  ╚═╝  ╚═╝ ╚═╝  ╚═══╝  ╚═════╝     ╚═╝         ╚═════╝  ╚═════╝   ╚═════╝  ╚══════╝ ║
+║                                                                                                 ║
+║              AI Ассистент для разработки                                                       ║
+║                    Prod. by AURA Tec.                                                          ║
+║                                                                                                 ║
+╚═════════════════════════════════════════════════════════════════════════════════════════════════╝
 """
-    return logo
-
 
 def get_small_logo() -> str:
-    """Возвращает маленький логотип"""
     if not supports_color():
-        return "HandyCode v2.0.0"
-
+        return "HandyCode v2.1.3"
     C = Colors
-    return f"{C.CYAN}HandyCode{C.RESET} {C.WHITE}v2.0.0{C.RESET} - {C.GREEN}AI Ассистент{C.RESET}"
-
+    return f"{C.CYAN}HandyCode{C.RESET} {C.WHITE}v2.1.3{C.RESET} – {C.GREEN}AI Ассистент{C.RESET}  {C.BRIGHT_BLACK}Prod. by AURA Tec.{C.RESET}"
 
 def get_install_logo() -> str:
-    """Возвращает логотип для установки"""
     if not supports_color():
         return get_logo_plain()
-
     C = Colors
-    logo = f"""
-    {C.CYAN}{C.BOLD}╔═════════════════════════════════════════════════════════════════════════════════════════════════╗
-    ║                                                                                                 ║
-    ║  {C.YELLOW}██╗  ██╗{C.CYAN}  {C.GREEN}█████╗{C.CYAN}    {C.BLUE}███╗   ██╗{C.CYAN}  {C.MAGENTA}██████╗{C.CYAN}   {C.RED}██╗   ██╗{C.CYAN}    {C.WHITE}██████╗{C.CYAN}   {C.GREEN}███████╗{C.CYAN}  {C.BLUE}██████╗{C.CYAN}    {C.MAGENTA}███████╗{C.CYAN} ║
-    ║  {C.YELLOW}██║  ██║{C.CYAN}  {C.GREEN}██╔══██╗{C.CYAN}  {C.BLUE}████╗  ██║{C.CYAN}  {C.MAGENTA}██╔══██╗{C.CYAN}  {C.RED}╚██╗ ██╔╝{C.CYAN}    {C.WHITE}██╔════╝{C.CYAN} {C.GREEN}██╔════██╗{C.CYAN}  {C.BLUE}██╔══██╗{C.CYAN}  {C.MAGENTA}██╔════╝{C.CYAN} ║
-    ║  {C.YELLOW}███████║{C.CYAN}  {C.GREEN}███████║{C.CYAN}  {C.BLUE}██╔██╗ ██║{C.CYAN}  {C.MAGENTA}██║  ██║{C.CYAN}   {C.RED}╚████╔╝{C.CYAN}     {C.WHITE}██║{C.CYAN}     {C.GREEN}██║      ██║{C.CYAN} {C.BLUE}██║  ██║{C.CYAN}  {C.MAGENTA}█████╗{C.CYAN}   ║
-    ║  {C.YELLOW}██╔══██║{C.CYAN}  {C.GREEN}██╔══██║{C.CYAN}  {C.BLUE}██║╚██╗██║{C.CYAN}  {C.MAGENTA}██║  ██║{C.CYAN}    {C.RED}╚██╔╝{C.CYAN}      {C.WHITE}██║{C.CYAN}      {C.GREEN}██║    ██║{C.CYAN}  {C.BLUE}██║  ██║{C.CYAN}  {C.MAGENTA}██╔══╝{C.CYAN}   ║
-    ║  {C.YELLOW}██║  ██║{C.CYAN}  {C.GREEN}██║  ██║{C.CYAN}  {C.BLUE}██║ ╚████║{C.CYAN}  {C.MAGENTA}██████╔╝{C.CYAN}     {C.RED}██║{C.CYAN}       {C.WHITE}╚██████╗{C.CYAN}  {C.GREEN}███████╔╝{C.CYAN}  {C.BLUE}██████╔╝{C.CYAN}  {C.MAGENTA}███████╗{C.CYAN} ║
-    ║  {C.YELLOW}╚═╝  ╚═╝{C.CYAN}  {C.GREEN}╚═╝  ╚═╝{C.CYAN}  {C.BLUE}╚═╝  ╚═══╝{C.CYAN}  {C.MAGENTA}╚═════╝{C.CYAN}      {C.RED}╚═╝{C.CYAN}       {C.WHITE} ╚═════╝{C.CYAN}   {C.GREEN}╚═════╝{C.CYAN}   {C.BLUE}╚═════╝{C.CYAN}   {C.MAGENTA}╚══════╝{C.CYAN} ║
-    ║                                                                                                 ║
-    ║  {C.WHITE}AI Ассистент для разработки{C.CYAN}                                                                    ║
-    ║        {C.WHITE}Prod. by AURA Tec.{C.CYAN}                                                                       ║
-    ║              {C.WHITE}2.1.3{C.CYAN}                                                                 ║
-    ║                                                                                                 ║
-    ╚═════════════════════════════════════════════════════════════════════════════════════════════════╝{C.RESET}
-    """
-    return logo
+    return f"""
+{C.CYAN}╔═════════════════════════════════════════════════════════════════════════════════════════════════╗
+║                                                                                                 ║
+║  {C.YELLOW}██╗  ██╗{C.CYAN}  {C.GREEN}█████╗{C.CYAN}    {C.BLUE}███╗   ██╗{C.CYAN}  {C.MAGENTA}██████╗{C.CYAN}   {C.RED}██╗   ██╗{C.CYAN}    {C.WHITE}██████╗{C.CYAN}   {C.GREEN}███████╗{C.CYAN}  {C.BLUE}██████╗{C.CYAN}    {C.MAGENTA}███████╗{C.CYAN} ║
+║  {C.YELLOW}██║  ██║{C.CYAN}  {C.GREEN}██╔══██╗{C.CYAN}  {C.BLUE}████╗  ██║{C.CYAN}  {C.MAGENTA}██╔══██╗{C.CYAN}  {C.RED}╚██╗ ██╔╝{C.CYAN}    {C.WHITE}██╔════╝{C.CYAN} {C.GREEN}██╔════██╗{C.CYAN}  {C.BLUE}██╔══██╗{C.CYAN}  {C.MAGENTA}██╔════╝{C.CYAN} ║
+║  {C.YELLOW}███████║{C.CYAN}  {C.GREEN}███████║{C.CYAN}  {C.BLUE}██╔██╗ ██║{C.CYAN}  {C.MAGENTA}██║  ██║{C.CYAN}   {C.RED}╚████╔╝{C.CYAN}     {C.WHITE}██║{C.CYAN}     {C.GREEN}██║      ██║{C.CYAN} {C.BLUE}██║  ██║{C.CYAN}  {C.MAGENTA}█████╗{C.CYAN}   ║
+║  {C.YELLOW}██╔══██║{C.CYAN}  {C.GREEN}██╔══██║{C.CYAN}  {C.BLUE}██║╚██╗██║{C.CYAN}  {C.MAGENTA}██║  ██║{C.CYAN}    {C.RED}╚██╔╝{C.CYAN}      {C.WHITE}██║{C.CYAN}      {C.GREEN}██║    ██║{C.CYAN}  {C.BLUE}██║  ██║{C.CYAN}  {C.MAGENTA}██╔══╝{C.CYAN}   ║
+║  {C.YELLOW}██║  ██║{C.CYAN}  {C.GREEN}██║  ██║{C.CYAN}  {C.BLUE}██║ ╚████║{C.CYAN}  {C.MAGENTA}██████╔╝{C.CYAN}     {C.RED}██║{C.CYAN}       {C.WHITE}╚██████╗{C.CYAN}  {C.GREEN}███████╔╝{C.CYAN}  {C.BLUE}██████╔╝{C.CYAN}  {C.MAGENTA}███████╗{C.CYAN} ║
+║  {C.YELLOW}╚═╝  ╚═╝{C.CYAN}  {C.GREEN}╚═╝  ╚═╝{C.CYAN}  {C.BLUE}╚═╝  ╚═══╝{C.CYAN}  {C.MAGENTA}╚═════╝{C.CYAN}      {C.RED}╚═╝{C.CYAN}       {C.WHITE} ╚═════╝{C.CYAN}   {C.GREEN}╚═════╝{C.CYAN}   {C.BLUE}╚═════╝{C.CYAN}   {C.MAGENTA}╚══════╝{C.CYAN} ║
+║                                                                                                 ║
+║                            {C.WHITE}УСТАНОВКА HANDYCODE{C.CYAN}                                             ║
+║  {C.WHITE}AI Ассистент для разработки{C.CYAN}                                                                    ║
+║        {C.WHITE}Prod. by AURA Tec.{C.CYAN}                                                                       ║
+║                                                                                                 ║
+╚═════════════════════════════════════════════════════════════════════════════════════════════════╝{C.RESET}
+"""

handycode-2.2.0/handycode/utils.py

@@ -0,0 +1,140 @@
+"""
+Вспомогательные функции для HandyCode
+"""
+
+import sys
+import os
+
+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'
+    YELLOW = '\033[33m'
+    BLUE = '\033[34m'
+    MAGENTA = '\033[35m'
+    CYAN = '\033[36m'
+    WHITE = '\033[37m'
+
+    # Яркие (для акцентов)
+    BRIGHT_BLACK = '\033[90m'
+    BRIGHT_RED = '\033[91m'
+    BRIGHT_GREEN = '\033[92m'
+    BRIGHT_YELLOW = '\033[93m'
+    BRIGHT_BLUE = '\033[94m'
+    BRIGHT_MAGENTA = '\033[95m'
+    BRIGHT_CYAN = '\033[96m'
+    BRIGHT_WHITE = '\033[97m'
+
+# Тема HandyCode (премиальная пастель)
+class Theme:
+    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    # серый для подписей
+    HIGHLIGHT = Colors.BRIGHT_WHITE
+
+def supports_color():
+    if os.name == 'nt':
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+            return True
+        except:
+            return False
+    return hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
+
+def colorize(text, color):
+    if supports_color():
+        return f"{color}{text}{Colors.RESET}"
+    return text
+
+def print_colored(text, color):
+    print(colorize(text, color))
+
+def print_header(text):
+    print(colorize(text, Theme.PRIMARY + Colors.BOLD))
+
+def print_success(text):
+    print(colorize(f"  ✔ {text}", Theme.SUCCESS))
+
+def print_error(text):
+    print(colorize(f"  ✘ {text}", Theme.ERROR))
+    return text
+
+def print_warning(text):
+    print(colorize(f"  ⚠ {text}", Theme.WARNING))
+
+def print_info(text):
+    print(colorize(f"  ℹ {text}", Theme.SECONDARY))
+
+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 + "┘"
+    print(colorize(top, color))
+    for line in lines:
+        print(colorize(f"│ {line.ljust(max_len-1)}│", color))
+    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:
+        print(colorize(f"    {line}", Theme.TEXT))
+    print()
+
+def print_status(text):
+    print(colorize(f"  ● {text}", Theme.PRIMARY))
+
+def print_file_action(action, path, details=""):
+    icons = {'create': '📄', 'modify': '✎', 'delete': '🗑', 'read': '📖'}
+    colors_map = {
+        'create': Theme.SUCCESS,
+        'modify': Theme.WARNING,
+        'delete': Theme.ERROR,
+        'read': Theme.SECONDARY,
+    }
+    icon = icons.get(action, '•')
+    color = colors_map.get(action, Theme.TEXT)
+    msg = f"  {icon} {path}"
+    if details:
+        msg += f" {colorize(details, Theme.MUTED)}"
+    print(colorize(msg, color))

{handycode-2.1.5 → handycode-2.2.0}/handycode.egg-info/PKG-INFO

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

{handycode-2.1.5 → handycode-2.2.0}/setup.py

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

handycode-2.1.5/handycode/utils.py

@@ -1,92 +0,0 @@
-"""
-Вспомогательные функции для HandyCode
-"""
-
-import sys
-import os
-
-
-# Цвета для терминала
-class Colors:
-    RESET = '\033[0m'
-    RED = '\033[91m'
-    GREEN = '\033[92m'
-    YELLOW = '\033[93m'
-    BLUE = '\033[94m'
-    MAGENTA = '\033[95m'
-    CYAN = '\033[96m'
-    WHITE = '\033[97m'
-    BOLD = '\033[1m'
-
-
-def supports_color():
-    """Проверяет поддержку цветов"""
-    if os.name == 'nt':  # Windows
-        try:
-            import ctypes
-            kernel32 = ctypes.windll.kernel32
-            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
-            return True
-        except:
-            return False
-    return hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
-
-
-def colorize(text, color):
-    """Добавляет цвет"""
-    if supports_color():
-        return f"{color}{text}{Colors.RESET}"
-    return text
-
-
-def print_colored(text, color):
-    """Выводит цветной текст"""
-    print(colorize(text, color))
-
-
-def print_header(text):
-    """Выводит заголовок"""
-    print(colorize(text, Colors.CYAN + Colors.BOLD))
-
-
-def print_success(text):
-    """Выводит успех"""
-    print(colorize(text, Colors.GREEN))
-
-
-def print_error(text):
-    """Выводит ошибку"""
-    print(colorize(text, Colors.RED))
-    return text
-
-
-def print_warning(text):
-    """Выводит предупреждение"""
-    print(colorize(text, Colors.YELLOW))
-
-
-def print_info(text):
-    """Выводит информацию"""
-    print(colorize(text, Colors.BLUE))
-
-
-def print_logo():
-    """Выводит логотип"""
-    from .logo import get_logo
-    print(get_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"