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

janito/agent/tools/create_file.py

@@ -0,0 +1,43 @@
+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_file(path: str, content: str, overwrite: bool = False) -> str:
+    """
+    Create a file with the specified content.
+
+    path: The path of the file to create
+    content: The content to write into the file
+    overwrite: Whether to overwrite the file if it exists (default: False)
+    """
+    old_lines = None
+    if os.path.exists(path):
+        if os.path.isdir(path):
+            print_error("❌ Error: is a directory")
+            return f"❌ Cannot create file: '{path}' is an existing directory."
+        if overwrite:
+            try:
+                with open(path, "r", encoding="utf-8") as f:
+                    old_lines = sum(1 for _ in f)
+            except Exception:
+                old_lines = 'unknown'
+        else:
+            print_error(f"❗ Error: file '{path}' exists and overwrite is False")
+            return f"❗ Cannot create file: '{path}' already exists and overwrite is False."
+
+    new_lines = content.count('\n') + 1 if content else 0
+
+    if old_lines is not None:
+        print_info(f"♻️  Replacing file: '{format_path(path)}' (line count: {old_lines} -> {new_lines}) ... ")
+    else:
+        print_info(f"📝 Creating file: '{format_path(path)}' (lines: {new_lines}) ... ")
+
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        print_success("✅ Success")
+        return f"✅ Successfully created the file at '{path}'."
+    except Exception as e:
+        print_error(f"❌ Error: {e}")
+        return f"❌ Failed to create the file at '{path}': {e}"

janito/agent/tools/fetch_url.py

@@ -0,0 +1,48 @@
+import requests
+from bs4 import BeautifulSoup
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+
+@ToolHandler.register_tool
+def fetch_url(url: str, search_strings: list[str] = None, on_progress: callable = None) -> str:
+    """
+    Fetch the content of a web page and extract its text.
+
+    url: The URL to fetch.
+    search_strings: Optional list of strings to filter the extracted text around those strings.
+    on_progress: Optional callback function for streaming progress updates.
+    """
+    if on_progress:
+        on_progress({'event': 'start', 'url': url})
+    print_info(f"\U0001F310 Fetching URL: {url} ... ")
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        if on_progress:
+            on_progress({'event': 'fetched', 'status_code': response.status_code})
+        soup = BeautifulSoup(response.text, 'html.parser')
+        text = soup.get_text(separator=' ', strip=True)
+
+        if search_strings:
+            filtered = []
+            for s in search_strings:
+                idx = text.find(s)
+                if idx != -1:
+                    start = max(0, idx - 200)
+                    end = min(len(text), idx + len(s) + 200)
+                    snippet = text[start:end]
+                    filtered.append(snippet)
+            if filtered:
+                text = '\n...\n'.join(filtered)
+            else:
+                text = "No matches found for the provided search strings."
+
+        print_success("\u2705 Success")
+        if on_progress:
+            on_progress({'event': 'done'})
+        return text
+    except Exception as e:
+        print_error(f"\u274c Error: {e}")
+        if on_progress:
+            on_progress({'event': 'error', 'error': str(e)})
+        return f"\u274c Failed to fetch URL '{url}': {e}"

janito/agent/tools/file_str_replace.py

@@ -0,0 +1,48 @@
+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 file_str_replace(path: str, old_string: str, new_string: str) -> str:
+    """
+    Replace a unique occurrence of a string in a file.
+
+    path: Path to the file
+    old_string: The exact string to replace
+        - must be unique within all the file lines
+    new_string: The replacement string
+
+
+
+    Returns a message indicating success on an error
+    """
+    if not os.path.isfile(path):
+        print_error(f"❌ Error: '{path}' is not a valid file.")
+        return f"❌ Error: '{path}' is not a valid file."
+
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except Exception as e:
+        print_error(f"❌ Error reading file: {e}")
+        return f"❌ Failed to read file '{path}': {e}"
+
+    num_matches = content.count(old_string)
+
+    if num_matches == 0:
+        print_info(f"ℹ️  No occurrences of the target string found in '{format_path(path)}'.")
+        return f"ℹ️ No occurrences of the target string found in '{path}'."
+    elif num_matches > 1:
+        print_error(f"❌ Error: More than one occurrence ({num_matches}) of the target string found in '{format_path(path)}'. Aborting replacement.")
+        return f"❌ Error: More than one occurrence ({num_matches}) of the target string found in '{path}'. Aborting replacement."
+
+    new_content = content.replace(old_string, new_string, 1)
+
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+        print_success(f"✅ Replaced the unique occurrence in '{format_path(path)}'.")
+        return f"✅ Successfully replaced the unique occurrence in '{path}'."
+    except Exception as e:
+        print_error(f"❌ Error writing file: {e}")
+        return f"❌ Failed to write updated content to '{path}': {e}"

janito/agent/tools/find_files.py

@@ -0,0 +1,37 @@
+import os
+import fnmatch
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path, format_number
+from janito.agent.tools.gitignore_utils import load_gitignore_patterns, filter_ignored
+
+@ToolHandler.register_tool
+def find_files(directory: str, pattern: str = "*") -> str:
+    """
+    Recursively find files matching a pattern within a directory, skipping ignored files/dirs.
+
+    directory: The root directory to start searching from.
+    pattern: Glob pattern to match filenames (default: '*').
+    """
+    print_info(f"🔍 Searching for files in '{format_path(directory)}' matching pattern '{pattern}' ... ")
+
+    # Check if pattern is an exact relative path to a file
+    full_path = os.path.join(directory, pattern)
+    if os.path.isfile(full_path):
+        print_success("✅ Found 1 file (exact match)")
+        return full_path
+
+    matches = []
+    ignore_patterns = load_gitignore_patterns()
+    try:
+        for root, dirs, files in os.walk(directory):
+            dirs, files = filter_ignored(root, dirs, files, ignore_patterns)
+            for filename in fnmatch.filter(files, pattern):
+                matches.append(os.path.join(root, filename))
+        print_success(f"✅ Found {format_number(len(matches))} files")
+        if matches:
+            return "\n".join(matches)
+        else:
+            return "No matching files found."
+    except Exception as e:
+        print_error(f"❌ Error: {e}")
+        return f"❌ Failed to search files in '{directory}': {e}"

janito/agent/tools/gitignore_utils.py

@@ -0,0 +1,40 @@
+import os
+import pathspec
+
+_spec = None
+
+
+def load_gitignore_patterns(gitignore_path='.gitignore'):
+    global _spec
+    if not os.path.exists(gitignore_path):
+        _spec = pathspec.PathSpec.from_lines('gitwildmatch', [])
+        return _spec
+    with open(gitignore_path, 'r') as f:
+        lines = f.readlines()
+    _spec = pathspec.PathSpec.from_lines('gitwildmatch', lines)
+    return _spec
+
+
+def is_ignored(path):
+    global _spec
+    if _spec is None:
+        _spec = load_gitignore_patterns()
+    # Normalize path to be relative and use forward slashes
+    rel_path = os.path.relpath(path).replace(os.sep, '/')
+    return _spec.match_file(rel_path)
+
+
+def filter_ignored(root, dirs, files, spec=None):
+    if spec is None:
+        global _spec
+        if _spec is None:
+            _spec = load_gitignore_patterns()
+        spec = _spec
+
+    def not_ignored(p):
+        rel_path = os.path.relpath(os.path.join(root, p)).replace(os.sep, '/')
+        return not spec.match_file(rel_path)
+
+    dirs[:] = [d for d in dirs if not_ignored(d)]
+    files = [f for f in files if not_ignored(f)]
+    return dirs, files

janito/agent/tools/move_file.py

@@ -0,0 +1,37 @@
+import shutil
+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 move_file(source_path: str, destination_path: str, overwrite: bool = False) -> str:
+    """
+    Move a file or directory from source_path to destination_path.
+
+    source_path: The path of the file or directory to move
+    destination_path: The target path
+    overwrite: Whether to overwrite the destination if it exists (default: False)
+    """
+    print_info(f"🚚 Moving '{format_path(source_path)}' to '{format_path(destination_path)}' ... ")
+    try:
+        if not os.path.exists(source_path):
+            print_error("❌ Error: source does not exist")
+            return f"❌ Source path '{source_path}' does not exist."
+
+        if os.path.exists(destination_path):
+            if not overwrite:
+                print_error("❌ Error: destination exists and overwrite is False")
+                return f"❌ Destination path '{destination_path}' already exists. Use overwrite=True to replace it."
+            # Remove destination if overwrite is True
+            if os.path.isdir(destination_path):
+                shutil.rmtree(destination_path)
+            else:
+                os.remove(destination_path)
+
+        shutil.move(source_path, destination_path)
+        print_success("✅ Success")
+        return f"✅ Successfully moved '{source_path}' to '{destination_path}'."
+    except Exception as e:
+        print_error(f"❌ Error: {e}")
+        return f"❌ Failed to move '{source_path}' to '{destination_path}': {e}"

janito/agent/tools/remove_file.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 remove_file(path: str) -> str:
+    """
+    Remove a specified file.
+
+    path: The path of the file to remove
+    """
+    print_info(f"🗑️ Removing file: '{format_path(path)}' ... ")
+    try:
+        os.remove(path)
+        print_success("✅ Success")
+        return f"✅ Successfully deleted the file at '{path}'."
+    except Exception as e:
+        print_error(f"❌ Error: {e}")
+        return f"❌ Failed to delete the file at '{path}': {e}"

janito/agent/tools/rich_live.py

@@ -0,0 +1,37 @@
+from contextlib import contextmanager
+from rich.live import Live
+from rich.panel import Panel
+from rich.console import Console
+
+console = Console()
+
+_global_live = None
+
+@contextmanager
+def global_live_panel(title="Working..."):
+    global _global_live
+    if _global_live is None:
+        _global_live = Live(Panel("", title=title), console=console, refresh_per_second=4)
+        _global_live.start()
+    try:
+        yield _global_live
+    finally:
+        pass  # Do not stop here; stopping is handled explicitly
+
+def stop_global_live_panel():
+    global _global_live
+    if _global_live is not None:
+        _global_live.stop()
+        _global_live = None
+
+@contextmanager
+def live_panel(title="Working..."):
+    global _global_live
+    if _global_live is not None:
+        # Update the global panel content instead of creating a nested panel
+        _global_live.update(Panel("", title=title))
+        yield _global_live
+    else:
+        # Fallback: create a temporary panel if no global panel is running
+        with Live(Panel("", title=title), console=console, refresh_per_second=4) as live:
+            yield live

janito/agent/tools/rich_utils.py

@@ -0,0 +1,31 @@
+from rich.console import Console
+from rich.text import Text
+
+console = Console()
+
+def print_info(message: str):
+    console.print(message, style="cyan")
+
+def print_success(message: str):
+    console.print(message, style="bold green")
+
+def print_error(message: str):
+    console.print(message, style="bold red")
+
+def print_warning(message: str):
+    console.print(message, style="yellow")
+
+def print_magenta(message: str):
+    console.print(message, style="magenta")
+
+def print_bash_stdout(message: str):
+    console.print(message, style="bold white on blue")
+
+def print_bash_stderr(message: str):
+    console.print(message, style="bold white on red")
+
+def format_path(path: str) -> Text:
+    return Text(path, style="cyan")
+
+def format_number(number) -> Text:
+    return Text(str(number), style="magenta")

janito/agent/tools/search_text.py

@@ -0,0 +1,41 @@
+import os
+import re
+import fnmatch
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path, format_number
+from janito.agent.tools.gitignore_utils import load_gitignore_patterns, filter_ignored
+
+@ToolHandler.register_tool
+def search_text(directory: str, file_pattern: str, text_pattern: str, case_sensitive: bool = False):
+    """
+    directory: Root directory to search.
+    file_pattern: Glob pattern for filenames (e.g., '*.py').
+    text_pattern: Regex pattern to search within files.
+    case_sensitive: Whether the search is case sensitive.
+
+    Returns a string with matches, each in 'filepath:line_number:matched_line' format, separated by newlines.
+    """
+    print_info(f"🔎 Searching for pattern '{text_pattern}' in files under '{format_path(directory)}' matching '{file_pattern}' ...")
+    flags = 0 if case_sensitive else re.IGNORECASE
+    regex = re.compile(text_pattern, flags)
+    results = []
+    ignore_patterns = load_gitignore_patterns()
+
+    try:
+        for root, dirs, files in os.walk(directory):
+            dirs, files = filter_ignored(root, dirs, files, ignore_patterns)
+            for filename in fnmatch.filter(files, file_pattern):
+                filepath = os.path.join(root, filename)
+                try:
+                    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+                        for lineno, line in enumerate(f, start=1):
+                            if regex.search(line):
+                                results.append(f"{filepath}:{lineno}:{line.rstrip()}")
+                except Exception as e:
+                    print_error(f"❌ Error reading file '{filepath}': {e}")
+                    continue  # Ignore unreadable files
+        print_success(f"✅ Found {format_number(len(results))} matches")
+    except Exception as e:
+        print_error(f"❌ Error during search: {e}")
+
+    return "\n".join(results)

janito/agent/tools/view_file.py

@@ -0,0 +1,34 @@
+import os
+from janito.agent.tool_handler import ToolHandler
+from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path, format_number
+
+@ToolHandler.register_tool
+def view_file(path: str, start_line: int = 1, end_line: int = None) -> str:
+    """
+    View the contents of a file or list the contents of a directory.
+
+    path: The path of the file or directory to view
+    start_line: The starting line number (1-based, default: 1)
+    end_line: The ending line number (inclusive). If None, view until end of file.
+    """
+    print_info(f"📂 View '{format_path(path)}' lines {format_number(start_line)} to {format_number(end_line) if end_line else 'end of file'}")
+    if os.path.isdir(path):
+        files = os.listdir(path)
+        print_success(f"✅ {format_number(len(files))} items")
+        return "\n".join(files)
+    else:
+        with open(path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        total_lines = len(lines)
+        if end_line is None or end_line > total_lines:
+            end_line = total_lines
+
+        # Adjust for 0-based index
+        start_idx = max(start_line - 1, 0)
+        end_idx = end_line
+
+        selected_lines = lines[start_idx:end_idx]
+        content = '\n'.join(f"{i + start_line}: {line.rstrip()}" for i, line in enumerate(selected_lines))
+        print_success(f"✅ Returned lines {format_number(start_line)} to {format_number(end_line)} of {format_number(total_lines)}")
+        return content

janito/cli/__init__.py

@@ -1,6 +0,0 @@
-"""
-CLI module for Janito.
-"""
-from janito.cli.app import app
-
-__all__ = ["app"]

janito/cli/_print_config.py

@@ -0,0 +1,68 @@
+import os
+from rich import print
+from ._utils import home_shorten
+
+def print_config_items(items, color_label=None):
+    if not items:
+        return
+    if color_label:
+        print(color_label)
+    home = os.path.expanduser("~")
+    for key, value in items.items():
+        if key == "system_prompt" and isinstance(value, str):
+            if value.startswith(home):
+                print(f"{key} = {home_shorten(value)}")
+            else:
+                print(f"{key} = {value}")
+        else:
+            print(f"{key} = {value}")
+    print()
+
+def print_full_config(local_config, global_config, unified_config, config_defaults, console=None):
+    """
+    Print local, global, and default config values in a unified way.
+    Handles masking API keys and showing the template file for system_prompt if not set.
+    """
+    local_items = {}
+    global_items = {}
+    local_keys = set(local_config.all().keys())
+    global_keys = set(global_config.all().keys())
+    all_keys = set(config_defaults.keys()) | global_keys | local_keys
+    out = print if console is None else console.print
+    if not (local_keys or global_keys):
+        out("No configuration found.")
+    else:
+        for key in sorted(local_keys):
+            if key == "api_key":
+                value = local_config.get("api_key")
+                value = value[:4] + '...' + value[-4:] if value and len(value) > 8 else ('***' if value else None)
+            else:
+                value = unified_config.get(key)
+            local_items[key] = value
+        for key in sorted(global_keys - local_keys):
+            if key == "api_key":
+                value = global_config.get("api_key")
+                value = value[:4] + '...' + value[-4:] if value and len(value) > 8 else ('***' if value else None)
+            else:
+                value = unified_config.get(key)
+            global_items[key] = value
+        # Mask API key
+        for cfg in (local_items, global_items):
+            if 'api_key' in cfg and cfg['api_key']:
+                val = cfg['api_key']
+                cfg['api_key'] = val[:4] + '...' + val[-4:] if len(val) > 8 else '***'
+        print_config_items(local_items, color_label="[cyan]🏠 Local Configuration[/cyan]")
+        print_config_items(global_items, color_label="[yellow]🌐 Global Configuration[/yellow]")
+        # Show defaults for unset keys
+        shown_keys = set(local_items.keys()) | set(global_items.keys())
+        default_items = {k: v for k, v in config_defaults.items() if k not in shown_keys and k != 'api_key'}
+        if default_items:
+            out("[green]🟢 Defaults (not set in config files)[/green]")
+            from pathlib import Path
+            template_path = Path(__file__).parent.parent / "templates" / "system_instructions.j2"
+            for key, value in default_items.items():
+                if key == "system_prompt" and value is None:
+                    out(f"{key} = file: {home_shorten(str(template_path))}")
+                else:
+                    out(f"{key} = {value}")
+            out("")

janito/cli/_utils.py

@@ -0,0 +1,8 @@
+import os
+
+def home_shorten(path: str) -> str:
+    """If path starts with the user's home directory, replace it with ~."""
+    home = os.path.expanduser("~")
+    if path and isinstance(path, str) and path.startswith(home):
+        return path.replace(home, "~", 1)
+    return path

janito/cli/arg_parser.py

@@ -0,0 +1,26 @@
+import argparse
+
+
+def create_parser():
+    parser = argparse.ArgumentParser(description="OpenRouter API call using OpenAI Python SDK")
+    parser.add_argument("prompt", type=str, nargs="?", help="Prompt to send to the model")
+    parser.add_argument("--max-tokens", type=int, default=None, help="Maximum tokens for model response (overrides config, default: 200000)")
+    parser.add_argument("-s", "--system-prompt", type=str, default=None, help="Optional system prompt")
+    parser.add_argument("-r", "--role", type=str, default=None, help="Role description for the system prompt")
+    parser.add_argument("-t", "--temperature", type=float, default=None, help="Sampling temperature (e.g., 0.0 - 2.0)")
+    parser.add_argument("--verbose-http", action="store_true", help="Enable verbose HTTP logging")
+    parser.add_argument("--verbose-http-raw", action="store_true", help="Enable raw HTTP wire-level logging")
+    parser.add_argument("--verbose-response", action="store_true", help="Pretty print the full response object")
+    parser.add_argument("--show-system", action="store_true", help="Show model, parameters, system prompt, and tool definitions, then exit")
+    parser.add_argument("--verbose-tools", action="store_true", help="Print tool call parameters and results")
+    parser.add_argument("--set-local-config", type=str, default=None, help='Set a local config key-value pair, format "key=val"')
+    parser.add_argument("--set-global-config", type=str, default=None, help='Set a global config key-value pair, format "key=val"')
+    parser.add_argument("--show-config", action="store_true", help="Show effective configuration and exit")
+    parser.add_argument("--set-api-key", type=str, default=None, help="Set and save the API key globally")
+    parser.add_argument("--version", action="store_true", help="Show program's version number and exit")
+    parser.add_argument("--help-config", action="store_true", help="Show all configuration options and exit")
+    parser.add_argument("--continue-session", action="store_true", help="Continue from the last saved conversation")
+    parser.add_argument("--web", action="store_true", help="Launch the Janito web server instead of CLI")
+    parser.add_argument("--config-reset-local", action="store_true", help="Remove the local config file (~/.janito/config.json)")
+    parser.add_argument("--config-reset-global", action="store_true", help="Remove the global config file (~/.janito/config.json)")
+    return parser