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

rubber_ducky-1.2.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: rubber-ducky
+Version: 1.2.0
+Summary: For developers who can never remember the right bash command
+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).
+- **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.0/README.md

@@ -0,0 +1,56 @@
+# 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).
+- **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.0/ducky/__init__.py

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

rubber_ducky-1.2.0/ducky/ducky.py

@@ -0,0 +1,472 @@
+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,
+) -> 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)
+
+
+class RubberDuck:
+    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 send_prompt(
+        self, prompt: str | None = None, code: str | None = None
+    ) -> AssistantResult:
+        user_content = (prompt or "").strip()
+
+        if code:
+            user_content = f"{user_content}\n\n{code}" if user_content else code
+
+        if self.quick and user_content:
+            user_content += ". Return a command and be extremely concise"
+
+        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
+
+        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.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 • Ctrl+J inserts newline • Ctrl+R reruns last command • '!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)
+
+    async def _process_text(self, text: str) -> None:
+        stripped = text.strip()
+        if not stripped:
+            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
+            )
+            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
+
+    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:
+    import os
+
+    files = os.listdir(directory)
+    code = ""
+    for file in files:
+        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,
+) -> 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:
+        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(
+        "--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"
+    )
+    args, _ = parser.parse_known_args()
+
+    ensure_history_dir()
+    logger = ConversationLogger(CONVERSATION_LOG_FILE)
+    rubber_ducky = RubberDuck(model=args.model, quick=False, command_mode=True)
+
+    code = read_files_from_dir(args.directory) if args.directory else None
+
+    piped_prompt: str | None = None
+    if not sys.stdin.isatty():
+        piped_prompt = sys.stdin.read()
+        piped_prompt = piped_prompt.strip() or None
+
+    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
+                )
+        else:
+            console.print("No input received from stdin.", style="yellow")
+        return
+
+    await interactive_session(rubber_ducky, logger=logger, code=code)
+
+
+def main() -> None:
+    asyncio.run(ducky())
+
+
+if __name__ == "__main__":
+    main()

rubber_ducky-1.2.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "rubber-ducky"
+version = "1.2.0"
+description = "For developers who can never remember the right bash command"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "colorama>=0.4.6",
+    "fastapi>=0.115.11",
+    "ollama>=0.6.0",
+    "openai>=1.60.2",
+    "prompt-toolkit>=3.0.48",
+    "rich>=13.9.4",
+    "termcolor>=2.5.0",
+]
+
+[project.scripts]
+ducky = "ducky.ducky:main"
+rubber-ducky = "ducky.ducky:main"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.uv]
+dev-dependencies = [
+    "ruff>=0.9.4",
+]

rubber_ducky-1.2.0/rubber_ducky.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: rubber-ducky
+Version: 1.2.0
+Summary: For developers who can never remember the right bash command
+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).
+- **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.1.5 → rubber_ducky-1.2.0}/rubber_ducky.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 LICENSE
 README.md
-setup.py
+pyproject.toml
 ducky/__init__.py
 ducky/ducky.py
 rubber_ducky.egg-info/PKG-INFO

{rubber_ducky-1.1.5 → rubber_ducky-1.2.0}/rubber_ducky.egg-info/entry_points.txt

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

rubber_ducky-1.2.0/rubber_ducky.egg-info/requires.txt

@@ -0,0 +1,7 @@
+colorama>=0.4.6
+fastapi>=0.115.11
+ollama>=0.6.0
+openai>=1.60.2
+prompt-toolkit>=3.0.48
+rich>=13.9.4
+termcolor>=2.5.0

rubber_ducky-1.1.5/PKG-INFO

@@ -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/README.md

@@ -1,51 +0,0 @@
-# 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/ducky/__init__.py

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

rubber_ducky-1.1.5/ducky/ducky.py

@@ -1,93 +0,0 @@
-import argparse
-import asyncio
-from ollama import AsyncClient
-
-
-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 """
-        self.client = AsyncClient()
-        self.model = model
-        self.quick = quick
-
-    async def call_llm(self, prompt: str | None = None) -> None:
-        chain = False if prompt else True
-
-        if prompt is None:
-            prompt = input("\nEnter your prompt (or press Enter for default review): ")
-
-        if self.quick:
-            prompt += ". 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:
-                break
-            prompt = input("\n>> ")
-
-
-def read_files_from_dir(directory: str) -> str:
-    import os
-
-    files = os.listdir(directory)
-    code = ""
-    for file in files:
-        code += open(directory + "/" + file).read()
-    return code
-
-
-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,
-    )
-    parser.add_argument(
-        "--model", "-m", help="The model to be used", default="qwen2.5-coder"
-    )
-    args, _ = parser.parse_known_args()
-
-    rubber_ducky = RubberDuck(model=args.model, quick=args.quick)
-
-    # Handle direct question from CLI
-    if args.question:
-        question = " ".join(args.question) 
-        await rubber_ducky.call_llm(prompt=question)
-        return
-
-    # 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
-
-    # Get code from file or directory
-    code = (open(args.file).read() if args.file 
-            else read_files_from_dir(args.directory))
-
-    await rubber_ducky.call_llm(code=code, prompt=args.prompt)
-
-
-def main():
-    asyncio.run(ducky())
-
-if __name__ == "__main__":
-    main()

rubber_ducky-1.1.5/rubber_ducky.egg-info/PKG-INFO

@@ -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/rubber_ducky.egg-info/requires.txt

@@ -1 +0,0 @@
-ollama

rubber_ducky-1.1.5/setup.py

@@ -1,25 +0,0 @@
-from setuptools import setup, find_packages
-
-with open('README.md', 'r', encoding='utf-8') as f:
-    long_description = f.read()
-
-setup(
-    name='rubber-ducky',
-    version='1.1.5',
-    description='AI Companion for Pair Programming',
-    long_description=long_description,
-    long_description_content_type='text/markdown',
-    url='https://github.com/ParthSareen/ducky',
-    author='Parth Sareen',
-    author_email='psareen@uwaterloo.ca',
-    license='MIT',
-    packages=find_packages(),
-    install_requires=[
-        'ollama',
-    ],
-    entry_points={
-        'console_scripts': [
-            'ducky=ducky.ducky:main',
-        ],
-    },
-)