rubber-ducky 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

ducky/__init__.py

@@ -1 +1,3 @@
-from .ducky import ducky
+from .ducky import ducky, main
+
+__all__ = ["ducky", "main"]

ducky/config.py

@@ -0,0 +1,60 @@
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+
+class ConfigManager:
+    """Manages Ducky configuration including model preferences."""
+    
+    def __init__(self, config_dir: Optional[Path] = None):
+        if config_dir is None:
+            config_dir = Path.home() / ".ducky"
+        self.config_dir = config_dir
+        self.config_file = self.config_dir / "config"
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        
+    def load_config(self) -> Dict[str, Any]:
+        """Load configuration from file, returning defaults if not found."""
+        default_config = {
+            "last_model": "qwen3-coder:480b-cloud",
+            "last_host": "https://ollama.com"
+        }
+        
+        if not self.config_file.exists():
+            return default_config
+            
+        try:
+            with open(self.config_file, 'r') as f:
+                config = json.load(f)
+                # Ensure all required keys are present
+                for key in default_config:
+                    if key not in config:
+                        config[key] = default_config[key]
+                return config
+        except (json.JSONDecodeError, IOError):
+            return default_config
+    
+    def save_config(self, config: Dict[str, Any]) -> None:
+        """Save configuration to file."""
+        try:
+            with open(self.config_file, 'w') as f:
+                json.dump(config, f, indent=2)
+        except IOError as e:
+            print(f"Warning: Could not save config: {e}")
+    
+    def get_last_model(self) -> tuple[str, str]:
+        """Get the last used model and host.
+        
+        Returns:
+            Tuple of (model_name, host)
+        """
+        config = self.load_config()
+        return config.get("last_model", "qwen3-coder:480b-cloud"), config.get("last_host", "https://ollama.com")
+    
+    def save_last_model(self, model_name: str, host: str) -> None:
+        """Save the last used model and host."""
+        config = self.load_config()
+        config["last_model"] = model_name
+        config["last_host"] = host
+        self.save_config(config)

ducky/ducky.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 import argparse
-import os
 import asyncio
+import json
+import os
 import sys
 from dataclasses import dataclass
-from datetime import datetime
-
-# import json included earlier
-from typing import Dict
+from datetime import UTC, datetime
+from rich.console import Console
 from pathlib import Path
 from textwrap import dedent
 from typing import Any, Dict, List
@@ -23,19 +22,22 @@ class Crumb:
     description: str | None = None
 
 
-from ollama import AsyncClient
 from contextlib import nullcontext
 
+from ollama import AsyncClient
+
+from .config import ConfigManager
+
 try:  # prompt_toolkit is optional at runtime
     from prompt_toolkit import PromptSession
+    from prompt_toolkit.application import Application
     from prompt_toolkit.history import FileHistory
     from prompt_toolkit.key_binding import KeyBindings
-    from prompt_toolkit.patch_stdout import patch_stdout
-    from prompt_toolkit.application import Application
     from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous
     from prompt_toolkit.layout.containers import HSplit, Window
     from prompt_toolkit.layout.controls import FormattedTextControl
     from prompt_toolkit.layout.layout import Layout
+    from prompt_toolkit.patch_stdout import patch_stdout
     from prompt_toolkit.styles import Style
     from prompt_toolkit.widgets import Box, Button, Dialog, Label, TextArea
 except ImportError:  # pragma: no cover - fallback mode
@@ -47,9 +49,6 @@ except ImportError:  # pragma: no cover - fallback mode
         return nullcontext()
 
 
-from rich.console import Console
-
-
 @dataclass
 class AssistantResult:
     content: str
@@ -165,9 +164,7 @@ class ConversationLogger:
         )
 
     def _append(self, entry: Dict[str, Any]) -> None:
-        import json
-
-        entry["timestamp"] = datetime.utcnow().isoformat()
+        entry["timestamp"] = datetime.now(UTC).isoformat()
         with self.log_path.open("a", encoding="utf-8") as handle:
             handle.write(json.dumps(entry, ensure_ascii=False))
             handle.write("\n")
@@ -223,7 +220,11 @@ async def run_shell_and_print(
 
 class RubberDuck:
     def __init__(
-        self, model: str, quick: bool = False, command_mode: bool = False
+        self,
+        model: str,
+        quick: bool = False,
+        command_mode: bool = False,
+        host: str = "",
     ) -> None:
         self.system_prompt = dedent(
             """
@@ -238,6 +239,16 @@ class RubberDuck:
             changes rather than responding to each line individually.
             """
         ).strip()
+
+        # Set OLLAMA_HOST based on whether it's a cloud model
+        if host:
+            os.environ["OLLAMA_HOST"] = host
+        elif "-cloud" in model:
+            os.environ["OLLAMA_HOST"] = "https://ollama.com"
+        elif "OLLAMA_HOST" not in os.environ:
+            # Default to localhost if not set and not a cloud model
+            os.environ["OLLAMA_HOST"] = "http://localhost:11434"
+
         self.client = AsyncClient()
         self.model = model
         self.quick = quick
@@ -261,17 +272,19 @@ class RubberDuck:
         """
         # Start with the base system prompt
         prompt_lines = [self.system_prompt]
-        
+
         if self.crumbs:
-            prompt_lines.append("\nCrumbs are simple scripts you can run with bash, uv, or bun.")
+            prompt_lines.append(
+                "\nCrumbs are simple scripts you can run with bash, uv, or bun."
+            )
             prompt_lines.append("Crumbs:")
             for c in self.crumbs.values():
                 description = c.description or "no description"
                 prompt_lines.append(f"- {c.name}: {description}")
-        
+
         # Update the system prompt
         self.system_prompt = "\n".join(prompt_lines)
-        
+
         # Update the first system message in the messages list
         if self.messages and self.messages[0]["role"] == "system":
             self.messages[0]["content"] = self.system_prompt
@@ -375,20 +388,54 @@ class RubberDuck:
 
         return command or None
 
-    async def list_models(self) -> list[str]:
+    async def list_models(self, host: str = "") -> list[str]:
         """List available Ollama models."""
+        # Set the host temporarily for this operation
+        original_host = os.environ.get("OLLAMA_HOST", "")
+        if host:
+            os.environ["OLLAMA_HOST"] = host
+            self.client = AsyncClient(host)
         try:
             response = await self.client.list()
-            return [model.model for model in response.models]
+            models = []
+            for m in response.models:
+                models.append(m.model)
+            return models
         except Exception as e:
             console.print(f"Error listing models: {e}", style="red")
             return []
-
-    def switch_model(self, model_name: str) -> None:
+        finally:
+            # Restore original host
+            if original_host:
+                os.environ["OLLAMA_HOST"] = original_host
+                self.client = AsyncClient(original_host)
+            elif "OLLAMA_HOST" in os.environ:
+                del os.environ["OLLAMA_HOST"]
+                self.client = AsyncClient()
+
+    def switch_model(self, model_name: str, host: str = "") -> None:
         """Switch to a different Ollama model."""
         self.model = model_name
+
+        # Set the host based on the model or explicit host
+        if host:
+            os.environ["OLLAMA_HOST"] = host
+            self.client = AsyncClient(host)
+        elif "-cloud" in model_name:
+            os.environ["OLLAMA_HOST"] = "https://ollama.com"
+            self.client = AsyncClient("https://ollama.com")
+        else:
+            os.environ["OLLAMA_HOST"] = "http://localhost:11434"
+            self.client = AsyncClient()
+
         console.print(f"Switched to model: {model_name}", style="green")
 
+    def clear_history(self) -> None:
+        """Reset conversation history to the initial system prompt."""
+        if self.messages:
+            self.messages = [self.messages[0]]
+        console.print("Conversation history cleared.", style="green")
+
 
 class InlineInterface:
     def __init__(
@@ -439,6 +486,11 @@ class InlineInterface:
         def _(event) -> None:
             event.app.exit(result="__RUN_LAST__")
 
+        @kb.add("c-s")
+        def _(event) -> None:
+            # This will be handled in the processing loop
+            event.app.exit(result="__COPY_LAST__")
+
         return kb
 
     async def run(self) -> None:
@@ -451,7 +503,7 @@ class InlineInterface:
             return
 
         console.print(
-            "Enter submits • empty Enter reruns the last suggested command (or explains the last shell output) • '!cmd' runs shell • Ctrl+D exits",
+            "Enter submits • empty Enter reruns the last suggested command (or explains the last shell output) • '!<cmd>' runs shell • Ctrl+D exits • Ctrl+S copies last command",
             style="dim",
         )
         while True:
@@ -462,7 +514,7 @@ class InlineInterface:
                 console.print()
                 console.print("Exiting.", style="dim")
                 return
-            except KeyboardInterrupt:
+            except (KeyboardInterrupt, asyncio.CancelledError):
                 console.print()
                 console.print("Interrupted. Press Ctrl+D to exit.", style="yellow")
                 continue
@@ -471,8 +523,53 @@ class InlineInterface:
                 await self._run_last_command()
                 continue
 
+            if text == "__COPY_LAST__":
+                await self._copy_last_command()
+                continue
+
             await self._process_text(text)
 
+    async def _copy_last_command(self) -> None:
+        """Copy the last suggested command to clipboard."""
+        if not self.last_command:
+            console.print("No suggested command available to copy.", style="yellow")
+            return
+
+        try:
+            import subprocess
+            import platform
+
+            command_to_copy = self.last_command
+
+            system = platform.system()
+            if system == "Darwin":  # macOS
+                process = subprocess.Popen(["pbcopy"], stdin=subprocess.PIPE, text=True)
+                process.communicate(input=command_to_copy)
+            elif system == "Windows":
+                process = subprocess.Popen(["clip"], stdin=subprocess.PIPE, text=True)
+                process.communicate(input=command_to_copy)
+            else:  # Linux and others
+                # Try xclip first, then xsel as fallback
+                try:
+                    process = subprocess.Popen(
+                        ["xclip", "-selection", "clipboard"],
+                        stdin=subprocess.PIPE,
+                        text=True,
+                    )
+                    process.communicate(input=command_to_copy)
+                except FileNotFoundError:
+                    # Try xsel as fallback
+                    process = subprocess.Popen(
+                        ["xsel", "-b", "-i"], stdin=subprocess.PIPE, text=True
+                    )
+                    process.communicate(input=command_to_copy)
+
+            console.print(f"Copied to clipboard: {command_to_copy}", style="green")
+        except Exception as e:
+            console.print(f"Failed to copy to clipboard: {e}", style="red")
+            console.print("You can manually copy the last command:", style="dim")
+            console.print(f"  {self.last_command}", style="bold")
+
     async def _run_last_command(self) -> None:
         if not self.last_command:
             console.print("No suggested command available yet.", style="yellow")
@@ -483,6 +580,9 @@ class InlineInterface:
             logger=self.logger,
             history=self.assistant.messages,
         )
+        # Add the command to prompt history so user can recall it with up arrow
+        if self.session and self.session.history and self.last_command:
+            self.session.history.append_string(self.last_command)
         self.last_shell_output = True
         self.pending_command = None
         self.last_command = None
@@ -503,17 +603,37 @@ class InlineInterface:
             await self._run_last_command()
             return
 
+        if stripped.lower() in {"/clear", "/reset"}:
+            await self._clear_history()
+            return
+
         if stripped.lower() == "/model":
             await self._select_model()
             return
 
+        if stripped.lower() == "/local":
+            await self._select_model(host="http://localhost:11434")
+            return
+
+        if stripped.lower() == "/cloud":
+            await self._select_model(host="https://ollama.com")
+            return
+
+        if stripped.lower() == "/help":
+            await self._show_help()
+            return
+
         if stripped.startswith("!"):
+            command = stripped[1:].strip()
             await run_shell_and_print(
                 self.assistant,
-                stripped[1:].strip(),
+                command,
                 logger=self.logger,
                 history=self.assistant.messages,
             )
+            # Add the command to prompt history so user can recall it with up arrow
+            if self.session and self.session.history and command:
+                self.session.history.append_string(command)
             self.last_shell_output = True
             self.pending_command = None
             return
@@ -549,29 +669,120 @@ class InlineInterface:
         )
         self.last_shell_output = None
 
-    async def _select_model(self) -> None:
+    async def _show_help(self) -> None:
+        """Display help information for all available commands."""
+        console.print("\nDucky CLI Help", style="bold blue")
+        console.print("===============", style="bold blue")
+        console.print()
+
+        commands = [
+            ("[bold]/help[/bold]", "Show this help message"),
+            ("[bold]/model[/bold]", "Select a model interactively (local or cloud)"),
+            (
+                "[bold]/local[/bold]",
+                "List and select from local models (localhost:11434)",
+            ),
+            ("[bold]/cloud[/bold]", "List and select from cloud models (ollama.com)"),
+            (
+                "[bold]/clear[/bold] or [bold]/reset[/bold]",
+                "Clear conversation history",
+            ),
+            (
+                "[bold]/run[/bold]",
+                "Re-run the last suggested command",
+            ),
+            (
+                "[bold]Empty Enter[/bold]",
+                "Re-run suggested command or explain last output",
+            ),
+            ("[bold]![<command>][/bold]", "Execute a shell command directly"),
+            ("[bold]Ctrl+D[/bold]", "Exit the application"),
+            ("[bold]Ctrl+R[/bold]", "Re-run the last suggested command"),
+            ("[bold]Ctrl+S[/bold]", "Copy the last suggested command to clipboard"),
+        ]
+
+        for command, description in commands:
+            console.print(f"{command:<30} {description}")
+
+        console.print()
+
+    async def _clear_history(self) -> None:
+        self.assistant.clear_history()
+        self.last_command = None
+        self.pending_command = None
+        self.last_shell_output = None
+
+    async def _select_model(self, host: str = "") -> None:
         """Show available models and allow user to select one with arrow keys."""
         if PromptSession is None or KeyBindings is None:
-            console.print("Model selection requires prompt_toolkit to be installed.", style="yellow")
+            console.print(
+                "Model selection requires prompt_toolkit to be installed.",
+                style="yellow",
+            )
             return
 
-        models = await self.assistant.list_models()
+        # Show current model
+        console.print(f"Current model: {self.assistant.model}", style="bold green")
+
+        # If no host specified, give user a choice between local and cloud
+        if not host:
+            console.print("\nSelect model type:", style="bold")
+            console.print("1. Local models (localhost:11434)")
+            console.print("2. Cloud models (ollama.com)")
+            console.print("Press Esc to cancel", style="dim")
+
+            try:
+                choice = await asyncio.to_thread(input, "Enter choice (1 or 2): ")
+                choice = choice.strip()
+
+                if choice.lower() == "esc":
+                    console.print("Model selection cancelled.", style="yellow")
+                    return
+
+                if choice == "1":
+                    host = "http://localhost:11434"
+                elif choice == "2":
+                    host = "https://ollama.com"
+                else:
+                    console.print("Invalid choice. Please select 1 or 2.", style="red")
+                    return
+            except (ValueError, EOFError):
+                console.print("Invalid input.", style="red")
+                return
+
+        models = await self.assistant.list_models(host)
         if not models:
-            console.print("No models available.", style="yellow")
+            if host == "http://localhost:11434":
+                console.print(
+                    "No local models available. Is Ollama running?", style="red"
+                )
+                console.print("Start Ollama with: ollama serve", style="yellow")
+            else:
+                console.print("No models available.", style="yellow")
             return
 
-        # Simple approach: show models as a list and let user type the number
-        console.print("Available models:", style="bold")
+        if host == "https://ollama.com":
+            console.print("\nAvailable cloud models:", style="bold")
+        elif host == "http://localhost:11434":
+            console.print("\nAvailable local models:", style="bold")
+        else:
+            console.print("\nAvailable models:", style="bold")
+
         for i, model in enumerate(models, 1):
             if model == self.assistant.model:
                 console.print(f"{i}. {model} (current)", style="green")
             else:
                 console.print(f"{i}. {model}")
 
+        console.print("Press Esc to cancel", style="dim")
         try:
             choice = await asyncio.to_thread(input, "Enter model number or name: ")
             choice = choice.strip()
-            
+
+            if choice.lower() == "esc":
+                console.print("Model selection cancelled.", style="yellow")
+                return
+
             # Check if it's a number
             if choice.isdigit():
                 index = int(choice) - 1
@@ -587,8 +798,15 @@ class InlineInterface:
                 else:
                     console.print("Invalid model name.", style="red")
                     return
-            
-            self.assistant.switch_model(selected_model)
+
+            self.assistant.switch_model(selected_model, host)
+
+            # Save the selected model and host to config
+            config_manager = ConfigManager()
+            config_manager.save_last_model(
+                selected_model,
+                host or os.environ.get("OLLAMA_HOST", "http://localhost:11434"),
+            )
         except (ValueError, EOFError):
             console.print("Invalid input.", style="red")
 
@@ -600,7 +818,7 @@ class InlineInterface:
                 console.print()
                 console.print("Exiting.", style="dim")
                 return
-            except KeyboardInterrupt:
+            except (KeyboardInterrupt, asyncio.CancelledError):
                 console.print()
                 console.print("Interrupted. Press Ctrl+D to exit.", style="yellow")
                 continue
@@ -668,9 +886,7 @@ async def ducky() -> None:
     parser.add_argument(
         "--directory", "-d", help="The directory to be processed", default=None
     )
-    parser.add_argument(
-        "--model", "-m", help="The model to be used", default="qwen3-coder:480b-cloud"
-    )
+    parser.add_argument("--model", "-m", help="The model to be used", default=None)
     parser.add_argument(
         "--local",
         "-l",
@@ -681,11 +897,27 @@ async def ducky() -> None:
 
     ensure_history_dir()
     logger = ConversationLogger(CONVERSATION_LOG_FILE)
+
+    # Load the last used model from config if no model is specified
+    config_manager = ConfigManager()
+    last_model, last_host = config_manager.get_last_model()
+
+    # If --local flag is used, override with local settings
     if getattr(args, "local", False):
         # Point Ollama client to local host and use gemma3 as default model
         os.environ["OLLAMA_HOST"] = "http://localhost:11434"
-        args.model = "gpt-oss:20b"
-    rubber_ducky = RubberDuck(model=args.model, quick=False, command_mode=True)
+        args.model = args.model or "gemma2:9b"
+        last_host = "http://localhost:11434"
+    # If no model is specified, use the last used model
+    elif args.model is None:
+        args.model = last_model
+        # Set the host based on the last used host
+        if last_host:
+            os.environ["OLLAMA_HOST"] = last_host
+
+    rubber_ducky = RubberDuck(
+        model=args.model, quick=False, command_mode=True, host=last_host
+    )
 
     code = read_files_from_dir(args.directory) if args.directory else None
 

{rubber_ducky-1.2.2.dist-info → rubber_ducky-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rubber-ducky
-Version: 1.2.2
+Version: 1.3.0
 Summary: Quick CLI do-it-all tool. Use natural language to spit out bash commands
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -35,7 +35,7 @@ Requirements:
 ```
 ducky                 # interactive inline session
 ducky --directory src  # preload code from a directory
-ducky --model llama3   # use a different Ollama model
+ducky --model qwen3 # use a different Ollama model
 ```
 
 Both `ducky` and `rubber-ducky` executables map to the same CLI, so `uvx rubber-ducky -- <args>` works as well.
@@ -54,6 +54,32 @@ Launching `ducky` with no arguments opens the inline interface:
 
 `ducky --directory <path>` streams the contents of the provided directory to the assistant the next time you submit a prompt (the directory is read once at startup).
 
+## Crumbs
+
+Crumbs are simple scripts that can be executed within Rubber Ducky. They are stored in `~/.ducky/crumbs/` and can be referenced by name in your prompts.
+
+To use a crumb, simply mention it in your prompt:
+```
+Can you use the uv-server crumb to run the HuggingFace prompt renderer?
+```
+
+### Creating Crumbs
+
+To create a new crumb:
+
+1. Create a new directory in `~/.ducky/crumbs/` with your crumb name
+2. Add an `info.txt` file with metadata:
+   ```
+   name: your-crumb-name
+   type: shell
+   description: Brief description of what this crumb does
+   ```
+3. Add your executable script file (e.g., `your-crumb-name.sh`)
+4. Create a symbolic link in `~/.local/bin` to make it available as a command:
+   ```bash
+   ln -s ~/.ducky/crumbs/your-crumb-name/your-crumb-name.sh ~/.local/bin/your-crumb-name
+   ```
+
 ## Development (uv)
 
 ```

rubber_ducky-1.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+ducky/__init__.py,sha256=2vLhJxOuJ3lnIeg5rmF6xUvybUT5Qhjej6AS0BeBASY,60
+ducky/config.py,sha256=AH7KMTxPYrtSSmIJ_3qv0WB1tYpAjOWPrvPb7bKQ_cA,2142
+ducky/ducky.py,sha256=1B500ievEsIg9mowpzqWuDNGck_DnUM0LdDRDHsm4yo,33716
+rubber_ducky-1.3.0.dist-info/licenses/LICENSE,sha256=gQ1rCmw18NqTk5GxG96F6vgyN70e1c4kcKUtWDwdNaE,1069
+rubber_ducky-1.3.0.dist-info/METADATA,sha256=BVIv6uBWho_khv8AbkQdPMP9PBB6xbvg-U6muGsfdCs,3874
+rubber_ducky-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubber_ducky-1.3.0.dist-info/entry_points.txt,sha256=WPnVUUNvWdMDcBlCo8JCzkLghGllMX5QVZyQghyq85Q,75
+rubber_ducky-1.3.0.dist-info/top_level.txt,sha256=4Q75MONDNPpQ3o17bTu7RFuKwFhTIRzlXP3_LDWQQ30,6
+rubber_ducky-1.3.0.dist-info/RECORD,,

rubber_ducky-1.2.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-ducky/__init__.py,sha256=9l8SmwX0t1BmITkcrzW9fVMPvD2LfgKLZlSXWzPJFSE,25
-ducky/ducky.py,sha256=bBf_BU0GIu_6bqbDO7jTkJzrDrL-4YIA-jFfhTUMvVg,24493
-rubber_ducky-1.2.2.dist-info/licenses/LICENSE,sha256=gQ1rCmw18NqTk5GxG96F6vgyN70e1c4kcKUtWDwdNaE,1069
-rubber_ducky-1.2.2.dist-info/METADATA,sha256=AM3v2H1FFazbpSqZSHoj8L2qKZ9ZgdT5Xzu__lQPlHc,3063
-rubber_ducky-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubber_ducky-1.2.2.dist-info/entry_points.txt,sha256=WPnVUUNvWdMDcBlCo8JCzkLghGllMX5QVZyQghyq85Q,75
-rubber_ducky-1.2.2.dist-info/top_level.txt,sha256=4Q75MONDNPpQ3o17bTu7RFuKwFhTIRzlXP3_LDWQQ30,6
-rubber_ducky-1.2.2.dist-info/RECORD,,