aloop 0.1.0__py3-none-any.whl

tools/web_search.py

@@ -0,0 +1,61 @@
+"""Web search tool using DuckDuckGo."""
+
+import asyncio
+from typing import Any, Dict, List
+
+from ddgs import DDGS
+
+from .base import BaseTool
+
+# Default timeout for web search operations
+DEFAULT_SEARCH_TIMEOUT = 30.0
+
+
+def _sync_search(query: str, max_results: int = 5) -> List[Dict[str, str]]:
+    """Synchronous search function to run in thread."""
+    with DDGS() as ddgs:
+        return list(ddgs.text(query, max_results=max_results))
+
+
+class WebSearchTool(BaseTool):
+    """Simple web search using DuckDuckGo (no API key needed)."""
+
+    @property
+    def name(self) -> str:
+        return "web_search"
+
+    @property
+    def description(self) -> str:
+        return "Search the web for information using DuckDuckGo"
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "query": {
+                "type": "string",
+                "description": "Search query",
+            },
+            "timeout": {
+                "type": "number",
+                "description": "Optional timeout in seconds (default: 30)",
+                "default": DEFAULT_SEARCH_TIMEOUT,
+            },
+        }
+
+    async def execute(self, query: str, timeout: float = DEFAULT_SEARCH_TIMEOUT) -> str:
+        """Execute web search and return results."""
+        try:
+            timeout_val = float(timeout) if timeout else DEFAULT_SEARCH_TIMEOUT
+            results = []
+            async with asyncio.timeout(timeout_val):
+                search_results = await asyncio.to_thread(_sync_search, query, 5)
+                for r in search_results:
+                    title = r.get("title", "")
+                    href = r.get("href", "")
+                    body = r.get("body", "")
+                    results.append(f"[{title}]({href})\n{body}\n")
+            return "\n---\n".join(results) if results else "No results found"
+        except TimeoutError:
+            return f"Error: Web search timed out after {timeout}s"
+        except Exception as e:
+            return f"Error searching web: {str(e)}"

utils/__init__.py

@@ -0,0 +1,15 @@
+"""Utility modules for agentic loop."""
+
+from . import terminal_ui
+from .logger import get_log_file_path, get_logger, setup_logger
+
+# Note: Runtime functions are NOT exported here to avoid circular imports.
+# Import directly from utils.runtime when needed:
+#   from utils.runtime import get_config_file, get_sessions_dir, etc.
+
+__all__ = [
+    "setup_logger",
+    "get_logger",
+    "get_log_file_path",
+    "terminal_ui",
+]

utils/logger.py

@@ -0,0 +1,105 @@
+"""Logging configuration for the agentic loop system."""
+
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from .runtime import get_log_dir
+
+# Global flag to track if logging has been initialized
+_logging_initialized = False
+_log_file_path = None
+
+
+def setup_logger(
+    log_dir: Optional[str] = None,
+    log_level: Optional[str] = None,
+    log_to_console: bool = False,
+) -> None:
+    """Configure the logging system globally.
+
+    This should be called once at the start of the application when --verbose is enabled.
+    Logging is written to .aloop/logs/ by default.
+
+    Args:
+        log_dir: Directory to store log files (default: .aloop/logs/)
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_to_console: Whether to also log to console
+    """
+    global _logging_initialized, _log_file_path
+
+    if _logging_initialized:
+        return
+
+    # Use runtime log directory by default
+    if log_dir is None:
+        log_dir = get_log_dir()
+
+    # Get log level from Config if not provided
+    if log_level is None:
+        try:
+            from config import Config
+
+            log_level = Config.LOG_LEVEL
+        except ImportError:
+            log_level = "DEBUG"
+
+    # Set root logger level
+    level = getattr(logging, log_level.upper(), logging.DEBUG)
+    logging.root.setLevel(level)
+
+    # Create formatter
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+    )
+
+    # Add file handler (always enabled when setup_logger is called)
+    log_path = Path(log_dir)
+    log_path.mkdir(exist_ok=True, parents=True)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_file = log_path / f"aloop_{timestamp}.log"
+    _log_file_path = str(log_file)
+
+    file_handler = logging.FileHandler(log_file, encoding="utf-8")
+    file_handler.setLevel(level)
+    file_handler.setFormatter(formatter)
+    logging.root.addHandler(file_handler)
+
+    # Add console handler if enabled
+    if log_to_console:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.WARNING)
+        console_handler.setFormatter(formatter)
+        logging.root.addHandler(console_handler)
+
+    _logging_initialized = True
+
+    # Log initialization message
+    logging.info(f"Logging initialized. Level: {log_level}, File: {_log_file_path}")
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance for a module.
+
+    Note: This no longer auto-initializes logging. Logging is only enabled
+    when --verbose flag is used and setup_logger() is called explicitly.
+    Without verbose mode, logs go nowhere (NullHandler behavior).
+
+    Args:
+        name: Logger name (typically __name__)
+
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(name)
+
+
+def get_log_file_path() -> Optional[str]:
+    """Get the path to the current log file.
+
+    Returns:
+        Path to log file, or None if logging to file is disabled
+    """
+    return _log_file_path

utils/model_pricing.py

@@ -0,0 +1,49 @@
+"""model pricing - updated at 2026-01-24"""
+
+# Pricing is in USD per 1 million tokens
+MODEL_PRICING = {
+    # --- OpenAI ---
+    "gpt-5": {"input": 1.25, "output": 10.00},
+    "gpt-4.5": {"input": 75.00, "output": 150.00},
+    "gpt-4o": {"input": 2.50, "output": 10.00},
+    "gpt-4o-mini": {"input": 0.15, "output": 0.60},
+    "o1": {"input": 15.00, "output": 60.00},
+    "o1-mini": {"input": 1.10, "output": 4.40},
+    "o3": {"input": 2.00, "output": 8.00},
+    "o3-mini": {"input": 0.55, "output": 2.20},
+    "o4-mini": {"input": 1.10, "output": 4.40},
+    # --- Anthropic ---
+    "claude-opus-4-5": {"input": 5.00, "output": 25.00},
+    "claude-sonnet-4-5": {"input": 3.00, "output": 15.00},
+    "claude-haiku-4-5": {"input": 1.00, "output": 5.00},
+    "claude-opus-4-1": {"input": 15.00, "output": 75.00},
+    "claude-sonnet-4": {"input": 3.00, "output": 15.00},
+    "claude-opus-4": {"input": 15.00, "output": 75.00},
+    "claude-haiku-3": {"input": 0.25, "output": 1.25},
+    "claude-3-5-sonnet-20241022": {"input": 3.00, "output": 15.00},
+    "claude-3-5-haiku-20241022": {"input": 0.80, "output": 4.00},
+    "claude-3-opus-20240229": {"input": 15.00, "output": 75.00},
+    # --- Google Gemini ---
+    "gemini-3-pro": {"input": 2.00, "output": 12.00},
+    "gemini-3-pro-preview": {"input": 2.00, "output": 12.00},
+    "gemini-3-flash": {"input": 0.50, "output": 3.00},
+    "gemini-3-flash-preview": {"input": 0.50, "output": 3.00},
+    "gemini-2-5-pro": {"input": 1.25, "output": 10.00},
+    "gemini-2-5-flash": {"input": 0.30, "output": 2.50},
+    "gemini-2-5-flash-lite": {"input": 0.10, "output": 0.40},
+    "gemini-2-0-flash": {"input": 0.10, "output": 0.40},
+    "gemini-2-0-flash-lite": {"input": 0.075, "output": 0.30},
+    "gemini-1-5-pro": {"input": 1.25, "output": 5.00},
+    "gemini-1-5-flash": {"input": 0.075, "output": 0.30},
+    # --- DeepSeek ---
+    "deepseek-v3": {"input": 0.14, "output": 0.28},
+    "deepseek-reasoner": {"input": 0.55, "output": 2.19},
+    # --- xAI (Grok) ---
+    "grok-4": {"input": 3.00, "output": 15.00},
+    "grok-4-fast": {"input": 0.20, "output": 0.50},
+    # --- Mistral ---
+    "mistral-large-2": {"input": 2.00, "output": 6.00},
+    "mistral-small-3": {"input": 0.10, "output": 0.30},
+    # --- Default ---
+    "default": {"input": 0.55, "output": 2.19},
+}

utils/runtime.py

@@ -0,0 +1,75 @@
+"""Runtime directory management for aloop.
+
+All runtime data is stored under ~/.aloop/ directory:
+- config: Configuration file (created by config.py on first import)
+- sessions/: YAML-based session persistence
+- logs/: Log files (only created with --verbose)
+- history: Interactive mode command history
+"""
+
+import os
+
+RUNTIME_DIR = os.path.join(os.path.expanduser("~"), ".aloop")
+
+
+def get_runtime_dir() -> str:
+    """Get the runtime directory path.
+
+    Returns:
+        Path to ~/.aloop directory
+    """
+    return RUNTIME_DIR
+
+
+def get_config_file() -> str:
+    """Get the configuration file path.
+
+    Returns:
+        Path to ~/.aloop/config
+    """
+    return os.path.join(RUNTIME_DIR, "config")
+
+
+def get_sessions_dir() -> str:
+    """Get the sessions directory path.
+
+    Returns:
+        Path to ~/.aloop/sessions/
+    """
+    return os.path.join(RUNTIME_DIR, "sessions")
+
+
+def get_log_dir() -> str:
+    """Get the log directory path.
+
+    Returns:
+        Path to ~/.aloop/logs/
+    """
+    return os.path.join(RUNTIME_DIR, "logs")
+
+
+def get_history_file() -> str:
+    """Get the command history file path.
+
+    Returns:
+        Path to ~/.aloop/history
+    """
+    return os.path.join(RUNTIME_DIR, "history")
+
+
+def ensure_runtime_dirs(create_logs: bool = False) -> None:
+    """Ensure runtime directories exist.
+
+    Creates:
+    - ~/.aloop/sessions/
+    - ~/.aloop/logs/ (only if create_logs=True)
+
+    Note: ~/.aloop/config is created by config.py on first import.
+
+    Args:
+        create_logs: Whether to create the logs directory (for --verbose mode)
+    """
+    os.makedirs(os.path.join(RUNTIME_DIR, "sessions"), exist_ok=True)
+
+    if create_logs:
+        os.makedirs(os.path.join(RUNTIME_DIR, "logs"), exist_ok=True)