rubber-ducky 1.1.5__py3-none-any.whl → 1.2.1__py3-none-any.whl

ducky/__init__.py

@@ -1 +1 @@
-from .ducky import ducky
+from .ducky import ducky

ducky/ducky.py

@@ -1,40 +1,429 @@
+from __future__ import annotations
+
 import argparse
 import asyncio
+import json
+import sys
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from textwrap import dedent
+from typing import Any, Dict, List
+
 from ollama import AsyncClient
+from contextlib import nullcontext
+
+try:  # prompt_toolkit is optional at runtime
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.history import FileHistory
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.patch_stdout import patch_stdout
+except ImportError:  # pragma: no cover - fallback mode
+    PromptSession = None  # type: ignore[assignment]
+    FileHistory = None  # type: ignore[assignment]
+    KeyBindings = None  # type: ignore[assignment]
+
+    def patch_stdout() -> nullcontext:
+        return nullcontext()
+
+
+from rich.console import Console
+
+
+@dataclass
+class AssistantResult:
+    content: str
+    command: str | None
+    thinking: str | None = None
+
+
+@dataclass
+class ShellResult:
+    command: str
+    stdout: str
+    stderr: str
+    returncode: int
+
+
+HISTORY_DIR = Path.home() / ".ducky"
+PROMPT_HISTORY_FILE = HISTORY_DIR / "prompt_history"
+CONVERSATION_LOG_FILE = HISTORY_DIR / "conversation.log"
+console = Console()
+
+
+def ensure_history_dir() -> Path:
+    HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+    return HISTORY_DIR
+
+
+class ConversationLogger:
+    def __init__(self, log_path: Path) -> None:
+        self.log_path = log_path
+
+    def log_user(self, content: str) -> None:
+        if content.strip():
+            self._append({"role": "user", "content": content})
+
+    def log_assistant(self, content: str, command: str | None) -> None:
+        entry: Dict[str, Any] = {"role": "assistant", "content": content}
+        if command:
+            entry["suggested_command"] = command
+        self._append(entry)
+
+    def log_shell(self, result: ShellResult) -> None:
+        self._append(
+            {
+                "role": "shell",
+                "command": result.command,
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "returncode": result.returncode,
+            }
+        )
+
+    def _append(self, entry: Dict[str, Any]) -> None:
+        entry["timestamp"] = datetime.utcnow().isoformat()
+        with self.log_path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(entry, ensure_ascii=False))
+            handle.write("\n")
+
+
+def print_shell_result(result: ShellResult) -> None:
+    printed = False
+    if result.stdout.strip():
+        console.print(result.stdout.rstrip(), highlight=False)
+        printed = True
+    if result.stderr.strip():
+        if printed:
+            console.print()
+        console.print("[stderr]", style="bold red")
+        console.print(result.stderr.rstrip(), style="red", highlight=False)
+        printed = True
+    if result.returncode != 0 or not printed:
+        suffix = (
+            f"(exit status {result.returncode})"
+            if result.returncode != 0
+            else "(command produced no output)"
+        )
+        console.print(suffix, style="yellow")
+
+
+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")
+        return
+    console.print(f"$ {command}", style="bold magenta")
+    result = await assistant.run_shell_command(command)
+    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:
-    def __init__(self, model: str, quick: bool = False) -> None:
-        self.system_prompt = """You are a pair progamming tool called Ducky or RubberDucky to help developers debug, think through design, and write code. 
-        Help the user think through their approach and provide feedback on the code. Think step by step and ask clarifying questions if needed.
-        If asked """
+    def __init__(
+        self, model: str, quick: bool = False, command_mode: bool = False
+    ) -> None:
+        self.system_prompt = dedent(
+            """
+            You are a pair programming tool called Ducky or RubberDucky to help
+            developers debug, think through design decisions, and write code.
+            Help the user reason about their approach and provide feedback on
+            the code. Think step by step and ask clarifying questions if
+            needed.
+
+            When the user provides git status output or similar multi-line terminal
+            output, provide a single comprehensive response that addresses all the
+            changes rather than responding to each line individually.
+            """
+        ).strip()
         self.client = AsyncClient()
         self.model = model
         self.quick = quick
+        self.command_mode = command_mode
+        self.messages: List[Dict[str, str]] = [
+            {"role": "system", "content": self.system_prompt}
+        ]
+        self.last_thinking: str | None = None
 
-    async def call_llm(self, prompt: str | None = None) -> None:
-        chain = False if prompt else True
+    async def send_prompt(
+        self, prompt: str | None = None, code: str | None = None
+    ) -> AssistantResult:
+        user_content = (prompt or "").strip()
 
-        if prompt is None:
-            prompt = input("\nEnter your prompt (or press Enter for default review): ")
+        if code:
+            user_content = f"{user_content}\n\n{code}" if user_content else code
 
-        if self.quick:
-            prompt += ". Return a command and be extremely concise"
+        if self.quick and user_content:
+            user_content += ". Return a command and be extremely concise"
 
-        responses = [self.system_prompt]
-        while True:
-            context_prompt = "\n".join(responses) + "\n" + prompt
-            stream = await self.client.generate(model=self.model, prompt=context_prompt, stream=True)
-            response_text = ""
-            async for chunk in stream:
-                if 'response' in chunk:
-                    print(chunk['response'], end='', flush=True)
-                    response_text += chunk['response']
-            print()
-            responses.append(response_text)
-            if not chain:
+        if self.command_mode:
+            instruction = (
+                "Return a single bash command that accomplishes the task. "
+                "Do not include explanations or formatting other than the command itself."
+            )
+            user_content = (
+                f"{user_content}\n\n{instruction}" if user_content else instruction
+            )
+
+        user_message: Dict[str, str] = {"role": "user", "content": user_content}
+        self.messages.append(user_message)
+
+        response = await self.client.chat(
+            model=self.model,
+            messages=self.messages,
+            stream=False,
+            think=True,
+        )
+
+        assistant_message: Any | None = response.message
+        if assistant_message is None:
+            raise RuntimeError("No response received from the model.")
+
+        content = getattr(assistant_message, "content", "") or ""
+        thinking = getattr(assistant_message, "thinking", None)
+
+        self.messages.append({"role": "assistant", "content": content})
+
+        if thinking:
+            self.last_thinking = thinking
+
+        command = self._extract_command(content) if self.command_mode else None
+
+        return AssistantResult(content=content, command=command, thinking=thinking)
+
+    async def run_shell_command(self, command: str) -> ShellResult:
+        process = await asyncio.create_subprocess_shell(
+            command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+        return ShellResult(
+            command=command,
+            stdout=stdout.decode(errors="replace"),
+            stderr=stderr.decode(errors="replace"),
+            returncode=process.returncode or 0,
+        )
+
+    def _extract_command(self, content: str) -> str | None:
+        lines = content.strip().splitlines()
+        if not lines:
+            return None
+
+        command_lines: List[str] = []
+
+        in_block = False
+        for line in lines:
+            stripped = line.strip()
+            if stripped.startswith("```"):
+                if in_block:
+                    break
+                in_block = True
+                continue
+            if in_block:
+                if stripped:
+                    command_lines = [stripped]
+                    break
+                continue
+            if stripped:
+                command_lines = [stripped]
                 break
-            prompt = input("\n>> ")
+
+        if not command_lines:
+            return None
+
+        command = command_lines[0]
+        first_semicolon = command.find(";")
+        if first_semicolon != -1:
+            command = command[:first_semicolon].strip()
+
+        return command or None
+
+
+class InlineInterface:
+    def __init__(
+        self,
+        assistant: RubberDuck,
+        logger: ConversationLogger | None = None,
+        code: str | None = None,
+    ) -> None:
+        ensure_history_dir()
+        self.assistant = assistant
+        self.logger = logger
+        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
+
+        if (
+            PromptSession is not None
+            and FileHistory is not None
+            and KeyBindings is not None
+        ):
+            self.session = PromptSession(
+                message=">> ",
+                multiline=True,
+                history=FileHistory(str(PROMPT_HISTORY_FILE)),
+                key_bindings=self._create_key_bindings(),
+            )
+
+    def _create_key_bindings(self) -> KeyBindings | None:
+        if KeyBindings is None:  # pragma: no cover - fallback mode
+            return None
+
+        kb = KeyBindings()
+
+        @kb.add("enter")
+        def _(event) -> None:
+            buffer = event.current_buffer
+            buffer.validate_and_handle()
+
+        @kb.add("c-j")
+        def _(event) -> None:
+            event.current_buffer.insert_text("\n")
+
+        @kb.add("c-r")
+        def _(event) -> None:
+            event.app.exit(result="__RUN_LAST__")
+
+        return kb
+
+    async def run(self) -> None:
+        if self.session is None:
+            console.print(
+                "prompt_toolkit not installed. Falling back to basic input (no history/shortcuts).",
+                style="yellow",
+            )
+            await self._run_basic_loop()
+            return
+
+        console.print(
+            "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:
+            try:
+                with patch_stdout():
+                    text = await self.session.prompt_async()
+            except EOFError:
+                console.print()
+                console.print("Exiting.", style="dim")
+                return
+            except KeyboardInterrupt:
+                console.print()
+                console.print("Interrupted. Press Ctrl+D to exit.", style="yellow")
+                continue
+
+            if text == "__RUN_LAST__":
+                await self._run_last_command()
+                continue
+
+            await self._process_text(text)
+
+    async def _run_last_command(self) -> None:
+        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,
+            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.startswith("!"):
+            await run_shell_and_print(
+                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(
+            self.assistant,
+            stripped,
+            code=self.code if not self._code_sent else None,
+            logger=self.logger,
+        )
+        if self.code and not self._code_sent:
+            self._code_sent = True
+        self.last_command = result.command
+        self.pending_command = result.command
+        self.last_shell_output = None
+
+    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 _run_basic_loop(self) -> None:  # pragma: no cover - fallback path
+        while True:
+            try:
+                text = await asyncio.to_thread(input, ">> ")
+            except EOFError:
+                console.print()
+                console.print("Exiting.", style="dim")
+                return
+            except KeyboardInterrupt:
+                console.print()
+                console.print("Interrupted. Press Ctrl+D to exit.", style="yellow")
+                continue
+
+            await self._process_text(text)
 
 
 def read_files_from_dir(directory: str) -> str:
@@ -43,51 +432,102 @@ def read_files_from_dir(directory: str) -> str:
     files = os.listdir(directory)
     code = ""
     for file in files:
-        code += open(directory + "/" + file).read()
+        full_path = f"{directory}/{file}"
+        if not os.path.isfile(full_path):
+            continue
+        with open(full_path, "r", encoding="utf-8", errors="ignore") as handle:
+            code += handle.read()
     return code
 
 
+async def run_single_prompt(
+    rubber_ducky: RubberDuck,
+    prompt: str,
+    code: str | None = None,
+    logger: ConversationLogger | None = None,
+    suppress_suggestion: bool = False,
+) -> AssistantResult:
+    if logger:
+        logger.log_user(prompt)
+    result = await rubber_ducky.send_prompt(prompt=prompt, code=code)
+    content = result.content or "(No content returned.)"
+    console.print(content, style="green", highlight=False)
+    if logger:
+        logger.log_assistant(content, 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
+
+
+def confirm(prompt: str, default: bool = False) -> bool:
+    suffix = " [Y/n]: " if default else " [y/N]: "
+    try:
+        choice = input(prompt + suffix)
+    except EOFError:
+        return default
+    choice = choice.strip().lower()
+    if not choice:
+        return default
+    return choice in {"y", "yes"}
+
+
+async def interactive_session(
+    rubber_ducky: RubberDuck,
+    logger: ConversationLogger | None = None,
+    code: str | None = None,
+) -> None:
+    ui = InlineInterface(rubber_ducky, logger=logger, code=code)
+    await ui.run()
+
+
 async def ducky() -> None:
     parser = argparse.ArgumentParser()
-    parser.add_argument("question", nargs="*", help="Direct question to ask", default=None)
-    parser.add_argument("--prompt", "-p", help="Custom prompt to be used", default=None)
-    parser.add_argument("--file", "-f", help="The file to be processed", default=None)
-    parser.add_argument("--directory", "-d", help="The directory to be processed", default=None)
-    parser.add_argument("--quick", "-q", help="Quick mode", default=False)
     parser.add_argument(
-        "--chain",
-        "-c",
-        help="Chain the output of the previous command to the next command",
-        action="store_true",
-        default=False,
+        "--directory", "-d", help="The directory to be processed", default=None
     )
     parser.add_argument(
-        "--model", "-m", help="The model to be used", default="qwen2.5-coder"
+        "--model", "-m", help="The model to be used", default="qwen3-coder:480b-cloud"
     )
     args, _ = parser.parse_known_args()
 
-    rubber_ducky = RubberDuck(model=args.model, quick=args.quick)
+    ensure_history_dir()
+    logger = ConversationLogger(CONVERSATION_LOG_FILE)
+    rubber_ducky = RubberDuck(model=args.model, quick=False, command_mode=True)
 
-    # Handle direct question from CLI
-    if args.question:
-        question = " ".join(args.question) 
-        await rubber_ducky.call_llm(prompt=question)
-        return
+    code = read_files_from_dir(args.directory) if args.directory else None
 
-    # Handle interactive mode (no file/directory specified)
-    if args.file is None and args.directory is None:
-        await rubber_ducky.call_llm(prompt=args.prompt)
-        return
+    piped_prompt: str | None = None
+    if not sys.stdin.isatty():
+        piped_prompt = sys.stdin.read()
+        piped_prompt = piped_prompt.strip() or None
 
-    # Get code from file or directory
-    code = (open(args.file).read() if args.file 
-            else read_files_from_dir(args.directory))
+    if piped_prompt is not None:
+        if piped_prompt:
+            result = await run_single_prompt(
+                rubber_ducky, piped_prompt, code=code, logger=logger
+            )
+            if (
+                result.command
+                and sys.stdout.isatty()
+                and confirm("Run suggested command?")
+            ):
+                await run_shell_and_print(
+                    rubber_ducky,
+                    result.command,
+                    logger=logger,
+                    history=rubber_ducky.messages,
+                )
+        else:
+            console.print("No input received from stdin.", style="yellow")
+        return
 
-    await rubber_ducky.call_llm(code=code, prompt=args.prompt)
+    await interactive_session(rubber_ducky, logger=logger, code=code)
 
 
-def main():
+def main() -> None:
     asyncio.run(ducky())
 
+
 if __name__ == "__main__":
     main()

rubber_ducky-1.2.1.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: rubber-ducky
+Version: 1.2.1
+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
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: fastapi>=0.115.11
+Requires-Dist: ollama>=0.6.0
+Requires-Dist: openai>=1.60.2
+Requires-Dist: prompt-toolkit>=3.0.48
+Requires-Dist: rich>=13.9.4
+Requires-Dist: termcolor>=2.5.0
+Dynamic: license-file
+
+# Rubber Ducky
+
+Rubber Ducky is an inline terminal companion that turns natural language prompts into runnable shell commands. Paste multi-line context, get a suggested command, and run it without leaving your terminal.
+
+## Quick Start
+
+| Action | Command |
+| --- | --- |
+| Install globally | `uv tool install rubber-ducky` |
+| Run once | `uvx rubber-ducky -- --help` |
+| Local install | `uv pip install rubber-ducky` |
+
+Requirements:
+- [Ollama](https://ollama.com) running locally
+- Model available via Ollama (default: `qwen3-coder:480b-cloud`, install with `ollama pull qwen3-coder:480b-cloud`)
+
+## Usage
+
+```
+ducky                 # interactive inline session
+ducky --directory src  # preload code from a directory
+ducky --model llama3   # use a different Ollama model
+```
+
+Both `ducky` and `rubber-ducky` executables map to the same CLI, so `uvx rubber-ducky -- <args>` works as well.
+
+### 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). 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`.
+- Every prompt, assistant response, and executed command is logged to `~/.ducky/conversation.log`.
+- Press **Ctrl+D** on an empty line to exit.
+- Non-interactive runs such as `cat prompt.txt | ducky` print one response (and suggested command) before exiting; if a TTY is available you'll be asked whether to run the suggested command immediately.
+- If `prompt_toolkit` is unavailable in your environment, Rubber Ducky falls back to a basic input loop (no history or shortcuts); install `prompt-toolkit>=3.0.48` to unlock the richer UI.
+
+`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).
+
+## Development (uv)
+
+```
+uv sync
+uv run ducky --help
+```
+
+`uv sync` creates a virtual environment and installs dependencies defined in `pyproject.toml` / `uv.lock`.
+
+## Telemetry & Storage
+
+Rubber Ducky stores:
+- `~/.ducky/prompt_history`: readline-compatible history file.
+- `~/.ducky/conversation.log`: JSON lines with timestamps for prompts, assistant messages, and shell executions.
+
+No other telemetry is collected; delete the directory if you want a fresh slate.

rubber_ducky-1.2.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+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,,

{rubber_ducky-1.1.5.dist-info → rubber_ducky-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{rubber_ducky-1.1.5.dist-info → rubber_ducky-1.2.1.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 ducky = ducky.ducky:main
+rubber-ducky = ducky.ducky:main

rubber_ducky-1.1.5.dist-info/METADATA

@@ -1,71 +0,0 @@
-Metadata-Version: 2.2
-Name: rubber-ducky
-Version: 1.1.5
-Summary: AI Companion for Pair Programming
-Home-page: https://github.com/ParthSareen/ducky
-Author: Parth Sareen
-Author-email: psareen@uwaterloo.ca
-License: MIT
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: ollama
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: summary
-
-# rubber ducky
-<p align="center">
-    <img src="ducky_img.webp" alt="Ducky Image" width="200" height="200">
-</p>
-
-## tl;dr
-- `pip install rubber-ducky`
-- Install ollama
-- `ollama pull codellama` (first time and then you can just have application in background)
-- There are probably other dependencies which I forgot to put in setup.py sorry in advance.
-- Run with `ducky <path>` or `ducky <question>`
-
-## Dependencies
-
-You will need Ollama installed on your machine. The model I use for this project is `codellama`. 
-
-For the first installation you can run `ollama pull codellama` and it should pull the necessary binaries for you.
-
-Ollama is also great because it'll spin up a server which can run in the background and can even do automatic model switching as long as you have it installed.
-
-## Usage
-
-Install through [pypi](https://pypi.org/project/rubber-ducky/):
-
-`pip install rubber-ducky` .
-
-### Simple run
-`ducky`
-
-or 
-
-`ducky <question>`
-
-or 
-
-`ducky -f <path>`
-
-
-### All options
-`ducky --file <path> --prompt <prompt> --directory <directory> --chain --model <model>`
-
-Where:
-- `--prompt` or `-p`: Custom prompt to be used
-- `--file` or `-f`: The file to be processed
-- `--directory` or `-d`: The directory to be processed
-- `--chain` or `-c`: Chain the output of the previous command to the next command
-- `--model` or `-m`: The model to be used (default is "codellama")
-
-
-## Example output
-![Screenshot of ducky](image.png)

rubber_ducky-1.1.5.dist-info/RECORD

@@ -1,8 +0,0 @@
-ducky/__init__.py,sha256=_7imP8Jc2SIapn4fzGkspmKvqxPTFDcDJWHZ_o_MnlE,24
-ducky/ducky.py,sha256=4F0vB-HWa96OKlLyKxB2NY4a0GmGTxThqnjlQLsRWgE,3245
-rubber_ducky-1.1.5.dist-info/LICENSE,sha256=gQ1rCmw18NqTk5GxG96F6vgyN70e1c4kcKUtWDwdNaE,1069
-rubber_ducky-1.1.5.dist-info/METADATA,sha256=fe4_S5vJE_XJUzto38xDfg2fGbQJYXQ3M4OBBZY0z4g,1905
-rubber_ducky-1.1.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-rubber_ducky-1.1.5.dist-info/entry_points.txt,sha256=LPndtj8UqEWtwYApv5LJJniH4FUrsriOqV2LA1X_UPQ,43
-rubber_ducky-1.1.5.dist-info/top_level.txt,sha256=4Q75MONDNPpQ3o17bTu7RFuKwFhTIRzlXP3_LDWQQ30,6
-rubber_ducky-1.1.5.dist-info/RECORD,,