handycode 2.1.6__tar.gz → 2.2.1__tar.gz

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

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

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

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

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

@@ -1,5 +1,5 @@
 """
-Основной класс ассистента HandyCode
+Основной класс ассистента HandyCode с интерактивным меню
 """
 
 import os
@@ -14,14 +14,12 @@ from datetime import datetime
 
 try:
     import readline
-
     HAS_READLINE = True
 except ImportError:
     HAS_READLINE = False
 
 try:
     import requests
-
     HAS_REQUESTS = True
 except ImportError:
     HAS_REQUESTS = False
@@ -34,61 +32,164 @@ from handycode.models import MODELS, get_model_settings
 from handycode.file_manager import FileManager
 from handycode.security import SecurityChecker
 from handycode.utils import (
-    Colors, print_colored, print_header, print_success,
+    Colors, Theme, colorize, print_colored, print_header, print_success,
     print_error, print_warning, print_info, print_logo,
-    print_divider, print_file_action, print_command, print_status
+    print_divider, print_file_action, print_status, print_section, print_box
 )
 
 
+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':  # стрелки
+                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 == b'\x1b': return 'escape'
+            return key.decode('utf-8', errors='ignore')
+    else:
+        import tty
+        import termios
+
+        def get_key():
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                key = sys.stdin.read(1)
+                if key == '\x1b':
+                    key += sys.stdin.read(2)
+                    if key == '\x1b[A': return 'up'
+                    if key == '\x1b[B': return 'down'
+                    return 'escape'
+                if key == '\r': return 'enter'
+                if key == ' ': return 'space'
+                return key
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+    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
+
+            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()
+
+    render()
+
+    while True:
+        key = get_key()
+
+        if key == 'up':
+            current = (current - 1) % len(commands)
+            render()
+        elif key == 'down':
+            current = (current + 1) % len(commands)
+            render()
+        elif key == 'space':
+            selected[current] = not selected[current]
+            render()
+        elif key in ['a', 'A']:
+            selected = [True] * len(commands)
+            render()
+        elif key in ['s', 'S']:
+            selected = [False] * len(commands)
+            render()
+        elif key in ['c', 'C', 'escape']:
+            return []
+        elif key == 'enter':
+            print()
+            return [cmd for cmd, sel in zip(commands, selected) if sel]
+
+
 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.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):
@@ -98,75 +199,61 @@ 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
-        except:
-            pass
+                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 - AI coding assistant. Create/modify/delete files and run commands.
-
-    FORMAT:
-    [[CREATE:path/file]]
-    code here
-    [[END]]
-
-    [[MODIFY:path/file]]
-    new code here
-    [[END]]
-
-    [[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."""
+FORMAT:
+[[CREATE:path/file]]
+code here
+[[END]]
+[[MODIFY:path/file]]
+new code here
+[[END]]
+[[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."""
 
     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\n  ⚠ Press 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 файлы в реальном времени
         while True:
             match = re.search(r'\[\[CREATE:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
             if match:
@@ -174,18 +261,12 @@ class HandyCode:
                 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_file_action('create', path, f"({lines} lines)")
-
+                    print_file_action('create', path, f"({content.count(chr(10))+1} lines)")
                 self.stream_buffer = self.stream_buffer[match.end():]
-            else:
-                break
-
-        # MODIFY файлы
+            else: break
         while True:
             match = re.search(r'\[\[MODIFY:(.+?)\]\](.*?)\[\[END\]\]', self.stream_buffer, re.DOTALL)
             if match:
@@ -193,30 +274,22 @@ class HandyCode:
                 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_file_action('modify', path, f"({lines} lines)")
-
+                    print_file_action('modify', path, f"({content.count(chr(10))+1} lines)")
                 self.stream_buffer = self.stream_buffer[match.end():]
-            else:
-                break
-
-        # EXEC команды
+            else: break
         while True:
             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
+            else: break
 
     def _make_request_streaming(self, data):
         self.stream_buffer = ""
         self.pending_commands = []
-
         if HAS_REQUESTS:
             return self._stream_requests(data)
         else:
@@ -224,28 +297,19 @@ class HandyCode:
 
     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 = 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']:
@@ -253,22 +317,16 @@ class HandyCode:
                                 content = delta.get('content', '')
                                 if content:
                                     full_response += content
-
                                     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(']]', '')
+                                        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:
@@ -278,27 +336,18 @@ class HandyCode:
     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 = False
-
-            with urllib.request.urlopen(req, context=ctx, timeout=120) as response:
-                for line in response:
+            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']:
@@ -306,21 +355,16 @@ class HandyCode:
                                 content = delta.get('content', '')
                                 if content:
                                     full_response += content
-
                                     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(']]', '')
+                                        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:
@@ -332,7 +376,6 @@ class HandyCode:
             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:]
 
@@ -344,9 +387,10 @@ class HandyCode:
         }
 
         try:
-            print_divider("─", 60, Colors.BRIGHT_BLACK)
-            print(colorize("  HandyCode", Colors.BRIGHT_CYAN + Colors.BOLD))
-            print_divider("─", 60, Colors.BRIGHT_BLACK)
+            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)
 
@@ -354,27 +398,21 @@ class HandyCode:
                 self.conversation_history.append({"role": "assistant", "content": response})
 
                 if self.pending_commands:
-                    print()
-                    print_divider("─", 60, Colors.BRIGHT_BLACK)
-                    print(colorize("  ⚡ Commands (confirmation required):", Colors.YELLOW))
-                    for i, cmd in enumerate(self.pending_commands, 1):
-                        print_command(cmd, i)
-
                     if self.auto_approve:
-                        choice = 'A'
+                        selected_commands = self.pending_commands
                     else:
-                        print()
-                        print(colorize(f"  {Colors.BRIGHT_BLACK}[A] Execute all  [S] Skip  [C] Cancel{Colors.RESET}",
-                                       Colors.BRIGHT_BLACK))
-                        choice = input(colorize("  > ", Colors.WHITE)).strip().upper()
+                        selected_commands = interactive_confirm(self.pending_commands)
 
-                    if choice == 'A':
+                    if selected_commands:
                         print()
-                        for cmd in self.pending_commands:
+                        print_section("⚡ Выполнение команд", [])
+                        for cmd in selected_commands:
                             if self.security.is_safe_command(cmd):
-                                print_status(f"Running: {cmd}")
+                                print_status(f"Выполняется: {cmd}")
                                 self.file_manager.execute_command(cmd)
                                 self.stats["commands_executed"].append(cmd)
+                    else:
+                        print_warning("Команды пропущены")
 
                 self.stats["messages_sent"] += 1
                 return response
@@ -384,52 +422,44 @@ class HandyCode:
     def _handle_command(self, user_input):
         parts = user_input.split()
         cmd = parts[0].lower()
-
         if cmd in ['/help', '/h']:
-            print()
-            print(colorize("  Commands:", Colors.BRIGHT_CYAN + Colors.BOLD))
-            print_divider("─", 40, Colors.BRIGHT_BLACK)
-            print(colorize("  /help          Show this help", Colors.WHITE))
-            print(colorize("  /scan          Scan project files", Colors.WHITE))
-            print(colorize("  /models        List AI models", Colors.WHITE))
-            print(colorize("  /model NAME    Switch model", Colors.WHITE))
-            print(colorize("  /clear         Clear chat history", Colors.WHITE))
-            print(colorize("  /save          Save session to file", Colors.WHITE))
-            print(colorize("  /stats         Show statistics", Colors.WHITE))
-            print(colorize("  /exit          Exit program", Colors.WHITE))
-            print()
+            print_box([
+                "/help      Справка",
+                "/scan      Показать проект",
+                "/models    Модели",
+                "/model N   Сменить модель",
+                "/clear     Очистить историю",
+                "/save      Сохранить сессию",
+                "/stats     Статистика",
+                "/exit      Выход"
+            ], Theme.PRIMARY)
         elif cmd in ['/scan', '/s']:
-            print()
-            print(colorize("  Project Files:", Colors.BRIGHT_CYAN + Colors.BOLD))
-            print_divider("─", 40, Colors.BRIGHT_BLACK)
             print(self.file_manager.scan_project())
         elif cmd in ['/models', '/m']:
-            print()
-            print(colorize("  Available Models:", Colors.BRIGHT_CYAN + Colors.BOLD))
-            print_divider("─", 40, Colors.BRIGHT_BLACK)
-            for name in MODELS:
-                marker = colorize(" (current)", Colors.GREEN) if MODELS[name] == self.current_model else ""
-                print(f"  • {name}{marker}")
+            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("Chat history cleared")
+            print_success("История очищена")
         elif cmd in ['/stats']:
-            print()
-            print(colorize("  Session Stats:", Colors.BRIGHT_CYAN + Colors.BOLD))
-            print_divider("─", 40, Colors.BRIGHT_BLACK)
-            print(colorize(f"  Messages: {self.stats['messages_sent']}", Colors.WHITE))
-            print(colorize(f"  Created: {len(self.stats['files_created'])} files", Colors.GREEN))
-            print(colorize(f"  Modified: {len(self.stats['files_modified'])} files", Colors.YELLOW))
-            print(colorize(f"  Deleted: {len(self.stats['files_deleted'])} files", Colors.RED))
-            print(colorize(f"  Commands: {len(self.stats['commands_executed'])}", Colors.CYAN))
+            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("Goodbye!")
+            print_success("До свидания!")
             os._exit(0)
         return ""
 
@@ -438,32 +468,19 @@ class HandyCode:
 
     def run(self):
         print_logo()
-        print_divider("─", 60, Colors.BRIGHT_BLACK)
-        print(colorize(f"  📁 Project: {self.project_path}", Colors.WHITE))
-        print(colorize(f"  🤖 Model: {self.current_model}", Colors.WHITE))
-        print(colorize(f"  {Colors.BRIGHT_BLACK}/help for commands{Colors.RESET}", Colors.BRIGHT_BLACK))
-        print_divider("─", 60, Colors.BRIGHT_BLACK)
+        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()
-
         while True:
             try:
                 self.reset_interrupt()
-                user_input = input(colorize("  ❯ ", Colors.BRIGHT_CYAN + Colors.BOLD)).strip()
+                user_input = input(colorize("  ❯ ", Theme.PRIMARY + Colors.BOLD)).strip()
                 if user_input:
                     self.send_message(user_input)
             except KeyboardInterrupt:
                 continue
             except EOFError:
-                break
-
-
-# Добавляем colorize как глобальную функцию для удобства
-def colorize(text, color):
-    if supports_color():
-        return f"{color}{text}{Colors.RESET}"
-    return text
-
-
-def supports_color():
-    from handycode.utils import supports_color as sc
-    return sc()
+                break

{handycode-2.1.6 → handycode-2.2.1}/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,51 +27,35 @@ def get_logo() -> str:
 """
     return logo
 
-
 def get_logo_plain() -> str:
-    """Возвращает простой ASCII логотип без цветов"""
-    logo = r"""
-╔══════════════════════════════════════════════════════════════╗
-║                                                              ║
-║  ██╗  ██╗  █████╗  ███╗   ██╗  ██████╗  ██╗   ██╗            ║
-║  ██║  ██║  ██╔══██╗ ████╗  ██║  ██╔══██╗ ╚██╗ ██╔╝           ║
-║  ███████║  ███████║ ██╔██╗ ██║  ██║  ██║  ╚████╔╝            ║
-║  ██╔══██║  ██╔══██║ ██║╚██╗██║  ██║  ██║   ╚██╔╝             ║
-║  ██║  ██║  ██║  ██║ ██║ ╚████║  ██████╔╝    ██║              ║
-║  ╚═╝  ╚═╝  ╚═╝  ╚═╝ ╚═╝  ╚═══╝  ╚═════╝     ╚═╝              ║
-║                                                              ║
-║           ██████╗   ███████╗   ██████╗  ███████╗             ║
-║          ██╔════╝  ██╔════██╗  ██╔══██╗ ██╔════╝             ║
-║          ██║      ██║      ██║ ██║  ██║ █████╗               ║
-║          ██║       ██║    ██║  ██║  ██║ ██╔══╝               ║
-║          ╚██████╗   ███████╔╝  ██████╔╝ ███████╗             ║
-║           ╚═════╝    ╚═════╝   ╚═════╝  ╚══════╝             ║
-║                                                              ║
-║              AI Ассистент для разработки                     ║
-║                    Prod. by AURA Tec.                        ║
-║                                                              ║
-╚══════════════════════════════════════════════════════════════╝
+    return r"""
+╔═════════════════════════════════════════════════════════════════════════════════════════════════╗
+║                                                                                                 ║
+║  ██╗  ██╗  █████╗  ███╗   ██╗  ██████╗  ██╗   ██╗     ██████╗  ███████╗  ██████╗  ███████╗ ║
+║  ██║  ██║  ██╔══██╗ ████╗  ██║  ██╔══██╗ ╚██╗ ██╔╝     ██╔════╝  ██╔════██╗ ██╔══██╗ ██╔════╝ ║
+║  ███████║  ███████║ ██╔██╗ ██║  ██║  ██║  ╚████╔╝      ██║       ██║      ██║ ██║  ██║ █████╗   ║
+║  ██╔══██║  ██╔══██║ ██║╚██╗██║  ██║  ██║   ╚██╔╝       ██║       ██║    ██║  ██║  ██║ ██╔══╝   ║
+║  ██║  ██║  ██║  ██║ ██║ ╚████║  ██████╔╝    ██║        ╚██████╗  ███████╔╝  ██████╔╝ ███████╗ ║
+║  ╚═╝  ╚═╝  ╚═╝  ╚═╝ ╚═╝  ╚═══╝  ╚═════╝     ╚═╝         ╚═════╝  ╚═════╝   ╚═════╝  ╚══════╝ ║
+║                                                                                                 ║
+║              AI Ассистент для разработки                                                       ║
+║                    Prod. by AURA Tec.                                                          ║
+║                                                                                                 ║
+╚═════════════════════════════════════════════════════════════════════════════════════════════════╝
 """
-    return logo
-
 
 def get_small_logo() -> str:
-    """Возвращает маленький логотип"""
     if not supports_color():
         return "HandyCode v2.1.3"
-
     C = Colors
-    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}"
-
+    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}╔═════════════════════════════════════════════════════════════════════════════════════════════════╗
+    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} ║
@@ -82,10 +64,9 @@ def get_install_logo() -> str:
 ║  {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}{C.BOLD}УСТАНОВКА HANDYCODE{C.CYAN}                                             ║
+║                            {C.WHITE}УСТАНОВКА HANDYCODE{C.CYAN}                                             ║
 ║  {C.WHITE}AI Ассистент для разработки{C.CYAN}                                                                    ║
 ║        {C.WHITE}Prod. by AURA Tec.{C.CYAN}                                                                       ║
 ║                                                                                                 ║
 ╚═════════════════════════════════════════════════════════════════════════════════════════════════╝{C.RESET}
-"""
-    return logo
+"""

handycode-2.2.1/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.6 → handycode-2.2.1}/handycode.egg-info/PKG-INFO

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

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

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

handycode-2.1.6/handycode/utils.py

@@ -1,140 +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'
-    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'
-    BOLD = '\033[1m'
-    DIM = '\033[2m'
-    ITALIC = '\033[3m'
-    UNDERLINE = '\033[4m'
-
-
-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, Colors.CYAN + Colors.BOLD))
-
-
-def print_success(text):
-    print(colorize(f"  ✓ {text}", Colors.GREEN))
-
-
-def print_error(text):
-    print(colorize(f"  ✗ {text}", Colors.RED))
-    return text
-
-
-def print_warning(text):
-    print(colorize(f"  ⚠ {text}", Colors.YELLOW))
-
-
-def print_info(text):
-    print(colorize(f"  ℹ {text}", Colors.BLUE))
-
-
-def print_logo():
-    from .logo import get_small_logo
-    print(get_small_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_box(text, color=Colors.CYAN):
-    """Рисует рамку вокруг текста"""
-    lines = text.strip().split('\n')
-    width = max(len(line) for line in lines) + 4
-    print(colorize(f"╭{'─' * (width - 2)}╮", color))
-    for line in lines:
-        print(colorize(f"│ {line.ljust(width - 4)} │", color))
-    print(colorize(f"╰{'─' * (width - 2)}╯", color))
-
-
-def print_divider(char="─", width=60, color=Colors.BRIGHT_BLACK):
-    """Рисует разделитель"""
-    print(colorize(char * width, color))
-
-
-def print_file_action(action_type, path, details=""):
-    """Красиво показывает действие с файлом"""
-    icons = {
-        'create': '📄',
-        'modify': '✏️',
-        'delete': '🗑️',
-        'read': '📖',
-    }
-    colors_map = {
-        'create': Colors.GREEN,
-        'modify': Colors.YELLOW,
-        'delete': Colors.RED,
-        'read': Colors.BLUE,
-    }
-
-    icon = icons.get(action_type, '•')
-    color = colors_map.get(action_type, Colors.WHITE)
-
-    if details:
-        print(colorize(f"  {icon} {path} {Colors.BRIGHT_BLACK}{details}{Colors.RESET}", color))
-    else:
-        print(colorize(f"  {icon} {path}", color))
-
-
-def print_command(cmd, index=1):
-    """Красиво показывает команду"""
-    print(colorize(f"  {index}. ⚡ {cmd}", Colors.YELLOW))
-
-
-def print_status(msg):
-    """Показывает статус"""
-    print(colorize(f"  ● {msg}", Colors.CYAN))