aloop 0.1.1__py3-none-any.whl

llm/model_manager.py

@@ -0,0 +1,265 @@
+"""Model manager for handling multiple models with YAML persistence."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from contextlib import suppress
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import urlparse
+
+from utils import get_logger
+
+logger = get_logger(__name__)
+
+DEFAULT_CONFIG_TEMPLATE = """# Model Configuration
+# This file is gitignored - do not commit to version control
+#
+# The key under `models` is the LiteLLM model ID (provider/model).
+# Fill in `api_key` directly in this file.
+#
+# Supported fields:
+#   - api_key: API key (required for most hosted providers)
+#   - api_base: Custom base URL (optional)
+#   - timeout: Request timeout in seconds (default: 600)
+#   - drop_params: Drop unsupported params (default: true)
+
+models:
+  # openai/gpt-4o:
+  #   api_key: sk-...
+  #   timeout: 300
+  # anthropic/claude-3-5-sonnet-20241022:
+  #   api_key: sk-ant-...
+  # ollama/llama2:
+  #   api_base: http://localhost:11434
+default: null
+"""
+
+
+def _coerce_int(value: Any, default: int) -> int:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return default
+    if isinstance(value, int):
+        return value
+    try:
+        return int(str(value).strip())
+    except (ValueError, TypeError):
+        return default
+
+
+def _coerce_bool(value: Any, default: bool) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        v = value.strip().lower()
+        if v in {"true", "1", "yes", "y", "on"}:
+            return True
+        if v in {"false", "0", "no", "n", "off"}:
+            return False
+    return default
+
+
+def _is_local_api_base(api_base: str | None) -> bool:
+    if not api_base:
+        return False
+    raw = str(api_base).strip()
+    if not raw:
+        return False
+    if "://" not in raw:
+        raw = f"http://{raw}"
+    parsed = urlparse(raw)
+    host = (parsed.hostname or "").lower()
+    return host in {"localhost", "127.0.0.1", "::1"}
+
+
+@dataclass
+class ModelProfile:
+    """Configuration for a single model."""
+
+    model_id: str  # LiteLLM model ID (e.g. "openai/gpt-4o")
+    api_key: str | None = None
+    api_base: str | None = None
+    timeout: int = 600
+    drop_params: bool = True
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def provider(self) -> str:
+        return self.model_id.split("/")[0] if "/" in self.model_id else "unknown"
+
+    @property
+    def display_name(self) -> str:
+        return self.model_id
+
+    def to_dict(self) -> dict[str, Any]:
+        result: dict[str, Any] = {"timeout": self.timeout, "drop_params": self.drop_params}
+        if self.api_key:
+            result["api_key"] = self.api_key
+        if self.api_base is not None:
+            result["api_base"] = self.api_base
+        if self.extra:
+            result.update(self.extra)
+        return result
+
+
+class ModelManager:
+    """Manages multiple models with YAML persistence."""
+
+    CONFIG_PATH = os.path.join(os.path.expanduser("~"), ".aloop", "models.yaml")
+
+    def __init__(self, config_path: str | None = None):
+        self.config_path = config_path or self.CONFIG_PATH
+        self.models: dict[str, ModelProfile] = {}
+        self.default_model_id: str | None = None
+        self.current_model_id: str | None = None
+        self._load()
+
+    def _ensure_yaml(self) -> None:
+        try:
+            import yaml  # noqa: F401
+        except ImportError as e:
+            raise RuntimeError(
+                "PyYAML is required for model configuration. Install it (e.g. `uv add pyyaml`)."
+            ) from e
+
+    def _atomic_write(self, content: str) -> None:
+        directory = os.path.dirname(self.config_path) or "."
+        os.makedirs(directory, exist_ok=True)
+
+        fd, tmp_path = tempfile.mkstemp(prefix=".models.", suffix=".tmp", dir=directory)
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                f.write(content)
+            os.replace(tmp_path, self.config_path)
+            with suppress(OSError):
+                os.chmod(self.config_path, 0o600)
+        finally:
+            with suppress(OSError):
+                os.unlink(tmp_path)
+
+    def _create_default_config(self) -> None:
+        self._atomic_write(DEFAULT_CONFIG_TEMPLATE)
+        logger.info(f"Created model config template at {self.config_path}")
+
+    def _load(self) -> None:
+        self._ensure_yaml()
+        import yaml
+
+        if not os.path.exists(self.config_path):
+            self._create_default_config()
+
+        with open(self.config_path, encoding="utf-8") as f:
+            config = yaml.safe_load(f) or {}
+
+        models = config.get("models") or {}
+        if not isinstance(models, dict):
+            logger.warning("Invalid models.yaml format: 'models' should be a mapping")
+            models = {}
+
+        for model_id, data in models.items():
+            if not isinstance(model_id, str) or not model_id.strip():
+                continue
+            if not isinstance(data, dict):
+                logger.warning(f"Invalid model config for '{model_id}', skipping")
+                continue
+
+            api_key = data.get("api_key")
+            api_base = data.get("api_base")
+            timeout = _coerce_int(data.get("timeout"), default=600)
+            drop_params = _coerce_bool(data.get("drop_params"), default=True)
+            extra = {
+                k: v
+                for k, v in data.items()
+                if k not in {"name", "api_key", "api_base", "timeout", "drop_params"}
+            }
+
+            self.models[model_id] = ModelProfile(
+                model_id=model_id,
+                api_key=None if api_key is None else str(api_key),
+                api_base=None if api_base is None else str(api_base),
+                timeout=timeout,
+                drop_params=drop_params,
+                extra=extra,
+            )
+
+        default = config.get("default")
+        self.default_model_id = default if isinstance(default, str) else None
+        if self.default_model_id not in self.models:
+            self.default_model_id = next(iter(self.models.keys()), None)
+
+        self.current_model_id = self.default_model_id
+        logger.info(f"Loaded {len(self.models)} models from {self.config_path}")
+
+    def _save(self) -> None:
+        self._ensure_yaml()
+        import yaml
+
+        config = {
+            "models": {mid: profile.to_dict() for mid, profile in self.models.items()},
+            "default": self.default_model_id,
+        }
+        header = "# Model Configuration\n# This file is gitignored - do not commit to version control\n\n"
+        body = yaml.safe_dump(config, sort_keys=False, allow_unicode=True)
+        self._atomic_write(header + body)
+
+    def is_configured(self) -> bool:
+        return bool(self.models) and bool(self.default_model_id)
+
+    def get_model(self, model_id: str) -> ModelProfile | None:
+        return self.models.get(model_id)
+
+    def list_models(self) -> list[ModelProfile]:
+        return list(self.models.values())
+
+    def get_model_ids(self) -> list[str]:
+        return list(self.models.keys())
+
+    def get_default_model_id(self) -> str | None:
+        return self.default_model_id
+
+    def get_current_model(self) -> ModelProfile | None:
+        if not self.current_model_id:
+            return None
+        return self.models.get(self.current_model_id)
+
+    def set_default(self, model_id: str) -> bool:
+        if model_id not in self.models:
+            return False
+        self.default_model_id = model_id
+        if not self.current_model_id:
+            self.current_model_id = model_id
+        self._save()
+        return True
+
+    def switch_model(self, model_id: str) -> ModelProfile | None:
+        if model_id not in self.models:
+            return None
+        self.current_model_id = model_id
+        return self.get_current_model()
+
+    def validate_model(self, model: ModelProfile) -> tuple[bool, str]:
+        """Validate a model has required configuration."""
+        if not model.model_id:
+            return False, "Model ID is missing."
+        if (
+            model.provider not in {"ollama", "localhost"}
+            and not _is_local_api_base(model.api_base)
+            and not (model.api_key or "").strip()
+        ):
+            return (
+                False,
+                f"API key not configured for {model.provider}. "
+                f"Edit `{self.config_path}` and set models['{model.model_id}'].api_key.",
+            )
+        return True, ""
+
+    def reload(self) -> None:
+        self.models.clear()
+        self.default_model_id = None
+        self.current_model_id = None
+        self._load()

llm/retry.py

@@ -0,0 +1,95 @@
+"""Retry utilities for LLM API calls using tenacity."""
+
+import asyncio
+from typing import Callable, TypeVar
+
+from tenacity import retry, retry_if_exception, stop_after_attempt
+from tenacity.wait import wait_base
+
+from config import Config
+from utils import get_logger
+
+logger = get_logger(__name__)
+T = TypeVar("T")
+
+
+def is_rate_limit_error(error: BaseException) -> bool:
+    """Check if an error is a rate limit error."""
+    error_str = str(error).lower()
+    rate_limit_indicators = [
+        "429",
+        "rate limit",
+        "quota",
+        "too many requests",
+        "resourceexhausted",
+    ]
+    return any(indicator in error_str for indicator in rate_limit_indicators)
+
+
+def is_retryable_error(error: BaseException) -> bool:
+    """Check if an error is retryable."""
+    if isinstance(error, asyncio.CancelledError):
+        return False
+
+    if is_rate_limit_error(error):
+        return True
+
+    error_str = str(error).lower()
+    error_type = type(error).__name__
+
+    if "RateLimitError" in error_type or "APIConnectionError" in error_type:
+        return True
+
+    retryable_indicators = [
+        "timeout",
+        "connection",
+        "server error",
+        "500",
+        "502",
+        "503",
+        "504",
+    ]
+    return any(indicator in error_str for indicator in retryable_indicators)
+
+
+class _ConfigBackoff(wait_base):
+    def __call__(self, retry_state) -> float:
+        attempt = max(retry_state.attempt_number - 1, 0)
+        return Config.get_retry_delay(attempt)
+
+
+def _log_before_sleep(retry_state) -> None:
+    error = retry_state.outcome.exception() if retry_state.outcome else None
+    if not error:
+        return
+    error_type = "Rate limit" if is_rate_limit_error(error) else "Retryable"
+    delay = _ConfigBackoff()(retry_state)
+    logger.warning(f"{error_type} error: {error}")
+    logger.warning(
+        "Retrying in %.1fs... (attempt %s/%s)",
+        delay,
+        retry_state.attempt_number,
+        Config.RETRY_MAX_ATTEMPTS + 1,
+    )
+
+
+def with_retry():
+    """Decorator to add async retry logic with exponential backoff.
+
+    The total number of attempts is RETRY_MAX_ATTEMPTS + 1:
+    - 1 initial attempt
+    - RETRY_MAX_ATTEMPTS retry attempts (if initial fails)
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        # stop_after_attempt counts total attempts, not retries
+        # So for N retries, we need N+1 total attempts
+        return retry(
+            retry=retry_if_exception(is_retryable_error),
+            stop=stop_after_attempt(Config.RETRY_MAX_ATTEMPTS + 1),
+            wait=_ConfigBackoff(),
+            reraise=True,
+            before_sleep=_log_before_sleep,
+        )(func)
+
+    return decorator

main.py

@@ -0,0 +1,246 @@
+"""Main entry point for the agentic loop system."""
+
+import argparse
+import asyncio
+import importlib.metadata
+import warnings
+
+from rich.console import Console
+
+from agent.agent import LoopAgent
+from config import Config
+from interactive import run_interactive_mode, run_model_setup_mode
+from llm import LiteLLMAdapter, ModelManager
+from memory import MemoryManager
+from tools.advanced_file_ops import EditTool, GlobTool, GrepTool
+from tools.calculator import CalculatorTool
+from tools.code_navigator import CodeNavigatorTool
+from tools.explore import ExploreTool
+from tools.file_ops import FileReadTool, FileSearchTool, FileWriteTool
+from tools.notify import NotifyTool
+from tools.parallel_execute import ParallelExecutionTool
+from tools.shell import ShellTool
+from tools.shell_background import BackgroundTaskManager, ShellTaskStatusTool
+from tools.smart_edit import SmartEditTool
+from tools.web_fetch import WebFetchTool
+from tools.web_search import WebSearchTool
+from utils import setup_logger, terminal_ui
+from utils.runtime import ensure_runtime_dirs
+
+warnings.filterwarnings("ignore", message="Pydantic serializer warnings.*", category=UserWarning)
+
+
+def create_agent(model_id: str | None = None):
+    """Factory function to create agents with tools.
+
+    Args:
+        model_id: Optional LiteLLM model ID to use (defaults to current/default)
+
+    Returns:
+        Configured LoopAgent instance with all tools
+    """
+    # Initialize background task manager (shared between shell tools)
+    task_manager = BackgroundTaskManager.get_instance()
+
+    # Initialize base tools
+    tools = [
+        FileReadTool(),
+        FileWriteTool(),
+        FileSearchTool(),
+        CalculatorTool(),
+        WebSearchTool(),
+        WebFetchTool(),
+        GlobTool(),
+        GrepTool(),
+        EditTool(),
+        SmartEditTool(),
+        CodeNavigatorTool(),
+        ShellTool(task_manager=task_manager),
+        ShellTaskStatusTool(task_manager=task_manager),
+        NotifyTool(),
+    ]
+
+    # Initialize model manager
+    model_manager = ModelManager()
+
+    if not model_manager.is_configured():
+        raise ValueError(
+            "No models configured. Run `aloop` without --task and use /model edit, "
+            "or edit `.aloop/models.yaml` to add at least one model and set `default`."
+        )
+
+    # Get the model to use
+    if model_id:
+        profile = model_manager.get_model(model_id)
+        if profile:
+            model_manager.switch_model(model_id)
+        else:
+            available = ", ".join(model_manager.get_model_ids())
+            terminal_ui.print_error(f"Model '{model_id}' not found, using default")
+            if available:
+                terminal_ui.console.print(f"Available: {available}")
+
+    current_profile = model_manager.get_current_model()
+    if not current_profile:
+        raise ValueError("No model available. Please check `.aloop/models.yaml`.")
+
+    is_valid, error_msg = model_manager.validate_model(current_profile)
+    if not is_valid:
+        raise ValueError(error_msg)
+
+    # Create LLM instance with the current profile
+    llm = LiteLLMAdapter(
+        model=current_profile.model_id,
+        api_key=current_profile.api_key,
+        api_base=current_profile.api_base,
+        drop_params=current_profile.drop_params,
+        timeout=current_profile.timeout,
+    )
+
+    agent = LoopAgent(
+        llm=llm,
+        tools=tools,
+        max_iterations=Config.MAX_ITERATIONS,
+        model_manager=model_manager,
+    )
+
+    # Add tools that require agent reference
+    agent.tool_executor.add_tool(ExploreTool(agent))
+    agent.tool_executor.add_tool(ParallelExecutionTool(agent))
+
+    return agent
+
+
+async def _resolve_session_id(resume_arg: str) -> str:
+    """Resolve --resume argument to a full session ID.
+
+    Args:
+        resume_arg: "latest" or a session ID / prefix
+
+    Returns:
+        Full session ID
+
+    Raises:
+        ValueError: If session cannot be found
+    """
+    if resume_arg == "latest":
+        session_id = await MemoryManager.find_latest_session()
+        if not session_id:
+            raise ValueError("No sessions found to resume.")
+        return session_id
+
+    session_id = await MemoryManager.find_session_by_prefix(resume_arg)
+    if not session_id:
+        raise ValueError(f"Session '{resume_arg}' not found.")
+    return session_id
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(description="Run an AI agent with tool-calling capabilities")
+
+    try:
+        version = importlib.metadata.version("aloop")
+    except importlib.metadata.PackageNotFoundError:
+        version = "dev"
+    parser.add_argument("--version", "-V", action="version", version=f"aloop {version}")
+
+    parser.add_argument(
+        "--task",
+        "-t",
+        type=str,
+        help="Task for the agent to complete (if not provided, enters interactive mode)",
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Enable verbose logging to .aloop/logs/",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        help="Model to use (LiteLLM model ID, e.g. openai/gpt-4o)",
+    )
+    parser.add_argument(
+        "--resume",
+        "-r",
+        nargs="?",
+        const="latest",
+        help="Resume a previous session (session ID prefix or 'latest')",
+    )
+
+    args = parser.parse_args()
+
+    # Initialize runtime directories (create logs dir only in verbose mode)
+    ensure_runtime_dirs(create_logs=args.verbose)
+
+    # Initialize logging only in verbose mode
+    if args.verbose:
+        setup_logger()
+
+    # Validate config
+    try:
+        Config.validate()
+    except ValueError as e:
+        terminal_ui.print_error(str(e), title="Configuration Error")
+        return
+
+    # Resolve --resume session ID early (before agent creation) so we can fail fast
+    resume_session_id = None
+    if args.resume:
+        try:
+            resume_session_id = asyncio.run(_resolve_session_id(args.resume))
+            terminal_ui.print_info(f"Resuming session: {resume_session_id}")
+        except ValueError as e:
+            terminal_ui.print_error(str(e), title="Resume Error")
+            return
+
+    # Create agent with optional model selection. If we're going into interactive mode and
+    # models aren't configured yet, enter a setup session first.
+    try:
+        agent = create_agent(model_id=args.model)
+    except ValueError as e:
+        if args.task:
+            terminal_ui.print_error(str(e), title="Model Configuration Error")
+            terminal_ui.console.print(
+                "Edit `.aloop/models.yaml` to add models and set `default` (this file is gitignored). "
+                "Tip: run `aloop` (interactive) and use /model edit."
+            )
+            return
+
+        terminal_ui.print_error(str(e), title="Model Setup Required")
+        ready = asyncio.run(run_model_setup_mode())
+        if not ready:
+            return
+
+        # Retry after setup.
+        agent = create_agent(model_id=args.model)
+
+    async def _run() -> None:
+        # Load resumed session if requested
+        if resume_session_id:
+            await agent.load_session(resume_session_id)
+
+        # If no task provided, enter interactive mode (default behavior)
+        if not args.task:
+            await run_interactive_mode(agent)
+            return
+
+        # Single-turn mode: execute one task and exit
+        task = args.task
+
+        # Quiet mode: suppress all Rich UI output, print raw result only
+        terminal_ui.console = Console(quiet=True)
+
+        # Run agent
+        result = await agent.run(task)
+
+        print(result)
+
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    main()

memory/__init__.py

@@ -0,0 +1,20 @@
+"""Memory management system for aloop framework.
+
+This module provides intelligent memory management with automatic compression,
+token tracking, cost optimization, and YAML-based persistence.
+"""
+
+from .compressor import WorkingMemoryCompressor
+from .manager import MemoryManager
+from .short_term import ShortTermMemory
+from .token_tracker import TokenTracker
+from .types import CompressedMemory, CompressionStrategy
+
+__all__ = [
+    "CompressedMemory",
+    "CompressionStrategy",
+    "MemoryManager",
+    "ShortTermMemory",
+    "WorkingMemoryCompressor",
+    "TokenTracker",
+]