rubber-ducky 1.2.1__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

@@ -3,21 +3,43 @@ from __future__ import annotations
 import argparse
 import asyncio
 import json
+import os
 import sys
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import UTC, datetime
+from rich.console import Console
 from pathlib import Path
 from textwrap import dedent
 from typing import Any, Dict, List
 
-from ollama import AsyncClient
+
+@dataclass
+class Crumb:
+    name: str
+    path: Path
+    type: str
+    enabled: bool
+    description: str | None = None
+
+
 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.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
     PromptSession = None  # type: ignore[assignment]
     FileHistory = None  # type: ignore[assignment]
@@ -27,9 +49,6 @@ except ImportError:  # pragma: no cover - fallback mode
         return nullcontext()
 
 
-from rich.console import Console
-
-
 @dataclass
 class AssistantResult:
     content: str
@@ -48,14 +67,77 @@ class ShellResult:
 HISTORY_DIR = Path.home() / ".ducky"
 PROMPT_HISTORY_FILE = HISTORY_DIR / "prompt_history"
 CONVERSATION_LOG_FILE = HISTORY_DIR / "conversation.log"
+CRUMBS_DIR = HISTORY_DIR / "crumbs"
+CRUMBS: Dict[str, Crumb] = {}
 console = Console()
 
 
 def ensure_history_dir() -> Path:
     HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+    CRUMBS_DIR.mkdir(parents=True, exist_ok=True)
     return HISTORY_DIR
 
 
+def load_crumbs() -> Dict[str, Crumb]:
+    """Populate the global ``CRUMBS`` dictionary from the ``CRUMBS_DIR``.
+
+    Each crumb is expected to be a directory containing an ``info.txt`` and a
+    script file matching the ``type`` field (``shell`` → ``*.sh``).
+    """
+
+    global CRUMBS
+    CRUMBS.clear()
+    if not CRUMBS_DIR.exists():
+        return CRUMBS
+
+    for crumb_dir in CRUMBS_DIR.iterdir():
+        if not crumb_dir.is_dir():
+            continue
+        info_path = crumb_dir / "info.txt"
+        if not info_path.is_file():
+            continue
+        # Parse key: value pairs
+        meta = {}
+        for line in info_path.read_text(encoding="utf-8").splitlines():
+            if ":" not in line:
+                continue
+            key, val = line.split(":", 1)
+            meta[key.strip()] = val.strip()
+        name = meta.get("name", crumb_dir.name)
+        ctype = meta.get("type", "shell")
+        description = meta.get("description")
+        # Find script file: look for executable in the directory
+        script_path: Path | None = None
+        if ctype == "shell":
+            # Prefer a file named <name>.sh if present
+            candidate = crumb_dir / f"{name}.sh"
+            if candidate.is_file() and os.access(candidate, os.X_OK):
+                script_path = candidate
+            else:
+                # Fallback: first .sh in dir
+                for p in crumb_dir.glob("*.sh"):
+                    if os.access(p, os.X_OK):
+                        script_path = p
+                        break
+        # Default to first file if script not found
+        if script_path is None:
+            files = list(crumb_dir.iterdir())
+            if files:
+                script_path = files[0]
+        if script_path is None:
+            continue
+        crumb = Crumb(
+            name=name,
+            path=script_path,
+            type=ctype,
+            enabled=False,
+            description=description,
+        )
+        CRUMBS[name] = crumb
+
+    return CRUMBS
+
+
 class ConversationLogger:
     def __init__(self, log_path: Path) -> None:
         self.log_path = log_path
@@ -82,7 +164,7 @@ class ConversationLogger:
         )
 
     def _append(self, entry: Dict[str, Any]) -> None:
-        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")
@@ -138,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(
             """
@@ -153,20 +239,66 @@ 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
         self.command_mode = command_mode
+        self.crumbs = load_crumbs()
         self.messages: List[Dict[str, str]] = [
             {"role": "system", "content": self.system_prompt}
         ]
-        self.last_thinking: str | None = None
+        # Update system prompt to include enabled crumb descriptions
+
+    def update_system_prompt(self) -> None:
+        """Append enabled crumb descriptions to the system prompt.
+
+        The system prompt is stored in ``self.system_prompt`` and injected as the
+        first system message. When crumbs are enabled, we add a section that
+        lists the crumb names and their descriptions. The format is simple:
+
+        ``Crumbs:``\n
+        ``- <name>: <description>``\n
+        If no crumbs are enabled the prompt is unchanged.
+        """
+        # 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("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
+        else:
+            # If there's no system message, add one
+            self.messages.insert(0, {"role": "system", "content": self.system_prompt})
 
     async def send_prompt(
         self, prompt: str | None = None, code: str | None = None
     ) -> AssistantResult:
         user_content = (prompt or "").strip()
 
+        self.update_system_prompt()
+
         if code:
             user_content = f"{user_content}\n\n{code}" if user_content else code
 
@@ -175,7 +307,7 @@ class RubberDuck:
 
         if self.command_mode:
             instruction = (
-                "Return a single bash command that accomplishes the task. "
+                "Return a single bash command that accomplishes the task. Unless user wants something els"
                 "Do not include explanations or formatting other than the command itself."
             )
             user_content = (
@@ -256,6 +388,54 @@ class RubberDuck:
 
         return command or None
 
+    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()
+            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 []
+        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__(
@@ -273,6 +453,7 @@ class InlineInterface:
         self.last_shell_output: str | None = None
         self.pending_command: str | None = None
         self.session: PromptSession | None = None
+        self.selected_model: str | None = None
 
         if (
             PromptSession is not None
@@ -305,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:
@@ -317,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:
@@ -328,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
@@ -337,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")
@@ -349,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
@@ -369,13 +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
@@ -390,7 +648,8 @@ class InlineInterface:
             self._code_sent = True
         self.last_command = result.command
         self.pending_command = result.command
-        self.last_shell_output = None
+        # Set last_shell_output to True so empty Enter will explain the result
+        self.last_shell_output = True
 
     async def _explain_last_command(self) -> None:
         if not self.assistant.messages or len(self.assistant.messages) < 2:
@@ -410,6 +669,147 @@ class InlineInterface:
         )
         self.last_shell_output = 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",
+            )
+            return
+
+        # 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:
+            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
+
+        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
+                if 0 <= index < len(models):
+                    selected_model = models[index]
+                else:
+                    console.print("Invalid model number.", style="red")
+                    return
+            else:
+                # Check if it's a model name
+                if choice in models:
+                    selected_model = choice
+                else:
+                    console.print("Invalid model name.", style="red")
+                    return
+
+            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")
+
     async def _run_basic_loop(self) -> None:  # pragma: no cover - fallback path
         while True:
             try:
@@ -418,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
@@ -486,14 +886,38 @@ 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=None)
     parser.add_argument(
-        "--model", "-m", help="The model to be used", default="qwen3-coder:480b-cloud"
+        "--local",
+        "-l",
+        action="store_true",
+        help="Run DuckY offline using a local Ollama instance on localhost:11434",
     )
     args, _ = parser.parse_known_args()
 
     ensure_history_dir()
     logger = ConversationLogger(CONVERSATION_LOG_FILE)
-    rubber_ducky = RubberDuck(model=args.model, quick=False, command_mode=True)
+
+    # 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 = 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.1.dist-info → rubber_ducky-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rubber-ducky
-Version: 1.2.1
+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.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-ducky/__init__.py,sha256=9l8SmwX0t1BmITkcrzW9fVMPvD2LfgKLZlSXWzPJFSE,25
-ducky/ducky.py,sha256=FWGkAnyWB8k6GxsAu5WkIxJ5mlnT9ymIAJsJf8ryTts,17347
-rubber_ducky-1.2.1.dist-info/licenses/LICENSE,sha256=gQ1rCmw18NqTk5GxG96F6vgyN70e1c4kcKUtWDwdNaE,1069
-rubber_ducky-1.2.1.dist-info/METADATA,sha256=MDt4yR-GtzqF4bB-j8s4kXt3tNUDYJ6H_7Mr6mLUEu0,3063
-rubber_ducky-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubber_ducky-1.2.1.dist-info/entry_points.txt,sha256=WPnVUUNvWdMDcBlCo8JCzkLghGllMX5QVZyQghyq85Q,75
-rubber_ducky-1.2.1.dist-info/top_level.txt,sha256=4Q75MONDNPpQ3o17bTu7RFuKwFhTIRzlXP3_LDWQQ30,6
-rubber_ducky-1.2.1.dist-info/RECORD,,