✨ ui updated

Author: FJRG2007

README.md

@@ -100,6 +100,7 @@ $ python run.py
 | Search engine with bypass                     | Active              |   ✅   |
 | Command Permission System                     | Active              |   ✅   |
 | Advanced History Management System            | Active              |   ✅   |
+| Automatic Prompt Improvement System           | Active              |   ✅   |
 
 <details>
   <summary>Other features</summary>
@@ -130,7 +131,7 @@ $ python run.py
 
 And coming soon...
 
-# Frequently Asked Questions
+## Frequently Asked Questions
 
 <details>
   <summary>What is the Multi-Key Pool System?</summary>

dymo-code.spec

@@ -98,6 +98,7 @@ hiddenimports = [
     'src.utils',
     'src.utils.basics',
     'src.ignore_patterns',
+    'src.prompt_enhancer',
     # Cloudscraper bypass modules
     'src.utils.bypasses',
     'src.utils.bypasses.cloudscraper',

src/agent.py

@@ -29,7 +29,8 @@
 from .ui import (
     console, display_tool_call, display_tool_result, display_executed_tool,
     display_code_execution_result, display_info, display_warning,
-    display_key_rotation_notice, display_model_fallback_notice, display_provider_exhausted_notice
+    display_key_rotation_notice, display_model_fallback_notice, display_provider_exhausted_notice,
+    display_assistant_response
 )
 from .logger import log_error, log_api_error, log_tool_error, log_debug
 from .history import history_manager
@@ -402,6 +403,20 @@ def _save_conversation(self):
         """Save the current conversation state"""
         history_manager.update_conversation(self.messages)
 
+    def _filter_valid_tool_calls(self, tool_calls: List[Any]) -> List[Any]:
+        """
+        Filter out tool calls for unknown/invalid tools.
+        Some models (especially Llama) may hallucinate tool names like 'commentary'.
+        """
+        valid_calls = []
+        for tc in tool_calls:
+            tool_name = tc.name if hasattr(tc, 'name') else tc.get('name', '')
+            if tool_name in TOOLS:
+                valid_calls.append(tc)
+            else:
+                log_debug(f"Ignoring unknown tool call: {tool_name}")
+        return valid_calls
+
     def _parse_tool_calls_from_text(self, text: str) -> List[ToolCall]:
         """
         Parse tool calls that appear as text in the response.
@@ -668,8 +683,7 @@ def _process_tool_calls_with_retry(
         follow_up_response = ""
         pending_tool_calls = []
         has_content = False
-        live_display = None
-        chunk_count = 0 # Buffer: only update display every N chunks.
+        chunk_count = 0  # Buffer counter for streaming.
 
         # Stream with Live panel for smooth updates.
         for chunk in client.stream_chat(
@@ -680,32 +694,26 @@ def _process_tool_calls_with_retry(
             if chunk.content:
                 if not has_content:
                     has_content = True
-                    # Stop spinner and start Live display
+                    # Stop spinner when streaming starts
                     self._update_status("streaming", "")
-                    live_display = Live(
-                        Panel(Markdown(follow_up_response or "..."), title="Assistant", title_align="left", border_style=COLORS['secondary'], box=ROUNDED),
-                        console=console,
-                        refresh_per_second=4,
-                        transient=True
-                    )
-                    live_display.start()
 
                 follow_up_response += chunk.content
                 chunk_count += 1
-                # Update the live panel only every 5 chunks to reduce re-renders.
-                if live_display and chunk_count % 5 == 0: live_display.update(Panel(Markdown(follow_up_response), title="Assistant", title_align="left", border_style=COLORS['secondary'], box=ROUNDED))
 
             if chunk.tool_calls:
-                pending_tool_calls.extend(chunk.tool_calls)
+                # Filter out invalid/unknown tool calls
+                valid_calls = self._filter_valid_tool_calls(chunk.tool_calls)
+                pending_tool_calls.extend(valid_calls)
 
-        # Stop live display and show final panel.
-        if live_display: live_display.stop()
-        if has_content and follow_up_response: console.print(Panel(Markdown(follow_up_response), title="Assistant", title_align="left", border_style=COLORS['secondary'], box=ROUNDED))
+        # Show final response using centralized display
+        if has_content and follow_up_response:
+            display_assistant_response(follow_up_response)
 
         # Check for tool calls in text response
         if not pending_tool_calls and follow_up_response:
             text_tool_calls = self._parse_tool_calls_from_text(follow_up_response)
-            if text_tool_calls: pending_tool_calls.extend(text_tool_calls)
+            if text_tool_calls:
+                pending_tool_calls.extend(text_tool_calls)
 
         # If the model wants to use more tools, process them (for multi-step tasks)
         if pending_tool_calls and allow_more_tools:
@@ -783,8 +791,7 @@ def chat(self, user_input: str, _retry_count: int = 0) -> str:
             # Get all tools including MCP tools.
             all_tools = get_all_tool_definitions()
             has_started_streaming = False
-            live_display = None
-            chunk_count = 0 # Buffer: only update display every N chunks.
+            chunk_count = 0  # Buffer counter for streaming.
 
             # Update status to generating.
             self._update_status("generating", "")
@@ -798,28 +805,16 @@ def chat(self, user_input: str, _retry_count: int = 0) -> str:
                 if chunk.content:
                     if not has_started_streaming:
                         has_started_streaming = True
-                        # Stop spinner before showing content
+                        # Stop spinner when streaming starts
                         self._update_status("streaming", "")
-                        # Start Live display for streaming
-                        live_display = Live(
-                            Panel(Markdown(response_text or "..."), title="Assistant", title_align="left", border_style=COLORS['secondary'], box=ROUNDED),
-                            console=console,
-                            refresh_per_second=4,
-                            transient=True
-                        )
-                        live_display.start()
 
                     response_text += chunk.content
                     chunk_count += 1
-                    # Update the live panel only every 5 chunks to reduce re-renders
-                    if live_display and chunk_count % 5 == 0:
-                        live_display.update(
-                            Panel(Markdown(response_text), title="Assistant", title_align="left", border_style=COLORS['secondary'], box=ROUNDED)
-                        )
 
-                # Collect tool calls
+                # Collect tool calls (filter out unknown tools)
                 if chunk.tool_calls:
-                    pending_tool_calls.extend(chunk.tool_calls)
+                    valid_calls = self._filter_valid_tool_calls(chunk.tool_calls)
+                    pending_tool_calls.extend(valid_calls)
 
                 # Collect executed tools (from Groq built-in tools like code_interpreter)
                 if chunk.executed_tools:
@@ -829,11 +824,10 @@ def chat(self, user_input: str, _retry_count: int = 0) -> str:
                 if chunk.reasoning:
                     log_debug(f"Model reasoning: {chunk.reasoning[:200]}...")
 
-            # Stop live display and show final panel
-            if live_display:
-                live_display.stop()
-            if has_started_streaming and response_text:
-                console.print(Panel(Markdown(response_text), title="Assistant", title_align="left", border_style=COLORS['secondary'], box=ROUNDED))
+            # Show final response using centralized display (only if we have content and no tool calls)
+            # If there are tool calls, the response will be shown after tool execution
+            if has_started_streaming and response_text and not pending_tool_calls:
+                display_assistant_response(response_text)
 
             # Display executed tools (code execution, web search, etc.)
             if executed_tools_list:
@@ -849,6 +843,7 @@ def chat(self, user_input: str, _retry_count: int = 0) -> str:
                 text_tool_calls = self._parse_tool_calls_from_text(response_text)
                 if text_tool_calls:
                     log_debug(f"Found {len(text_tool_calls)} tool call(s) in text response")
+                    # Already filtered by _parse_tool_calls_from_text
                     pending_tool_calls.extend(text_tool_calls)
 
             # Process tool calls if any

src/async_input.py

@@ -225,17 +225,34 @@ def _windows_input_loop(self):
                                 sys.stdout.write(buffer)
                                 sys.stdout.flush()
                         elif "@" in buffer:
-                            # Path autocomplete
+                            # Path autocomplete with drill-down for directories
                             path_suggestions = get_path_suggestions(buffer)
                             if path_suggestions:
                                 # Find @ position and replace path part
                                 at_index = buffer.rfind("@")
-                                new_path = path_suggestions[0]["path"]
+                                selected = path_suggestions[0]
+                                new_path = selected["path"]
                                 buffer = buffer[:at_index + 1] + new_path
+
+                                # If it's a directory, keep drilling down
+                                # (get_path_suggestions will show contents on next Tab)
                                 self._clear_line()
                                 self._show_prompt()
                                 sys.stdout.write(buffer)
                                 sys.stdout.flush()
+
+                                # Show hint for directories with content
+                                if selected["is_dir"] and selected.get("file_count", 0) + selected.get("dir_count", 0) > 0:
+                                    meta = selected.get("meta", "")
+                                    if meta:
+                                        sys.stdout.write(f" [{meta}]")
+                                        sys.stdout.flush()
+                                        # Clear the hint after showing
+                                        time.sleep(0.5)
+                                        self._clear_line()
+                                        self._show_prompt()
+                                        sys.stdout.write(buffer)
+                                        sys.stdout.flush()
                         continue
 
                     # Special keys (arrows)

src/config.py

@@ -355,6 +355,26 @@ def items(self):
 3. **NEVER GIVE UP**: On error → analyze → fix → retry until success
 4. **VERIFY**: Run code, read files to confirm changes work
 
+## PROBLEM SOLVING - CRITICAL
+When asked to compare, find missing items, or sync between sources:
+1. **GATHER ALL DATA FIRST**: Read/list BOTH sources completely before concluding
+2. **BUILD EXPLICIT LISTS**: Create lists of items from each source
+3. **COMPARE SYSTEMATICALLY**: Check each item from source A against source B
+4. **LIST DIFFERENCES**: Explicitly state what's missing/different
+5. **EXECUTE ALL FIXES**: Don't stop after one fix - complete the entire task
+
+Example: "Add missing algorithms from folder A to file B"
+- Step 1: List ALL files in folder A → ["algo1", "algo2", "algo3", "algo4"]
+- Step 2: Read file B and extract ALL existing algorithms → ["algo1", "algo2"]
+- Step 3: Compare: Missing = ["algo3", "algo4"]
+- Step 4: Add EACH missing item, don't stop until all are added
+- Step 5: Verify by re-reading file B
+
+## TASK ITERATION
+- If user says "there are more" or "not fixed" → RE-ANALYZE from scratch
+- Never assume previous analysis was complete
+- Re-read sources, rebuild lists, find what was missed
+
 ## TASK DIVISION (spawn_agents)
 For 3+ independent subtasks, use spawn_agents to parallelize work.
 

src/interactive_input.py

@@ -221,46 +221,76 @@ def _render_path_suggestions(self) -> Panel:
         table = Table(show_header=False, box=None, padding=(0, 1))
         table.add_column("Icon", width=3)
         table.add_column("Name", style="white")
-        table.add_column("Type", style=f"{COLORS['muted']}")
+        table.add_column("Info", style=f"{COLORS['muted']}")
 
-        for i, path_info in enumerate(self.suggestions[:8]):
+        for i, path_info in enumerate(self.suggestions[:10]):
             icon = path_info["icon"]
             name = path_info["name"]
-            meta = "directory" if path_info["is_dir"] else "file"
+            # Use meta if available (contains file count for dirs, size for files)
+            meta = path_info.get("meta", "directory" if path_info["is_dir"] else "file")
+
+            # Add visual hint for directories with content
+            if path_info["is_dir"]:
+                name_display = f"{name}/"
+                # Add arrow hint to indicate drill-down
+                if path_info.get("file_count", 0) > 0 or path_info.get("dir_count", 0) > 0:
+                    name_display += " →"
+            else:
+                name_display = name
 
             if i == self.selected_index:
                 table.add_row(
                     f"[{COLORS['primary']}]{icon}[/]",
-                    f"[bold {COLORS['primary']}]{name}[/]",
+                    f"[bold {COLORS['primary']}]{name_display}[/]",
                     f"[{COLORS['primary']}]{meta}[/]"
                 )
             else:
-                table.add_row(icon, name, meta)
+                table.add_row(icon, name_display, meta)
+
+        # Add hint at the bottom
+        hint = "[Tab] select  [Enter] confirm  [Esc] cancel"
+        if any(s["is_dir"] for s in self.suggestions[:10]):
+            hint = "[Tab] drill-down  [Enter] confirm folder  [Esc] cancel"
 
         return Panel(
             table,
             title="[bold]@ Path[/bold]",
+            subtitle=f"[{COLORS['muted']}]{hint}[/]",
             border_style=COLORS['primary'],
             box=ROUNDED,
             padding=(0, 1)
         )
 
-    def _complete_selected(self):
-        """Complete input with selected suggestion"""
+    def _complete_selected(self, force_close: bool = False):
+        """
+        Complete input with selected suggestion.
+        For directories: drill-down to show contents (unless force_close=True)
+        For files: complete and close suggestions
+        """
         if self.suggestions and 0 <= self.selected_index < len(self.suggestions):
             if self.suggestion_type == "command":
                 cmd = self.suggestions[self.selected_index]
                 self.buffer = f"/{cmd.name}"
                 if cmd.has_args:
                     self.buffer += " "
+                self.showing_suggestions = False
             else:
                 # Path completion
                 at_index = self.buffer.rfind("@")
                 path_info = self.suggestions[self.selected_index]
                 self.buffer = self.buffer[:at_index + 1] + path_info["path"]
 
+                # For directories: drill-down (show contents) unless force_close
+                if path_info["is_dir"] and not force_close:
+                    # Update suggestions to show directory contents
+                    self._update_suggestions()
+                    self.selected_index = 0
+                    # Keep showing suggestions
+                else:
+                    # For files or forced close: close suggestions
+                    self.showing_suggestions = False
+
             self.cursor_pos = len(self.buffer)
-            self.showing_suggestions = False
 
     def get_input(self, prompt_prefix: str = "") -> str:
         """
@@ -279,8 +309,18 @@ def get_input(self, prompt_prefix: str = "") -> str:
             if msvcrt.kbhit():
                 char = msvcrt.getwch()
 
-                # Enter - submit
+                # Enter - submit or confirm selection
                 if char == '\r':
+                    # If showing path suggestions and a directory is selected, confirm it
+                    if self.showing_suggestions and self.suggestion_type == "path":
+                        if self.suggestions and 0 <= self.selected_index < len(self.suggestions):
+                            path_info = self.suggestions[self.selected_index]
+                            # Complete the selection (force close for directories)
+                            self._complete_selected(force_close=True)
+                            self._clear_line()
+                            self._render_input_line()
+                            continue  # Don't submit yet, let user continue typing or submit
+
                     console.print()  # New line
                     result = self.buffer.strip()
                     if result:
@@ -354,8 +394,12 @@ def get_input(self, prompt_prefix: str = "") -> str:
                     self._clear_line()
                     self._render_input_line()
 
-                    # Show suggestions if typing a command
-                    if self.showing_suggestions:
+                    # Show suggestions if typing a command or path
+                    # Always show after typing / in a path context
+                    if self.showing_suggestions or (char == "/" and "@" in self.buffer):
+                        if "@" in self.buffer and char == "/":
+                            # Force update suggestions when typing / in path
+                            self._update_suggestions()
                         self._render_suggestions()
 
 

src/main.py

@@ -904,12 +904,10 @@ def main():
             else:
                 # Get input from user using async input handler
                 user_input = async_input.get_input()
+                # No need to print - prompt_toolkit already shows it while typing
 
             if not user_input: continue
 
-            # Show the user's input so it stays visible in chat history
-            async_input.print_submitted_input(user_input)
-
             # Handle commands
             command_result = handle_command(user_input, agent, queue_manager, command_handler)