janito 1.14.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/cli/verbose_output.py

@@ -0,0 +1,196 @@
+"""
+Verbose output formatting and error handling for janito CLI (shared for single and chat modes).
+"""
+
+from rich import print as rich_print
+from rich.align import Align
+from rich.panel import Panel
+from rich.text import Text
+from janito.version import __version__ as VERSION
+from janito.cli.utils import format_tokens
+
+
+def print_verbose_header(agent, args):
+    if hasattr(args, "verbose") and args.verbose:
+        role = (
+            agent.template_vars.get("role") if hasattr(agent, "template_vars") else None
+        )
+        role_part = f" (Role: {role})" if role else ""
+        parts = [
+            f"Janito {VERSION}",
+            f"Provider: {agent.llm_provider.__class__.__name__}",
+            f"Model: {agent.llm_provider.model_name}{role_part}",
+            f"Driver: {agent.llm_provider.__class__.__module__.split('.')[-2] if len(agent.llm_provider.__class__.__module__.split('.')) > 1 else agent.llm_provider.__class__.__name__}",
+        ]
+        if hasattr(args, "think") and args.think:
+            parts.append("Thinking ON")
+        info_line = " | ".join(part.strip() for part in parts)
+        rich_print(
+            Panel(
+                Align(f"[cyan]{info_line}[/cyan]", align="center"),
+                style="on grey11",
+                expand=True,
+            )
+        )
+
+
+def print_verbose_info(label, content, style="green", align_content=False):
+    icon = "[bold]●[/bold]" if style == "green" else "[bold]🔷[/bold]"
+    panel_title = f"{icon} [bold {style}]{label}[/bold {style}]"
+    from rich.console import Console
+    from rich.align import Align
+    from rich.text import Text
+
+    console = Console()
+    width = console.size.width
+    obfuscated_content = content
+    # Obfuscate api_key if LLMDriverConfig
+    if (
+        hasattr(content, "__dataclass_fields__")
+        and "api_key" in content.__dataclass_fields__
+    ):
+        # Copy and mask the api_key
+        from copy import deepcopy
+
+        obfuscated_content = deepcopy(content)
+        if hasattr(obfuscated_content, "api_key") and obfuscated_content.api_key:
+            val = obfuscated_content.api_key
+            if len(val) > 8:
+                masked = val[:2] + "***" + val[-2:]
+            else:
+                masked = "***"
+            obfuscated_content.api_key = masked
+        else:
+            obfuscated_content.api_key = None
+    if align_content:
+        rendered_content = Align.center(Text(str(obfuscated_content)))
+    else:
+        rendered_content = Text(str(obfuscated_content))
+    panel = Panel(
+        rendered_content,
+        title=panel_title,
+        border_style=style,
+        expand=False,
+        width=min(width - 8, 100),
+    )
+    console.print(Align.center(panel))
+
+
+def print_performance(start_time, end_time, performance_collector, args):
+    if start_time is None or end_time is None:
+        generation_time_ns = None
+    else:
+        generation_time_ns = (end_time - start_time) * 1e9
+    if hasattr(args, "verbose") and args.verbose:
+        from rich.table import Table
+        from rich.style import Style
+        from rich import box
+
+        total_requests = performance_collector.get_total_requests()
+        avg_duration = performance_collector.get_average_duration()
+        status_counts = performance_collector.get_status_counts()
+        token_usage = performance_collector.get_token_usage()
+        error_count = performance_collector.get_error_count()
+        avg_turns = performance_collector.get_average_turns()
+        content_parts = performance_collector.get_content_part_count()
+
+        left = []
+        right = []
+        right.append(("[bold]Total Requests[/bold]", f"{total_requests}"))
+        left.append(("[bold]Avg Duration[/bold]", f"{avg_duration:.3f}s"))
+        right.append(
+            (
+                "[bold]Status Counts[/bold]",
+                (
+                    ", ".join(f"{k}: {v}" for k, v in status_counts.items())
+                    if status_counts
+                    else "-"
+                ),
+            )
+        )
+        if token_usage:
+            usage_str = ", ".join(
+                f"{k.removesuffix('_token_count').removesuffix('_tokens')}: {format_tokens(v)}"
+                for k, v in token_usage.items()
+            )
+        else:
+            usage_str = "-"
+        left.append(("[bold]Token Usage[/bold]", usage_str))
+        right.append(
+            ("[bold]Avg Turns[/bold]", f"{avg_turns:.2f}" if avg_turns > 0 else "-")
+        )
+        left.append(
+            (
+                "[bold]Content Parts[/bold]",
+                f"{content_parts}" if content_parts > 0 else "-",
+            )
+        )
+        right.append(
+            ("[bold]Errors[/bold]", f"{error_count}" if error_count > 0 else "-")
+        )
+
+        total_tool_events = performance_collector.get_total_tool_events()
+        tool_names_counter = performance_collector.get_tool_names_counter()
+        tool_error_count = performance_collector.get_tool_error_count()
+        tool_error_messages = performance_collector.get_tool_error_messages()
+        tool_action_counter = performance_collector.get_tool_action_counter()
+        tool_subtype_counter = performance_collector.get_tool_subtype_counter()
+
+        tool_names_str = (
+            ", ".join(f"{k}: {v}" for k, v in tool_names_counter.items())
+            if tool_names_counter
+            else "-"
+        )
+        tool_actions_str = (
+            ", ".join(
+                f"{k.split('.')[-1]}: {v}" for k, v in tool_action_counter.items()
+            )
+            if tool_action_counter
+            else "-"
+        )
+        tool_subtypes_str = (
+            ", ".join(f"{k}: {v}" for k, v in tool_subtype_counter.items())
+            if tool_subtype_counter
+            else "-"
+        )
+        tool_errors_str = f"{tool_error_count}"
+        tool_error_msgs_str = (
+            "\n".join(tool_error_messages[:2])
+            + ("\n..." if len(tool_error_messages) > 2 else "")
+            if tool_error_count
+            else "-"
+        )
+
+        left.append(("[bold]Tool Events[/bold]", f"{total_tool_events}"))
+        right.append(("[bold]Tool Usage[/bold]", tool_names_str))
+        left.append(("[bold]Tool Errors[/bold]", tool_errors_str))
+
+        max_len = max(len(left), len(right))
+        while len(left) < max_len:
+            left.append(("", ""))
+        while len(right) < max_len:
+            right.append(("", ""))
+
+        from rich.table import Table
+
+        table = Table(
+            show_header=False,
+            box=box.SIMPLE,
+            pad_edge=False,
+            style="cyan",
+            expand=False,
+        )
+        table.add_column(justify="right")
+        table.add_column(justify="left")
+        table.add_column(justify="right")
+        table.add_column(justify="left")
+        for (l_key, l_val), (r_key, r_val) in zip(left, right):
+            table.add_row(l_key, l_val, r_key, r_val)
+        if total_requests == 0:
+            table.add_row("[bold]Info[/bold]", "No performance data available.", "", "")
+        rich_print(Panel(table, style="on grey11", expand=True))
+
+
+def handle_exception(e):
+    rich_print(f"[bold red]Error:[/bold red] {e}")
+    return

janito/config.py

@@ -0,0 +1,5 @@
+# Shared Janito ConfigManager singleton
+from janito.config_manager import ConfigManager
+
+# Only one global instance! Used by CLI, provider_config, others:
+config = ConfigManager(config_path=None)

janito/config_manager.py

@@ -0,0 +1,110 @@
+import json
+from pathlib import Path
+from threading import Lock
+
+
+class ConfigManager:
+    """
+    Unified configuration manager supporting:
+      - Defaults
+      - File-based configuration
+      - Runtime overrides (e.g., CLI args)
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if not cls._instance:
+                cls._instance = super(ConfigManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
+        # Lazy single-init
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+        self._initialized = True
+
+        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
+        self.defaults = dict(defaults) if defaults else {}
+        self.file_config = {}
+        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
+        self._load_file_config()
+
+    def _load_file_config(self):
+        if self.config_path.exists():
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                try:
+                    self.file_config = json.load(f)
+                except Exception:
+                    self.file_config = {}
+        else:
+            self.file_config = {}
+
+    def save(self):
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+
+    def get(self, key, default=None):
+        # Precedence: runtime_overrides > file_config > defaults
+        for layer in (self.runtime_overrides, self.file_config, self.defaults):
+            if key in layer and layer[key] is not None:
+                return layer[key]
+        return default
+
+    def runtime_set(self, key, value):
+        self.runtime_overrides[key] = value
+
+    def file_set(self, key, value):
+        # Always reload, update, and persist
+        self._load_file_config()
+        self.file_config[key] = value
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+
+    def all(self, layered=False):
+        merged = dict(self.defaults)
+        merged.update(self.file_config)
+        merged.update(self.runtime_overrides)
+        if layered:
+            # Only file+runtime, i.e., what is saved to disk
+            d = dict(self.file_config)
+            d.update(self.runtime_overrides)
+            return d
+        return merged
+
+    # Namespaced provider/model config
+    def get_provider_config(self, provider, default=None):
+        providers = self.file_config.get("providers") or {}
+        return providers.get(provider) or (default or {})
+
+    def set_provider_config(self, provider, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        self.file_config["providers"][provider][key] = value
+
+    def get_provider_model_config(self, provider, model, default=None):
+        return (
+            self.file_config.get("providers")
+            or {}.get(provider, {}).get("models", {}).get(model)
+            or (default or {})
+        )
+
+    def set_provider_model_config(self, provider, model, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        if "models" not in self.file_config["providers"][provider]:
+            self.file_config["providers"][provider]["models"] = {}
+        if model not in self.file_config["providers"][provider]["models"]:
+            self.file_config["providers"][provider]["models"][model] = {}
+        self.file_config["providers"][provider]["models"][model][key] = value
+
+    # Support loading runtime overrides after init (e.g. after parsing CLI args)
+    def apply_runtime_overrides(self, overrides_dict):
+        self.runtime_overrides.update(overrides_dict)

janito/conversation_history.py

@@ -0,0 +1,30 @@
+import json
+from typing import List, Dict, Optional
+
+
+class LLMConversationHistory:
+    """
+    Stores the conversation history between user and LLM (assistant/system).
+    Each message is a dict with keys: 'role', 'content', and optional 'metadata'.
+    """
+
+    def __init__(self):
+        self._history: List[Dict] = []
+
+    def add_message(self, role: str, content: str, metadata: Optional[Dict] = None):
+        message = {"role": role, "content": content}
+        if metadata:
+            message["metadata"] = metadata
+        self._history.append(message)
+
+    def get_history(self) -> List[Dict]:
+        return list(self._history)
+
+    def clear(self):
+        self._history.clear()
+
+    def export_json(self) -> str:
+        return json.dumps(self._history, indent=2)
+
+    def import_json(self, json_str: str):
+        self._history = json.loads(json_str)

janito/{agent/tools_utils/dir_walk_utils.py → dir_walk_utils.py}

@@ -2,7 +2,7 @@ import os
 from .gitignore_utils import GitignoreFilter
 
 
-def walk_dir_with_gitignore(root_dir, max_depth=None):
+def walk_dir_with_gitignore(root_dir, max_depth=None, include_gitignored=False):
     """
     Walks the directory tree starting at root_dir, yielding (root, dirs, files) tuples,
     with .gitignore rules applied.
@@ -20,5 +20,6 @@ def walk_dir_with_gitignore(root_dir, max_depth=None):
                 # For max_depth=1, only root (depth=0). For max_depth=2, root and one level below (depth=0,1).
                 if depth > 0:
                     continue
-        dirs, files = gitignore.filter_ignored(root, dirs, files)
+        if not include_gitignored:
+            dirs, files = gitignore.filter_ignored(root, dirs, files)
         yield root, dirs, files

janito/driver_events.py

@@ -0,0 +1,98 @@
+import attr
+from typing import Any, ClassVar
+from enum import Enum
+from janito.event_bus.event import Event
+
+
+class RequestStatus(Enum):
+    SUCCESS = "success"
+    ERROR = "error"
+    CANCELLED = "cancelled"
+    EMPTY_RESPONSE = "empty_response"
+    TIMEOUT = "timeout"
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class DriverEvent(Event):
+    """
+    Base class for events related to a driver (e.g., LLM, API provider).
+    Includes driver name and request ID for correlation.
+    """
+
+    category: ClassVar[str] = "driver"
+    driver_name: str = None
+    request_id: str = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class GenerationStarted(DriverEvent):
+    conversation_history: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class GenerationFinished(DriverEvent):
+    total_turns: int = 0
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class RequestStarted(DriverEvent):
+    payload: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class RequestFinished(DriverEvent):
+    """
+    Used for all request completions: success, error, cancellation, empty response, or timeout.
+    status should be a RequestStatus value.
+    - For errors, fill error/exception/traceback fields.
+    - For cancellations, fill reason field.
+    - For empty response, fill error/details fields as appropriate.
+    - For timeout, fill error/details fields as appropriate.
+    """
+
+    response: Any = None
+    status: RequestStatus = (
+        None  # RequestStatus.SUCCESS, ERROR, CANCELLED, EMPTY_RESPONSE, TIMEOUT
+    )
+    usage: dict = None
+    finish_type: str = None  # 'success', 'error', 'cancelled', etc. (legacy)
+    error: str = None
+    exception: Exception = None
+    traceback: str = None
+    reason: str = None  # for cancellations or empty/timeout reasons
+    details: dict = None  # for additional info (empty response, timeout, etc.)
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ContentPartFound(DriverEvent):
+    content_part: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallStarted(DriverEvent):
+    tool_call_id: str = None
+    name: str = None
+    arguments: Any = None
+
+    @property
+    def tool_name(self):
+        return self.name
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallFinished(DriverEvent):
+    tool_call_id: str = None
+    name: str = None
+    result: Any = None
+
+    @property
+    def tool_name(self):
+        return self.name
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ResponseReceived(DriverEvent):
+    parts: list = None
+    tool_results: list = None  # each as dict or custom ToolResult dataclass
+    timestamp: float = None  # UNIX epoch seconds, normalized
+    metadata: dict = None

janito/drivers/anthropic/driver.py

@@ -0,0 +1,113 @@
+from janito.llm.driver import LLMDriver
+from janito.llm.driver_config import LLMDriverConfig
+from janito.driver_events import (
+    GenerationStarted,
+    GenerationFinished,
+    RequestStarted,
+    RequestFinished,
+    ResponseReceived,
+)
+from janito.llm.message_parts import TextMessagePart
+import uuid
+import traceback
+import time
+
+# Safe import of anthropic SDK
+try:
+    import anthropic
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: anthropic (pip install anthropic)"
+
+
+class AnthropicModelDriver(LLMDriver):
+    available = False
+    unavailable_reason = "AnthropicModelDriver is not implemented yet."
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    """
+    LLMDriver for Anthropic's Claude API (v3), using the anthropic SDK.
+    """
+    required_config = ["api_key", "model"]
+
+    def __init__(self, tools_adapter=None):
+        raise ImportError(self.unavailable_reason)
+
+    def _create_client(self):
+        try:
+            import anthropic
+        except ImportError:
+            raise Exception(
+                "The 'anthropic' Python SDK is required. Please install via `pip install anthropic`."
+            )
+        return anthropic.Anthropic(api_key=self.api_key)
+
+    def _run_generation(
+        self, messages_or_prompt, system_prompt=None, tools=None, **kwargs
+    ):
+        request_id = str(uuid.uuid4())
+        client = self._create_client()
+        try:
+            prompt = ""
+            if isinstance(messages_or_prompt, str):
+                prompt = messages_or_prompt
+            elif isinstance(messages_or_prompt, list):
+                chat = []
+                for msg in messages_or_prompt:
+                    if msg.get("role") == "user":
+                        chat.append("Human: " + msg.get("content", ""))
+                    elif msg.get("role") == "assistant":
+                        chat.append("Assistant: " + msg.get("content", ""))
+                prompt = "\n".join(chat)
+            if system_prompt:
+                prompt = f"System: {system_prompt}\n{prompt}"
+
+            self.publish(
+                GenerationStarted,
+                request_id,
+                conversation_history=list(getattr(self, "_history", [])),
+            )
+            self.publish(RequestStarted, request_id, payload={})
+            start_time = time.time()
+            response = client.completions.create(
+                model=self.model_name,
+                max_tokens_to_sample=int(getattr(self.config, "max_response", 1024)),
+                prompt=prompt,
+                temperature=float(getattr(self.config, "default_temp", 0.7)),
+            )
+            duration = time.time() - start_time
+            content = response.completion if hasattr(response, "completion") else None
+            self.publish(
+                RequestFinished,
+                request_id,
+                response=content,
+                status=RequestStatus.SUCCESS,
+                usage={},
+            )
+            parts = []
+            if content:
+                parts.append(TextMessagePart(content=content))
+            self.publish(
+                ResponseReceived,
+                request_id=request_id,
+                parts=parts,
+                tool_results=[],
+                timestamp=time.time(),
+                metadata={"raw_response": response},
+            )
+            self.publish(GenerationFinished, request_id, total_turns=1)
+        except Exception as e:
+            self.publish(
+                RequestFinished,
+                request_id,
+                status=RequestStatus.ERROR,
+                error=str(e),
+                exception=e,
+                traceback=traceback.format_exc(),
+            )

janito/drivers/azure_openai/driver.py

@@ -0,0 +1,36 @@
+from janito.drivers.openai.driver import OpenAIModelDriver
+
+# Safe import of AzureOpenAI SDK
+try:
+    from openai import AzureOpenAI
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: openai (pip install openai)"
+
+from janito.llm.driver_config import LLMDriverConfig
+
+
+class AzureOpenAIModelDriver(OpenAIModelDriver):
+    available = DRIVER_AVAILABLE
+    unavailable_reason = DRIVER_UNAVAILABLE_REASON
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    required_config = {"base_url"}  # Update key as used in your config logic
+
+    def __init__(self, tools_adapter=None):
+        if not self.available:
+            raise ImportError(
+                f"AzureOpenAIModelDriver unavailable: {self.unavailable_reason}"
+            )
+        super().__init__(tools_adapter=tools_adapter)
+        self.azure_endpoint = None
+        self.api_version = None
+        self.api_key = None
+
+    # ... rest of the implementation ...

janito/drivers/driver_registry.py

@@ -0,0 +1,33 @@
+# janito/drivers/driver_registry.py
+"""
+DriverRegistry: Maps driver string names to class objects for use by providers.
+"""
+
+from typing import Dict, Type
+
+# --- Import driver classes ---
+from janito.drivers.anthropic.driver import AnthropicModelDriver
+from janito.drivers.azure_openai.driver import AzureOpenAIModelDriver
+from janito.drivers.google_genai.driver import GoogleGenaiModelDriver
+from janito.drivers.mistralai.driver import MistralAIModelDriver
+from janito.drivers.openai.driver import OpenAIModelDriver
+
+_DRIVER_REGISTRY: Dict[str, Type] = {
+    "AnthropicModelDriver": AnthropicModelDriver,
+    "AzureOpenAIModelDriver": AzureOpenAIModelDriver,
+    "GoogleGenaiModelDriver": GoogleGenaiModelDriver,
+    "MistralAIModelDriver": MistralAIModelDriver,
+    "OpenAIModelDriver": OpenAIModelDriver,
+}
+
+
+def get_driver_class(name: str):
+    """Get the driver class by string name."""
+    try:
+        return _DRIVER_REGISTRY[name]
+    except KeyError:
+        raise ValueError(f"No driver found for name: {name}")
+
+
+def register_driver(name: str, cls: type):
+    _DRIVER_REGISTRY[name] = cls