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

code_puppy/__init__.py

@@ -1,2 +1,3 @@
 import importlib.metadata
+
 __version__ = importlib.metadata.version("code-puppy")

code_puppy/agent.py

@@ -18,14 +18,16 @@ from code_puppy.session_memory import SessionMemory
 MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
 
 # Load puppy rules if provided
-PUPPY_RULES_PATH = Path('.puppy_rules')
+PUPPY_RULES_PATH = Path(".puppy_rules")
 PUPPY_RULES = None
 if PUPPY_RULES_PATH.exists():
-    with open(PUPPY_RULES_PATH, 'r') as f:
+    with open(PUPPY_RULES_PATH, "r") as f:
         PUPPY_RULES = f.read()
 
+
 class AgentResponse(pydantic.BaseModel):
     """Represents a response from the agent."""
+
     output_message: str = pydantic.Field(
         ..., description="The final output message to display to the user"
     )
@@ -33,31 +35,39 @@ class AgentResponse(pydantic.BaseModel):
         False, description="True if user input is needed to continue the task"
     )
 
+
 # --- NEW DYNAMIC AGENT LOGIC ---
 _LAST_MODEL_NAME = None
 _code_generation_agent = None
 _session_memory = None
 
+
 def session_memory():
-    '''
+    """
     Returns a singleton SessionMemory instance to allow agent and tools to persist and recall context/history.
-    '''
+    """
     global _session_memory
     if _session_memory is None:
         _session_memory = SessionMemory()
     return _session_memory
 
+
 def reload_code_generation_agent():
     """Force-reload the agent, usually after a model change."""
     global _code_generation_agent, _LAST_MODEL_NAME
     from code_puppy.config import get_model_name
+
     model_name = get_model_name()
-    console.print(f'[bold cyan]Loading Model: {model_name}[/bold cyan]')
-    models_path = Path(MODELS_JSON_PATH) if MODELS_JSON_PATH else Path(__file__).parent / "models.json"
+    console.print(f"[bold cyan]Loading Model: {model_name}[/bold cyan]")
+    models_path = (
+        Path(MODELS_JSON_PATH)
+        if MODELS_JSON_PATH
+        else Path(__file__).parent / "models.json"
+    )
     model = ModelFactory.get_model(model_name, ModelFactory.load_config(models_path))
     instructions = get_system_prompt()
     if PUPPY_RULES:
-        instructions += f'\n{PUPPY_RULES}'
+        instructions += f"\n{PUPPY_RULES}"
     agent = Agent(
         model=model,
         instructions=instructions,
@@ -69,11 +79,12 @@ def reload_code_generation_agent():
     _LAST_MODEL_NAME = model_name
     # NEW: Log session event
     try:
-        session_memory().log_task(f'Agent loaded with model: {model_name}')
+        session_memory().log_task(f"Agent loaded with model: {model_name}")
     except Exception:
         pass
     return _code_generation_agent
 
+
 def get_code_generation_agent(force_reload=False):
     """
     Retrieve the agent with the currently set MODEL_NAME.
@@ -81,6 +92,7 @@ def get_code_generation_agent(force_reload=False):
     """
     global _code_generation_agent, _LAST_MODEL_NAME
     from code_puppy.config import get_model_name
+
     model_name = get_model_name()
     if _code_generation_agent is None or _LAST_MODEL_NAME != model_name or force_reload:
         return reload_code_generation_agent()

code_puppy/agent_prompts.py

@@ -106,10 +106,9 @@ Return your final response as a structured output having the following fields:
  * awaiting_user_input: True if user input is needed to continue the task. If you get an error, you might consider asking the user for help.
 """
 
+
 def get_system_prompt():
     """Returns the main system prompt, populated with current puppy and owner name."""
     return SYSTEM_PROMPT_TEMPLATE.format(
-        puppy_name=get_puppy_name(),
-        owner_name=get_owner_name()
+        puppy_name=get_puppy_name(), owner_name=get_owner_name()
     )
-

code_puppy/command_line/file_path_completion.py

@@ -4,18 +4,23 @@ from typing import Iterable
 from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.document import Document
 
+
 class FilePathCompleter(Completer):
     """A simple file path completer that works with a trigger symbol."""
+
     def __init__(self, symbol: str = "@"):
         self.symbol = symbol
-    def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:
+
+    def get_completions(
+        self, document: Document, complete_event
+    ) -> Iterable[Completion]:
         text = document.text
         cursor_position = document.cursor_position
         text_before_cursor = text[:cursor_position]
         if self.symbol not in text_before_cursor:
             return
         symbol_pos = text_before_cursor.rfind(self.symbol)
-        text_after_symbol = text_before_cursor[symbol_pos + len(self.symbol):]
+        text_after_symbol = text_before_cursor[symbol_pos + len(self.symbol) :]
         start_position = -(len(text_after_symbol))
         try:
             pattern = text_after_symbol + "*"
@@ -36,7 +41,9 @@ class FilePathCompleter(Completer):
             else:
                 paths = glob.glob(pattern)
                 if not pattern.startswith(".") and not pattern.startswith("*/."):
-                    paths = [p for p in paths if not os.path.basename(p).startswith(".")]
+                    paths = [
+                        p for p in paths if not os.path.basename(p).startswith(".")
+                    ]
             paths.sort()
             for path in paths:
                 is_dir = os.path.isdir(path)
@@ -49,7 +56,7 @@ class FilePathCompleter(Completer):
                     elif text_after_symbol.startswith("~"):
                         home = os.path.expanduser("~")
                         if path.startswith(home):
-                            display_path = "~" + path[len(home):]
+                            display_path = "~" + path[len(home) :]
                         else:
                             display_path = path
                     else:

code_puppy/command_line/meta_command_handler.py

@@ -1,4 +1,12 @@
-META_COMMANDS_HELP = '''
+import os
+from rich.console import Console
+from code_puppy.command_line.model_picker_completion import (
+    load_model_names,
+    update_model_in_input,
+)
+from code_puppy.command_line.utils import make_directory_table
+
+META_COMMANDS_HELP = """
 [bold magenta]Meta Commands Help[/bold magenta]
 ~help, ~h             Show this help message
 ~cd [dir]             Change directory or show directories
@@ -6,17 +14,14 @@ META_COMMANDS_HELP = '''
 ~m <model>            Set active model
 ~show                 Show puppy status info
 ~<unknown>            Show unknown meta command warning
-'''
+"""
 
-from code_puppy.command_line.model_picker_completion import update_model_in_input, load_model_names, get_active_model
-from rich.console import Console
-import os
-from code_puppy.command_line.utils import make_directory_table
 
 def handle_meta_command(command: str, console: Console) -> bool:
     # ~codemap (code structure visualization)
     if command.startswith("~codemap"):
         from code_puppy.tools.code_map import make_code_map
+
         tokens = command.split()
         if len(tokens) > 1:
             target_dir = os.path.expanduser(tokens[1])
@@ -26,7 +31,7 @@ def handle_meta_command(command: str, console: Console) -> bool:
             tree = make_code_map(target_dir, show_doc=True)
             console.print(tree)
         except Exception as e:
-            console.print(f'[red]Error generating code map:[/red] {e}')
+            console.print(f"[red]Error generating code map:[/red] {e}")
         return True
     """
     Handle meta/config commands prefixed with '~'.
@@ -40,7 +45,7 @@ def handle_meta_command(command: str, console: Console) -> bool:
                 table = make_directory_table()
                 console.print(table)
             except Exception as e:
-                console.print(f'[red]Error listing directory:[/red] {e}')
+                console.print(f"[red]Error listing directory:[/red] {e}")
             return True
         elif len(tokens) == 2:
             dirname = tokens[1]
@@ -49,36 +54,41 @@ def handle_meta_command(command: str, console: Console) -> bool:
                 target = os.path.join(os.getcwd(), target)
             if os.path.isdir(target):
                 os.chdir(target)
-                console.print(f'[bold green]Changed directory to:[/bold green] [cyan]{target}[/cyan]')
+                console.print(
+                    f"[bold green]Changed directory to:[/bold green] [cyan]{target}[/cyan]"
+                )
             else:
-                console.print(f'[red]Not a directory:[/red] [bold]{dirname}[/bold]')
+                console.print(f"[red]Not a directory:[/red] [bold]{dirname}[/bold]")
             return True
 
     if command.strip().startswith("~show"):
-        from code_puppy.config import get_puppy_name, get_owner_name
         from code_puppy.command_line.model_picker_completion import get_active_model
+        from code_puppy.config import get_owner_name, get_puppy_name
+
         puppy_name = get_puppy_name()
         owner_name = get_owner_name()
         model = get_active_model()
         from code_puppy.config import get_yolo_mode
+
         yolo_mode = get_yolo_mode()
-        console.print(f'''[bold magenta]🐶 Puppy Status[/bold magenta]
+        console.print(f"""[bold magenta]🐶 Puppy Status[/bold magenta]
  \n[bold]puppy_name:[/bold]     [cyan]{puppy_name}[/cyan]
 [bold]owner_name:[/bold]     [cyan]{owner_name}[/cyan]
 [bold]model:[/bold]          [green]{model}[/green]
-[bold]YOLO_MODE:[/bold]      {'[red]ON[/red]' if yolo_mode else '[yellow]off[/yellow]'}
-''')
+[bold]YOLO_MODE:[/bold]      {"[red]ON[/red]" if yolo_mode else "[yellow]off[/yellow]"}
+""")
         return True
 
     if command.startswith("~set"):
         # Syntax: ~set KEY=VALUE or ~set KEY VALUE
-        from code_puppy.config import set_config_value, get_config_keys
+        from code_puppy.config import get_config_keys, set_config_value
+
         tokens = command.split(None, 2)
-        argstr = command[len('~set'):].strip()
+        argstr = command[len("~set") :].strip()
         key = None
         value = None
-        if '=' in argstr:
-            key, value = argstr.split('=', 1)
+        if "=" in argstr:
+            key, value = argstr.split("=", 1)
             key = key.strip()
             value = value.strip()
         elif len(tokens) >= 3:
@@ -86,16 +96,18 @@ def handle_meta_command(command: str, console: Console) -> bool:
             value = tokens[2]
         elif len(tokens) == 2:
             key = tokens[1]
-            value = ''
+            value = ""
         else:
-            console.print('[yellow]Usage:[/yellow] ~set KEY=VALUE or ~set KEY VALUE')
-            console.print('Config keys: ' + ', '.join(get_config_keys()))
+            console.print("[yellow]Usage:[/yellow] ~set KEY=VALUE or ~set KEY VALUE")
+            console.print("Config keys: " + ", ".join(get_config_keys()))
             return True
         if key:
             set_config_value(key, value)
-            console.print(f'[green]🌶 Set[/green] [cyan]{key}[/cyan] = "{value}" in puppy.cfg!')
+            console.print(
+                f'[green]🌶 Set[/green] [cyan]{key}[/cyan] = "{value}" in puppy.cfg!'
+            )
         else:
-            console.print('[red]You must supply a key.[/red]')
+            console.print("[red]You must supply a key.[/red]")
         return True
 
     if command.startswith("~m"):
@@ -103,26 +115,34 @@ def handle_meta_command(command: str, console: Console) -> bool:
         new_input = update_model_in_input(command)
         if new_input is not None:
             from code_puppy.agent import get_code_generation_agent
+
             model = get_active_model()
             get_code_generation_agent(force_reload=True)
-            console.print(f"[bold green]Active model set and loaded:[/bold green] [cyan]{model}[/cyan]")
+            console.print(
+                f"[bold green]Active model set and loaded:[/bold green] [cyan]{model}[/cyan]"
+            )
             return True
         # If no model matched, show available models
         model_names = load_model_names()
         console.print(f"[yellow]Available models:[/yellow] {', '.join(model_names)}")
-        console.print(f"[yellow]Usage:[/yellow] ~m <model_name>")
+        console.print("[yellow]Usage:[/yellow] ~m <model_name>")
         return True
     if command in ("~help", "~h"):
         console.print(META_COMMANDS_HELP)
         return True
     if command.startswith("~"):
-        name = command[1:].split()[0] if len(command)>1 else ""
+        name = command[1:].split()[0] if len(command) > 1 else ""
         if name:
-            console.print(f"[yellow]Unknown meta command:[/yellow] {command}\n[dim]Type ~help for options.[/dim]")
+            console.print(
+                f"[yellow]Unknown meta command:[/yellow] {command}\n[dim]Type ~help for options.[/dim]"
+            )
         else:
             # Show current model ONLY here
             from code_puppy.command_line.model_picker_completion import get_active_model
+
             current_model = get_active_model()
-            console.print(f"[bold green]Current Model:[/bold green] [cyan]{current_model}[/cyan]")
+            console.print(
+                f"[bold green]Current Model:[/bold green] [cyan]{current_model}[/cyan]"
+            )
         return True
     return False

code_puppy/command_line/model_picker_completion.py

@@ -9,14 +9,16 @@ from code_puppy.config import get_model_name, set_model_name
 
 MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH")
 if not MODELS_JSON_PATH:
-    MODELS_JSON_PATH = os.path.join(os.path.dirname(__file__), '..', 'models.json')
+    MODELS_JSON_PATH = os.path.join(os.path.dirname(__file__), "..", "models.json")
     MODELS_JSON_PATH = os.path.abspath(MODELS_JSON_PATH)
 
+
 def load_model_names():
-    with open(MODELS_JSON_PATH, 'r') as f:
+    with open(MODELS_JSON_PATH, "r") as f:
         models = json.load(f)
     return list(models.keys())
 
+
 def get_active_model():
     """
     Returns the active model from the config using get_model_name().
@@ -24,37 +26,43 @@ def get_active_model():
     """
     return get_model_name()
 
+
 def set_active_model(model_name: str):
     """
     Sets the active model name by updating both config (for persistence)
     and env (for process lifetime override).
     """
     set_model_name(model_name)
-    os.environ['MODEL_NAME'] = model_name.strip()
+    os.environ["MODEL_NAME"] = model_name.strip()
     # Reload agent globally
     try:
-        from code_puppy.agent import reload_code_generation_agent, get_code_generation_agent
-        reload_code_generation_agent() # This will reload dynamically everywhere
-    except Exception as e:
+        from code_puppy.agent import reload_code_generation_agent
+
+        reload_code_generation_agent()  # This will reload dynamically everywhere
+    except Exception:
         pass  # If reload fails, agent will still be switched next interpreter run
 
+
 class ModelNameCompleter(Completer):
     """
     A completer that triggers on '~m' to show available models from models.json.
     Only '~m' (not just '~') will trigger the dropdown.
     """
+
     def __init__(self, trigger: str = "~m"):
         self.trigger = trigger
         self.model_names = load_model_names()
 
-    def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:
+    def get_completions(
+        self, document: Document, complete_event
+    ) -> Iterable[Completion]:
         text = document.text
         cursor_position = document.cursor_position
         text_before_cursor = text[:cursor_position]
         if self.trigger not in text_before_cursor:
             return
         symbol_pos = text_before_cursor.rfind(self.trigger)
-        text_after_trigger = text_before_cursor[symbol_pos + len(self.trigger):]
+        text_after_trigger = text_before_cursor[symbol_pos + len(self.trigger) :]
         start_position = -(len(text_after_trigger))
         for model_name in self.model_names:
             meta = "Model (selected)" if model_name == get_active_model() else "Model"
@@ -65,25 +73,31 @@ class ModelNameCompleter(Completer):
                 display_meta=meta,
             )
 
+
 def update_model_in_input(text: str) -> Optional[str]:
     # If input starts with ~m and a model name, set model and strip it out
     content = text.strip()
     if content.startswith("~m"):
         rest = content[2:].strip()
         for model in load_model_names():
-            if rest.startswith(model):
+            if rest == model:
                 set_active_model(model)
                 # Remove ~mmodel from the input
-                idx = text.find("~m"+model)
+                idx = text.find("~m" + model)
                 if idx != -1:
-                    new_text = (text[:idx] + text[idx+len("~m"+model):]).strip()
+                    new_text = (text[:idx] + text[idx + len("~m" + model) :]).strip()
                     return new_text
     return None
 
-async def get_input_with_model_completion(prompt_str: str = ">>> ", trigger: str = "~m", history_file: Optional[str] = None) -> str:
+
+async def get_input_with_model_completion(
+    prompt_str: str = ">>> ", trigger: str = "~m", history_file: Optional[str] = None
+) -> str:
     history = FileHistory(os.path.expanduser(history_file)) if history_file else None
     session = PromptSession(
-        completer=ModelNameCompleter(trigger), history=history, complete_while_typing=True
+        completer=ModelNameCompleter(trigger),
+        history=history,
+        complete_while_typing=True,
     )
     text = await session.prompt_async(prompt_str)
     possibly_stripped = update_model_in_input(text)