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

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

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

{rubber_ducky-1.2.1 → 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]
@@ -48,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
@@ -82,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))
@@ -157,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
 
@@ -175,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 = (
@@ -256,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__(
@@ -273,6 +406,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
@@ -369,6 +503,10 @@ class InlineInterface:
             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,
@@ -390,7 +528,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 +549,49 @@ class InlineInterface:
         )
         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:
             try:
@@ -489,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

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

@@ -1,6 +1,6 @@
 [project]
 name = "rubber-ducky"
-version = "1.2.1"
+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"

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

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