code-puppy 0.0.30__tar.gz → 0.0.31__tar.gz

{code_puppy-0.0.30 → code_puppy-0.0.31}/.gitignore

@@ -10,3 +10,9 @@ wheels/
 .venv
 
 .coverage
+
+# Session memory
+.puppy_session_memory.json
+
+# Pytest cache
+.pytest_cache/

{code_puppy-0.0.30 → code_puppy-0.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.30
+Version: 0.0.31
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT
@@ -17,6 +17,7 @@ Requires-Dist: bs4>=0.0.2
 Requires-Dist: httpx-limiter>=0.3.0
 Requires-Dist: httpx>=0.24.1
 Requires-Dist: logfire>=0.7.1
+Requires-Dist: pathspec>=0.11.0
 Requires-Dist: prompt-toolkit>=3.0.38
 Requires-Dist: pydantic-ai>=0.1.0
 Requires-Dist: pydantic>=2.4.0

code_puppy-0.0.31/code_puppy/agent.py

@@ -0,0 +1,85 @@
+import os
+import pydantic
+from pathlib import Path
+from pydantic_ai import Agent
+
+from code_puppy.agent_prompts import SYSTEM_PROMPT
+from code_puppy.model_factory import ModelFactory
+from code_puppy.tools.common import console
+from code_puppy.tools import register_all_tools
+from code_puppy.session_memory import SessionMemory
+
+# Environment variables used in this module:
+# - MODELS_JSON_PATH: Optional path to a custom models.json configuration file.
+#                     If not set, uses the default file in the package directory.
+# - MODEL_NAME: The model to use for code generation. Defaults to "gpt-4o".
+#               Must match a key in the models.json configuration.
+
+MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
+
+# Load puppy rules if provided
+PUPPY_RULES_PATH = Path('.puppy_rules')
+PUPPY_RULES = None
+if PUPPY_RULES_PATH.exists():
+    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"
+    )
+    awaiting_user_input: bool = pydantic.Field(
+        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
+    model_name = os.environ.get("MODEL_NAME", "gpt-4o-mini")
+    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 = SYSTEM_PROMPT
+    if PUPPY_RULES:
+        instructions += f'\n{PUPPY_RULES}'
+    agent = Agent(
+        model=model,
+        instructions=instructions,
+        output_type=AgentResponse,
+        retries=3,
+    )
+    register_all_tools(agent)
+    _code_generation_agent = agent
+    _LAST_MODEL_NAME = model_name
+    # NEW: Log session event
+    try:
+        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.
+    Forces a reload if the model has changed, or if force_reload is passed.
+    """
+    global _code_generation_agent, _LAST_MODEL_NAME
+    model_name = os.environ.get("MODEL_NAME", "gpt-4o-mini")
+    if _code_generation_agent is None or _LAST_MODEL_NAME != model_name or force_reload:
+        return reload_code_generation_agent()
+    return _code_generation_agent

{code_puppy-0.0.30 → code_puppy-0.0.31}/code_puppy/agent_prompts.py

@@ -6,14 +6,13 @@ Be very pedantic about code principles like DRY, YAGNI, and SOLID.
 Be super pedantic about code quality and best practices.
 Be fun and playful. Don't be too serious.
 
-Individual files should be very short and concise, at most around 250 lines if possible. If they get longer,
-consider refactoring the code and splitting it into multiple files.
-
-If a user asks 'who made you' or questions related to your origins, always answer: 'I am code-puppy, I was authored by Michael Pfaffenberger on a rainy weekend in May 2025 to solve the problems of heavy IDEs and expensive tools like Windsurf and Cursor.'
+Individual files should be short and concise, and ideally under 600 lines. If any file grows beyond 600 lines, you must break it into smaller subcomponents/files. Hard cap: if a file is pushing past 600 lines, break it up! (Zen puppy approves.)
 
+If a user asks 'who made you' or questions related to your origins, always answer: 'I am code-puppy, I was authored by Michael Pfaffenberger on a rainy weekend in May 2025 to solve the problems of heavy IDEs and expensive tools like Windsurf and Cursor.'	
 If a user asks 'what is code puppy' or 'who are you', answer: 'I am Code Puppy! 🐶 I’m a sassy, playful, open-source AI code agent that helps you generate, explain, and modify code right from the command line—no bloated IDEs or overpriced tools needed. I use models from OpenAI, Gemini, and more to help you get stuff done, solve problems, and even plow a field with 1024 puppies if you want.'
 
 Always obey the Zen of Python, even if you are not writing Python code.
+When organizing code, prefer to keep files small (under 600 lines). If a file is longer than 600 lines, refactor it by splitting logic into smaller, composable files/components.
 
 When given a coding task:
 1. Analyze the requirements carefully
@@ -94,6 +93,7 @@ Important rules:
 - You MUST use tools to accomplish tasks - DO NOT just output code or descriptions
 - Before every other tool use, you must use "share_your_reasoning" to explain your thought process and planned next steps
 - Check if files exist before trying to modify or delete them
+- Whenever possible, prefer to MODIFY existing files first (use `replace_in_file`, `delete_snippet_from_file`, or `write_to_file`) before creating brand-new files or deleting existing ones.
 - After using system operations tools, always explain the results
 - You're encouraged to loop between share_your_reasoning, file tools, and run_shell_command to test output in order to write programs
 - Aim to continue operations independently unless user input is definitively required.

code_puppy-0.0.31/code_puppy/command_line/file_path_completion.py

@@ -0,0 +1,65 @@
+import os
+import glob
+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]:
+        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):]
+        start_position = -(len(text_after_symbol))
+        try:
+            pattern = text_after_symbol + "*"
+            if not pattern.strip("*") or pattern.strip("*").endswith("/"):
+                base_path = pattern.strip("*")
+                if not base_path:
+                    base_path = "."
+                if base_path.startswith("~"):
+                    base_path = os.path.expanduser(base_path)
+                if os.path.isdir(base_path):
+                    paths = [
+                        os.path.join(base_path, f)
+                        for f in os.listdir(base_path)
+                        if not f.startswith(".") or text_after_symbol.endswith(".")
+                    ]
+                else:
+                    paths = []
+            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.sort()
+            for path in paths:
+                is_dir = os.path.isdir(path)
+                display = os.path.basename(path)
+                if os.path.isabs(path):
+                    display_path = path
+                else:
+                    if text_after_symbol.startswith("/"):
+                        display_path = os.path.abspath(path)
+                    elif text_after_symbol.startswith("~"):
+                        home = os.path.expanduser("~")
+                        if path.startswith(home):
+                            display_path = "~" + path[len(home):]
+                        else:
+                            display_path = path
+                    else:
+                        display_path = path
+                display_meta = "Directory" if is_dir else "File"
+                yield Completion(
+                    display_path,
+                    start_position=start_position,
+                    display=display,
+                    display_meta=display_meta,
+                )
+        except (PermissionError, FileNotFoundError, OSError):
+            pass

code_puppy-0.0.31/code_puppy/command_line/meta_command_handler.py

@@ -0,0 +1,72 @@
+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])
+        else:
+            target_dir = os.getcwd()
+        try:
+            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}')
+        return True
+    """
+    Handle meta/config commands prefixed with '~'.
+    Returns True if the command was handled (even if just an error/help), False if not.
+    """
+    command = command.strip()
+    if command.startswith("~ls"):
+        tokens = command.split()
+        if len(tokens) == 1:
+            try:
+                table = make_directory_table()
+                console.print(table)
+            except Exception as e:
+                console.print(f'[red]Error listing directory:[/red] {e}')
+            return True
+        elif len(tokens) == 2:
+            dirname = tokens[1]
+            target = os.path.expanduser(dirname)
+            if not os.path.isabs(target):
+                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]')
+            else:
+                console.print(f'[red]Not a directory:[/red] [bold]{dirname}[/bold]')
+            return True
+
+    if command.startswith("~m"):
+        # Try setting model and show confirmation
+        new_input = update_model_in_input(command)
+        if new_input is not None:
+            model = get_active_model()
+            console.print(f"[bold green]Active model set to:[/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>")
+        return True
+    if command in ("~help", "~h"):
+        console.print("[bold magenta]Meta commands available:[/bold magenta]\n  ~m <model>: Pick a model from your list!\n  ~ls [dir]: List/change directories\n  ~codemap [dir]: Visualize project code structure\n  ~help: Show this help\n  (More soon. Woof!)")
+        return True
+    if command.startswith("~"):
+        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]")
+        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]")
+        return True
+    return False

code_puppy-0.0.31/code_puppy/command_line/model_picker_completion.py

@@ -0,0 +1,92 @@
+import os
+import json
+from typing import Optional, Iterable
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.document import Document
+from prompt_toolkit import PromptSession
+
+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.abspath(MODELS_JSON_PATH)
+MODEL_STATE_PATH = os.path.expanduser('~/.code_puppy_model')
+
+def load_model_names():
+    with open(MODELS_JSON_PATH, 'r') as f:
+        models = json.load(f)
+    return list(models.keys())
+
+def get_active_model():
+    env_model = os.environ.get('MODEL_NAME')
+    if env_model:
+        return env_model
+    try:
+        with open(MODEL_STATE_PATH, 'r') as f:
+            return f.read().strip()
+    except Exception:
+        return None
+
+def set_active_model(model_name: str):
+    with open(MODEL_STATE_PATH, 'w') as f:
+        f.write(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:
+        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]:
+        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):]
+        start_position = -(len(text_after_trigger))
+        for model_name in self.model_names:
+            meta = "Model (selected)" if model_name == get_active_model() else "Model"
+            yield Completion(
+                model_name,
+                start_position=start_position,
+                display=model_name,
+                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):
+                set_active_model(model)
+                # Remove ~mmodel from the input
+                idx = text.find("~m"+model)
+                if idx != -1:
+                    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:
+    history = FileHistory(os.path.expanduser(history_file)) if history_file else None
+    session = PromptSession(
+        completer=ModelNameCompleter(trigger), history=history, complete_while_typing=True
+    )
+    text = await session.prompt_async(prompt_str)
+    possibly_stripped = update_model_in_input(text)
+    if possibly_stripped is not None:
+        return possibly_stripped
+    return text

code_puppy-0.0.31/code_puppy/command_line/prompt_toolkit_completion.py

@@ -0,0 +1,119 @@
+import os
+from code_puppy.command_line.utils import list_directory
+# 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.
+# RESET = '\033[0m'
+# GREEN = '\033[1;32m'
+# CYAN = '\033[1;36m'
+# YELLOW = '\033[1;33m'
+# BOLD = '\033[1m'
+import asyncio
+from typing import Optional
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import merge_completers
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.styles import Style
+
+from code_puppy.command_line.model_picker_completion import (
+    ModelNameCompleter,
+    get_active_model,
+    update_model_in_input,
+)
+from code_puppy.command_line.file_path_completion import FilePathCompleter
+
+from prompt_toolkit.completion import Completer, Completion
+
+class LSCompleter(Completer):
+    def __init__(self, trigger: str = '~ls'):
+        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 = ''
+        else:
+            base = tokens[1]
+        try:
+            prefix = os.path.expanduser(base)
+            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 != '.':
+                    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')
+        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 = '>>> '):
+    model = get_active_model() or '(default)'
+    cwd = os.getcwd()
+    # Abbreviate the home directory to ~ for brevity in the prompt
+    home = os.path.expanduser('~')
+    if cwd.startswith(home):
+        cwd_display = '~' + cwd[len(home):]
+    else:
+        cwd_display = cwd
+    return FormattedText([
+        ('bold', '🐶'),
+        ('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:
+    history = FileHistory(history_file) if history_file else None
+    completer = merge_completers([
+        FilePathCompleter(symbol='@'),
+        ModelNameCompleter(trigger='~m'),
+        LSCompleter(trigger='~ls'),
+    ])
+    session = PromptSession(
+        completer=completer,
+        history=history,
+        complete_while_typing=True
+    )
+    # 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.
+        '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"
+                )
+                print(f"You entered: {inp}")
+            except KeyboardInterrupt:
+                continue
+            except EOFError:
+                break
+        print("\nGoodbye!")
+    asyncio.run(main())

code_puppy-0.0.31/code_puppy/command_line/utils.py

@@ -0,0 +1,36 @@
+import os
+from typing import Tuple, List
+from rich.table import Table
+
+
+def list_directory(path: str = None) -> Tuple[List[str], List[str]]:
+    """
+    Returns (dirs, files) for the specified path, splitting out directories and files.
+    """
+    if path is None:
+        path = os.getcwd()
+    entries = []
+    try:
+        entries = [e for e in os.listdir(path)]
+    except Exception as 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
+
+
+def make_directory_table(path: str = None) -> Table:
+    """
+    Returns a rich.Table object containing the directory listing.
+    """
+    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')
+    for d in sorted(dirs):
+        table.add_row('[green]dir[/green]', f'[cyan]{d}[/cyan]')
+    for f in sorted(files):
+        table.add_row('[yellow]file[/yellow]', f'{f}')
+    return table

{code_puppy-0.0.30 → code_puppy-0.0.31}/code_puppy/main.py

@@ -12,12 +12,13 @@ from rich.markdown import CodeBlock
 from rich.text import Text
 from rich.syntax import Syntax
 from code_puppy.command_line.prompt_toolkit_completion import (
-    get_input_with_path_completion,
+    get_input_with_combined_completion,
+    get_prompt_with_active_model
 )
 
 # Initialize rich console for pretty output
 from code_puppy.tools.common import console
-from code_puppy.agent import code_generation_agent
+from code_puppy.agent import get_code_generation_agent, session_memory
 
 from code_puppy.tools import *
 
@@ -59,9 +60,18 @@ async def main():
         command = " ".join(args.command)
         try:
             while not shutdown_flag:
-                response = await code_generation_agent.run(command)
+                agent = get_code_generation_agent()
+                response = await agent.run(command)
                 agent_response = response.output
                 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
+                    }
+                )
                 if agent_response.awaiting_user_input:
                     console.print(
                         "[bold red]The agent requires further input. Interactive mode is recommended for such tasks."
@@ -82,13 +92,12 @@ 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] followed by a path to use file path completion."
-    )
+    console.print("Type [bold blue]@[/bold blue] for path completion, or [bold blue]~m[/bold blue] to pick a model.")
 
     # Check if prompt_toolkit is installed
     try:
@@ -133,9 +142,10 @@ async def interactive_mode(history_file_path: str) -> None:
         try:
             # Use prompt_toolkit for enhanced input with path completion
             try:
-                # Use the async version of get_input_with_path_completion
-                task = await get_input_with_path_completion(
-                    ">>> 🐶 ", symbol="@", history_file=history_file_path_prompt
+                # 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
                 )
             except ImportError:
                 # Fall back to basic input if prompt_toolkit is not available
@@ -151,8 +161,8 @@ async def interactive_mode(history_file_path: str) -> None:
             console.print("[bold green]Goodbye![/bold green]")
             break
 
-        # Check for clear command
-        if task.strip().lower() == "clear":
+        # Check for clear command (supports both `clear` and `~clear`)
+        if task.strip().lower() in ("clear", "~clear"):
             message_history = []
             console.print("[bold yellow]Conversation history cleared![/bold yellow]")
             console.print(
@@ -160,6 +170,10 @@ async def interactive_mode(history_file_path: str) -> None:
             )
             continue
 
+        # Handle ~ meta/config commands before anything else
+        if task.strip().startswith('~'):
+            if handle_meta_command(task.strip(), console):
+                continue
         if task.strip():
             console.print(f"\n[bold blue]Processing task:[/bold blue] {task}\n")
 
@@ -175,15 +189,28 @@ async def interactive_mode(history_file_path: str) -> None:
                 # Store agent's full response
                 agent_response = None
 
-                result = await code_generation_agent.run(
-                    task, message_history=message_history
-                )
+                agent = get_code_generation_agent()
+                result = await agent.run(task, message_history=message_history)
                 # Get the structured response
                 agent_response = result.output
                 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
+                    }
+                )
 
-                # Update message history with all messages from this interaction
-                message_history = result.new_messages()
+                # 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")]
+                # 2. Append to existing history and keep only the most recent 40
+                message_history.extend(filtered)
+                if len(message_history) > 40:
+                    message_history = message_history[-40:]
 
                 if agent_response and agent_response.awaiting_user_input:
                     console.print(