quantalogic 0.2.0__py3-none-any.whl

quantalogic/interactive_text_editor.py

@@ -0,0 +1,190 @@
+"""Utility functions for the QuantaLogic AI Assistant."""
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+from rich.console import Console
+from rich.panel import Panel
+
+
+class InputHistoryManager:
+    """Manages the history of input states for undo functionality."""
+
+    def __init__(self):
+        """Initialize the InputHistoryManager with an empty history stack and current state."""
+        self.history_stack = []
+        self.current_state = []
+
+    def push_state(self, lines):
+        """Push the current state to the history stack and update the current state.
+
+        Args:
+            lines (list): The current lines of input to be saved in the history.
+        """
+        self.history_stack.append(self.current_state.copy())
+        self.current_state = lines.copy()
+
+    def undo(self, lines):
+        """Revert to the previous state from the history stack.
+
+        Args:
+            lines (list): The current lines of input to be updated to the previous state.
+
+        Returns:
+            bool: True if undo was successful, False otherwise.
+        """
+        if self.history_stack:
+            self.current_state = self.history_stack.pop()
+            lines[:] = self.current_state
+            return True
+        return False
+
+
+def handle_edit_command(lines, args, console, session, history_manager):
+    """Handle the 'edit' command to modify a specific line.
+
+    Args:
+        lines (list): The current lines of input.
+        args (list): The arguments provided with the command.
+        console (Console): The console object for output.
+        session (PromptSession): The prompt session for user input.
+        history_manager (InputHistoryManager): The history manager for state tracking.
+    """
+    try:
+        edit_line_num = int(args[0]) - 1
+        if 0 <= edit_line_num < len(lines):
+            console.print(f"[bold]Editing Line {edit_line_num + 1}:[/bold] {lines[edit_line_num]}")
+            new_line = session.prompt("New content: ")
+            history_manager.push_state(lines)
+            lines[edit_line_num] = new_line
+        else:
+            console.print("[red]Invalid line number.[/red]")
+    except (ValueError, IndexError):
+        console.print("[red]Invalid edit command. Usage: edit <line_number>[/red]")
+
+
+def handle_delete_command(lines, args, console, history_manager):
+    """Handle the 'delete' command to remove a specific line.
+
+    Args:
+        lines (list): The current lines of input.
+        args (list): The arguments provided with the command.
+        console (Console): The console object for output.
+        history_manager (InputHistoryManager): The history manager for state tracking.
+    """
+    try:
+        delete_line_num = int(args[0]) - 1
+        if 0 <= delete_line_num < len(lines):
+            history_manager.push_state(lines)
+            lines.pop(delete_line_num)
+            console.print(f"[bold]Deleted Line {delete_line_num + 1}[/bold]")
+        else:
+            console.print("[red]Invalid line number.[/red]")
+    except (ValueError, IndexError):
+        console.print("[red]Invalid delete command. Usage: delete <line_number>[/red]")
+
+
+def handle_replace_command(lines, args, console, history_manager):
+    """Handle the 'replace' command to search and replace text in all lines.
+
+    Args:
+        lines (list): The current lines of input.
+        args (list): The arguments provided with the command.
+        console (Console): The console object for output.
+        history_manager (InputHistoryManager): The history manager for state tracking.
+    """
+    try:
+        search_str, replace_str = args
+        history_manager.push_state(lines)
+        for i in range(len(lines)):
+            lines[i] = lines[i].replace(search_str, replace_str)
+        console.print("[bold]Search and replace completed.[/bold]")
+    except ValueError:
+        console.print("[red]Invalid replace command. Usage: replace <search_str> <replace_str>[/red]")
+
+
+commands = {"edit": handle_edit_command, "delete": handle_delete_command, "replace": handle_replace_command}
+
+
+def handle_command(line, lines, console, session, history_manager):
+    """Handle a command entered by the user.
+
+    Args:
+        line (str): The command line entered by the user.
+        lines (list): The current lines of input.
+        console (Console): The console object for output.
+        session (PromptSession): The prompt session for user input.
+        history_manager (InputHistoryManager): The history manager for state tracking.
+
+    Returns:
+        bool: True if the command was handled, False otherwise.
+    """
+    parts = line.split()
+    if not parts:
+        return False
+    command = parts[0]
+    args = parts[1:]
+    if command in commands:
+        commands[command](lines, args, console, session, history_manager)
+        return True
+    return False
+
+
+def get_multiline_input(console: Console) -> str:
+    """Get multiline input from the user with enhanced UX.
+
+    Args:
+        console (Console): The console object for output.
+
+    Returns:
+        str: The multiline input provided by the user.
+    """
+    console.print(
+        Panel(
+            "Enter your task. Press [bold]Enter[/bold] twice to submit.\n"
+            "Available commands:\n"
+            "  edit <line_number> - Edit a specific line\n"
+            "  delete <line_number> - Delete a specific line\n"
+            "  replace <search_str> <replace_str> - Replace text in all lines",
+            title="Multi-line Input",
+            border_style="blue",
+        )
+    )
+
+    lines = []
+    history_manager = InputHistoryManager()
+    blank_lines = 0
+    line_number = 1
+
+    bindings = KeyBindings()
+
+    @bindings.add("c-z")
+    def _(event):
+        if history_manager.undo(lines):
+            console.print("[bold]Undo successful.[/bold]")
+
+    session = PromptSession(history=InMemoryHistory(), auto_suggest=AutoSuggestFromHistory(), key_bindings=bindings)
+
+    try:
+        while True:
+            prompt_text = f"{line_number:>3}: "
+            line = session.prompt(prompt_text, rprompt="Press Enter twice to submit")
+
+            if line.strip() == "":
+                blank_lines += 1
+                if blank_lines == 2:
+                    break
+            else:
+                blank_lines = 0
+                if not handle_command(line, lines, console, session, history_manager):
+                    history_manager.push_state(lines)
+                    lines.append(line)
+                    line_number += 1
+    except EOFError:
+        console.print("\n[bold]Input terminated.[/bold]")
+    except KeyboardInterrupt:
+        console.print("\n[bold]Input cancelled by user.[/bold]")
+        return ""
+
+    return "\n".join(lines)

quantalogic/main.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+"""Main module for the QuantaLogic agent."""
+
+# Standard library imports
+import sys
+from typing import Optional
+
+# Third-party imports
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from quantalogic.agent import Agent
+
+# Local application imports
+from quantalogic.agent_config import (
+    MODEL_NAME,
+    create_coding_agent,
+    create_full_agent,
+    create_interpreter_agent,
+    create_orchestrator_agent,
+)
+from quantalogic.interactive_text_editor import get_multiline_input
+from quantalogic.print_event import console_print_events
+
+AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic"]
+
+
+def create_agent_for_mode(mode: str, model_name: str) -> Agent:
+    """Create an agent based on the specified mode."""
+    if mode == "code":
+        return create_coding_agent(model_name, basic=False)
+    if mode == "code-basic":
+        return create_coding_agent(model_name, basic=True)
+    elif mode == "basic":
+        return create_orchestrator_agent(model_name)
+    elif mode == "full":
+        return create_full_agent(model_name)
+    elif mode == "interpreter":
+        return create_interpreter_agent(model_name)
+    else:
+        raise ValueError(f"Unknown agent mode: {mode}")
+
+
+def switch_verbose(verbose_mode: bool) -> None:
+    pass
+
+
+def get_task_from_file(file_path: str) -> str:
+    """Get task content from specified file."""
+    try:
+        with open(file_path, encoding="utf-8") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Error: File '{file_path}' not found.")
+    except PermissionError:
+        raise PermissionError(f"Error: Permission denied when reading '{file_path}'.")
+    except Exception as e:
+        raise Exception(f"Unexpected error reading file: {e}")
+
+
+def display_welcome_message(console: Console, model_name: str) -> None:
+    """Display the welcome message and instructions."""
+    version = get_version()
+    console.print(
+        Panel.fit(
+            f"[bold cyan]🌟 Welcome to QuantaLogic AI Assistant v{version} ! 🌟[/bold cyan]\n\n"
+            "[green]🎯 How to Use:[/green]\n\n"
+            "1. [bold]Describe your task[/bold]: Tell the AI what you need help with.\n"
+            '   - Example: "Write a Python function to calculate Fibonacci numbers."\n'
+            '   - Example: "Explain quantum computing in simple terms."\n'
+            '   - Example: "Generate a list of 10 creative project ideas."\n'
+            '   - Example: "Create a project plan for a new AI startup.\n'
+            '   - Example: "Help me debug this Python code."\n\n'
+            "2. [bold]Submit your task[/bold]: Press [bold]Enter[/bold] twice to send your request.\n\n"
+            "3. [bold]Exit the app[/bold]: Leave the input blank and press [bold]Enter[/bold] twice to close the assistant.\n\n"
+            f"[yellow]ℹ️ System Info:[/yellow]\n\n"
+            f"- Version: {get_version()}\n"
+            f"- Model: {model_name}\n\n"
+            "[bold magenta]💡 Pro Tips:[/bold magenta]\n\n"
+            "- Be as specific as possible in your task description to get the best results!\n"
+            "- Use clear and concise language when describing your task\n"
+            "- For coding tasks, include relevant context and requirements\n"
+            "- The AI can handle complex tasks - don't hesitate to ask challenging questions!",
+            title="[bold]Instructions[/bold]",
+            border_style="blue",
+        )
+    )
+
+
+def get_version() -> str:
+    """Get the current version of the package."""
+    return "QuantaLogic version: 1.0.0"
+
+
+@click.group(invoke_without_command=True)
+@click.option("--version", is_flag=True, help="Show version information.")
+@click.pass_context
+def cli(ctx: click.Context, version: bool) -> None:
+    """QuantaLogic AI Assistant - A powerful AI tool for various tasks."""
+    if version:
+        console = Console()
+        console.print(f"QuantaLogic version: {get_version()}")
+        sys.exit(0)
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(task)
+
+
+@cli.command()
+@click.option("--file", type=click.Path(exists=True), help="Path to task file.")
+@click.option(
+    "--model-name",
+    default=MODEL_NAME,
+    help='Specify the model to use (litellm format, e.g. "openrouter/deepseek-chat").',
+)
+@click.option("--verbose", is_flag=True, help="Enable verbose output.")
+@click.option("--mode", type=click.Choice(AGENT_MODES), default="code", help="Agent mode (code/search/full).")
+@click.argument("task", required=False)
+def task(file: Optional[str], model_name: str, verbose: bool, mode: str, task: Optional[str]) -> None:
+    """Execute a task with the QuantaLogic AI Assistant."""
+    console = Console()
+    switch_verbose(verbose)
+
+    try:
+        if file:
+            task_content = get_task_from_file(file)
+        else:
+            if task:
+                task_content = task
+            else:
+                display_welcome_message(console, model_name)
+                task_content = get_multiline_input(console).strip()
+                if not task_content:
+                    console.print("[yellow]No task provided. Exiting...[/yellow]")
+                    sys.exit(2)
+
+        if model_name != MODEL_NAME:
+            console.print(
+                Panel.fit(
+                    f"[bold]Task to be submitted:[/bold]\n{task_content}",
+                    title="[bold]Task Preview[/bold]",
+                    border_style="blue",
+                )
+            )
+            if not Confirm.ask("[bold]Are you sure you want to submit this task?[/bold]"):
+                console.print("[yellow]Task submission cancelled. Exiting...[/yellow]")
+                sys.exit(0)
+
+        agent = create_agent_for_mode(mode, model_name)
+        agent.event_emitter.on(
+            [
+                "task_complete",
+                "task_think_start",
+                "task_think_end",
+                "tool_execution_start",
+                "tool_execution_end",
+                "error_max_iterations_reached",
+                "memory_full",
+                "memory_compacted",
+                "memory_summary",
+            ],
+            console_print_events,
+        )
+
+        result = agent.solve_task(task=task_content, max_iterations=300)
+
+        console.print(
+            Panel.fit(
+                f"[bold]Task Result:[/bold]\n{result}", title="[bold]Execution Output[/bold]", border_style="green"
+            )
+        )
+
+    except Exception as e:
+        console.print(f"[red]{str(e)}[/red]")
+        sys.exit(1)
+
+
+def main():
+    """Entry point for the quantalogic CLI."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

quantalogic/memory.py

@@ -0,0 +1,217 @@
+"""Memory for the agent."""
+
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    """Represents a message in the agent's memory."""
+
+    role: str
+    content: str
+
+
+class AgentMemory:
+    """Memory for the agent."""
+
+    def __init__(self):
+        """Initialize the agent memory."""
+        self.memory: list[Message] = []
+
+    def add(self, message: Message):
+        """Add a message to the agent memory.
+
+        Args:
+            message (Message): The message to add to memory.
+        """
+        self.memory.append(message)
+
+    def reset(self):
+        """Reset the agent memory."""
+        self.memory.clear()
+
+    def compact(self, n: int = 2):
+        """Compact the memory to keep only essential messages.
+
+        This method keeps:
+        - The system message (if present)
+        - First two pairs of user-assistant messages
+        - Last n pairs of user-assistant messages (default: 2)
+
+        Args:
+            n (int): Number of last message pairs to keep. Defaults to 2.
+        """
+        if not self.memory:
+            return
+
+        # Keep system message if present
+        compacted_memory = []
+        if self.memory and self.memory[0].role == "system":
+            compacted_memory.append(self.memory[0])
+            messages = self.memory[1:]
+        else:
+            messages = self.memory[:]
+
+        # Extract user-assistant pairs
+        pairs = []
+        i = 0
+        while i < len(messages) - 1:
+            if messages[i].role == "user" and messages[i + 1].role == "assistant":
+                pairs.append((messages[i], messages[i + 1]))
+            i += 2
+
+        # Keep first two and last n pairs
+        total_pairs_to_keep = 2 + n
+        if len(pairs) <= total_pairs_to_keep:
+            for user_msg, assistant_msg in pairs:
+                compacted_memory.extend([user_msg, assistant_msg])
+        else:
+            # Add first two pairs
+            for pair in pairs[:2]:
+                compacted_memory.extend(pair)
+            # Add last n pairs
+            for pair in pairs[-n:]:
+                compacted_memory.extend(pair)
+
+        self.memory = compacted_memory
+
+
+class VariableMemory:
+    """Memory for a variable."""
+
+    def __init__(self):
+        """Initialize the variable memory."""
+        self.memory: dict[str, tuple[str, str]] = {}
+        self.counter: int = 0
+
+    def add(self, value: str) -> str:
+        """Add a value to the variable memory.
+
+        Args:
+            value (str): The value to add to memory.
+
+        Returns:
+            str: The key associated with the added value.
+        """
+        self.counter += 1
+        key = f"var{self.counter}"
+        self.memory[key] = (key, value)
+        return key
+
+    def reset(self):
+        """Reset the variable memory."""
+        self.memory.clear()
+        self.counter = 0
+
+    def get(self, key: str, default: str | None = None) -> str | None:
+        """Get a value from the variable memory.
+
+        Args:
+            key (str): The key of the value to retrieve.
+            default (str, optional): Default value if key is not found. Defaults to None.
+
+        Returns:
+            str | None: The value associated with the key, or default if not found.
+        """
+        return self.memory.get(key, default)[1] if key in self.memory else default
+
+    def __getitem__(self, key: str) -> str:
+        """Get a value using dictionary-style access.
+
+        Args:
+            key (str): The key of the value to retrieve.
+
+        Returns:
+            str: The value associated with the key.
+
+        Raises:
+            KeyError: If the key is not found.
+        """
+        return self.memory[key][1]
+
+    def __setitem__(self, key: str, value: str):
+        """Set a value using dictionary-style assignment.
+
+        Args:
+            key (str): The key to set.
+            value (str): The value to associate with the key.
+        """
+        self.memory[key] = (key, value)
+
+    def __delitem__(self, key: str):
+        """Delete a key-value pair using dictionary-style deletion.
+
+        Args:
+            key (str): The key to delete.
+
+        Raises:
+            KeyError: If the key is not found.
+        """
+        del self.memory[key]
+
+    def __contains__(self, key: str) -> bool:
+        """Check if a key exists in the memory.
+
+        Args:
+            key (str): The key to check.
+
+        Returns:
+            bool: True if the key exists, False otherwise.
+        """
+        return key in self.memory
+
+    def __len__(self) -> int:
+        """Get the number of items in the memory.
+
+        Returns:
+            int: Number of items in the memory.
+        """
+        return len(self.memory)
+
+    def keys(self):
+        """Return a view of the memory's keys.
+
+        Returns:
+            dict_keys: A view of the memory's keys.
+        """
+        return self.memory.keys()
+
+    def values(self):
+        """Return a view of the memory's values.
+
+        Returns:
+            dict_values: A view of the memory's values.
+        """
+        return (value[1] for value in self.memory.values())
+
+    def items(self):
+        """Return a view of the memory's items.
+
+        Returns:
+            dict_items: A view of the memory's items.
+        """
+        return ((key, value[1]) for key, value in self.memory.items())
+
+    def pop(self, key: str, default: str | None = None) -> str | None:
+        """Remove and return a value for a key.
+
+        Args:
+            key (str): The key to remove.
+            default (str, optional): Default value if key is not found. Defaults to None.
+
+        Returns:
+            str | None: The value associated with the key, or default if not found.
+        """
+        return self.memory.pop(key, (None, default))[1] if default is not None else self.memory.pop(key)[1]
+
+    def update(self, other: dict[str, str] | None = None, **kwargs):
+        """Update the memory with key-value pairs from another dictionary.
+
+        Args:
+            other (dict, optional): Dictionary to update from. Defaults to None.
+            **kwargs: Additional key-value pairs to update.
+        """
+        if other is not None:
+            for key, value in other.items():
+                self.memory[key] = (key, value)
+        for key, value in kwargs.items():
+            self.memory[key] = (key, value)

quantalogic/model_names.py

@@ -0,0 +1,19 @@
+# Model names for reference
+# MODEL_NAME = "ollama/qwen2.5-coder:7b"
+# MODEL_NAME = "lm_studio/qwen2.5-coder-14b-instruct-mlx@8bit"
+# MODEL_NAME = "lm_studio/qwen2.5-coder-3b-instruct-mlx"
+# MODEL_NAME = "lm_studio/qwen2-7b-instruct"
+# MODEL_NAME = "gpt-4o-mini"
+# MODEL_NAME = "gpt-4o"
+# MODEL_NAME = "lm_studio/qwen2-7b-instruct"
+# MODEL_NAME = "lm_studio/llama-3.2-3b-instruct"
+# MODEL_NAME = "lm_studio/llama-3.3-70b-instruct"
+# MODEL_NAME = "bedrock/amazon.nova-pro-v1:0"
+# MODEL_NAME = "bedrock/amazon.nova-micro-v1:0"
+# MODEL_NAME = "bedrock/amazon.nova-lite-v1:0"
+# MODEL_NAME = "mistral/mistral-large-2411"
+# MODEL_NAME = "openrouter/meta-llama/llama-3.2-90b-vision-instruct:free"
+# MODEL_NAME = "openrouter/google/gemini-2.0-flash-thinking-exp:free"
+# MODEL_NAME = "openrouter/google/gemini-2.0-flash-exp:free"
+# MODEL_NAME = "openrouter/qwen/qwen-2.5-coder-32b-instruct"
+# MODEL_NAME = "openrouter/anthropic/claude-3.5-sonnet"

quantalogic/print_event.py

@@ -0,0 +1,66 @@
+"""Print events with rich formatting."""
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.tree import Tree
+
+
+def console_print_events(event: str, data: dict[str, any] = None):
+    """Print events with rich formatting.
+
+    Args:
+        event (str): Name of the event.
+        data (Dict[str, Any], optional): Additional event data. Defaults to None.
+    """
+    console = Console()
+
+    # Define panel title with enhanced styling
+    panel_title = f"[bold cyan]Event: {event}[/bold cyan]"
+
+    if not data:
+        # Display a friendly message when no data is available
+        console.print(
+            Panel(
+                "[italic yellow]No additional event data available.[/italic yellow]",
+                title=panel_title,
+                border_style="dim",
+                expand=True,
+                padding=(1, 2),
+            )
+        )
+        return
+
+    # Function to render nested dictionaries as a tree
+    def render_tree(data: dict[str, any], tree: Tree):
+        for key, value in data.items():
+            if isinstance(value, dict):
+                branch = tree.add(f"[bold magenta]{key}[/bold magenta]")
+                render_tree(value, branch)
+            elif isinstance(value, list):
+                branch = tree.add(f"[bold magenta]{key}[/bold magenta]")
+                for index, item in enumerate(value, start=1):
+                    if isinstance(item, dict):
+                        sub_branch = branch.add(f"[cyan]Item {index}[/cyan]")
+                        render_tree(item, sub_branch)
+                    else:
+                        branch.add(f"[green]{item}[/green]")
+            else:
+                tree.add(f"[bold yellow]{key}[/bold yellow]: [white]{value}[/white]")
+
+    # Create a Tree to represent nested data
+    tree = Tree(f"[bold blue]{event} Details[/bold blue]", guide_style="bold bright_blue")
+
+    render_tree(data, tree)
+
+    # Create a panel to display the tree
+    panel = Panel(
+        tree,
+        title=panel_title,
+        border_style="bright_blue",
+        padding=(1, 2),
+        box=box.ROUNDED,
+        expand=True,
+    )
+
+    console.print(panel)