janito 1.5.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

janito/cli/logging_setup.py

@@ -7,7 +7,9 @@ def setup_verbose_logging(args):
         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"))
+        handler.setFormatter(
+            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        )
         httpx_logger.addHandler(handler)
 
     if args.verbose_http_raw:
@@ -16,12 +18,16 @@ def setup_verbose_logging(args):
         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"))
+        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"))
+        handler.setFormatter(
+            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        )
         httpx_logger.addHandler(handler)

janito/cli/main.py

@@ -1,29 +1,29 @@
 """Main CLI entry point for Janito."""
 
-import janito.agent.tool_auto_imports
 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
 
+# Ensure all tools are registered at startup
+import janito.agent.tools  # noqa: F401
+
 
 def main():
-    """Entry point for the Janito CLI.
+    """Unified entry point for the Janito CLI and web server."""
+    import sys
 
-    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  # Kept here: avoids circular import at module level
+    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():
@@ -33,8 +33,9 @@ def main():
 
     handle_config_commands(args)
     setup_verbose_logging(args)
-    if getattr(args, 'web', False):
+    if getattr(args, "web", False):
         import subprocess  # Only needed if launching web
-        subprocess.run(['python', '-m', 'janito.web'])
+
+        subprocess.run([sys.executable, "-m", "janito.web"])
     else:
         run_cli(args)

janito/cli/runner/__init__.py

@@ -0,0 +1,2 @@
+from .cli_main import run_cli
+from .formatting import format_tokens

janito/cli/runner/cli_main.py

@@ -0,0 +1,148 @@
+import sys
+import os
+from rich.console import Console
+from janito.agent.profile_manager import AgentProfileManager
+from janito.agent.runtime_config import unified_config, runtime_config
+from janito.agent.config import get_api_key
+from janito import __version__
+from .formatting import format_tokens
+from .scan import scan_project
+from .config import get_system_prompt_template
+from janito.agent.conversation_exceptions import (
+    MaxRoundsExceededError,
+    EmptyResponseError,
+    ProviderError,
+)
+
+def run_cli(args):
+    if args.version:
+        print(f"janito version {__version__}")
+        sys.exit(0)
+
+    # --scan: auto-detect tech/skills and save to .janito/tech.txt
+    if getattr(args, "scan", False):
+        scan_project()
+        sys.exit(0)
+
+    # Check for .janito/tech.txt and print a tip if missing
+    tech_txt_path = os.path.join(".janito", "tech.txt")
+    if not os.path.exists(tech_txt_path):
+        print("⚠️  No tech.txt found in .janito.")
+        print(
+            "💡 Tip: Run with --scan first to auto-detect project tech/skills and improve results."
+        )
+
+    role = args.role or unified_config.get("role", "software engineer")
+
+    # Ensure runtime_config is updated so chat shell sees the role
+    if args.role:
+        runtime_config.set("role", args.role)
+
+    # Set runtime_config['model'] if --model is provided (highest priority, session only)
+    if getattr(args, "model", None):
+        runtime_config.set("model", args.model)
+
+    # Set runtime_config['max_tools'] if --max-tools is provided
+    if getattr(args, "max_tools", None) is not None:
+        runtime_config.set("max_tools", args.max_tools)
+
+    # Set trust-tools mode if enabled
+    if getattr(args, "trust_tools", False):
+        runtime_config.set("trust_tools", True)
+
+    # Get system prompt template (instructions/config logic)
+    system_prompt_template = get_system_prompt_template(args, role)
+
+    if args.show_system:
+        api_key = get_api_key()
+        model = unified_config.get("model")
+        print("Model:", model)
+        print("Parameters: {}")
+        print(
+            "System Prompt Template:",
+            system_prompt_template or "(default system prompt template 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")
+    azure_openai_api_version = unified_config.get(
+        "azure_openai_api_version", "2023-05-15"
+    )
+    # Handle vanilla mode
+    vanilla_mode = getattr(args, "vanilla", False)
+    if vanilla_mode:
+        runtime_config.set("vanilla_mode", True)
+        system_prompt_template = None
+        runtime_config.set("system_prompt_template", None)
+        if args.temperature is None:
+            runtime_config.set("temperature", None)
+    else:
+        runtime_config.set("vanilla_mode", False)
+
+    interaction_style = getattr(args, "style", None) or unified_config.get(
+        "interaction_style", "default"
+    )
+
+    if not getattr(args, "prompt", None):
+        interaction_mode = "chat"
+    else:
+        interaction_mode = "prompt"
+
+    profile_manager = AgentProfileManager(
+        api_key=api_key,
+        model=model,
+        role=role,
+        interaction_style=interaction_style,
+        interaction_mode=interaction_mode,
+        verbose_tools=args.verbose_tools,
+        base_url=base_url,
+        azure_openai_api_version=azure_openai_api_version,
+        use_azure_openai=unified_config.get("use_azure_openai", False),
+    )
+    profile_manager.refresh_prompt()
+
+    if args.max_tokens is not None:
+        runtime_config.set("max_tokens", args.max_tokens)
+
+    if not getattr(args, "prompt", None):
+        from janito.cli_chat_shell.chat_loop import start_chat_shell
+
+        start_chat_shell(
+            profile_manager, continue_session=getattr(args, "continue_session", False)
+        )
+        sys.exit(0)
+
+    prompt = args.prompt
+    console = Console()
+    from janito.agent.rich_message_handler import RichMessageHandler
+
+    message_handler = RichMessageHandler()
+    messages = []
+    if profile_manager.system_prompt_template:
+        messages.append(
+            {"role": "system", "content": profile_manager.system_prompt_template}
+        )
+    messages.append({"role": "user", "content": prompt})
+    try:
+        try:
+            max_rounds = runtime_config.get("max_rounds", 50)
+            profile_manager.agent.handle_conversation(
+                messages,
+                message_handler=message_handler,
+                spinner=True,
+                max_rounds=max_rounds,
+                verbose_response=getattr(args, "verbose_response", False),
+                verbose_events=getattr(args, "verbose_events", False),
+                stream=getattr(args, "stream", False),
+                verbose_stream=getattr(args, "verbose_stream", False),
+            )
+        except MaxRoundsExceededError:
+            console.print("[red]Max conversation rounds exceeded.[/red]")
+        except ProviderError as e:
+            console.print(f"[red]Provider error:[/red] {e}")
+        except EmptyResponseError as e:
+            console.print(f"[red]Error:[/red] {e}")
+    except KeyboardInterrupt:
+        console.print("[yellow]Interrupted by user.[/yellow]")

janito/cli/runner/config.py

@@ -0,0 +1,33 @@
+import os
+from janito.agent.profile_manager import AgentProfileManager
+from janito.agent.runtime_config import unified_config, runtime_config
+from janito.agent.config import get_api_key
+
+def get_system_prompt_template(args, role):
+    system_prompt_template = None
+    if getattr(args, "system_prompt_template_file", None):
+        with open(args.system_prompt_template_file, "r", encoding="utf-8") as f:
+            system_prompt_template = f.read()
+        runtime_config.set(
+            "system_prompt_template_file", args.system_prompt_template_file
+        )
+    else:
+        system_prompt_template = getattr(
+            args, "system_prompt_template", None
+        ) or unified_config.get("system_prompt_template")
+        if getattr(args, "system_prompt_template", None):
+            runtime_config.set("system_prompt_template", system_prompt_template)
+        if system_prompt_template is None:
+            profile_manager = AgentProfileManager(
+                api_key=get_api_key(),
+                model=unified_config.get("model"),
+                role=role,
+                interaction_style=unified_config.get("interaction_style", "default"),
+                interaction_mode=unified_config.get("interaction_mode", "prompt"),
+                verbose_tools=unified_config.get("verbose_tools", False),
+                base_url=unified_config.get("base_url", None),
+                azure_openai_api_version=unified_config.get("azure_openai_api_version", None),
+                use_azure_openai=unified_config.get("use_azure_openai", False),
+            )
+            system_prompt_template = profile_manager.render_prompt()
+    return system_prompt_template

janito/cli/runner/formatting.py

@@ -0,0 +1,12 @@
+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)

janito/cli/runner/scan.py

@@ -0,0 +1,44 @@
+import os
+from janito.agent.openai_client import Agent
+from janito.agent.runtime_config import unified_config
+from janito.agent.config import get_api_key
+
+def scan_project():
+    prompt_path = os.path.abspath(os.path.join(
+        os.path.dirname(__file__),
+        "..", "..", "agent", "templates", "detect_tech_prompt.j2"
+    ))
+    with open(prompt_path, "r", encoding="utf-8") as f:
+        detect_prompt = f.read()
+    api_key = get_api_key()
+    model = unified_config.get("model")
+    base_url = unified_config.get("base_url", "https://openrouter.ai/api/v1")
+    azure_openai_api_version = unified_config.get("azure_openai_api_version", "2023-05-15")
+    use_azure_openai = unified_config.get("use_azure_openai", False)
+    agent = Agent(
+        api_key=api_key,
+        model=model,
+        system_prompt_template=detect_prompt,
+        verbose_tools=True,
+        base_url=base_url,
+        azure_openai_api_version=azure_openai_api_version,
+        use_azure_openai=use_azure_openai,
+    )
+    from janito.agent.rich_message_handler import RichMessageHandler
+    message_handler = RichMessageHandler()
+    messages = [{"role": "system", "content": detect_prompt}]
+    print("🔍 Scanning project for relevant tech/skills...")
+    result = agent.chat(
+        messages,
+        message_handler=message_handler,
+        spinner=True,
+        max_rounds=10,
+        verbose_response=False,
+        verbose_events=False,
+        stream=False,
+    )
+    os.makedirs(".janito", exist_ok=True)
+    tech_txt = os.path.join(".janito", "tech.txt")
+    with open(tech_txt, "w", encoding="utf-8") as f:
+        f.write(result["content"].strip() + "\n")
+    print(f"✅ Tech/skills detected and saved to {tech_txt}")

janito/cli_chat_shell/__init__.py

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

janito/cli_chat_shell/chat_loop.py

@@ -1,93 +1,47 @@
-from janito.agent.rich_tool_handler import MessageHandler
-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 janito.agent.rich_message_handler import RichMessageHandler
+from .chat_state import load_chat_state, save_chat_state
+from .chat_ui import setup_prompt_session, print_welcome_message
 from .commands import handle_command
-from janito.agent.config import effective_config
-from janito.agent.runtime_config import runtime_config
-from janito.agent.conversation import EmptyResponseError, ProviderError
+from janito.agent.conversation_exceptions import EmptyResponseError, ProviderError
 
 
-def start_chat_shell(agent, continue_session=False, max_rounds=50):
-    message_handler = MessageHandler()
+def start_chat_shell(profile_manager, continue_session=False, max_rounds=50):
+    agent = profile_manager.agent
+    message_handler = RichMessageHandler()
     console = message_handler.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
-        message_handler.handle_message({'type': 'success', 'message': 'Restored last saved conversation.'})
+    # Load state
+    state = load_chat_state(continue_session)
+    messages = state["messages"]
+    mem_history = state["mem_history"]
+    last_usage_info = state["last_usage_info"]
+    last_elapsed = state["last_elapsed"]
 
     # 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__, continued=continue_session)
-
-    # Toolbar references
-    def get_messages():
-        return messages
-
-    def get_usage():
-        return last_usage_info
-
-    def get_elapsed():
-        return last_elapsed
+    if profile_manager.system_prompt_template and not any(
+        m.get("role") == "system" for m in messages
+    ):
+        messages.insert(0, {"role": "system", "content": agent.system_prompt_template})
 
-    # Try to get model name from agent
-    model_name = getattr(agent, 'model', None)
+    print_welcome_message(console, continued=continue_session)
 
-    session = get_prompt_session(
-        get_toolbar_func(
-            get_messages, get_usage, get_elapsed, model_name=model_name,
-            role_ref=lambda: ("*using custom system prompt*" if (runtime_config.get('system_prompt') or runtime_config.get('system_prompt_file')) else (runtime_config.get('role') or effective_config.get('role')))
-        ),
-        mem_history
+    session = setup_prompt_session(
+        messages, last_usage_info, last_elapsed, mem_history, profile_manager, agent
     )
 
-
-    # Main chat loop
     while True:
-        # max_rounds is now available for use in the chat loop
-
         try:
-            if state.get('paste_mode'):
-                console.print('')
-                user_input = session.prompt('Multiline> ', multiline=True)
+            if state.get("paste_mode"):
+                console.print("")
+                user_input = session.prompt("Multiline> ", multiline=True)
                 was_paste_mode = True
-                state['paste_mode'] = False
+                state["paste_mode"] = False
             else:
                 from prompt_toolkit.formatted_text import HTML
-                user_input = session.prompt(HTML('<prompt>💬 </prompt>'), multiline=False)
+
+                user_input = session.prompt(
+                    HTML("<prompt>💬 </prompt>"), multiline=False
+                )
                 was_paste_mode = False
         except EOFError:
             console.print("\n[bold red]Exiting...[/bold red]")
@@ -95,19 +49,39 @@ def start_chat_shell(agent, continue_session=False, max_rounds=50):
         except KeyboardInterrupt:
             console.print()  # Move to next line
             try:
-                confirm = input("Do you really want to exit? (y/n): ").strip().lower()
+                confirm = (
+                    session.prompt(
+                        HTML("<prompt>Do you really want to exit? (y/n): </prompt>")
+                    )
+                    .strip()
+                    .lower()
+                )
             except KeyboardInterrupt:
-                message_handler.handle_message({'type': 'error', 'message': 'Exiting...'})
+                message_handler.handle_message(
+                    {"type": "error", "message": "Exiting..."}
+                )
                 break
-            if confirm == 'y':
-                message_handler.handle_message({'type': 'error', 'message': 'Exiting...'})
+            if confirm == "y":
+                message_handler.handle_message(
+                    {"type": "error", "message": "Exiting..."}
+                )
                 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':
+        cmd_input = user_input.strip().lower()
+        if not was_paste_mode and (cmd_input.startswith("/") or cmd_input == "exit"):
+            # Treat both '/exit' and 'exit' as commands
+            result = handle_command(
+                user_input.strip(),
+                console,
+                profile_manager=profile_manager,
+                agent=agent,
+                messages=messages,
+                mem_history=mem_history,
+                state=state,
+            )
+            if result == "exit":
                 break
             continue
 
@@ -117,29 +91,34 @@ def start_chat_shell(agent, continue_session=False, max_rounds=50):
         mem_history.append_string(user_input)
         messages.append({"role": "user", "content": user_input})
 
-        start_time = None
         import time
-        start_time = time.time()
 
+        start_time = time.time()
 
         try:
-            response = agent.chat(messages, spinner=True, max_rounds=max_rounds, message_handler=message_handler)
+            response = profile_manager.agent.handle_conversation(
+                messages,
+                max_rounds=max_rounds,
+                message_handler=message_handler,
+                spinner=True,
+            )
         except KeyboardInterrupt:
-            message_handler.handle_message({'type': 'info', 'message': 'Request interrupted. Returning to prompt.'})
+            message_handler.handle_message(
+                {"type": "info", "message": "Request interrupted. Returning to prompt."}
+            )
             continue
         except ProviderError as e:
-            message_handler.handle_message({'type': 'error', 'message': f'Provider error: {e}'})
+            message_handler.handle_message(
+                {"type": "error", "message": f"Provider error: {e}"}
+            )
             continue
         except EmptyResponseError as e:
-            message_handler.handle_message({'type': 'error', 'message': f'Error: {e}'})
+            message_handler.handle_message({"type": "error", "message": f"Error: {e}"})
             continue
         last_elapsed = time.time() - start_time
 
-        usage = response.get('usage')
+        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)
+        save_chat_state(messages, mem_history, last_usage_info)

janito/cli_chat_shell/chat_state.py

@@ -0,0 +1,38 @@
+from .session_manager import (
+    load_last_conversation,
+    load_input_history,
+    save_conversation,
+    save_input_history,
+)
+from prompt_toolkit.history import InMemoryHistory
+
+
+def load_chat_state(continue_session: bool):
+    messages = []
+    last_usage_info = None
+    last_elapsed = None
+    history_list = load_input_history()
+    mem_history = InMemoryHistory()
+    for item in history_list:
+        mem_history.append_string(item)
+    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)
+    state = {
+        "messages": messages,
+        "mem_history": mem_history,
+        "history_list": history_list,
+        "last_usage_info": last_usage_info,
+        "last_elapsed": last_elapsed,
+    }
+    return state
+
+
+def save_chat_state(messages, mem_history, last_usage_info):
+    prompts = [h for h in mem_history.get_strings()]
+    save_conversation(messages, prompts, last_usage_info)
+    save_input_history(prompts)

janito/cli_chat_shell/chat_ui.py

@@ -0,0 +1,43 @@
+from .ui import print_welcome, get_toolbar_func, get_prompt_session
+from janito import __version__
+from janito.agent.config import effective_config
+from janito.agent.runtime_config import runtime_config
+
+
+def setup_prompt_session(
+    messages, last_usage_info, last_elapsed, mem_history, profile_manager, agent
+):
+    model_name = getattr(agent, "model", None)
+
+    def get_messages():
+        return messages
+
+    def get_usage():
+        return last_usage_info
+
+    def get_elapsed():
+        return last_elapsed
+
+    session = get_prompt_session(
+        get_toolbar_func(
+            get_messages,
+            get_usage,
+            get_elapsed,
+            model_name=model_name,
+            role_ref=lambda: (
+                "*using custom system prompt*"
+                if (
+                    runtime_config.get("system_prompt_template")
+                    or runtime_config.get("system_prompt_template_file")
+                )
+                else (runtime_config.get("role") or effective_config.get("role"))
+            ),
+            style_ref=lambda: getattr(profile_manager, "interaction_style", "default"),
+        ),
+        mem_history,
+    )
+    return session
+
+
+def print_welcome_message(console, continued):
+    print_welcome(console, version=__version__, continued=continued)

janito/cli_chat_shell/commands/__init__.py

@@ -0,0 +1,45 @@
+from .session import handle_continue, handle_history
+from .system import handle_system, handle_role, handle_style
+from .session_control import handle_exit, handle_restart
+from .utility import handle_help, handle_clear, handle_multi
+from .config import handle_reload
+from .history_reset import handle_reset
+from ..config_shell import handle_config_shell
+from janito.agent.runtime_config import runtime_config
+
+COMMAND_HANDLERS = {
+    "/history": handle_history,
+    "/continue": handle_continue,
+    "/exit": handle_exit,
+    "exit": handle_exit,
+    "/restart": handle_restart,
+    "/help": handle_help,
+    "/multi": handle_multi,
+    "/system": handle_system,
+}
+
+if not runtime_config.get("vanilla_mode", False):
+    COMMAND_HANDLERS["/role"] = handle_role
+
+COMMAND_HANDLERS.update(
+    {
+        "/clear": handle_clear,
+        "/reset": handle_reset,
+        "/config": handle_config_shell,
+        "/reload": handle_reload,
+        "/style": handle_style,
+    }
+)
+
+
+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