code-puppy 0.0.123__tar.gz → 0.0.124__tar.gz

{code_puppy-0.0.123 → code_puppy-0.0.124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.123
+Version: 0.0.124
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/callbacks.py

@@ -9,6 +9,9 @@ PhaseType = Literal[
     "invoke_agent",
     "agent_exception",
     "version_check",
+    "edit_file",
+    "delete_file",
+    "run_shell_command",
     "load_model_config",
     "load_prompt",
 ]
@@ -20,6 +23,9 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "invoke_agent": [],
     "agent_exception": [],
     "version_check": [],
+    "edit_file": [],
+    "delete_file": [],
+    "run_shell_command": [],
     "load_model_config": [],
     "load_prompt": [],
 }
@@ -148,5 +154,17 @@ def on_load_model_config(*args, **kwargs) -> List[Any]:
     return _trigger_callbacks_sync("load_model_config", *args, **kwargs)
 
 
+def on_edit_file(*args, **kwargs) -> Any:
+    return _trigger_callbacks_sync("edit_file", *args, **kwargs)
+
+
+def on_delete_file(*args, **kwargs) -> Any:
+    return _trigger_callbacks_sync("delete_file", *args, **kwargs)
+
+
+def on_run_shell_command(*args, **kwargs) -> Any:
+    return _trigger_callbacks_sync("run_shell_command", *args, **kwargs)
+
+
 def on_load_prompt():
     return _trigger_callbacks_sync("load_prompt")

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/command_line/command_handler.py

@@ -22,7 +22,7 @@ COMMANDS_HELP = """
 /compact              Summarize and compact current chat history
 /dump_context <name>  Save current message history to file
 /load_context <name>  Load message history from file
-/set                  Set puppy config key-values (e.g., /set yolo_mode true)
+/set                  Set puppy config key-values (e.g., /set yolo_mode true, /set compaction_strategy truncation)
 /tools                Show available tools and capabilities
 /<unknown>            Show unknown command warning
 """
@@ -47,9 +47,12 @@ def handle_command(command: str):
         return True
 
     if command.strip().startswith("/compact"):
+        from code_puppy.config import get_compaction_strategy
         from code_puppy.message_history_processor import (
             estimate_tokens_for_message,
             summarize_messages,
+            truncation,
+            get_protected_token_count,
         )
         from code_puppy.messaging import (
             emit_error,
@@ -66,13 +69,23 @@ def handle_command(command: str):
                 return True
 
             before_tokens = sum(estimate_tokens_for_message(m) for m in history)
+            compaction_strategy = get_compaction_strategy()
             emit_info(
-                f"🤔 Compacting {len(history)} messages... (~{before_tokens} tokens)"
+                f"🤔 Compacting {len(history)} messages using {compaction_strategy} strategy... (~{before_tokens} tokens)"
             )
 
-            compacted, _ = summarize_messages(history, with_protection=False)
+            if compaction_strategy == "truncation":
+                protected_tokens = get_protected_token_count()
+                compacted = truncation(history, protected_tokens)
+                summarized_messages = []  # No summarization in truncation mode
+            else:
+                # Default to summarization
+                compacted, summarized_messages = summarize_messages(
+                    history, with_protection=False
+                )
+
             if not compacted:
-                emit_error("Summarization failed. History unchanged.")
+                emit_error("Compaction failed. History unchanged.")
                 return True
 
             set_message_history(compacted)
@@ -83,8 +96,14 @@ def handle_command(command: str):
                 if before_tokens > 0
                 else 0
             )
+
+            strategy_info = (
+                f"using {compaction_strategy} strategy"
+                if compaction_strategy == "truncation"
+                else "via summarization"
+            )
             emit_success(
-                f"✨ Done! History: {len(history)} → {len(compacted)} messages\n"
+                f"✨ Done! History: {len(history)} → {len(compacted)} messages {strategy_info}\n"
                 f"🏦 Tokens: {before_tokens:,} → {after_tokens:,} ({reduction_pct:.1f}% reduction)"
             )
             return True
@@ -119,16 +138,19 @@ def handle_command(command: str):
             get_owner_name,
             get_protected_token_count,
             get_puppy_name,
-            get_summarization_threshold,
+            get_compaction_threshold,
             get_yolo_mode,
         )
 
+        from code_puppy.config import get_compaction_strategy
+
         puppy_name = get_puppy_name()
         owner_name = get_owner_name()
         model = get_active_model()
         yolo_mode = get_yolo_mode()
         protected_tokens = get_protected_token_count()
-        summary_threshold = get_summarization_threshold()
+        compaction_threshold = get_compaction_threshold()
+        compaction_strategy = get_compaction_strategy()
 
         status_msg = f"""[bold magenta]🐶 Puppy Status[/bold magenta]
 
@@ -137,7 +159,8 @@ def handle_command(command: str):
 [bold]model:[/bold]                 [green]{model}[/green]
 [bold]YOLO_MODE:[/bold]             {"[red]ON[/red]" if yolo_mode else "[yellow]off[/yellow]"}
 [bold]protected_tokens:[/bold]      [cyan]{protected_tokens:,}[/cyan] recent tokens preserved
-[bold]summary_threshold:[/bold]     [cyan]{summary_threshold:.1%}[/cyan] context usage triggers summarization
+[bold]compaction_threshold:[/bold]     [cyan]{compaction_threshold:.1%}[/cyan] context usage triggers compaction
+[bold]compaction_strategy:[/bold]   [cyan]{compaction_strategy}[/cyan] (summarization or truncation)
 
 """
         emit_info(status_msg)
@@ -162,8 +185,11 @@ def handle_command(command: str):
             key = tokens[1]
             value = ""
         else:
+            config_keys = get_config_keys()
+            if "compaction_strategy" not in config_keys:
+                config_keys.append("compaction_strategy")
             emit_warning(
-                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(get_config_keys())}"
+                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(config_keys)}\n[dim]Note: compaction_strategy can be 'summarization' or 'truncation'[/dim]"
             )
             return True
         if key:

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/config.py

@@ -68,13 +68,33 @@ def get_owner_name():
 # using get_protected_token_count() and get_summarization_threshold()
 
 
+def get_model_context_length() -> int:
+    """
+    Get the context length for the currently configured model from models.json
+    """
+    try:
+        from code_puppy.model_factory import ModelFactory
+
+        model_configs = ModelFactory.load_config()
+        model_name = get_model_name()
+
+        # Get context length from model config
+        model_config = model_configs.get(model_name, {})
+        context_length = model_config.get("context_length", 128000)  # Default value
+
+        return int(context_length)
+    except Exception:
+        # Fallback to default context length if anything goes wrong
+        return 128000
+
+
 # --- 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").
+    plus certain preset expected keys (e.g. "yolo_mode", "model", "compaction_strategy").
     """
-    default_keys = ["yolo_mode", "model"]
+    default_keys = ["yolo_mode", "model", "compaction_strategy"]
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     keys = set(config[DEFAULT_SECTION].keys()) if DEFAULT_SECTION in config else set()
@@ -354,30 +374,56 @@ def get_protected_token_count():
     This is the number of tokens in recent messages that won't be summarized.
     Defaults to 50000 if unset or misconfigured.
     Configurable by 'protected_token_count' key.
+    Enforces that protected tokens don't exceed 75% of model context length.
     """
     val = get_value("protected_token_count")
     try:
-        return max(1000, int(val)) if val else 50000  # Minimum 1000 tokens
+        # Get the model context length to enforce the 75% limit
+        model_context_length = get_model_context_length()
+        max_protected_tokens = int(model_context_length * 0.75)
+
+        # Parse the configured value
+        configured_value = int(val) if val else 50000
+
+        # Apply constraints: minimum 1000, maximum 75% of context length
+        return max(1000, min(configured_value, max_protected_tokens))
     except (ValueError, TypeError):
-        return 50000
+        # If parsing fails, return a reasonable default that respects the 75% limit
+        model_context_length = get_model_context_length()
+        max_protected_tokens = int(model_context_length * 0.75)
+        return min(50000, max_protected_tokens)
 
 
-def get_summarization_threshold():
+def get_compaction_threshold():
     """
-    Returns the user-configured summarization threshold as a float between 0.0 and 1.0.
-    This is the proportion of model context that triggers summarization.
+    Returns the user-configured compaction threshold as a float between 0.0 and 1.0.
+    This is the proportion of model context that triggers compaction.
     Defaults to 0.85 (85%) if unset or misconfigured.
-    Configurable by 'summarization_threshold' key.
+    Configurable by 'compaction_threshold' key.
     """
-    val = get_value("summarization_threshold")
+    val = get_value("compaction_threshold")
     try:
         threshold = float(val) if val else 0.85
         # Clamp between reasonable bounds
-        return max(0.1, min(0.95, threshold))
+        return max(0.8, min(0.95, threshold))
     except (ValueError, TypeError):
         return 0.85
 
 
+def get_compaction_strategy() -> str:
+    """
+    Returns the user-configured compaction strategy.
+    Options are 'summarization' or 'truncation'.
+    Defaults to 'summarization' if not set or misconfigured.
+    Configurable by 'compaction_strategy' key.
+    """
+    val = get_value("compaction_strategy")
+    if val and val.lower() in ["summarization", "truncation"]:
+        return val.lower()
+    # Default to summarization
+    return "summarization"
+
+
 def save_command_to_history(command: str):
     """Save a command to the history file with an ISO format timestamp.
 

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/main.py

@@ -321,12 +321,14 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                             initial_command, usage_limits=get_custom_usage_limits()
                         )
                     finally:
-                        set_message_history(prune_interrupted_tool_calls(get_message_history()))
+                        set_message_history(
+                            prune_interrupted_tool_calls(get_message_history())
+                        )
 
             agent_response = response.output
 
             emit_system_message(
-                f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response.output_message}"
+                f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response}"
             )
             new_msgs = response.all_messages()
             message_history_accumulator(new_msgs)
@@ -466,7 +468,9 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                                 usage_limits=get_custom_usage_limits(),
                             )
                         finally:
-                            set_message_history(prune_interrupted_tool_calls(get_message_history()))
+                            set_message_history(
+                                prune_interrupted_tool_calls(get_message_history())
+                            )
 
                     # Create the task
                     agent_task = asyncio.create_task(run_agent_task())

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/message_history_processor.py

@@ -1,4 +1,5 @@
 import json
+import queue
 from typing import Any, List, Set, Tuple
 
 import pydantic
@@ -7,7 +8,8 @@ from pydantic_ai.messages import ModelMessage, ModelRequest, TextPart, ToolCallP
 from code_puppy.config import (
     get_model_name,
     get_protected_token_count,
-    get_summarization_threshold,
+    get_compaction_threshold,
+    get_compaction_strategy,
 )
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.model_factory import ModelFactory
@@ -87,6 +89,12 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
     return max(1, total_tokens)
 
 
+def filter_huge_messages(messages: List[ModelMessage]) -> List[ModelMessage]:
+    filtered = [m for m in messages if estimate_tokens_for_message(m) < 50000]
+    pruned = prune_interrupted_tool_calls(filtered)
+    return pruned
+
+
 def split_messages_for_protected_summarization(
     messages: List[ModelMessage],
 ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
@@ -306,7 +314,8 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
                 status_bar.update_token_info(
                     total_current_tokens, model_max, proportion_used
                 )
-            except Exception:
+            except Exception as e:
+                emit_error(e)
                 # Fallback to chat message if status bar update fails
                 emit_info(
                     f"\n[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f} [/bold white on blue] \n",
@@ -323,12 +332,26 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
         emit_info(
             f"\n[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f} [/bold white on blue] \n"
         )
+    # Get the configured compaction threshold
+    compaction_threshold = get_compaction_threshold()
+
+    # Get the configured compaction strategy
+    compaction_strategy = get_compaction_strategy()
+
+    if proportion_used > compaction_threshold:
+        if compaction_strategy == "truncation":
+            # Use truncation instead of summarization
+            protected_tokens = get_protected_token_count()
+            result_messages = truncation(
+                filter_huge_messages(messages), protected_tokens
+            )
+            summarized_messages = []  # No summarization in truncation mode
+        else:
+            # Default to summarization
+            result_messages, summarized_messages = summarize_messages(
+                filter_huge_messages(messages)
+            )
 
-    # Get the configured summarization threshold
-    summarization_threshold = get_summarization_threshold()
-
-    if proportion_used > summarization_threshold:
-        result_messages, summarized_messages = summarize_messages(messages)
         final_token_count = sum(
             estimate_tokens_for_message(msg) for msg in result_messages
         )
@@ -360,6 +383,30 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
     return messages
 
 
+def truncation(
+    messages: List[ModelMessage], protected_tokens: int
+) -> List[ModelMessage]:
+    emit_info("Truncating message history to manage token usage")
+    result = [messages[0]]  # Always keep the first message (system prompt)
+    num_tokens = 0
+    stack = queue.LifoQueue()
+
+    # Put messages in reverse order (most recent first) into the stack
+    # but break when we exceed protected_tokens
+    for idx, msg in enumerate(reversed(messages[1:])):  # Skip the first message
+        num_tokens += estimate_tokens_for_message(msg)
+        if num_tokens > protected_tokens:
+            break
+        stack.put(msg)
+
+    # Pop messages from stack to get them in chronological order
+    while not stack.empty():
+        result.append(stack.get())
+
+    result = prune_interrupted_tool_calls(result)
+    return result
+
+
 def message_history_accumulator(messages: List[Any]):
     _message_history = get_message_history()
     message_history_hashes = set([hash_message(m) for m in _message_history])

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/tools/command_runner.py

@@ -12,6 +12,7 @@ from pydantic_ai import RunContext
 from rich.markdown import Markdown
 from rich.text import Text
 
+from code_puppy.callbacks import on_run_shell_command
 from code_puppy.messaging import (
     emit_divider,
     emit_error,
@@ -543,7 +544,8 @@ def register_command_runner_tools(agent):
             This tool can execute arbitrary shell commands. Exercise caution when
             running untrusted commands, especially those that modify system state.
         """
-        return run_shell_command(context, command, cwd, timeout)
+        result = run_shell_command(context, command, cwd, timeout)
+        on_run_shell_command(result)
 
     @agent.tool
     def agent_share_your_reasoning(

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/tools/file_modifications.py

@@ -20,6 +20,7 @@ import json_repair
 from pydantic import BaseModel
 from pydantic_ai import RunContext
 
+from code_puppy.callbacks import on_delete_file, on_edit_file
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.tools.common import _find_best_window, generate_group_id
 
@@ -542,6 +543,7 @@ def register_file_modifications_tools(agent):
                 }
         group_id = generate_group_id("edit_file", payload.file_path)
         result = _edit_file(context, payload, group_id)
+        on_edit_file(result)
         if "diff" in result:
             del result["diff"]
         return result
@@ -600,6 +602,7 @@ def register_file_modifications_tools(agent):
         # Generate group_id for delete_file tool execution
         group_id = generate_group_id("delete_file", file_path)
         result = _delete_file(context, file_path, message_group=group_id)
+        on_delete_file(result)
         if "diff" in result:
             del result["diff"]
         return result

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/tui/app.py

@@ -27,7 +27,11 @@ from code_puppy.message_history_processor import (
 
 # Import our message queue system
 from code_puppy.messaging import TUIRenderer, get_global_queue
-from code_puppy.state_management import clear_message_history, get_message_history, set_message_history
+from code_puppy.state_management import (
+    clear_message_history,
+    get_message_history,
+    set_message_history,
+)
 from code_puppy.tui.components import (
     ChatView,
     CustomTextArea,
@@ -499,7 +503,9 @@ class CodePuppyTUI(App):
                             # Handle regular exceptions
                             self.add_error_message(f"MCP/Agent error: {str(eg)}")
                     finally:
-                        set_message_history(prune_interrupted_tool_calls(get_message_history()))
+                        set_message_history(
+                            prune_interrupted_tool_calls(get_message_history())
+                        )
                 except Exception as agent_error:
                     # Handle any other errors in agent processing
                     self.add_error_message(

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/tui/components/status_bar.py

@@ -101,15 +101,15 @@ class StatusBar(Static):
         token_color = "green"
         if self.token_count > 0 and self.token_capacity > 0:
             # Import here to avoid circular import
-            from code_puppy.config import get_summarization_threshold
+            from code_puppy.config import get_compaction_threshold
 
-            summarization_threshold = get_summarization_threshold()
+            get_compaction_threshold = get_compaction_threshold()
 
-            if self.token_proportion > summarization_threshold:
+            if self.token_proportion > get_compaction_threshold:
                 token_color = "red"
                 token_status = f"🔴 {self.token_count}/{self.token_capacity} ({self.token_proportion:.1%})"
             elif self.token_proportion > (
-                summarization_threshold - 0.15
+                get_compaction_threshold - 0.15
             ):  # 15% before summarization threshold
                 token_color = "yellow"
                 token_status = f"🟡 {self.token_count}/{self.token_capacity} ({self.token_proportion:.1%})"

{code_puppy-0.0.123 → code_puppy-0.0.124}/code_puppy/tui/screens/settings.py

@@ -100,9 +100,20 @@ class SettingsScreen(ModalScreen):
                     )
 
                 with Container(classes="setting-row"):
-                    yield Static("Summary Threshold:", classes="setting-label")
+                    yield Static("Compaction Strategy:", classes="setting-label")
+                    yield Select(
+                        [
+                            ("Summarization", "summarization"),
+                            ("Truncation", "truncation"),
+                        ],
+                        id="compaction-strategy-select",
+                        classes="setting-input",
+                    )
+
+                with Container(classes="setting-row"):
+                    yield Static("Compaction Threshold:", classes="setting-label")
                     yield Input(
-                        id="summary-threshold-input",
+                        id="compaction-threshold-input",
                         classes="setting-input",
                         placeholder="e.g., 0.85",
                     )
@@ -118,7 +129,8 @@ class SettingsScreen(ModalScreen):
             get_owner_name,
             get_protected_token_count,
             get_puppy_name,
-            get_summarization_threshold,
+            get_compaction_strategy,
+            get_compaction_threshold,
         )
 
         # Load current values
@@ -126,12 +138,18 @@ class SettingsScreen(ModalScreen):
         owner_name_input = self.query_one("#owner-name-input", Input)
         model_select = self.query_one("#model-select", Select)
         protected_tokens_input = self.query_one("#protected-tokens-input", Input)
-        summary_threshold_input = self.query_one("#summary-threshold-input", Input)
+        compaction_threshold_input = self.query_one(
+            "#compaction-threshold-input", Input
+        )
+        compaction_strategy_select = self.query_one(
+            "#compaction-strategy-select", Select
+        )
 
         puppy_name_input.value = get_puppy_name() or ""
         owner_name_input.value = get_owner_name() or ""
         protected_tokens_input.value = str(get_protected_token_count())
-        summary_threshold_input.value = str(get_summarization_threshold())
+        compaction_threshold_input.value = str(get_compaction_threshold())
+        compaction_strategy_select.value = get_compaction_strategy()
 
         # Load available models
         self.load_model_options(model_select)
@@ -146,9 +164,7 @@ class SettingsScreen(ModalScreen):
         """Load available models into the model select widget."""
         try:
             # Use the same method that interactive mode uses to load models
-            import os
 
-            from code_puppy.config import CONFIG_DIR
             from code_puppy.model_factory import ModelFactory
 
             # Load models using the same path and method as interactive mode
@@ -171,7 +187,11 @@ class SettingsScreen(ModalScreen):
     @on(Button.Pressed, "#save-button")
     def save_settings(self) -> None:
         """Save the modified settings."""
-        from code_puppy.config import set_config_value, set_model_name
+        from code_puppy.config import (
+            set_config_value,
+            set_model_name,
+            get_model_context_length,
+        )
 
         try:
             # Get values from inputs
@@ -182,8 +202,8 @@ class SettingsScreen(ModalScreen):
             protected_tokens = self.query_one(
                 "#protected-tokens-input", Input
             ).value.strip()
-            summary_threshold = self.query_one(
-                "#summary-threshold-input", Input
+            compaction_threshold = self.query_one(
+                "#compaction-threshold-input", Input
             ).value.strip()
 
             # Validate and save
@@ -201,31 +221,46 @@ class SettingsScreen(ModalScreen):
             # Validate and save protected tokens
             if protected_tokens.isdigit():
                 tokens_value = int(protected_tokens)
+                model_context_length = get_model_context_length()
+                max_protected_tokens = int(model_context_length * 0.75)
+
                 if tokens_value >= 1000:  # Minimum validation
-                    set_config_value("protected_token_count", protected_tokens)
+                    if tokens_value <= max_protected_tokens:  # Maximum validation
+                        set_config_value("protected_token_count", protected_tokens)
+                    else:
+                        raise ValueError(
+                            f"Protected tokens must not exceed 75% of model context length ({max_protected_tokens} tokens for current model)"
+                        )
                 else:
                     raise ValueError("Protected tokens must be at least 1000")
             elif protected_tokens:  # If not empty but not digit
                 raise ValueError("Protected tokens must be a valid number")
 
-            # Validate and save summary threshold
-            if summary_threshold:
+            # Validate and save compaction threshold
+            if compaction_threshold:
                 try:
-                    threshold_value = float(summary_threshold)
-                    if 0.1 <= threshold_value <= 0.95:  # Same bounds as config function
-                        set_config_value("summarization_threshold", summary_threshold)
+                    threshold_value = float(compaction_threshold)
+                    if 0.8 <= threshold_value <= 0.95:  # Same bounds as config function
+                        set_config_value("compaction_threshold", compaction_threshold)
                     else:
                         raise ValueError(
-                            "Summary threshold must be between 0.1 and 0.95"
+                            "Compaction threshold must be between 0.8 and 0.95"
                         )
                 except ValueError as ve:
                     if "must be between" in str(ve):
                         raise ve
                     else:
                         raise ValueError(
-                            "Summary threshold must be a valid decimal number"
+                            "Compaction threshold must be a valid decimal number"
                         )
 
+            # Save compaction strategy
+            compaction_strategy = self.query_one(
+                "#compaction-strategy-select", Select
+            ).value
+            if compaction_strategy in ["summarization", "truncation"]:
+                set_config_value("compaction_strategy", compaction_strategy)
+
             # Return success message with model change info
             message = "Settings saved successfully!"
             if selected_model:

{code_puppy-0.0.123 → code_puppy-0.0.124}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.123"
+version = "0.0.124"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"