code-puppy 0.0.53__py3-none-any.whl → 0.0.55__py3-none-any.whl

code_puppy/command_line/prompt_toolkit_completion.py

@@ -1,6 +1,7 @@
 import os
 from code_puppy.command_line.utils import list_directory
-from code_puppy.config import get_puppy_name, get_owner_name, get_config_keys, get_value
+from code_puppy.config import get_puppy_name, get_config_keys, get_value
+
 # ANSI color codes are no longer necessary because prompt_toolkit handles
 # styling via the `Style` class. We keep them here commented-out in case
 # someone needs raw ANSI later, but they are unused in the current code.
@@ -12,6 +13,7 @@ from code_puppy.config import get_puppy_name, get_owner_name, get_config_keys, g
 import asyncio
 from typing import Optional
 from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.completion import merge_completers
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.styles import Style
@@ -27,107 +29,143 @@ from code_puppy.command_line.file_path_completion import FilePathCompleter
 
 from prompt_toolkit.completion import Completer, Completion
 
+
 class SetCompleter(Completer):
-    def __init__(self, trigger: str = '~set'):
+    def __init__(self, trigger: str = "~set"):
         self.trigger = trigger
+
     def get_completions(self, document, complete_event):
         text = document.text_before_cursor
         if not text.strip().startswith(self.trigger):
             return
         # If the only thing typed is exactly '~set', suggest space
         if text.strip() == self.trigger:
-            yield Completion(self.trigger + ' ', start_position=-len(self.trigger), display=f'{self.trigger} ', display_meta='set config')
+            yield Completion(
+                self.trigger + " ",
+                start_position=-len(self.trigger),
+                display=f"{self.trigger} ",
+                display_meta="set config",
+            )
         tokens = text.strip().split()
         # completion for the first arg after ~set
         if len(tokens) == 1:
             # user just typed ~set <-- suggest config keys
-            base = ''
+            base = ""
         else:
             base = tokens[1]
         # --- SPECIAL HANDLING FOR 'model' KEY ---
-        if base == 'model':
+        if base == "model":
             # Don't return any completions -- let ModelNameCompleter handle it
             return
         for key in get_config_keys():
-            if key == 'model':
+            if key == "model":
                 continue  # exclude 'model' from regular ~set completions
             if key.startswith(base):
                 prev_value = get_value(key)
                 # Ensure there's a space after '~set' if it's the only thing typed
-                if text.strip() == self.trigger or text.strip() == self.trigger + '':
-                    prefix = self.trigger + ' '  # Always enforce a space
-                    insert_text = f'{prefix}{key} = {prev_value}' if prev_value is not None else f'{prefix}{key} = '
+                if text.strip() == self.trigger or text.strip() == self.trigger + "":
+                    prefix = self.trigger + " "  # Always enforce a space
+                    insert_text = (
+                        f"{prefix}{key} = {prev_value}"
+                        if prev_value is not None
+                        else f"{prefix}{key} = "
+                    )
                     sp = -len(text)
                 else:
-                    insert_text = f'{key} = {prev_value}' if prev_value is not None else f'{key} = '
+                    insert_text = (
+                        f"{key} = {prev_value}"
+                        if prev_value is not None
+                        else f"{key} = "
+                    )
                     sp = -len(base)
                 # Make it obvious the value part is from before
-                yield Completion(insert_text, start_position=sp, display_meta=f'puppy.cfg key (was: {prev_value})' if prev_value is not None else 'puppy.cfg key')
+                yield Completion(
+                    insert_text,
+                    start_position=sp,
+                    display_meta=f"puppy.cfg key (was: {prev_value})"
+                    if prev_value is not None
+                    else "puppy.cfg key",
+                )
+
 
 class CDCompleter(Completer):
-    def __init__(self, trigger: str = '~cd'):
+    def __init__(self, trigger: str = "~cd"):
         self.trigger = trigger
+
     def get_completions(self, document, complete_event):
         text = document.text_before_cursor
         if not text.strip().startswith(self.trigger):
             return
         tokens = text.strip().split()
         if len(tokens) == 1:
-            base = ''
+            base = ""
         else:
             base = tokens[1]
         try:
             prefix = os.path.expanduser(base)
-            part = os.path.dirname(prefix) if os.path.dirname(prefix) else '.'
+            part = os.path.dirname(prefix) if os.path.dirname(prefix) else "."
             dirs, _ = list_directory(part)
             dirnames = [d for d in dirs if d.startswith(os.path.basename(base))]
             base_dir = os.path.dirname(base)
             for d in dirnames:
                 # Build the completion text so we keep the already-typed directory parts.
-                if base_dir and base_dir != '.':
+                if base_dir and base_dir != ".":
                     suggestion = os.path.join(base_dir, d)
                 else:
                     suggestion = d
                 # Append trailing slash so the user can continue tabbing into sub-dirs.
                 suggestion = suggestion.rstrip(os.sep) + os.sep
-                yield Completion(suggestion, start_position=-len(base), display=d + os.sep, display_meta='Directory')
+                yield Completion(
+                    suggestion,
+                    start_position=-len(base),
+                    display=d + os.sep,
+                    display_meta="Directory",
+                )
         except Exception:
             # Silently ignore errors (e.g., permission issues, non-existent dir)
             pass
 
-from prompt_toolkit.formatted_text import FormattedText
-def get_prompt_with_active_model(base: str = '>>> '):
+
+def get_prompt_with_active_model(base: str = ">>> "):
     puppy = get_puppy_name()
-    owner = get_owner_name()
-    model = get_active_model() or '(default)'
+    model = get_active_model() or "(default)"
     cwd = os.getcwd()
-    home = os.path.expanduser('~')
+    home = os.path.expanduser("~")
     if cwd.startswith(home):
-        cwd_display = '~' + cwd[len(home):]
+        cwd_display = "~" + cwd[len(home) :]
     else:
         cwd_display = cwd
-    return FormattedText([
-        ('bold', '🐶 '),
-        ('class:puppy', f'{puppy}'),
-        ('', ' '),
-        ('class:model', f'[' + str(model) + '] '),
-        ('class:cwd', f'(' + str(cwd_display) + ') '),
-        ('class:arrow', str(base)),
-    ])
-
-async def get_input_with_combined_completion(prompt_str = '>>> ', history_file: Optional[str] = None) -> str:
+    return FormattedText(
+        [
+            ("bold", "🐶 "),
+            ("class:puppy", f"{puppy}"),
+            ("", " "),
+            ("class:model", "[" + str(model) + "] "),
+            ("class:cwd", "(" + str(cwd_display) + ") "),
+            ("class:arrow", str(base)),
+        ]
+    )
+
+
+async def get_input_with_combined_completion(
+    prompt_str=">>> ", history_file: Optional[str] = None
+) -> str:
     history = FileHistory(history_file) if history_file else None
-    completer = merge_completers([
-        FilePathCompleter(symbol='@'),
-        ModelNameCompleter(trigger='~m'),
-        CDCompleter(trigger='~cd'),
-        SetCompleter(trigger='~set'),
-    ])
+    completer = merge_completers(
+        [
+            FilePathCompleter(symbol="@"),
+            ModelNameCompleter(trigger="~m"),
+            CDCompleter(trigger="~cd"),
+            SetCompleter(trigger="~set"),
+        ]
+    )
     # Add custom key bindings for Alt+M to insert a new line without submitting
     bindings = KeyBindings()
-    @bindings.add(Keys.Escape, 'm')  # Alt+M
+
+    @bindings.add(Keys.Escape, "m")  # Alt+M
     def _(event):
-        event.app.current_buffer.insert_text('\n')
+        event.app.current_buffer.insert_text("\n")
+
     @bindings.add(Keys.Escape)
     def _(event):
         """Cancel the current prompt when the user presses the ESC key alone."""
@@ -137,35 +175,40 @@ async def get_input_with_combined_completion(prompt_str = '>>> ', history_file:
         completer=completer,
         history=history,
         complete_while_typing=True,
-        key_bindings=bindings
+        key_bindings=bindings,
     )
     # If they pass a string, backward-compat: convert it to formatted_text
     if isinstance(prompt_str, str):
         from prompt_toolkit.formatted_text import FormattedText
+
         prompt_str = FormattedText([(None, prompt_str)])
-    style = Style.from_dict({
-        # Keys must AVOID the 'class:' prefix – that prefix is used only when
-        # tagging tokens in `FormattedText`. See prompt_toolkit docs.
-        'puppy': 'bold magenta',
-        'owner': 'bold white',
-        'model': 'bold cyan',
-        'cwd': 'bold green',
-        'arrow': 'bold yellow',
-    })
+    style = Style.from_dict(
+        {
+            # Keys must AVOID the 'class:' prefix – that prefix is used only when
+            # tagging tokens in `FormattedText`. See prompt_toolkit docs.
+            "puppy": "bold magenta",
+            "owner": "bold white",
+            "model": "bold cyan",
+            "cwd": "bold green",
+            "arrow": "bold yellow",
+        }
+    )
     text = await session.prompt_async(prompt_str, style=style)
     possibly_stripped = update_model_in_input(text)
     if possibly_stripped is not None:
         return possibly_stripped
     return text
 
+
 if __name__ == "__main__":
     print("Type '@' for path-completion or '~m' to pick a model. Ctrl+D to exit.")
+
     async def main():
         while True:
             try:
                 inp = await get_input_with_combined_completion(
                     get_prompt_with_active_model(),
-                    history_file="~/.path_completion_history.txt"
+                    history_file="~/.path_completion_history.txt",
                 )
                 print(f"You entered: {inp}")
             except KeyboardInterrupt:
@@ -173,4 +216,5 @@ if __name__ == "__main__":
             except EOFError:
                 break
         print("\nGoodbye!")
+
     asyncio.run(main())

code_puppy/command_line/utils.py

@@ -13,7 +13,7 @@ def list_directory(path: str = None) -> Tuple[List[str], List[str]]:
     try:
         entries = [e for e in os.listdir(path)]
     except Exception as e:
-        raise RuntimeError(f'Error listing directory: {e}')
+        raise RuntimeError(f"Error listing directory: {e}")
     dirs = [e for e in entries if os.path.isdir(os.path.join(path, e))]
     files = [e for e in entries if not os.path.isdir(os.path.join(path, e))]
     return dirs, files
@@ -26,11 +26,13 @@ def make_directory_table(path: str = None) -> Table:
     if path is None:
         path = os.getcwd()
     dirs, files = list_directory(path)
-    table = Table(title=f"\U0001F4C1 [bold blue]Current directory:[/bold blue] [cyan]{path}[/cyan]")
-    table.add_column('Type', style='dim', width=8)
-    table.add_column('Name', style='bold')
+    table = Table(
+        title=f"\U0001f4c1 [bold blue]Current directory:[/bold blue] [cyan]{path}[/cyan]"
+    )
+    table.add_column("Type", style="dim", width=8)
+    table.add_column("Name", style="bold")
     for d in sorted(dirs):
-        table.add_row('[green]dir[/green]', f'[cyan]{d}[/cyan]')
+        table.add_row("[green]dir[/green]", f"[cyan]{d}[/cyan]")
     for f in sorted(files):
-        table.add_row('[yellow]file[/yellow]', f'{f}')
+        table.add_row("[yellow]file[/yellow]", f"{f}")
     return table

code_puppy/config.py

@@ -7,6 +7,7 @@ CONFIG_FILE = os.path.join(CONFIG_DIR, "puppy.cfg")
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
+
 def ensure_config_exists():
     """
     Ensure that the .code_puppy dir and puppy.cfg exist, prompting if needed.
@@ -30,7 +31,9 @@ def ensure_config_exists():
             if key == "puppy_name":
                 val = input("What should we name the puppy? ").strip()
             elif key == "owner_name":
-                val = input("What's your name (so Code Puppy knows its master)? ").strip()
+                val = input(
+                    "What's your name (so Code Puppy knows its master)? "
+                ).strip()
             else:
                 val = input(f"Enter {key}: ").strip()
             config[DEFAULT_SECTION][key] = val
@@ -38,48 +41,55 @@ def ensure_config_exists():
             config.write(f)
     return config
 
+
 def get_value(key: str):
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     val = config.get(DEFAULT_SECTION, key, fallback=None)
     return val
 
+
 def get_puppy_name():
     return get_value("puppy_name") or "Puppy"
 
+
 def get_owner_name():
     return get_value("owner_name") or "Master"
 
+
 # --- CONFIG SETTER STARTS HERE ---
 def get_config_keys():
-    '''
+    """
     Returns the list of all config keys currently in puppy.cfg,
     plus certain preset expected keys (e.g. "yolo_mode", "model").
-    '''
-    default_keys = ['yolo_mode', 'model']
+    """
+    default_keys = ["yolo_mode", "model"]
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     keys = set(config[DEFAULT_SECTION].keys()) if DEFAULT_SECTION in config else set()
     keys.update(default_keys)
     return sorted(keys)
 
+
 def set_config_value(key: str, value: str):
-    '''
+    """
     Sets a config value in the persistent config file.
-    '''
+    """
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     if DEFAULT_SECTION not in config:
         config[DEFAULT_SECTION] = {}
     config[DEFAULT_SECTION][key] = value
-    with open(CONFIG_FILE, 'w') as f:
+    with open(CONFIG_FILE, "w") as f:
         config.write(f)
 
+
 # --- MODEL STICKY EXTENSION STARTS HERE ---
 def get_model_name():
     """Returns the last used model name stored in config, or None if unset."""
     return get_value("model") or "gpt-4.1"
 
+
 def set_model_name(model: str):
     """Sets the model name in the persistent config file."""
     config = configparser.ConfigParser()
@@ -90,6 +100,7 @@ def set_model_name(model: str):
     with open(CONFIG_FILE, "w") as f:
         config.write(f)
 
+
 def get_yolo_mode():
     """
     Checks puppy.cfg for 'yolo_mode' (case-insensitive in value only).
@@ -99,16 +110,16 @@ def get_yolo_mode():
     Allowed values for ON: 1, '1', 'true', 'yes', 'on' (all case-insensitive for value).
     Always prioritizes the config once set!
     """
-    true_vals = {'1', 'true', 'yes', 'on'}
-    cfg_val = get_value('yolo_mode')
+    true_vals = {"1", "true", "yes", "on"}
+    cfg_val = get_value("yolo_mode")
     if cfg_val is not None:
         if str(cfg_val).strip().lower() in true_vals:
             return True
         return False
-    env_val = os.getenv('YOLO_MODE')
+    env_val = os.getenv("YOLO_MODE")
     if env_val is not None:
         # Persist the env value now
-        set_config_value('yolo_mode', env_val)
+        set_config_value("yolo_mode", env_val)
         if str(env_val).strip().lower() in true_vals:
             return True
         return False

code_puppy/main.py

@@ -14,14 +14,14 @@ from rich.text import Text
 from rich.syntax import Syntax
 from code_puppy.command_line.prompt_toolkit_completion import (
     get_input_with_combined_completion,
-    get_prompt_with_active_model
+    get_prompt_with_active_model,
 )
 
 # Initialize rich console for pretty output
 from code_puppy.tools.common import console
 from code_puppy.agent import get_code_generation_agent, session_memory
 
-from code_puppy.tools import *
+# from code_puppy.tools import *  # noqa: F403
 
 
 # Define a function to get the secret file path
@@ -36,12 +36,14 @@ async def main():
     # Ensure the config directory and puppy.cfg with name info exist (prompt user if needed)
     ensure_config_exists()
     current_version = __version__
-    latest_version = fetch_latest_version('code-puppy')
-    console.print(f'Current version: {current_version}')
-    console.print(f'Latest version: {latest_version}')
+    latest_version = fetch_latest_version("code-puppy")
+    console.print(f"Current version: {current_version}")
+    console.print(f"Latest version: {latest_version}")
     if latest_version and latest_version != current_version:
-        console.print(f'[bold yellow]A new version of code puppy is available: {latest_version}[/bold yellow]')
-        console.print('[bold green]Please consider updating![/bold green]')
+        console.print(
+            f"[bold yellow]A new version of code puppy is available: {latest_version}[/bold yellow]"
+        )
+        console.print("[bold green]Please consider updating![/bold green]")
     global shutdown_flag
     shutdown_flag = False  # ensure this is initialized
 
@@ -69,11 +71,11 @@ async def main():
                 console.print(agent_response.output_message)
                 # Log to session memory
                 session_memory().log_task(
-                    f'Command executed: {command}',
-                    extras={ 
-                        'output': agent_response.output_message,
-                        'awaiting_user_input': agent_response.awaiting_user_input
-                    }
+                    f"Command executed: {command}",
+                    extras={
+                        "output": agent_response.output_message,
+                        "awaiting_user_input": agent_response.awaiting_user_input,
+                    },
                 )
                 if agent_response.awaiting_user_input:
                     console.print(
@@ -96,19 +98,23 @@ async def main():
 # Add the file handling functionality for interactive mode
 async def interactive_mode(history_file_path: str) -> None:
     from code_puppy.command_line.meta_command_handler import handle_meta_command
+
     """Run the agent in interactive mode."""
     console.print("[bold green]Code Puppy[/bold green] - Interactive Mode")
     console.print("Type 'exit' or 'quit' to exit the interactive mode.")
     console.print("Type 'clear' to reset the conversation history.")
-    console.print("Type [bold blue]@[/bold blue] for path completion, or [bold blue]~m[/bold blue] to pick a model.")
+    console.print(
+        "Type [bold blue]@[/bold blue] for path completion, or [bold blue]~m[/bold blue] to pick a model."
+    )
 
     # Show meta commands right at startup - DRY!
     from code_puppy.command_line.meta_command_handler import META_COMMANDS_HELP
+
     console.print(META_COMMANDS_HELP)
 
     # Check if prompt_toolkit is installed
     try:
-        import prompt_toolkit
+        import prompt_toolkit  # noqa: F401
 
         console.print("[dim]Using prompt_toolkit for enhanced tab completion[/dim]")
     except ImportError:
@@ -152,7 +158,7 @@ async def interactive_mode(history_file_path: str) -> None:
                 # Use the async version of get_input_with_combined_completion
                 task = await get_input_with_combined_completion(
                     get_prompt_with_active_model(),
-                    history_file=history_file_path_prompt
+                    history_file=history_file_path_prompt,
                 )
             except ImportError:
                 # Fall back to basic input if prompt_toolkit is not available
@@ -178,7 +184,7 @@ async def interactive_mode(history_file_path: str) -> None:
             continue
 
         # Handle ~ meta/config commands before anything else
-        if task.strip().startswith('~'):
+        if task.strip().startswith("~"):
             if handle_meta_command(task.strip(), console):
                 continue
         if task.strip():
@@ -203,17 +209,21 @@ async def interactive_mode(history_file_path: str) -> None:
                 console.print(agent_response.output_message)
                 # Log to session memory
                 session_memory().log_task(
-                    f'Interactive task: {task}',
-                    extras={ 
-                        'output': agent_response.output_message,
-                        'awaiting_user_input': agent_response.awaiting_user_input
-                    }
+                    f"Interactive task: {task}",
+                    extras={
+                        "output": agent_response.output_message,
+                        "awaiting_user_input": agent_response.awaiting_user_input,
+                    },
                 )
 
                 # Update message history but apply filters & limits
                 new_msgs = result.new_messages()
                 # 1. Drop any system/config messages (e.g., "agent loaded with model")
-                filtered = [m for m in new_msgs if not (isinstance(m, dict) and m.get("role") == "system")]
+                filtered = [
+                    m
+                    for m in new_msgs
+                    if not (isinstance(m, dict) and m.get("role") == "system")
+                ]
                 # 2. Append to existing history and keep only the most recent 40
                 message_history.extend(filtered)
                 if len(message_history) > 40:

code_puppy/model_factory.py

@@ -10,7 +10,7 @@ from pydantic_ai.providers.google_gla import GoogleGLAProvider
 from pydantic_ai.providers.openai import OpenAIProvider
 from pydantic_ai.providers.anthropic import AnthropicProvider
 from anthropic import AsyncAnthropic
-from openai import AsyncAzureOpenAI # For Azure OpenAI client
+from openai import AsyncAzureOpenAI  # For Azure OpenAI client
 import httpx
 from httpx import Response
 import threading
@@ -121,9 +121,7 @@ def make_client(
 def get_custom_config(model_config):
     custom_config = model_config.get("custom_endpoint", {})
     if not custom_config:
-        raise ValueError(
-            "Custom model requires 'custom_endpoint' configuration"
-        )
+        raise ValueError("Custom model requires 'custom_endpoint' configuration")
 
     url = custom_config.get("url")
     if not url:
@@ -192,7 +190,9 @@ class ModelFactory:
         elif model_type == "anthropic":
             api_key = os.environ.get("ANTHROPIC_API_KEY", None)
             if not api_key:
-                raise ValueError('ANTHROPIC_API_KEY environment variable must be set for Anthropic models.')
+                raise ValueError(
+                    "ANTHROPIC_API_KEY environment variable must be set for Anthropic models."
+                )
             anthropic_client = AsyncAnthropic(api_key=api_key)
             provider = AnthropicProvider(anthropic_client=anthropic_client)
             return AnthropicModel(model_name=model_config["name"], provider=provider)
@@ -234,7 +234,7 @@ class ModelFactory:
                 raise ValueError(
                     f"Azure OpenAI API version environment variable '{api_version_config[1:] if api_version_config.startswith('$') else ''}' not found or is empty."
                 )
-            
+
             api_key_config = model_config.get("api_key")
             if not api_key_config:
                 raise ValueError(
@@ -255,7 +255,7 @@ class ModelFactory:
                 azure_endpoint=azure_endpoint,
                 api_version=api_version,
                 api_key=api_key,
-                max_retries=azure_max_retries
+                max_retries=azure_max_retries,
             )
             provider = OpenAIProvider(openai_client=azure_client)
             return OpenAIModel(model_name=model_config["name"], provider=provider)