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

janito/cli/main.py

@@ -1,202 +1,14 @@
-"""Main CLI entry point for Janito."""
+# Ensure all output is written before the program exits, especially when output is piped or buffered.
+from janito.cli.main_cli import JanitoCLI
+import atexit, sys
 
-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.cli_main import run_cli
-from janito.agent.runtime_config import unified_config
-from janito.cli.livereload_starter import start_livereload
-
-# Ensure all tools are registered at startup
-import janito.agent.tools  # noqa: F401
-from janito.i18n import tr
-
-
-def handle_list_sessions(args):
-    import os
-    import glob
-
-    n = args.list if args.list is not None else 10
-    history_dir = os.path.join(os.path.expanduser(".janito"), "chat_history")
-    if not os.path.exists(history_dir):
-        print("No session history found.")
-        return True
-    files = glob.glob(os.path.join(history_dir, "*.json"))
-    files = sorted(files, key=os.path.getmtime, reverse=True)
-    print(f"Last {n} sessions:")
-    for f in files[:n]:
-        session_id = os.path.splitext(os.path.basename(f))[0]
-        print(session_id)
-    return True
-
-
-def handle_view_session(args):
-    import os
-    import json
-
-    history_dir = os.path.join(os.path.expanduser(".janito"), "chat_history")
-    session_file = os.path.join(history_dir, f"{args.view}.json")
-    if not os.path.exists(session_file):
-        print(f"Session '{args.view}' not found.")
-        return 1
-    with open(session_file, "r", encoding="utf-8") as f:
-        try:
-            messages = json.load(f)
-        except Exception as e:
-            print(f"Failed to load session: {e}")
-            return 1
-    print(f"Conversation history for session '{args.view}':\n")
-    for i, msg in enumerate(messages, 1):
-        role = msg.get("role", "?")
-        content = msg.get("content", "")
-        print(f"[{i}] {role}: {content}\n")
-    return 0
-
-
-def handle_lang_selection(args):
-    import janito.i18n as i18n
-    from janito.agent.runtime_config import runtime_config
-
-    lang = getattr(args, "lang", None) or unified_config.get("lang", None) or "en"
-    runtime_config.set("lang", lang)
-    i18n.set_locale(lang)
-
-
-def handle_help_config(args):
-    from janito.agent.config import CONFIG_OPTIONS
-    from janito.agent.config_defaults import CONFIG_DEFAULTS
-
-    print(tr("Available configuration options:\n"))
-    for key, desc in CONFIG_OPTIONS.items():
-        default = CONFIG_DEFAULTS.get(key, None)
-        print(
-            tr(
-                "{key:15} {desc} (default: {default})",
-                key=key,
-                desc=desc,
-                default=default,
-            )
-        )
-
-
-def handle_list_tools(args):
-    from janito.agent.tool_registry import get_tool_schemas
-    from rich.console import Console
-    from rich.table import Table
-
-    console = Console()
-    table = Table(
-        title="Ferramentas Registradas", show_lines=True, style="bold magenta"
-    )
-    table.add_column("Gnome", style="cyan", no_wrap=True)
-    table.add_column("Descrição", style="green")
-    table.add_column("Parâmetros", style="yellow")
-    for schema in get_tool_schemas():
-        fn = schema["function"]
-        params = "\n".join(
-            [
-                f"[bold]{k}[/]: {v['type']}"
-                for k, v in fn["parameters"].get("properties", {}).items()
-            ]
-        )
-        table.add_row(f"[b]{fn['name']}[/b]", fn["description"], params or "-")
-    console.print(table)
-
-
-def handle_info(args):
-    from janito import __version__
-    from rich.console import Console
-    from rich.text import Text
-    from janito.agent.runtime_config import runtime_config
-
-    model = unified_config.get("model")
-    temperature = unified_config.get("temperature")
-    max_tokens = unified_config.get("max_tokens")
-    system_prompt_val = None
-    if getattr(args, "system_file", None):
-        try:
-            with open(args.system_file, "r", encoding="utf-8") as f:
-                system_prompt_val = f.read().strip()
-            runtime_config.set("system_prompt_template", system_prompt_val)
-        except Exception as e:
-            system_prompt_val = f"(error reading system-file: {e})"
-    elif getattr(args, "system", None):
-        system_prompt_val = args.system
-        runtime_config.set("system_prompt_template", system_prompt_val)
-    else:
-        system_prompt_val = runtime_config.get("system_prompt_template")
-    if not system_prompt_val:
-        try:
-            from janito.agent.profile_manager import AgentProfileManager
-            from janito.agent.config import get_api_key
-
-            role = args.role or unified_config.get("role", "software engineer")
-            interaction_mode = "chat" if not getattr(args, "prompt", None) else "prompt"
-            profile = "base"
-            profile_manager = AgentProfileManager(
-                api_key=get_api_key(),
-                model=unified_config.get("model"),
-            )
-            system_prompt_val = profile_manager.get_system_prompt(
-                role, interaction_mode, profile
-            )
-        except Exception as e:
-            system_prompt_val = f"(error: {e})"
-    console = Console()
-    info_text = Text()
-    info_text.append(f"Janito v{__version__}", style="bold cyan")
-    info_text.append(" | model: ", style="white")
-    info_text.append(str(model), style="green")
-    info_text.append(" | temp: ", style="white")
-    info_text.append(str(temperature), style="yellow")
-    info_text.append(" | max_tokens: ", style="white")
-    info_text.append(str(max_tokens), style="magenta")
-    info_text.append(" | system: ", style="white")
-    info_text.append(str(system_prompt_val), style="bold blue")
-    console.print(info_text, style="dim")
+atexit.register(lambda: sys.stdout.flush())
 
 
 def main():
-    """Unified entry point for the Janito CLI and web server."""
-    import sys
-    from janito.agent.config import local_config, global_config
+    cli = JanitoCLI()
+    cli.run()
 
-    local_config.load()
-    global_config.load()
-    parser = create_parser()
-    args = parser.parse_args()
-    # Handle --list [n] before anything else
-    if getattr(args, "list", None) is not None:
-        if handle_list_sessions(args):
-            sys.exit(0)
-    # Handle --view <id> to print conversation history
-    if getattr(args, "view", None) is not None:
-        sys.exit(handle_view_session(args))
-    handle_lang_selection(args)
-    if getattr(args, "help_config", False):
-        handle_help_config(args)
-        sys.exit(0)
-    if getattr(args, "list_tools", False):
-        handle_list_tools(args)
-        sys.exit(0)
-    if getattr(args, "info", False):
-        handle_info(args)
-    handle_config_commands(args)
-    setup_verbose_logging(args)
-    if getattr(args, "web", False):
-        import subprocess
 
-        subprocess.run([sys.executable, "-m", "janito.web"])
-    elif getattr(args, "live", False):
-        port = 35729
-        livereload_proc, started, livereload_stdout_path, livereload_stderr_path = (
-            start_livereload(port)
-        )
-        try:
-            run_cli(args)
-        finally:
-            if livereload_proc:
-                livereload_proc.terminate()
-                livereload_proc.wait()
-    else:
-        run_cli(args)
+if __name__ == "__main__":
+    main()

janito/cli/main_cli.py

@@ -0,0 +1,312 @@
+import argparse
+import enum
+from janito.cli.core.setters import handle_api_key_set, handle_set
+from janito.cli.core.getters import handle_getter
+from janito.cli.core.runner import (
+    prepare_llm_driver_config,
+    handle_runner,
+    get_prompt_mode,
+)
+from janito.cli.core.event_logger import (
+    setup_event_logger_if_needed,
+    inject_debug_event_bus_if_needed,
+)
+
+definition = [
+    (
+        ["--verbose-api"],
+        {
+            "action": "store_true",
+            "help": "Print API calls and responses of LLM driver APIs for debugging/tracing.",
+        },
+    ),
+    (
+        ["--verbose-tools"],
+        {
+            "action": "store_true",
+            "help": "Print info messages for tool execution in tools adapter.",
+        },
+    ),
+    (
+        ["--verbose-agent"],
+        {
+            "action": "store_true",
+            "help": "Print info messages for agent event and message part handling.",
+        },
+    ),
+    (
+        ["-z", "--zero"],
+        {
+            "action": "store_true",
+            "help": "IDE zero mode: disables system prompt & all tools for raw LLM interaction",
+        },
+    ),
+    (
+        ["-x", "--exec"],
+        {
+            "action": "store_true",
+            "help": "Enable execution/run tools (allows running code or shell tools from the CLI)",
+        },
+    ),
+    (["--unset"], {"metavar": "KEY", "help": "Unset (remove) a config key"}),
+    (["--version"], {"action": "version", "version": None}),
+    (["--list-tools"], {"action": "store_true", "help": "List all registered tools"}),
+    (["--show-config"], {"action": "store_true", "help": "Show the current config"}),
+    (
+        ["--list-providers"],
+        {"action": "store_true", "help": "List supported LLM providers"},
+    ),
+    (
+        ["-l", "--list-models"],
+        {"action": "store_true", "help": "List all supported models"},
+    ),
+    (
+        ["--set-api-key"],
+        {
+            "metavar": "API_KEY",
+            "help": "Set API key for the provider (requires -p PROVIDER)",
+        },
+    ),
+    (["--set"], {"metavar": "[PROVIDER_NAME.]KEY=VALUE", "help": "Set a config key"}),
+    (["-s", "--system"], {"metavar": "SYSTEM_PROMPT", "help": "Set a system prompt"}),
+    (
+        ["-S", "--show-system"],
+        {
+            "action": "store_true",
+            "help": "Show the resolved system prompt for the main agent",
+        },
+    ),
+    (["-r", "--role"], {"metavar": "ROLE", "help": "Set the role for the agent"}),
+    (["-p", "--provider"], {"metavar": "PROVIDER", "help": "Select the provider"}),
+    (["-m", "--model"], {"metavar": "MODEL", "help": "Select the model"}),
+    (
+        ["-t", "--temperature"],
+        {"type": float, "default": None, "help": "Set the temperature"},
+    ),
+    (
+        ["-v", "--verbose"],
+        {"action": "store_true", "help": "Print extra information before answering"},
+    ),
+    (
+        ["-R", "--raw"],
+        {
+            "action": "store_true",
+            "help": "Print the raw JSON response from the OpenAI API (if applicable)",
+        },
+    ),
+    (
+        ["-w", "--web"],
+        {
+            "action": "store_true",
+            "default": False,
+            "help": "Enable the builtin lightweight web file viewer for terminal links (disabled by default)",
+        },
+    ),
+    (
+        ["--termweb-port"],
+        {
+            "type": int,
+            "default": 8088,
+            "help": "Port for the termweb server (default: 8088)",
+        },
+    ),
+    (["user_prompt"], {"nargs": argparse.REMAINDER, "help": "Prompt to submit"}),
+    (
+        ["-e", "--event-log"],
+        {"action": "store_true", "help": "Enable event logging to the system bus"},
+    ),
+    (
+        ["--event-debug"],
+        {
+            "action": "store_true",
+            "help": "Print debug info on event subscribe/submit methods",
+        },
+    ),
+]
+
+MODIFIER_KEYS = [
+    "provider",
+    "model",
+    "role",
+    "system",
+    "temperature",
+    "verbose",
+    "raw",
+    "web",
+    "termweb_port",
+    "verbose_api",
+    "verbose_tools",
+    "exec",
+]
+SETTER_KEYS = ["set", "set_provider", "set_api_key", "unset"]
+GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
+
+
+class RunMode(enum.Enum):
+    GET = "get"
+    SET = "set"
+    RUN = "run"
+
+
+class JanitoCLI:
+    def __init__(self):
+        import janito.tools
+
+        self.parser = argparse.ArgumentParser(
+            description="Janito CLI - A tool for running LLM-powered workflows from the command line."
+            "\n\nExample usage: janito -p openai -m gpt-3.5-turbo 'Your prompt here'\n\n"
+            "Use -m or --model to set the model for the session."
+        )
+        self._define_args()
+        self.args = self.parser.parse_args()
+        self._set_all_arg_defaults()
+        from janito.cli.rich_terminal_reporter import RichTerminalReporter
+
+        self.rich_reporter = RichTerminalReporter(raw_mode=self.args.raw)
+
+    def _define_args(self):
+        for argnames, argkwargs in definition:
+            # Patch version argument dynamically with real version
+            if "--version" in argnames:
+                from janito import __version__ as janito_version
+
+                argkwargs["version"] = f"Janito {janito_version}"
+            self.parser.add_argument(*argnames, **argkwargs)
+
+    def _set_all_arg_defaults(self):
+        # Gather all possible keys from definition, MODIFIER_KEYS, SETTER_KEYS, GETTER_KEYS
+        all_keys = set()
+        for argnames, argkwargs in definition:
+            for name in argnames:
+                key = name.lstrip("-").replace("-", "_")
+                all_keys.add(key)
+        all_keys.update(MODIFIER_KEYS)
+        all_keys.update(SETTER_KEYS)
+        all_keys.update(GETTER_KEYS)
+        # Set defaults for all keys if not present
+        for key in all_keys:
+            if not hasattr(self.args, key):
+                setattr(self.args, key, None)
+
+    def collect_modifiers(self):
+        return {
+            k: getattr(self.args, k)
+            for k in MODIFIER_KEYS
+            if getattr(self.args, k, None) is not None
+        }
+
+    def exec_enabled(self):
+        return getattr(self.args, "exec", False)
+
+    def classify(self):
+        if any(getattr(self.args, k, None) for k in SETTER_KEYS):
+            return RunMode.SET
+        if any(getattr(self.args, k, None) for k in GETTER_KEYS):
+            return RunMode.GET
+        return RunMode.RUN
+
+    def run(self):
+        # Handle --show-system/-S before anything else
+        if getattr(self.args, "show_system", False):
+            from janito.cli.cli_commands.show_system_prompt import (
+                handle_show_system_prompt,
+            )
+
+            handle_show_system_prompt(self.args)
+            return
+        run_mode = self.classify()
+        if run_mode == RunMode.SET:
+            if self._run_set_mode():
+                return
+        # Special handling: provider is not required for list_providers, list_tools, show_config
+        if run_mode == RunMode.GET and (
+            self.args.list_providers or self.args.list_tools or self.args.show_config
+        ):
+            self._maybe_print_verbose_provider_model()
+            handle_getter(self.args)
+            return
+        provider = self._get_provider_or_default()
+        if provider is None:
+            print(
+                "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
+            )
+            return
+        modifiers = self.collect_modifiers()
+        self._maybe_print_verbose_modifiers(modifiers)
+        setup_event_logger_if_needed(self.args)
+        inject_debug_event_bus_if_needed(self.args)
+        provider, llm_driver_config, agent_role = prepare_llm_driver_config(
+            self.args, modifiers
+        )
+        if provider is None or llm_driver_config is None:
+            return
+        self._maybe_print_verbose_llm_config(llm_driver_config, run_mode)
+        if run_mode == RunMode.RUN:
+            self._maybe_print_verbose_run_mode()
+            handle_runner(
+                self.args,
+                provider,
+                llm_driver_config,
+                agent_role,
+                verbose_tools=self.args.verbose_tools,
+                exec_enabled=self.exec_enabled(),
+            )
+        elif run_mode == RunMode.GET:
+            handle_getter(self.args)
+
+    def _run_set_mode(self):
+        if handle_api_key_set(self.args):
+            return True
+        if handle_set(self.args):
+            return True
+        from janito.cli.core.unsetters import handle_unset
+
+        if handle_unset(self.args):
+            return True
+        return False
+
+    def _get_provider_or_default(self):
+        provider = self.args.provider
+        if provider is None:
+            from janito.provider_config import get_config_provider
+
+            provider = get_config_provider()
+        return provider
+
+    def _maybe_print_verbose_modifiers(self, modifiers):
+        if self.args.verbose:
+            from janito.cli.verbose_output import print_verbose_info
+
+            print_verbose_info("Modifiers collected", modifiers, style="blue")
+
+    def _maybe_print_verbose_provider_model(self):
+        if self.args.verbose:
+            from janito.cli.verbose_output import print_verbose_info
+
+            print_verbose_info(
+                "Validated provider/model",
+                f"Provider: {self.args.provider} | Model: {self.args.model}",
+                style="blue",
+            )
+
+    def _maybe_print_verbose_llm_config(self, llm_driver_config, run_mode):
+        if self.args.verbose:
+            from janito.cli.verbose_output import print_verbose_info
+
+            print_verbose_info("LLMDriverConfig", llm_driver_config, style="cyan")
+            print_verbose_info(
+                "Dispatch branch", run_mode, style="cyan", align_content=True
+            )
+
+    def _maybe_print_verbose_run_mode(self):
+        if self.args.verbose:
+            from janito.cli.verbose_output import print_verbose_info
+
+            print_verbose_info(
+                "Run mode", get_prompt_mode(self.args), style="cyan", align_content=True
+            )
+
+
+if __name__ == "__main__":
+    cli = JanitoCLI()
+    cli.run()