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

janito/cli/config_commands.py

@@ -0,0 +1,131 @@
+import sys
+from janito.agent.config import local_config, global_config
+from janito.agent.runtime_config import unified_config, runtime_config
+from rich import print
+from ._utils import home_shorten
+
+
+def handle_config_commands(args):
+    """Handle --set-local-config, --set-global-config, --show-config. Exit if any are used."""
+    did_something = False
+
+    if args.set_local_config:
+        from janito.agent.config import CONFIG_OPTIONS
+        try:
+            key, val = args.set_local_config.split("=", 1)
+        except ValueError:
+            print("Invalid format for --set-local-config, expected key=val")
+            sys.exit(1)
+        key = key.strip()
+        if key not in CONFIG_OPTIONS:
+            print(f"Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}")
+            sys.exit(1)
+        local_config.set(key, val.strip())
+        local_config.save()
+        runtime_config.set(key, val.strip())
+        print(f"Local config updated: {key} = {val.strip()}")
+        did_something = True
+
+    if args.set_global_config:
+        from janito.agent.config import CONFIG_OPTIONS
+        try:
+            key, val = args.set_global_config.split("=", 1)
+        except ValueError:
+            print("Invalid format for --set-global-config, expected key=val")
+            sys.exit(1)
+        key = key.strip()
+        if key not in CONFIG_OPTIONS:
+            print(f"Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}")
+            sys.exit(1)
+        global_config.set(key, val.strip())
+        global_config.save()
+        runtime_config.set(key, val.strip())
+        print(f"Global config updated: {key} = {val.strip()}")
+        did_something = True
+
+    if args.set_api_key:
+        global_config.set("api_key", args.set_api_key.strip())
+        global_config.save()
+        runtime_config.set("api_key", args.set_api_key.strip())
+        print("Global API key saved.")
+        did_something = True
+
+    if args.show_config:
+        local_items = {}
+        global_items = {}
+
+        # Collect and group keys
+        from janito.agent.config_defaults import CONFIG_DEFAULTS
+        local_keys = set(local_config.all().keys())
+        global_keys = set(global_config.all().keys())
+        all_keys = set(CONFIG_DEFAULTS.keys()) | global_keys | local_keys
+        if not (local_keys or global_keys):
+            print("No configuration found.")
+        else:
+            from janito.agent.config import get_api_key
+            from janito.agent.runtime_config import unified_config
+            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 local config
+            from ._print_config import print_config_items
+            print_config_items(local_items, color_label="[cyan]🏠 Local Configuration[/cyan]")
+
+            # Print global config
+            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:
+            print("[green]🟢 Defaults (not set in config files)[/green]")
+            for key, value in default_items.items():
+                # Special case for system_prompt: show template file if None
+                if key == "system_prompt" and value is None:
+                    from pathlib import Path
+                    template_path = Path(__file__).parent.parent / "templates" / "system_instructions.j2"
+                    print(f"{key} = file: {home_shorten(str(template_path))}")
+                else:
+                    print(f"{key} = {value}")
+            print()
+        did_something = True
+
+    import os
+    from pathlib import Path
+    if getattr(args, "config_reset_local", False):
+        local_path = Path('.janito/config.json')
+        if local_path.exists():
+            os.remove(local_path)
+            print(f"Removed local config file: {local_path}")
+        else:
+            print(f"Local config file does not exist: {local_path}")
+        sys.exit(0)
+    if getattr(args, "config_reset_global", False):
+        global_path = Path.home() / '.janito/config.json'
+        if global_path.exists():
+            os.remove(global_path)
+            print(f"Removed global config file: {global_path}")
+        else:
+            print(f"Global config file does not exist: {global_path}")
+        sys.exit(0)
+    if did_something:
+        sys.exit(0)

janito/cli/logging_setup.py

@@ -0,0 +1,27 @@
+import os
+import logging
+
+
+def setup_verbose_logging(args):
+    if args.verbose_http or args.verbose_http_raw:
+        httpx_logger = logging.getLogger("httpx")
+        httpx_logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+        httpx_logger.addHandler(handler)
+
+    if args.verbose_http_raw:
+        os.environ["HTTPX_LOG_LEVEL"] = "trace"
+
+        httpcore_logger = logging.getLogger("httpcore")
+        httpcore_logger.setLevel(logging.DEBUG)
+        handler_core = logging.StreamHandler()
+        handler_core.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+        httpcore_logger.addHandler(handler_core)
+
+        # Re-add handler to httpx logger in case
+        httpx_logger = logging.getLogger("httpx")
+        httpx_logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+        httpx_logger.addHandler(handler)

janito/cli/main.py

@@ -0,0 +1,39 @@
+"""Main CLI entry point for Janito."""
+
+from janito.cli.arg_parser import create_parser
+from janito.cli.config_commands import handle_config_commands
+from janito.cli.logging_setup import setup_verbose_logging
+from janito.cli.runner import run_cli
+
+
+def main():
+    """Entry point for the Janito CLI.
+
+    Parses command-line arguments, handles config commands, sets up logging,
+    and launches either the CLI chat shell or the web server.
+    """
+    # Ensure configs are loaded once at CLI startup
+    from janito.agent.config import local_config, global_config
+    local_config.load()
+    global_config.load()
+
+    parser = create_parser()
+    args = parser.parse_args()
+
+    from janito.agent.config import CONFIG_OPTIONS
+    from janito.agent.config_defaults import CONFIG_DEFAULTS
+    import sys
+    if getattr(args, "help_config", False):
+        print("Available configuration options:\n")
+        for key, desc in CONFIG_OPTIONS.items():
+            default = CONFIG_DEFAULTS.get(key, None)
+            print(f"{key:15} {desc} (default: {default})")
+        sys.exit(0)
+
+    handle_config_commands(args)
+    setup_verbose_logging(args)
+    if getattr(args, 'web', False):
+        import subprocess
+        subprocess.run(['python', '-m', 'janito.web'])
+    else:
+        run_cli(args)

janito/cli/runner.py

@@ -0,0 +1,135 @@
+import sys
+import os
+from rich.console import Console
+from rich.markdown import Markdown
+from janito.render_prompt import render_system_prompt
+from janito.agent.agent import Agent
+from janito.agent.conversation import MaxRoundsExceededError, EmptyResponseError, ProviderError
+from janito.agent.runtime_config import unified_config, runtime_config
+from janito.agent.config import get_api_key
+from janito import __version__
+from rich.rule import Rule
+
+
+def format_tokens(n):
+    if n is None:
+        return "?"
+    try:
+        n = int(n)
+    except (TypeError, ValueError):
+        return str(n)
+    if n >= 1_000_000:
+        return f"{n/1_000_000:.1f}m"
+    if n >= 1_000:
+        return f"{n/1_000:.1f}k"
+    return str(n)
+
+
+def run_cli(args):
+    if args.version:
+        print(f"janito version {__version__}")
+        sys.exit(0)
+
+    role = args.role or unified_config.get("role", "software engineer")
+    # if args.role:
+    #     runtime_config.set('role', args.role)
+    system_prompt = args.system_prompt or unified_config.get("system_prompt")
+    if system_prompt is None:
+        system_prompt = render_system_prompt(role)
+
+    if args.show_system:
+        api_key = get_api_key()
+        model = unified_config.get('model')
+        agent = Agent(api_key=api_key, model=model)
+        print("Model:", agent.model)
+        print("Parameters: {}")
+        import json
+        print("System Prompt:", system_prompt or "(default system prompt not provided)")
+        sys.exit(0)
+
+    api_key = get_api_key()
+
+    model = unified_config.get('model')
+    base_url = unified_config.get('base_url', 'https://openrouter.ai/api/v1')
+    agent = Agent(api_key=api_key, model=model, system_prompt=system_prompt, verbose_tools=args.verbose_tools, base_url=base_url)
+
+    # Save runtime max_tokens override if provided
+    if args.max_tokens is not None:
+        runtime_config.set('max_tokens', args.max_tokens)
+    if not args.prompt:
+        console = Console()
+
+        if not getattr(args, 'continue_session', False):
+            save_path = os.path.join('.janito', 'last_conversation.json')
+            if os.path.exists(save_path):
+                try:
+                    with open(save_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                    messages = data.get('messages', [])
+                    num_messages = len(messages)
+                    console.print(f"[bold yellow]A previous conversation with {num_messages} messages was found.[/bold yellow]")
+
+                    last_usage_info = data.get('last_usage_info')
+                    if last_usage_info:
+                        prompt_tokens = last_usage_info.get('prompt_tokens', 0)
+                        completion_tokens = last_usage_info.get('completion_tokens', 0)
+                        total_tokens = prompt_tokens + completion_tokens
+                        console.print(Rule(f"Token usage - Prompt: {format_tokens(prompt_tokens)}, Completion: {format_tokens(completion_tokens)}, Total: {format_tokens(total_tokens)}"))
+
+                    console.print("You can resume it anytime by typing [bold]/continue[/bold].")
+                except Exception:
+                    pass  # Fail silently if file is corrupt or unreadable
+
+        from janito.cli_chat_shell.chat_loop import start_chat_shell
+        start_chat_shell(agent, continue_session=getattr(args, 'continue_session', False))
+        sys.exit(0)
+
+    prompt = args.prompt
+
+    console = Console()
+
+    waiting_displayed = [True]
+
+    def on_content(data):
+        content = data.get("content", "")
+        if waiting_displayed[0]:
+            # Clear the waiting message
+            sys.stdout.flush()
+            waiting_displayed[0] = False
+        console.print(Markdown(content))
+
+    messages = []
+    if agent.system_prompt:
+        messages.append({"role": "system", "content": agent.system_prompt})
+
+    messages.append({"role": "user", "content": prompt})
+
+    try:
+        try:
+            response = agent.chat(
+                messages,
+                on_content=on_content,
+                spinner=True,
+            )
+            if args.verbose_response:
+                import json
+                console.print_json(json.dumps(response))
+
+            usage = response.get('usage')
+            if usage:
+                prompt_tokens = usage.get('prompt_tokens')
+                completion_tokens = usage.get('completion_tokens')
+                total_tokens = usage.get('total_tokens')
+                console.print(Rule(f"Token usage - Prompt: {format_tokens(prompt_tokens)}, Completion: {format_tokens(completion_tokens)}, Total: {format_tokens(total_tokens)}"))
+        except MaxRoundsExceededError:
+            print("[Error] Conversation exceeded maximum rounds.")
+            sys.exit(1)
+        except ProviderError as e:
+            print(f"[Error] Provider error: {e}")
+            sys.exit(1)
+        except EmptyResponseError as e:
+            print(f"[Error] {e}")
+            sys.exit(1)
+    except KeyboardInterrupt:
+        print("\n[Interrupted by user]")
+        sys.exit(1)

janito/cli_chat_shell/__init__.py

@@ -0,0 +1 @@
+from .chat_loop import start_chat_shell

janito/cli_chat_shell/chat_loop.py

@@ -0,0 +1,147 @@
+from rich.console import Console
+from rich.markdown import Markdown
+from prompt_toolkit.history import InMemoryHistory
+from .session_manager import load_last_conversation, load_input_history
+from .ui import print_welcome, get_toolbar_func, get_prompt_session
+from janito import __version__
+from .commands import handle_command
+from janito.agent.config import effective_config
+from janito.agent.conversation import EmptyResponseError, ProviderError
+
+
+def start_chat_shell(agent, continue_session=False):
+    console = Console()
+
+    # Load input history
+    history_list = load_input_history()
+    mem_history = InMemoryHistory()
+    for item in history_list:
+        mem_history.append_string(item)
+
+        # Initialize chat state variables
+    messages = []
+    last_usage_info = None
+    last_elapsed = None
+
+    state = {
+        'messages': messages,
+        'mem_history': mem_history,
+        'history_list': history_list,
+        'last_usage_info': last_usage_info,
+        'last_elapsed': last_elapsed,
+    }
+
+    # Restore conversation if requested
+    if continue_session:
+        msgs, prompts, usage = load_last_conversation()
+        messages = msgs
+        last_usage_info = usage
+        mem_history = InMemoryHistory()
+        for item in prompts:
+            mem_history.append_string(item)
+        # update state dict with restored data
+
+        state['messages'] = messages
+        state['last_usage_info'] = last_usage_info
+        state['mem_history'] = mem_history
+        console.print('[bold green]Restored last saved conversation.[/bold green]')
+
+    # Add system prompt if needed
+    if agent.system_prompt and not any(m.get('role') == 'system' for m in messages):
+        messages.insert(0, {"role": "system", "content": agent.system_prompt})
+
+    print_welcome(console, version=__version__)
+
+    # Toolbar references
+    def get_messages():
+        return messages
+
+    def get_usage():
+        return last_usage_info
+
+    def get_elapsed():
+        return last_elapsed
+
+    # Try to get model name from agent
+    model_name = getattr(agent, 'model', None)
+
+    session = get_prompt_session(
+        get_toolbar_func(
+            get_messages, get_usage, get_elapsed, model_name=model_name,
+            role_ref=lambda: effective_config.get('role')
+        ),
+        mem_history
+    )
+
+
+    # Main chat loop
+    while True:
+        try:
+            if state.get('paste_mode'):
+                console.print('')
+                user_input = session.prompt('Multiline> ', multiline=True)
+                was_paste_mode = True
+                state['paste_mode'] = False
+            else:
+                from prompt_toolkit.formatted_text import HTML
+                user_input = session.prompt(HTML('<prompt>💬 </prompt>'), multiline=False)
+                was_paste_mode = False
+        except EOFError:
+            console.print("\n[bold red]Exiting...[/bold red]")
+            break
+        except KeyboardInterrupt:
+            console.print()  # Move to next line
+            try:
+                confirm = input("Do you really want to exit? (y/n): ").strip().lower()
+            except KeyboardInterrupt:
+                console.print("\n[bold red]Exiting...[/bold red]")
+                break
+            if confirm == 'y':
+                console.print("[bold red]Exiting...[/bold red]")
+                break
+            else:
+                continue
+
+        if not was_paste_mode and user_input.strip().startswith('/'):
+            result = handle_command(user_input.strip(), console, agent=agent, messages=messages, mem_history=mem_history, state=state)
+            if result == 'exit':
+                break
+            continue
+
+        if not user_input.strip():
+            continue
+
+        mem_history.append_string(user_input)
+        messages.append({"role": "user", "content": user_input})
+
+        start_time = None
+        import time
+        start_time = time.time()
+
+        # Define streaming content handler
+        def on_content(chunk):
+            content_piece = chunk.get('content')
+            if content_piece:
+                console.print(Markdown(content_piece))
+
+        try:
+            response = agent.chat(messages, on_content=on_content, spinner=True)
+        except KeyboardInterrupt:
+            console.print("[bold yellow]Request interrupted. Returning to prompt.[/bold yellow]")
+            continue
+        except ProviderError as e:
+            console.print(f"[bold red]Provider error:[/bold red] {e}")
+            continue
+        except EmptyResponseError as e:
+            console.print(f"[bold red]Error:[/bold red] {e}")
+            continue
+        last_elapsed = time.time() - start_time
+
+        usage = response.get('usage')
+        last_usage_info = usage
+
+        # Save conversation and input history
+        from .session_manager import save_conversation, save_input_history
+        prompts = [h for h in mem_history.get_strings()]
+        save_conversation(messages, prompts, last_usage_info)
+        save_input_history(prompts)

janito/cli_chat_shell/commands.py

@@ -0,0 +1,202 @@
+import os
+import sys
+import json
+from prompt_toolkit.history import InMemoryHistory
+from janito.render_prompt import render_system_prompt
+from .load_prompt import load_prompt
+from janito.agent.config import effective_config
+
+
+def handle_exit(console, **kwargs):
+    console.print("[bold red]Exiting chat mode.[/bold red]")
+    sys.exit(0)
+
+
+def handle_restart(console, **kwargs):
+    console.print("[bold yellow]Restarting CLI...[/bold yellow]")
+    os.execv(sys.executable, [sys.executable, "-m", "janito"] + sys.argv[1:])
+
+
+def handle_continue(console, state, **kwargs):
+    save_path = os.path.join('.janito', 'last_conversation.json')
+    if not os.path.exists(save_path):
+        console.print('[bold red]No saved conversation found.[/bold red]')
+        return
+    try:
+        with open(save_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        state['messages'].clear()
+        state['messages'].extend(data.get('messages', []))
+        state['history_list'].clear()
+        state['history_list'].extend(data.get('prompts', []))
+        state['mem_history'] = InMemoryHistory()
+        for item in state['history_list']:
+            state['mem_history'].append_string(item)
+        state['last_usage_info'] = data.get('last_usage_info')
+        console.print('[bold green]Conversation restored from last session.[/bold green]')
+    except Exception as e:
+        console.print(f'[bold red]Failed to load conversation:[/bold red] {e}')
+
+def handle_history(console, state, *args, **kwargs):
+    messages = state.get('messages', [])
+    try:
+        if not args:
+            # Default: last 5 messages
+            start = max(0, len(messages) - 5)
+            end = len(messages)
+        elif len(args) == 1:
+            count = int(args[0])
+            start = max(0, len(messages) - count)
+            end = len(messages)
+        elif len(args) >= 2:
+            start = int(args[0])
+            end = int(args[1]) + 1  # inclusive
+        else:
+            start = 0
+            end = len(messages)
+
+        console.print(f"[bold cyan]Showing messages {start} to {end - 1} (total {len(messages)}):[/bold cyan]")
+        for idx, msg in enumerate(messages[start:end], start=start):
+            role = msg.get('role', 'unknown')
+            content = msg.get('content', '')
+            console.print(f"[bold]{idx} [{role}]:[/bold] {content}")
+    except Exception as e:
+        console.print(f"[bold red]Error parsing arguments or displaying history:[/bold red] {e}")
+
+def handle_help(console, **kwargs):
+    console.print("""
+[bold green]Available commands:[/bold green]
+  /exit     - Exit chat mode
+  /restart  - Restart the CLI
+  /help     - Show this help message
+  /continue - Restore last saved conversation
+  /reset    - Reset conversation history
+  /system   - Show the system prompt
+  /role     - Change the system role
+  /clear    - Clear the terminal screen
+  /multi    - Provide multiline input as next message
+  /config   - Show or set configuration (see: /config show, /config set local|global key=value)
+""")
+
+
+def handle_reload(console, *args, **kwargs):
+    """
+    /reload [filename] - Reload the system prompt from the default or specified file
+    """
+    agent = kwargs.get('agent')
+    state = kwargs.get('state')
+    filename = args[0] if args else None
+    try:
+        prompt_text = load_prompt(filename)
+        if hasattr(agent, 'system_prompt'):
+            agent.system_prompt = prompt_text
+        # Update the first system message in the conversation if present
+        messages = state.get('messages') if state else None
+        if messages:
+            for msg in messages:
+                if msg.get('role') == 'system':
+                    msg['content'] = prompt_text
+                    break
+        console.print(f"[bold green]System prompt reloaded from {'default file' if not filename else filename}![/bold green]")
+    except Exception as e:
+        console.print(f"[bold red]Failed to reload system prompt:[/bold red] {e}")
+
+
+def handle_system(console, **kwargs):
+    prompt = getattr(kwargs.get('agent'), 'system_prompt', None)
+    if not prompt:
+        prompt = render_system_prompt("software engineer")
+    console.print(f"[bold magenta]System Prompt:[/bold magenta]\n{prompt}")
+
+
+def handle_clear(console, **kwargs):
+    os.system('cls' if os.name == 'nt' else 'clear')
+
+
+def handle_reset(console, state, **kwargs):
+    import os
+    save_path = os.path.join('.janito', 'last_conversation.json')
+
+    # Clear in-memory conversation and prompt history
+    state['messages'].clear()
+    state['history_list'].clear()
+    state['mem_history'] = InMemoryHistory()
+    state['last_usage_info'] = None
+    state['last_elapsed'] = None
+
+    # Delete saved conversation file if exists
+    if os.path.exists(save_path):
+        try:
+            os.remove(save_path)
+            console.print('[bold yellow]Deleted saved conversation history.[/bold yellow]')
+        except Exception as e:
+            console.print(f'[bold red]Failed to delete saved conversation:[/bold red] {e}')
+    else:
+        console.print('[bold yellow]No saved conversation to delete.[/bold yellow]')
+
+    console.print('[bold green]Conversation history has been reset.[/bold green]')
+
+
+def handle_multi(console, state, **kwargs):
+    console.print("[bold yellow]Multiline mode activated. Provide or write your text and press Esc + Enter to submit.[/bold yellow]")
+    state['paste_mode'] = True
+
+from janito.agent.runtime_config import runtime_config
+from .config_shell import handle_config_shell
+
+def handle_role(console, *args, **kwargs):
+    state = kwargs.get('state')
+    agent = kwargs.get('agent')
+    if not args:
+        console.print('[bold red]Usage: /role <new role description>[/bold red]')
+        return
+    new_role = ' '.join(args)
+    # Update system message in conversation
+    found = False
+    for msg in state['messages']:
+        if msg.get('role') == 'system':
+            msg['content'] = render_system_prompt(new_role)
+            found = True
+            break
+    if not found:
+        # Insert new system message at the beginning
+        state['messages'].insert(0, {'role': 'system', 'content': new_role})
+    # Update agent's system prompt attribute if exists
+    if hasattr(agent, 'system_prompt'):
+        agent.system_prompt = render_system_prompt(new_role)
+    # Also store the raw role string
+    if hasattr(agent, 'role_name'):
+        agent.role_name = new_role
+    else:
+        setattr(agent, 'role_name', new_role)
+    # Update runtime config so all lookups see the new role
+    runtime_config.set('role', new_role)
+    console.print(f"[bold green]System role updated to:[/bold green] {new_role}")
+
+
+COMMAND_HANDLERS = {
+    "/history": handle_history,
+    "/continue": handle_continue,
+    "/exit": handle_exit,
+    "/restart": handle_restart,
+
+    "/help": handle_help,
+    "/multi": handle_multi,
+    "/system": handle_system,
+    "/role": handle_role,
+    "/clear": handle_clear,
+    "/reset": handle_reset,
+    "/config": handle_config_shell,
+    "/reload": handle_reload,
+}
+
+
+def handle_command(command, console, **kwargs):
+    parts = command.strip().split()
+    cmd = parts[0]
+    args = parts[1:]
+    handler = COMMAND_HANDLERS.get(cmd)
+    if handler:
+        return handler(console, *args, **kwargs)
+    console.print(f"[bold red]Invalid command: {cmd}. Type /help for a list of commands.[/bold red]")
+    return None