code-puppy 0.0.196__tar.gz → 0.0.197__tar.gz

{code_puppy-0.0.196 → code_puppy-0.0.197}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.196
+Version: 0.0.197
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -25,7 +25,7 @@ Requires-Dist: logfire>=0.7.1
 Requires-Dist: openai>=1.99.1
 Requires-Dist: pathspec>=0.11.0
 Requires-Dist: playwright>=1.40.0
-Requires-Dist: prompt-toolkit>=3.0.38
+Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic-ai==1.0.6
 Requires-Dist: pydantic>=2.4.0
 Requires-Dist: pyjwt>=2.8.0
@@ -69,6 +69,17 @@ Code Puppy is an AI-powered code generation agent, designed to understand progra
 
 ## Features
 
+### Session Autosave & Contexts
+- Autosaves live in `~/.code_puppy/autosaves` and include a `.pkl` and `_meta.json` per session.
+- On startup, you’ll be prompted to optionally load a recent autosave (with message counts and timestamps).
+- Autosaves use a stable session ID per interactive run so subsequent prompts overwrite the same session (not N new files). Rotate via `/session new` when you want a fresh session.
+- Loading an autosave makes it the active autosave target (future autosaves overwrite that loaded session).
+- Loading a manual context with `/load_context <name>` automatically rotates the autosave ID to avoid overwriting anything.
+- Helpers:
+  - `/session id` shows the current autosave ID and file prefix
+  - `/session new` rotates the autosave ID
+
+
 - **Multi-language support**: Capable of generating code in various programming languages.
 - **Interactive CLI**: A command-line interface for interactive use.
 - **Detailed explanations**: Provides insights into generated code to understand its logic and structure.

{code_puppy-0.0.196 → code_puppy-0.0.197}/README.md

@@ -25,6 +25,17 @@ Code Puppy is an AI-powered code generation agent, designed to understand progra
 
 ## Features
 
+### Session Autosave & Contexts
+- Autosaves live in `~/.code_puppy/autosaves` and include a `.pkl` and `_meta.json` per session.
+- On startup, you’ll be prompted to optionally load a recent autosave (with message counts and timestamps).
+- Autosaves use a stable session ID per interactive run so subsequent prompts overwrite the same session (not N new files). Rotate via `/session new` when you want a fresh session.
+- Loading an autosave makes it the active autosave target (future autosaves overwrite that loaded session).
+- Loading a manual context with `/load_context <name>` automatically rotates the autosave ID to avoid overwriting anything.
+- Helpers:
+  - `/session id` shows the current autosave ID and file prefix
+  - `/session new` rotates the autosave ID
+
+
 - **Multi-language support**: Capable of generating code in various programming languages.
 - **Interactive CLI**: A command-line interface for interactive use.
 - **Detailed explanations**: Provides insights into generated code to understand its logic and structure.

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/agents/base_agent.py

@@ -720,10 +720,7 @@ class BaseAgent(ABC):
             emit_system_message(
                 f"[green]Successfully loaded {len(servers)} MCP server(s)[/green]"
             )
-        else:
-            emit_system_message(
-                "[yellow]No MCP servers available (check if servers are enabled)[/yellow]"
-            )
+        # Stay silent when there are no servers configured/available
         return servers
 
     def reload_mcp_servers(self):
@@ -891,7 +888,8 @@ class BaseAgent(ABC):
             asyncio.CancelledError: When execution is cancelled by user
         """
         group_id = str(uuid.uuid4())
-        pydantic_agent = self.reload_code_generation_agent()
+        # Avoid double-loading: reuse existing agent if already built
+        pydantic_agent = self._code_generation_agent or self.reload_code_generation_agent()
 
         async def run_agent_task():
             try:

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/command_line/command_handler.py

@@ -11,125 +11,93 @@ from code_puppy.tools.tools_content import tools_content
 
 
 def get_commands_help():
-    """Generate commands help using Rich Text objects to avoid markup conflicts."""
+    """Generate aligned commands help using Rich Text for safe markup."""
     from rich.text import Text
 
     # Ensure plugins are loaded so custom help can register
     _ensure_plugins_loaded()
 
-    # Build help text programmatically
-    help_lines = []
-
-    # Title
-    help_lines.append(Text("Commands Help", style="bold magenta"))
-
-    # Commands - build each line programmatically
-    help_lines.append(
-        Text("/help, /h", style="cyan") + Text("             Show this help message")
-    )
-    help_lines.append(
-        Text("/cd", style="cyan")
-        + Text(" <dir>             Change directory or show directories")
-    )
-    help_lines.append(
-        Text("/agent", style="cyan")
-        + Text(" <name>         Switch to a different agent or show available agents")
-    )
-    help_lines.append(
-        Text("/exit, /quit", style="cyan") + Text("          Exit interactive mode")
-    )
-    help_lines.append(
-        Text("/generate-pr-description", style="cyan")
-        + Text(" [@dir]  Generate comprehensive PR description")
-    )
-    help_lines.append(
-        Text("/model, /m", style="cyan") + Text(" <model>   Set active model")
-    )
-    help_lines.append(
-        Text("/reasoning", style="cyan")
-        + Text(" <low|medium|high>  Set OpenAI reasoning effort for GPT-5 models")
-    )
-    help_lines.append(
-        Text("/pin_model", style="cyan")
-        + Text(" <agent> <model>  Pin a specific model to an agent")
-    )
-    help_lines.append(
-        Text("/mcp", style="cyan")
-        + Text("                  Manage MCP servers (list, start, stop, status, etc.)")
-    )
-    help_lines.append(
-        Text("/motd", style="cyan")
-        + Text("                 Show the latest message of the day (MOTD)")
-    )
-    help_lines.append(
-        Text("/show", style="cyan")
-        + Text("                 Show puppy config key-values")
-    )
-    help_lines.append(
-        Text("/compact", style="cyan")
-        + Text(
-            "              Summarize and compact current chat history (uses compaction_strategy config)"
-        )
-    )
-    help_lines.append(
-        Text("/dump_context", style="cyan")
-        + Text(" <name>  Save current message history to file")
-    )
-    help_lines.append(
-        Text("/load_context", style="cyan")
-        + Text(" <name>  Load message history from file")
-    )
-    help_lines.append(
-        Text("/set", style="cyan")
-        + Text(
-            "                  Set puppy config key-values (e.g., /set yolo_mode true, /set auto_save_session true)"
-        )
-    )
-    help_lines.append(
-        Text("/tools", style="cyan")
-        + Text("                Show available tools and capabilities")
-    )
-    help_lines.append(
-        Text("/truncate", style="cyan")
-        + Text(
-            " <N>              Truncate message history to N most recent messages (keeping system message)"
-        )
-    )
-    help_lines.append(
-        Text("/<unknown>", style="cyan")
-        + Text("            Show unknown command warning")
-    )
+    # Collect core commands with their syntax parts and descriptions
+    # (cmd_syntax, description)
+    core_cmds = [
+        ("/help, /h", "Show this help message"),
+        ("/cd <dir>", "Change directory or show directories"),
+        (
+            "/agent <name>",
+            "Switch to a different agent or show available agents",
+        ),
+        ("/exit, /quit", "Exit interactive mode"),
+        ("/generate-pr-description [@dir]", "Generate comprehensive PR description"),
+        ("/model, /m <model>", "Set active model"),
+        ("/reasoning <low|medium|high>", "Set OpenAI reasoning effort for GPT-5 models"),
+        ("/pin_model <agent> <model>", "Pin a specific model to an agent"),
+        ("/mcp", "Manage MCP servers (list, start, stop, status, etc.)"),
+        ("/motd", "Show the latest message of the day (MOTD)"),
+        ("/show", "Show puppy config key-values"),
+        (
+            "/compact",
+            "Summarize and compact current chat history (uses compaction_strategy config)",
+        ),
+        ("/dump_context <name>", "Save current message history to file"),
+        ("/load_context <name>", "Load message history from file"),
+        (
+            "/set",
+            "Set puppy config (e.g., /set yolo_mode true, /set auto_save_session true)",
+        ),
+        ("/tools", "Show available tools and capabilities"),
+        (
+            "/truncate <N>",
+            "Truncate history to N most recent messages (keeping system message)",
+        ),
+        ("/<unknown>", "Show unknown command warning"),
+    ]
+
+    # Determine padding width for the left column
+    left_width = max(len(cmd) for cmd, _ in core_cmds) + 2  # add spacing
+
+    lines: list[Text] = []
+    lines.append(Text("Commands Help", style="bold magenta"))
+
+    for cmd, desc in core_cmds:
+        left = Text(cmd.ljust(left_width), style="cyan")
+        right = Text(desc)
+        line = Text()
+        line.append_text(left)
+        line.append_text(right)
+        lines.append(line)
 
     # Add custom commands from plugins (if any)
     try:
         from code_puppy import callbacks
 
         custom_help_results = callbacks.on_custom_command_help()
-        # Flatten various returns into a list of (name, description)
-        custom_entries = []
+        custom_entries: list[tuple[str, str]] = []
         for res in custom_help_results:
             if not res:
                 continue
             if isinstance(res, tuple) and len(res) == 2:
-                custom_entries.append(res)
+                custom_entries.append((str(res[0]), str(res[1])))
             elif isinstance(res, list):
                 for item in res:
                     if isinstance(item, tuple) and len(item) == 2:
-                        custom_entries.append(item)
+                        custom_entries.append((str(item[0]), str(item[1])))
         if custom_entries:
-            help_lines.append(Text("\n", style="dim"))
-            help_lines.append(Text("Custom Commands", style="bold magenta"))
+            lines.append(Text("", style="dim"))
+            lines.append(Text("Custom Commands", style="bold magenta"))
+            # Compute padding for custom commands as well
+            custom_left_width = max(len(name) for name, _ in custom_entries) + 3
             for name, desc in custom_entries:
-                help_lines.append(
-                    Text(f"/{name}", style="cyan") + Text(f"  {desc}")
-                )
+                left = Text(f"/{name}".ljust(custom_left_width), style="cyan")
+                right = Text(desc)
+                line = Text()
+                line.append_text(left)
+                line.append_text(right)
+                lines.append(line)
     except Exception:
-        # If callbacks fail, skip custom help silently
         pass
 
-    # Combine all lines
     final_text = Text()
-    for i, line in enumerate(help_lines):
+    for i, line in enumerate(lines):
         if i > 0:
             final_text.append("\n")
         final_text.append_text(line)

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/command_line/prompt_toolkit_completion.py

@@ -194,24 +194,48 @@ async def get_input_with_combined_completion(
             LoadContextCompleter(trigger="/load_context"),
         ]
     )
-    # Add custom key bindings for multiline input
+    # Add custom key bindings and multiline toggle
     bindings = KeyBindings()
 
-    @bindings.add(Keys.Escape, "m")  # Alt+M (legacy support)
+    # Multiline mode state
+    multiline = {"enabled": False}
+
+    # Toggle multiline with Alt+M
+    @bindings.add(Keys.Escape, "m")
     def _(event):
-        event.app.current_buffer.insert_text("\n")
+        multiline["enabled"] = not multiline["enabled"]
+        status = "ON" if multiline["enabled"] else "OFF"
+        # Print status for user feedback (version-agnostic)
+        print(f"[multiline] {status}", flush=True)
+
+    # Also toggle multiline with F2 (more reliable across platforms)
+    @bindings.add("f2")
+    def _(event):
+        multiline["enabled"] = not multiline["enabled"]
+        status = "ON" if multiline["enabled"] else "OFF"
+        print(f"[multiline] {status}", flush=True)
 
-    # Create a special binding for shift+enter
-    @bindings.add("escape", "enter")
+    # Newline insert bindings — robust and explicit
+    # Ctrl+J (line feed) works in virtually all terminals; mark eager so it wins
+    @bindings.add("c-j", eager=True)
     def _(event):
-        """Pressing alt+enter (meta+enter) inserts a newline."""
         event.app.current_buffer.insert_text("\n")
 
-    # Override the default enter behavior to check for shift
-    @bindings.add("enter", filter=~is_searching)
+    # Also allow Ctrl+Enter for newline (terminal-dependent)
+    try:
+        @bindings.add("c-enter", eager=True)
+        def _(event):
+            event.app.current_buffer.insert_text("\n")
+    except Exception:
+        pass
+
+    # Enter behavior depends on multiline mode
+    @bindings.add("enter", filter=~is_searching, eager=True)
     def _(event):
-        """Accept input only when we're not in an interactive search buffer."""
-        event.current_buffer.validate_and_handle()
+        if multiline["enabled"]:
+            event.app.current_buffer.insert_text("\n")
+        else:
+            event.current_buffer.validate_and_handle()
 
     @bindings.add(Keys.Escape)
     def _(event):

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/main.py

@@ -272,16 +272,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
     emit_info("[bold green]Code Puppy[/bold green] - Interactive Mode")
     emit_system_message("Type '/exit' or '/quit' to exit the interactive mode.")
     emit_system_message("Type 'clear' to reset the conversation history.")
+    emit_system_message("[dim]Type /help to view all commands[/dim]")
     emit_system_message(
-        "Type [bold blue]@[/bold blue] for path completion, or [bold blue]/m[/bold blue] to pick a model. Use [bold blue]Esc+Enter[/bold blue] for multi-line input."
+        "Type [bold blue]@[/bold blue] for path completion, or [bold blue]/m[/bold blue] to pick a model. Toggle multiline with [bold blue]Alt+M[/bold blue] or [bold blue]F2[/bold blue]; newline: [bold blue]Ctrl+J[/bold blue]."
     )
     emit_system_message(
         "Press [bold red]Ctrl+C[/bold red] during processing to cancel the current task or inference."
     )
-    from code_puppy.command_line.command_handler import get_commands_help
-
-    help_text = get_commands_help()
-    emit_system_message(help_text)
     try:
         from code_puppy.command_line.motd import print_motd
 

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/tui/app.py

@@ -176,6 +176,13 @@ class CodePuppyTUI(App):
         # Start the message renderer EARLY to catch startup messages
         # Using call_after_refresh to start it as soon as possible after mount
         self.call_after_refresh(self.start_message_renderer_sync)
+        
+        # Kick off a non-blocking preload of the agent/model so the
+        # status bar shows loading before first prompt
+        self.call_after_refresh(self.preload_agent_on_startup)
+        
+        # After preload, offer to restore an autosave session (like interactive mode)
+        self.call_after_refresh(self.maybe_prompt_restore_autosave)
 
         # Apply responsive design adjustments
         self.apply_responsive_layout()
@@ -187,16 +194,40 @@ class CodePuppyTUI(App):
         if self.initial_command:
             self.call_after_refresh(self.process_initial_command)
 
+    def _tighten_text(self, text: str) -> str:
+        """Aggressively tighten whitespace: trim lines, collapse multiples, drop extra blanks."""
+        try:
+            import re
+
+            # Split into lines, strip each, drop empty runs
+            lines = [re.sub(r"\s+", " ", ln.strip()) for ln in text.splitlines()]
+            # Remove consecutive blank lines
+            tight_lines = []
+            last_blank = False
+            for ln in lines:
+                is_blank = (ln == "")
+                if is_blank and last_blank:
+                    continue
+                tight_lines.append(ln)
+                last_blank = is_blank
+            return "\n".join(tight_lines).strip()
+        except Exception:
+            return text.strip()
+
     def add_system_message(
         self, content: str, message_group: str = None, group_id: str = None
     ) -> None:
         """Add a system message to the chat."""
         # Support both parameter names for backward compatibility
         final_group_id = message_group or group_id
+        # Tighten only plain strings
+        content_to_use = (
+            self._tighten_text(content) if isinstance(content, str) else content
+        )
         message = ChatMessage(
             id=f"sys_{datetime.now(timezone.utc).timestamp()}",
             type=MessageType.SYSTEM,
-            content=content,
+            content=content_to_use,
             timestamp=datetime.now(timezone.utc),
             group_id=final_group_id,
         )
@@ -245,10 +276,13 @@ class CodePuppyTUI(App):
 
     def add_error_message(self, content: str, message_group: str = None) -> None:
         """Add an error message to the chat."""
+        content_to_use = (
+            self._tighten_text(content) if isinstance(content, str) else content
+        )
         message = ChatMessage(
             id=f"error_{datetime.now(timezone.utc).timestamp()}",
             type=MessageType.ERROR,
-            content=content,
+            content=content_to_use,
             timestamp=datetime.now(timezone.utc),
             group_id=message_group,
         )
@@ -303,9 +337,9 @@ class CodePuppyTUI(App):
 
         # Only handle keys when input field is focused
         if input_field.has_focus:
-            # Handle Ctrl+Enter for new lines (more reliable than Shift+Enter)
-            if event.key == "ctrl+enter":
-                input_field.insert("\\n")
+            # Handle Ctrl+Enter or Shift+Enter for a new line
+            if event.key in ("ctrl+enter", "shift+enter"):
+                input_field.insert("\n")
                 event.prevent_default()
                 return
 
@@ -484,6 +518,14 @@ class CodePuppyTUI(App):
                     self.update_agent_progress("Processing", 75)
                     agent_response = result.output
                     self.add_agent_message(agent_response)
+
+                    # Auto-save session if enabled (mirror --interactive)
+                    try:
+                        from code_puppy.config import auto_save_session_if_enabled
+                        auto_save_session_if_enabled()
+                    except Exception:
+                        pass
+
                     # Refresh history display to show new interaction
                     self.refresh_history_display()
 
@@ -842,6 +884,36 @@ class CodePuppyTUI(App):
         """Synchronous wrapper to start message renderer via run_worker."""
         self.run_worker(self.start_message_renderer(), exclusive=False)
 
+    async def preload_agent_on_startup(self) -> None:
+        """Preload the agent/model at startup so loading status is visible."""
+        try:
+            # Show loading in status bar and spinner
+            self.start_agent_progress("Loading")
+
+            # Warm up agent/model without blocking UI
+            import asyncio
+
+            from code_puppy.agents.agent_manager import get_current_agent
+
+            agent = get_current_agent()
+
+            # Run the synchronous reload in a worker thread
+            await asyncio.to_thread(agent.reload_code_generation_agent)
+
+            # After load, refresh current model (in case of fallback or changes)
+            from code_puppy.config import get_global_model_name
+
+            self.current_model = get_global_model_name()
+
+            # Let the user know model/agent are ready
+            self.add_system_message("Model and agent preloaded. Ready to roll 🛼")
+        except Exception as e:
+            # Surface any preload issues but keep app usable
+            self.add_error_message(f"Startup preload failed: {e}")
+        finally:
+            # Always stop spinner and set ready state
+            self.stop_agent_progress()
+
     async def start_message_renderer(self):
         """Start the message renderer to consume messages from the queue."""
         if not self._renderer_started:
@@ -884,9 +956,9 @@ class CodePuppyTUI(App):
                             f"Error processing startup message: {e}"
                         )
 
-                # Create a single grouped startup message
+                # Create a single grouped startup message (tightened)
                 grouped_content = "\n".join(startup_content_lines)
-                self.add_system_message(grouped_content)
+                self.add_system_message(self._tighten_text(grouped_content))
 
                 # Clear the startup buffer after processing
                 self.message_queue.clear_startup_buffer()
@@ -894,6 +966,80 @@ class CodePuppyTUI(App):
             # Now start the regular message renderer
             await self.message_renderer.start()
 
+    async def maybe_prompt_restore_autosave(self) -> None:
+        """Offer to restore an autosave session at startup (TUI version)."""
+        try:
+            import asyncio
+            from pathlib import Path
+
+            from code_puppy.config import AUTOSAVE_DIR, set_current_autosave_from_session_name
+            from code_puppy.session_storage import list_sessions, load_session
+
+            base_dir = Path(AUTOSAVE_DIR)
+            sessions = list_sessions(base_dir)
+            if not sessions:
+                return
+
+            # Show modal picker for selection
+            from .screens.autosave_picker import AutosavePicker
+
+            async def handle_result(result_name: str | None):
+                if not result_name:
+                    return
+                try:
+                    # Load history and set into agent
+                    from code_puppy.agents.agent_manager import get_current_agent
+
+                    history = load_session(result_name, base_dir)
+                    agent = get_current_agent()
+                    agent.set_message_history(history)
+
+                    # Set current autosave session id so subsequent autosaves overwrite this session
+                    try:
+                        set_current_autosave_from_session_name(result_name)
+                    except Exception:
+                        pass
+
+                    # Update token info/status bar
+                    total_tokens = sum(
+                        agent.estimate_tokens_for_message(msg) for msg in history
+                    )
+                    try:
+                        status_bar = self.query_one(StatusBar)
+                        status_bar.update_token_info(
+                            total_tokens,
+                            agent.get_model_context_length(),
+                            total_tokens / max(1, agent.get_model_context_length()),
+                        )
+                    except Exception:
+                        pass
+
+                    # Notify
+                    session_path = base_dir / f"{result_name}.pkl"
+                    self.add_system_message(
+                        f"✅ Autosave loaded: {len(history)} messages ({total_tokens} tokens)\n"
+                        f"📁 From: {session_path}"
+                    )
+
+                    # Refresh history sidebar
+                    self.refresh_history_display()
+                except Exception as e:
+                    self.add_error_message(f"Failed to load autosave: {e}")
+
+            # Push modal and await result
+            picker = AutosavePicker(base_dir)
+
+            # Use Textual's push_screen with a result callback
+            def on_picker_result(result_name=None):
+                # Schedule async handler to avoid blocking UI
+                import asyncio
+                self.run_worker(handle_result(result_name), exclusive=False)
+
+            self.push_screen(picker, on_picker_result)
+        except Exception as e:
+            # Fail silently but show debug in chat
+            self.add_system_message(f"[dim]Autosave prompt error: {e}[/dim]")
+
     async def stop_message_renderer(self):
         """Stop the message renderer."""
         if self._renderer_started:

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/tui/components/input_area.py

@@ -133,7 +133,7 @@ class InputArea(Container):
             yield CustomTextArea(id="input-field", show_line_numbers=False)
             yield SubmitCancelButton()
         yield Static(
-            "Enter to send • Alt+Enter for new line • Ctrl+1 for help",
+            "Enter to send • Shift+Enter for new line • Ctrl+1 for help",
             id="input-help",
         )
 

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/tui/components/status_bar.py

@@ -83,7 +83,10 @@ class StatusBar(Static):
         elif self.agent_status == "Busy":
             status_indicator = "🔄"
             status_color = "orange"
-        else:  # Ready
+        elif self.agent_status == "Loading":
+            status_indicator = "⏳"
+            status_color = "cyan"
+        else:  # Ready or anything else
             status_indicator = "✅"
             status_color = "green"
 

{code_puppy-0.0.196 → code_puppy-0.0.197}/code_puppy/tui/screens/__init__.py

@@ -6,10 +6,12 @@ from .help import HelpScreen
 from .mcp_install_wizard import MCPInstallWizardScreen
 from .settings import SettingsScreen
 from .tools import ToolsScreen
+from .autosave_picker import AutosavePicker
 
 __all__ = [
     "HelpScreen",
     "SettingsScreen",
     "ToolsScreen",
     "MCPInstallWizardScreen",
+    "AutosavePicker",
 ]