janito 0.15.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

janito/__init__.py

@@ -1,5 +1 @@
-"""
-Janito package.
-"""
-
-__version__ = "0.15.0"
+__version__ = "1.0.1"

janito/__main__.py

@@ -1,7 +1,5 @@
-"""
-Main entry point for Janito.
-"""
-from janito.cli import app
+from janito.cli.main import main
+
 
 if __name__ == "__main__":
-    app()
+    main()

janito/agent/__init__.py

@@ -0,0 +1 @@
+from . import tools

janito/agent/agent.py

@@ -0,0 +1,96 @@
+"""Agent module: defines the core LLM agent with tool and conversation handling."""
+
+import os
+import json
+from openai import OpenAI
+from janito.agent.conversation import ConversationHandler
+from janito.agent.tool_handler import ToolHandler
+
+class Agent:
+    """LLM Agent capable of handling conversations and tool calls."""
+
+    REFERER = "www.janito.dev"
+    TITLE = "Janito"
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str = None,
+        system_prompt: str | None = None,
+        verbose_tools: bool = False,
+        tool_handler = None,
+        base_url: str = "https://openrouter.ai/api/v1"
+    ):
+        """
+        Initialize the Agent.
+
+        Args:
+            api_key: API key for OpenAI-compatible service.
+            model: Model name to use.
+            system_prompt: Optional system prompt override.
+            verbose_tools: Enable verbose tool call logging.
+            tool_handler: Optional custom ToolHandler instance.
+            base_url: API base URL.
+        """
+        self.api_key = api_key
+        self.model = model
+        self.system_prompt = system_prompt
+        if os.environ.get("USE_AZURE_OPENAI"):
+            from openai import AzureOpenAI
+            self.client = AzureOpenAI(
+                api_key=api_key,
+                azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
+                api_version=os.environ.get("AZURE_OPENAI_API_VERSION", "2023-05-15"),
+            )
+        else:
+            self.client = OpenAI(
+                base_url=base_url,
+                api_key=api_key,
+                default_headers={
+                    "HTTP-Referer": self.REFERER,
+                    "X-Title": self.TITLE
+                }
+            )
+        if tool_handler is not None:
+            self.tool_handler = tool_handler
+        else:
+            self.tool_handler = ToolHandler(verbose=verbose_tools)
+
+        self.conversation_handler = ConversationHandler(
+            self.client, self.model, self.tool_handler
+        )
+
+    def chat(self, messages, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None):
+        import time
+        from janito.agent.conversation import ProviderError
+
+        max_retries = 5
+        for attempt in range(1, max_retries + 1):
+            try:
+                return self.conversation_handler.handle_conversation(
+                    messages,
+                    max_tokens=max_tokens,
+                    on_content=on_content,
+                    on_tool_progress=on_tool_progress,
+                    verbose_response=verbose_response,
+                    spinner=spinner
+                )
+            except ProviderError as e:
+                error_data = getattr(e, 'error_data', {}) or {}
+                code = error_data.get('code', '')
+                # Retry only on 5xx errors
+                if isinstance(code, int) and 500 <= code < 600:
+                    pass
+                elif isinstance(code, str) and code.isdigit() and 500 <= int(code) < 600:
+                    code = int(code)
+                else:
+                    raise
+
+                if attempt < max_retries:
+                    print(f"ProviderError with 5xx code encountered (attempt {attempt}/{max_retries}). Retrying in 5 seconds...")
+                    time.sleep(5)
+                else:
+                    print("Max retries reached. Raising error.")
+                    raise
+            except Exception:
+                raise

janito/agent/config.py

@@ -0,0 +1,113 @@
+import json
+import os
+from pathlib import Path
+from threading import Lock
+
+
+class SingletonMeta(type):
+    _instances = {}
+    _lock: Lock = Lock()
+
+    def __call__(cls, *args, **kwargs):
+        with cls._lock:
+            if cls not in cls._instances:
+                instance = super().__call__(*args, **kwargs)
+                cls._instances[cls] = instance
+        return cls._instances[cls]
+
+
+class BaseConfig:
+    def __init__(self):
+        self._data = {}
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def set(self, key, value):
+        self._data[key] = value
+
+    def all(self):
+        return self._data
+
+
+
+
+class FileConfig(BaseConfig):
+    def __init__(self, path):
+        super().__init__()
+        self.path = Path(path).expanduser()
+        self.load()
+
+    def load(self):
+        if self.path.exists():
+            try:
+                with open(self.path, 'r') as f:
+                    self._data = json.load(f)
+                    # Remove keys with value None (null in JSON)
+                    self._data = {k: v for k, v in self._data.items() if v is not None}
+            except Exception as e:
+                print(f"Warning: Failed to load config file {self.path}: {e}")
+                self._data = {}
+        else:
+            self._data = {}
+
+    def save(self):
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.path, 'w') as f:
+            json.dump(self._data, f, indent=2)
+
+
+CONFIG_OPTIONS = {
+    "api_key": "API key for OpenAI-compatible service (required)",
+    "model": "Model name to use (e.g., 'openrouter/optimus-alpha')",
+    "base_url": "API base URL (OpenAI-compatible endpoint)",
+    "role": "Role description for the system prompt (e.g., 'software engineer')",
+    "system_prompt": "Override the entire system prompt text",
+    "temperature": "Sampling temperature (float, e.g., 0.0 - 2.0)",
+    "max_tokens": "Maximum tokens for model response (int)"
+}
+
+# Import defaults for reference
+from .config_defaults import CONFIG_DEFAULTS
+
+class EffectiveConfig:
+    """Read-only merged view of local and global configs"""
+    def __init__(self, local_cfg, global_cfg):
+        self.local_cfg = local_cfg
+        self.global_cfg = global_cfg
+
+    def get(self, key, default=None):
+        from .config_defaults import CONFIG_DEFAULTS
+        for cfg in (self.local_cfg, self.global_cfg):
+            val = cfg.get(key)
+            if val is not None:
+                # Treat explicit None/null as not set
+                if val is None:
+                    continue
+                return val
+        # Use centralized defaults if no config found
+        if default is None and key in CONFIG_DEFAULTS:
+            return CONFIG_DEFAULTS[key]
+        return default
+
+    def all(self):
+        merged = {}
+        # Start with global, override with local
+        for cfg in (self.global_cfg, self.local_cfg):
+            merged.update(cfg.all())
+        return merged
+
+
+# Singleton instances
+
+local_config = FileConfig(Path('.janito/config.json'))
+global_config = FileConfig(Path.home() / '.janito/config.json')
+
+effective_config = EffectiveConfig(local_config, global_config)
+
+def get_api_key():
+    """Retrieve API key from config files (local, then global)."""
+    api_key = effective_config.get("api_key")
+    if api_key:
+        return api_key
+    raise ValueError("API key not found. Please configure 'api_key' in your config.")

janito/agent/config_defaults.py

@@ -0,0 +1,10 @@
+# Centralized config defaults for Janito
+CONFIG_DEFAULTS = {
+    "api_key": None,  # Must be set by user
+    "model": "openrouter/optimus-alpha",    # Default model
+    "base_url": "https://openrouter.ai/api/v1",
+    "role": "software engineer",
+    "system_prompt": None,  # None means auto-generate from role
+    "temperature": 0.2,
+    "max_tokens": 200000,
+}

janito/agent/conversation.py

@@ -0,0 +1,107 @@
+import json
+
+class MaxRoundsExceededError(Exception):
+    pass
+
+class EmptyResponseError(Exception):
+    pass
+
+class ProviderError(Exception):
+    def __init__(self, message, error_data):
+        self.error_data = error_data
+        super().__init__(message)
+
+class ConversationHandler:
+    def __init__(self, client, model, tool_handler):
+        self.client = client
+        self.model = model
+        self.tool_handler = tool_handler
+
+    def handle_conversation(self, messages, max_rounds=50, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None):
+        if not messages:
+            raise ValueError("No prompt provided in messages")
+
+        from rich.console import Console
+        console = Console()
+
+        from janito.agent.runtime_config import unified_config
+
+        # Resolve max_tokens priority: runtime param > config > default
+        resolved_max_tokens = max_tokens
+        if resolved_max_tokens is None:
+            resolved_max_tokens = unified_config.get('max_tokens', 200000)
+
+        for _ in range(max_rounds):
+            if spinner:
+                                # Calculate word count for all messages
+                word_count = sum(len(str(m.get('content', '')).split()) for m in messages if 'content' in m)
+                spinner_msg = f"[bold green]Waiting for AI response... ({word_count} words in conversation)"
+                with console.status(spinner_msg, spinner="dots") as status:
+                    response = self.client.chat.completions.create(
+                        model=self.model,
+                        messages=messages,
+                        tools=self.tool_handler.get_tool_schemas(),
+                        tool_choice="auto",
+                        temperature=0.2,
+                        max_tokens=resolved_max_tokens
+                    )
+                    status.stop()
+                    # console.print("\r\033[2K", end="")  # Clear the spinner line removed
+            else:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    tools=self.tool_handler.get_tool_schemas(),
+                    tool_choice="auto",
+                    temperature=0.2,
+                    max_tokens=resolved_max_tokens
+                )
+
+            if verbose_response:
+                import pprint
+                pprint.pprint(response)
+
+            # Check for provider errors
+            if hasattr(response, 'error') and response.error:
+                error_msg = response.error.get('message', 'Unknown provider error')
+                error_code = response.error.get('code', 'unknown')
+                raise ProviderError(f"Provider error: {error_msg} (Code: {error_code})", response.error)
+                
+            if not response.choices:
+                raise EmptyResponseError("The LLM API returned no choices in the response.")
+
+            choice = response.choices[0]
+
+            # Extract token usage info if available
+            usage = getattr(response, 'usage', None)
+            if usage:
+                usage_info = {
+                    'prompt_tokens': getattr(usage, 'prompt_tokens', None),
+                    'completion_tokens': getattr(usage, 'completion_tokens', None),
+                    'total_tokens': getattr(usage, 'total_tokens', None)
+                }
+            else:
+                usage_info = None
+
+            # Call the on_content callback if provided and content is not None
+            if on_content is not None and choice.message.content is not None:
+                on_content({"content": choice.message.content})
+
+            # If no tool calls, return the assistant's message and usage info
+            if not choice.message.tool_calls:
+                return {
+    "content": choice.message.content,
+    "usage": usage_info
+}
+
+            tool_responses = []
+            for tool_call in choice.message.tool_calls:
+                result = self.tool_handler.handle_tool_call(tool_call, on_progress=on_tool_progress)
+                tool_responses.append({"tool_call_id": tool_call.id, "content": result})
+
+            messages.append({"role": "assistant", "content": choice.message.content, "tool_calls": [tc.to_dict() for tc in choice.message.tool_calls]})
+
+            for tr in tool_responses:
+                messages.append({"role": "tool", "tool_call_id": tr["tool_call_id"], "content": tr["content"]})
+
+        raise MaxRoundsExceededError("Max conversation rounds exceeded")

janito/agent/queued_tool_handler.py

@@ -0,0 +1,16 @@
+from janito.agent.tool_handler import ToolHandler
+
+class QueuedToolHandler(ToolHandler):
+    def __init__(self, queue, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._queue = queue
+
+    def handle_tool_call(self, tool_call, on_progress=None):
+        def enqueue_progress(data):
+            
+            self._queue.put(('tool_progress', data))
+
+        if on_progress is None:
+            on_progress = enqueue_progress
+
+        return super().handle_tool_call(tool_call, on_progress=on_progress)

janito/agent/runtime_config.py

@@ -0,0 +1,30 @@
+from .config import BaseConfig, EffectiveConfig, effective_config
+
+class RuntimeConfig(BaseConfig):
+    """In-memory only config, reset on restart"""
+    pass
+
+runtime_config = RuntimeConfig()
+
+class UnifiedConfig:
+    """
+    Config lookup order:
+    1. runtime_config (in-memory, highest priority)
+    2. effective_config (local/global, read-only)
+    """
+    def __init__(self, runtime_cfg, effective_cfg):
+        self.runtime_cfg = runtime_cfg
+        self.effective_cfg = effective_cfg
+
+    def get(self, key, default=None):
+        val = self.runtime_cfg.get(key)
+        if val is not None:
+            return val
+        return self.effective_cfg.get(key, default)
+
+    def all(self):
+        merged = dict(self.effective_cfg.all())
+        merged.update(self.runtime_cfg.all())
+        return merged
+
+unified_config = UnifiedConfig(runtime_config, effective_config)

janito/agent/tool_handler.py

@@ -0,0 +1,124 @@
+import os
+import json
+import traceback
+
+class ToolHandler:
+    _tool_registry = {}
+
+    @classmethod
+    def register_tool(cls, func):
+        import inspect
+
+        name = func.__name__
+        description = func.__doc__ or ""
+
+        sig = inspect.signature(func)
+        params_schema = {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+
+        for param_name, param in sig.parameters.items():
+            if param.annotation is param.empty:
+                raise TypeError(f"Parameter '{param_name}' in tool '{name}' is missing a type hint.")
+            param_type = param.annotation
+            json_type = "string"
+            if param_type == int:
+                json_type = "integer"
+            elif param_type == float:
+                json_type = "number"
+            elif param_type == bool:
+                json_type = "boolean"
+            elif param_type == dict:
+                json_type = "object"
+            elif param_type == list:
+                json_type = "array"
+            params_schema["properties"][param_name] = {"type": json_type}
+            if param.default is param.empty:
+                params_schema["required"].append(param_name)
+
+        cls._tool_registry[name] = {
+            "function": func,
+            "description": description,
+            "parameters": params_schema
+        }
+        return func
+
+    def __init__(self, verbose=False):
+        self.verbose = verbose
+        self.tools = []
+
+    def register(self, func):
+        self.tools.append(func)
+        return func
+
+    def get_tools(self):
+        return self.tools
+
+    def get_tool_schemas(self):
+        schemas = []
+        for name, entry in self._tool_registry.items():
+            schemas.append({
+                "type": "function",
+                "function": {
+                    "name": name,
+                    "description": entry["description"],
+                    "parameters": entry["parameters"]
+                }
+            })
+        return schemas
+
+    def handle_tool_call(self, tool_call, on_progress=None):
+        import uuid
+        call_id = getattr(tool_call, 'id', None) or str(uuid.uuid4())
+        tool_entry = self._tool_registry.get(tool_call.function.name)
+        if not tool_entry:
+            return f"Unknown tool: {tool_call.function.name}"
+        func = tool_entry["function"]
+        args = json.loads(tool_call.function.arguments)
+        if self.verbose:
+            print(f"[Tool Call] {tool_call.function.name} called with arguments: {args}")
+        try:
+            import inspect
+            sig = inspect.signature(func)
+            if on_progress:
+                on_progress({
+                    'event': 'start',
+                    'call_id': call_id,
+                    'tool': tool_call.function.name,
+                    'args': args
+                })
+            if 'on_progress' in sig.parameters and on_progress is not None:
+                args['on_progress'] = on_progress
+            result = func(**args)
+            if self.verbose:
+                preview = result
+                if isinstance(result, str):
+                    lines = result.splitlines()
+                    if len(lines) > 10:
+                        preview = "\n".join(lines[:10]) + "\n... (truncated)"
+                    elif len(result) > 500:
+                        preview = result[:500] + "... (truncated)"
+                print(f"[Tool Result] {tool_call.function.name} returned:\n{preview}")
+            if on_progress:
+                on_progress({
+                    'event': 'finish',
+                    'call_id': call_id,
+                    'tool': tool_call.function.name,
+                    'args': args,
+                    'result': result
+                })
+            return result
+        except Exception as e:
+            tb = traceback.format_exc()
+            if on_progress:
+                on_progress({
+                    'event': 'finish',
+                    'call_id': call_id,
+                    'tool': tool_call.function.name,
+                    'args': args,
+                    'error': str(e),
+                    'traceback': tb
+                })
+            return f"Error running tool {tool_call.function.name}: {e}"

janito/agent/tools/__init__.py

@@ -0,0 +1,11 @@
+from .ask_user import ask_user
+from .create_directory import create_directory
+from .create_file import create_file
+from .remove_file import remove_file
+from .view_file import view_file
+from .find_files import find_files
+from .search_text import search_text
+from .bash_exec import bash_exec
+from .fetch_url import fetch_url
+from .move_file import move_file
+from .file_str_replace import file_str_replace

janito/agent/tools/ask_user.py

@@ -0,0 +1,63 @@
+from janito.agent.tool_handler import ToolHandler
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.styles import Style
+
+
+@ToolHandler.register_tool
+def ask_user(question: str) -> str:
+    """
+    Ask the user a question and return their response.
+
+    question: The question to ask the user
+    """
+    from rich import print as rich_print
+    from rich.panel import Panel
+
+    rich_print(Panel.fit(question, title="Question", style="cyan"))
+
+    bindings = KeyBindings()
+
+    mode = {'multiline': False}
+
+    @bindings.add('c-r')
+    def _(event):
+        # Disable reverse search
+        pass
+
+    style = Style.from_dict({
+        'bottom-toolbar': 'bg:#333333 #ffffff',
+        'b': 'bold',
+        'prompt': 'bold bg:#000080 #ffffff',
+    })
+
+    def get_toolbar():
+        if mode['multiline']:
+            return HTML('<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>')
+        else:
+            return HTML('<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>')
+
+    session = PromptSession(
+        multiline=False,
+        key_bindings=bindings,
+        editing_mode=EditingMode.EMACS,
+        bottom_toolbar=get_toolbar,
+        style=style
+    )
+
+    prompt_icon = HTML('<prompt>💬 </prompt>')
+
+    while True:
+        response = session.prompt(prompt_icon)
+        if not mode['multiline'] and response.strip() == '/multi':
+            mode['multiline'] = True
+            session.multiline = True
+            continue
+        elif mode['multiline'] and response.strip() == '/single':
+            mode['multiline'] = False
+            session.multiline = False
+            continue
+        else:
+            return response

janito/agent/tools/bash_exec.py

@@ -0,0 +1,58 @@
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_bash_stdout, print_bash_stderr
+import subprocess
+import threading
+from typing import Callable, Optional
+
+
+@ToolHandler.register_tool
+def bash_exec(command: str, on_progress: Optional[Callable[[dict], None]] = None) -> str:
+    """
+    command: The Bash command to execute.
+    on_progress: Optional callback function for streaming progress updates.
+
+    Execute a non interactive bash command and print output live.
+
+    Returns:
+    str: A formatted message string containing stdout, stderr, and return code.
+    """
+    print_info(f"[bash_exec] Executing command: {command}")
+    result = {'stdout': '', 'stderr': '', 'returncode': None}
+
+    def run_command():
+        try:
+            process = subprocess.Popen(
+                command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding='utf-8', errors='replace'
+            )
+            stdout_lines = []
+            stderr_lines = []
+
+            def read_stream(stream, collector, print_func, stream_name):
+                for line in iter(stream.readline, ''):
+                    collector.append(line)
+                    print_func(line.rstrip())
+                    if callable(on_progress):
+                        on_progress({'stream': stream_name, 'line': line.rstrip()})
+                stream.close()
+
+            stdout_thread = threading.Thread(target=read_stream, args=(process.stdout, stdout_lines, print_bash_stdout, 'stdout'))
+            stderr_thread = threading.Thread(target=read_stream, args=(process.stderr, stderr_lines, print_bash_stderr, 'stderr'))
+            stdout_thread.start()
+            stderr_thread.start()
+            stdout_thread.join()
+            stderr_thread.join()
+            result['returncode'] = process.wait()
+            result['stdout'] = ''.join(stdout_lines)
+            result['stderr'] = ''.join(stderr_lines)
+        except Exception as e:
+            result['stderr'] = str(e)
+            result['returncode'] = -1
+
+    thread = threading.Thread(target=run_command)
+    thread.start()
+    thread.join()  # Wait for the thread to finish
+
+    print_info(f"[bash_exec] Command execution completed.")
+    print_info(f"[bash_exec] Return code: {result['returncode']}")
+
+    return f"stdout:\n{result['stdout']}\nstderr:\n{result['stderr']}\nreturncode: {result['returncode']}"

janito/agent/tools/create_directory.py

@@ -0,0 +1,19 @@
+import os
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path
+
+@ToolHandler.register_tool
+def create_directory(path: str) -> str:
+    """
+    Create a directory at the specified path.
+
+    path: The path of the directory to create
+    """
+    print_info(f"📁 Creating directory: '{format_path(path)}' ... ")
+    try:
+        os.makedirs(path, exist_ok=True)
+        print_success("✅ Success")
+        return f"✅ Directory '{path}' created successfully."
+    except Exception as e:
+        print_error(f"❌ Error: {e}")
+        return f"❌ Error creating directory '{path}': {e}"