rubber-ducky 1.2.0__tar.gz → 1.2.2__tar.gz

{rubber_ducky-1.2.0/rubber_ducky.egg-info → rubber_ducky-1.2.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: rubber-ducky
-Version: 1.2.0
-Summary: For developers who can never remember the right bash command
+Version: 1.2.2
+Summary: Quick CLI do-it-all tool. Use natural language to spit out bash commands
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -43,7 +43,7 @@ Both `ducky` and `rubber-ducky` executables map to the same CLI, so `uvx rubber-
 ### Inline Session (default)
 
 Launching `ducky` with no arguments opens the inline interface:
-- **Enter** submits; **Ctrl+J** inserts a newline (helpful when crafting multi-line prompts).
+- **Enter** submits; **Ctrl+J** inserts a newline (helpful when crafting multi-line prompts). Hitting **Enter on an empty prompt** reruns the latest suggested command; if none exists yet, it explains the most recent shell output.
 - **Ctrl+R** re-runs the last suggested command.
 - Prefix any line with **`!`** (e.g., `!ls -la`) to run a shell command immediately.
 - Arrow keys browse prompt history, backed by `~/.ducky/prompt_history`.

{rubber_ducky-1.2.0 → rubber_ducky-1.2.2}/README.md

@@ -27,7 +27,7 @@ Both `ducky` and `rubber-ducky` executables map to the same CLI, so `uvx rubber-
 ### Inline Session (default)
 
 Launching `ducky` with no arguments opens the inline interface:
-- **Enter** submits; **Ctrl+J** inserts a newline (helpful when crafting multi-line prompts).
+- **Enter** submits; **Ctrl+J** inserts a newline (helpful when crafting multi-line prompts). Hitting **Enter on an empty prompt** reruns the latest suggested command; if none exists yet, it explains the most recent shell output.
 - **Ctrl+R** re-runs the last suggested command.
 - Prefix any line with **`!`** (e.g., `!ls -la`) to run a shell command immediately.
 - Arrow keys browse prompt history, backed by `~/.ducky/prompt_history`.

{rubber_ducky-1.2.0 → rubber_ducky-1.2.2}/ducky/ducky.py

@@ -1,15 +1,28 @@
 from __future__ import annotations
 
 import argparse
+import os
 import asyncio
-import json
 import sys
 from dataclasses import dataclass
 from datetime import datetime
+
+# import json included earlier
+from typing import Dict
 from pathlib import Path
 from textwrap import dedent
 from typing import Any, Dict, List
 
+
+@dataclass
+class Crumb:
+    name: str
+    path: Path
+    type: str
+    enabled: bool
+    description: str | None = None
+
+
 from ollama import AsyncClient
 from contextlib import nullcontext
 
@@ -18,6 +31,13 @@ try:  # prompt_toolkit is optional at runtime
     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.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]
@@ -25,6 +45,8 @@ except ImportError:  # pragma: no cover - fallback mode
 
     def patch_stdout() -> nullcontext:
         return nullcontext()
+
+
 from rich.console import Console
 
 
@@ -46,14 +68,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
@@ -80,6 +165,8 @@ class ConversationLogger:
         )
 
     def _append(self, entry: Dict[str, Any]) -> None:
+        import json
+
         entry["timestamp"] = datetime.utcnow().isoformat()
         with self.log_path.open("a", encoding="utf-8") as handle:
             handle.write(json.dumps(entry, ensure_ascii=False))
@@ -110,6 +197,7 @@ async def run_shell_and_print(
     assistant: RubberDuck,
     command: str,
     logger: ConversationLogger | None = None,
+    history: list[dict[str, str]] | None = None,
 ) -> None:
     if not command:
         console.print("No command provided.", style="yellow")
@@ -119,6 +207,18 @@ async def run_shell_and_print(
     print_shell_result(result)
     if logger:
         logger.log_shell(result)
+    if history is not None:
+        history.append({"role": "user", "content": f"!{command}"})
+        combined_output: list[str] = []
+        if result.stdout.strip():
+            combined_output.append(result.stdout.rstrip())
+        if result.stderr.strip():
+            combined_output.append(f"[stderr]\n{result.stderr.rstrip()}")
+        if result.returncode != 0:
+            combined_output.append(f"(exit status {result.returncode})")
+        if not combined_output:
+            combined_output.append("(command produced no output)")
+        history.append({"role": "assistant", "content": "\n\n".join(combined_output)})
 
 
 class RubberDuck:
@@ -142,16 +242,50 @@ class RubberDuck:
         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
 
@@ -160,7 +294,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 = (
@@ -241,6 +375,20 @@ class RubberDuck:
 
         return command or None
 
+    async def list_models(self) -> list[str]:
+        """List available Ollama models."""
+        try:
+            response = await self.client.list()
+            return [model.model for model in response.models]
+        except Exception as e:
+            console.print(f"Error listing models: {e}", style="red")
+            return []
+
+    def switch_model(self, model_name: str) -> None:
+        """Switch to a different Ollama model."""
+        self.model = model_name
+        console.print(f"Switched to model: {model_name}", style="green")
+
 
 class InlineInterface:
     def __init__(
@@ -255,7 +403,10 @@ class InlineInterface:
         self.last_command: str | None = None
         self.code = code
         self._code_sent = False
+        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
@@ -300,7 +451,7 @@ class InlineInterface:
             return
 
         console.print(
-            "Enter submits • Ctrl+J inserts newline • Ctrl+R reruns last command • '!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",
             style="dim",
         )
         while True:
@@ -326,21 +477,45 @@ class InlineInterface:
         if not self.last_command:
             console.print("No suggested command available yet.", style="yellow")
             return
-        await run_shell_and_print(self.assistant, self.last_command, logger=self.logger)
+        await run_shell_and_print(
+            self.assistant,
+            self.last_command,
+            logger=self.logger,
+            history=self.assistant.messages,
+        )
+        self.last_shell_output = True
+        self.pending_command = None
+        self.last_command = None
 
     async def _process_text(self, text: str) -> None:
         stripped = text.strip()
         if not stripped:
+            if self.pending_command:
+                await self._run_last_command()
+                return
+            if self.last_shell_output:
+                await self._explain_last_command()
+                return
+            console.print("Nothing to run yet.", style="yellow")
             return
 
         if stripped.lower() in {":run", "/run"}:
             await self._run_last_command()
             return
 
+        if stripped.lower() == "/model":
+            await self._select_model()
+            return
+
         if stripped.startswith("!"):
             await run_shell_and_print(
-                self.assistant, stripped[1:].strip(), logger=self.logger
+                self.assistant,
+                stripped[1:].strip(),
+                logger=self.logger,
+                history=self.assistant.messages,
             )
+            self.last_shell_output = True
+            self.pending_command = None
             return
 
         result = await run_single_prompt(
@@ -352,6 +527,70 @@ class InlineInterface:
         if self.code and not self._code_sent:
             self._code_sent = True
         self.last_command = result.command
+        self.pending_command = result.command
+        # 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:
+            console.print("No shell output to explain yet.", style="yellow")
+            return
+        last_entry = self.assistant.messages[-1]
+        if last_entry["role"] != "assistant":
+            console.print("No shell output to explain yet.", style="yellow")
+            return
+        prompt = (
+            "The user ran a shell command above. Summarize the key findings from the output, "
+            "highlight problems if any, and suggest next steps. Do NOT suggest a shell command or code snippet.\n\n"
+            f"{last_entry['content']}"
+        )
+        await run_single_prompt(
+            self.assistant, prompt, logger=self.logger, suppress_suggestion=True
+        )
+        self.last_shell_output = None
+
+    async def _select_model(self) -> 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
+
+        models = await self.assistant.list_models()
+        if not models:
+            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")
+        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}")
+
+        try:
+            choice = await asyncio.to_thread(input, "Enter model number or name: ")
+            choice = choice.strip()
+            
+            # 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)
+        except (ValueError, EOFError):
+            console.print("Invalid input.", style="red")
 
     async def _run_basic_loop(self) -> None:  # pragma: no cover - fallback path
         while True:
@@ -388,6 +627,7 @@ async def run_single_prompt(
     prompt: str,
     code: str | None = None,
     logger: ConversationLogger | None = None,
+    suppress_suggestion: bool = False,
 ) -> AssistantResult:
     if logger:
         logger.log_user(prompt)
@@ -396,7 +636,7 @@ async def run_single_prompt(
     console.print(content, style="green", highlight=False)
     if logger:
         logger.log_assistant(content, result.command)
-    if result.command:
+    if result.command and not suppress_suggestion:
         console.print("\nSuggested command:", style="cyan", highlight=False)
         console.print(result.command, style="bold cyan", highlight=False)
     return result
@@ -431,10 +671,20 @@ async def ducky() -> None:
     parser.add_argument(
         "--model", "-m", help="The model to be used", default="qwen3-coder:480b-cloud"
     )
+    parser.add_argument(
+        "--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)
+    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)
 
     code = read_files_from_dir(args.directory) if args.directory else None
@@ -455,7 +705,10 @@ async def ducky() -> None:
                 and confirm("Run suggested command?")
             ):
                 await run_shell_and_print(
-                    rubber_ducky, result.command, logger=logger
+                    rubber_ducky,
+                    result.command,
+                    logger=logger,
+                    history=rubber_ducky.messages,
                 )
         else:
             console.print("No input received from stdin.", style="yellow")

{rubber_ducky-1.2.0 → rubber_ducky-1.2.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "rubber-ducky"
-version = "1.2.0"
-description = "For developers who can never remember the right bash command"
+version = "1.2.2"
+description = "Quick CLI do-it-all tool. Use natural language to spit out bash commands"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [

{rubber_ducky-1.2.0 → rubber_ducky-1.2.2/rubber_ducky.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: rubber-ducky
-Version: 1.2.0
-Summary: For developers who can never remember the right bash command
+Version: 1.2.2
+Summary: Quick CLI do-it-all tool. Use natural language to spit out bash commands
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -43,7 +43,7 @@ Both `ducky` and `rubber-ducky` executables map to the same CLI, so `uvx rubber-
 ### Inline Session (default)
 
 Launching `ducky` with no arguments opens the inline interface:
-- **Enter** submits; **Ctrl+J** inserts a newline (helpful when crafting multi-line prompts).
+- **Enter** submits; **Ctrl+J** inserts a newline (helpful when crafting multi-line prompts). Hitting **Enter on an empty prompt** reruns the latest suggested command; if none exists yet, it explains the most recent shell output.
 - **Ctrl+R** re-runs the last suggested command.
 - Prefix any line with **`!`** (e.g., `!ls -la`) to run a shell command immediately.
 - Arrow keys browse prompt history, backed by `~/.ducky/prompt_history`.