janito 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

janito/cli/config_commands.py

@@ -9,6 +9,18 @@ def handle_config_commands(args):
     """Handle --set-local-config, --set-global-config, --show-config. Exit if any are used."""
     did_something = False
 
+    if args.run_config:
+        for run_item in args.run_config:
+            try:
+                key, val = run_item.split("=", 1)
+            except ValueError:
+                print("Invalid format for --run-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)
+            runtime_config.set(key, val.strip())
     if args.set_local_config:
         from janito.agent.config import CONFIG_OPTIONS
         try:
@@ -34,17 +46,33 @@ def handle_config_commands(args):
             print("Invalid format for --set-global-config, expected key=val")
             sys.exit(1)
         key = key.strip()
-        if key not in CONFIG_OPTIONS:
+        if key not in CONFIG_OPTIONS and not key.startswith("template."):
             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 key.startswith('template.'):
+            subkey = key[len('template.'):]
+            template_dict = global_config.get('template', {})
+            template_dict[subkey] = val.strip()
+            global_config.set('template', template_dict)
+            global_config.save()
+            # Remove legacy flat key if present
+            if key in global_config._data:
+                del global_config._data[key]
+            runtime_config.set('template', template_dict)
+            print(f"Global config updated: template.{subkey} = {val.strip()}")
+            did_something = True
+        else:
+            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())
+        # Merge: load full config, update api_key, save all
+        existing = dict(global_config.all())
+        existing["api_key"] = args.set_api_key.strip()
+        global_config._data = existing
         global_config.save()
         runtime_config.set("api_key", args.set_api_key.strip())
         print("Global API key saved.")
@@ -64,7 +92,18 @@ def handle_config_commands(args):
         else:
             from janito.agent.config import get_api_key
             from janito.agent.runtime_config import unified_config
+            # Handle template as nested dict
             for key in sorted(local_keys):
+                if key == "template":
+                    template_dict = local_config.get("template", {})
+                    if template_dict:
+                        local_items["template"] = f"({len(template_dict)} keys set)"
+                        for tkey, tval in template_dict.items():
+                            local_items[f"  template.{tkey}"] = tval
+                    continue
+                if key.startswith("template."):
+                    # Skip legacy flat keys
+                    continue
                 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)
@@ -72,6 +111,15 @@ def handle_config_commands(args):
                     value = unified_config.get(key)
                 local_items[key] = value
             for key in sorted(global_keys - local_keys):
+                if key == "template":
+                    template_dict = global_config.get("template", {})
+                    if template_dict:
+                        global_items["template"] = f"({len(template_dict)} keys set)"
+                        for tkey, tval in template_dict.items():
+                            global_items[f"  template.{tkey}"] = tval
+                    continue
+                if key.startswith("template."):
+                    continue
                 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)
@@ -102,7 +150,7 @@ def handle_config_commands(args):
                 # 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"
+                    template_path = Path(__file__).parent / "agent" / "templates" / "system_instructions.j2"
                     print(f"{key} = (default template path: {home_shorten(str(template_path))})")
                 else:
                     print(f"{key} = {value}")

janito/cli/runner.py

@@ -31,6 +31,7 @@ def run_cli(args):
         sys.exit(0)
 
     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)
@@ -39,21 +40,28 @@ def run_cli(args):
     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 mode if enabled
+    if getattr(args, 'trust', False):
+        runtime_config.set('trust', True)
+
     # New logic for --system-file
     system_prompt = None
     if getattr(args, 'system_file', None):
-        try:
-            with open(args.system_file, 'r', encoding='utf-8') as f:
-                system_prompt = f.read()
-            runtime_config.set('system_prompt_file', args.system_file)
-        except Exception as e:
-            print(f"[red]Failed to read system prompt file:[/red] {e}")
-            sys.exit(1)
+        with open(args.system_file, 'r', encoding='utf-8') as f:
+            system_prompt = f.read()
+        runtime_config.set('system_prompt_file', args.system_file)
+
     else:
         system_prompt = args.system_prompt or unified_config.get("system_prompt")
         if args.system_prompt:
             runtime_config.set('system_prompt', system_prompt)
         if system_prompt is None:
+            # Pass full merged config (runtime overrides effective)
+
             system_prompt = render_system_prompt(role)
 
     if args.show_system:
@@ -72,10 +80,12 @@ def run_cli(args):
     # Always get model from unified_config (which checks runtime_config first)
     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 --enable-tools flag
     from janito.agent.tool_handler import ToolHandler
-    tool_handler = ToolHandler(verbose=args.verbose_tools, enable_tools=not getattr(args, 'disable_tools', False))
-    agent = Agent(api_key=api_key, model=model, system_prompt=system_prompt, verbose_tools=args.verbose_tools, base_url=base_url, tool_handler=tool_handler)
+    tool_handler = ToolHandler(verbose=args.verbose_tools, enable_tools=not getattr(args, 'no_tools', False))
+    use_azure_openai = unified_config.get('use_azure_openai', False)
+    agent = Agent(api_key=api_key, model=model, system_prompt=system_prompt, verbose_tools=args.verbose_tools, base_url=base_url, tool_handler=tool_handler, azure_openai_api_version=azure_openai_api_version, use_azure_openai=use_azure_openai)
 
     # Save runtime max_tokens override if provided
     if args.max_tokens is not None:
@@ -103,10 +113,12 @@ def run_cli(args):
 
     try:
         try:
+            max_rounds = runtime_config.get('max_rounds', 50)
             response = agent.chat(
                 messages,
                 on_content=on_content,
                 spinner=True,
+                max_rounds=max_rounds,
             )
             if args.verbose_response:
                 import json

janito/cli_chat_shell/chat_loop.py

@@ -10,7 +10,7 @@ from janito.agent.runtime_config import runtime_config
 from janito.agent.conversation import EmptyResponseError, ProviderError
 
 
-def start_chat_shell(agent, continue_session=False):
+def start_chat_shell(agent, continue_session=False, max_rounds=50):
     console = Console()
 
     # Load input history
@@ -51,7 +51,7 @@ def start_chat_shell(agent, continue_session=False):
     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__)
+    print_welcome(console, version=__version__, continued=continue_session)
 
     # Toolbar references
     def get_messages():
@@ -77,6 +77,8 @@ def start_chat_shell(agent, continue_session=False):
 
     # Main chat loop
     while True:
+        # max_rounds is now available for use in the chat loop
+
         try:
             if state.get('paste_mode'):
                 console.print('')
@@ -126,7 +128,7 @@ def start_chat_shell(agent, continue_session=False):
                 console.print(Markdown(content_piece))
 
         try:
-            response = agent.chat(messages, on_content=on_content, spinner=True)
+            response = agent.chat(messages, on_content=on_content, spinner=True, max_rounds=max_rounds)
         except KeyboardInterrupt:
             console.print("[bold yellow]Request interrupted. Returning to prompt.[/bold yellow]")
             continue

janito/cli_chat_shell/commands.py

@@ -22,46 +22,43 @@ def handle_continue(console, state, **kwargs):
     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}')
+
+    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]')
+
 
 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}")
+    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}")
+
 
 def handle_help(console, **kwargs):
     console.print("""

janito/cli_chat_shell/config_shell.py

@@ -58,7 +58,7 @@ def handle_config_shell(console, *args, **kwargs):
             console.print("[bold red]Invalid format, expected key=val[/bold red]")
             return
         key = key.strip()
-        if key not in CONFIG_OPTIONS:
+        if key not in CONFIG_OPTIONS and not key.startswith("template."):
             console.print(f"[bold red]Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}")
             return
         val = val.strip()

janito/cli_chat_shell/load_prompt.py

@@ -7,7 +7,7 @@ def load_prompt(filename=None):
     """
     if filename is None:
         # Default prompt file path (can be customized)
-        filename = os.path.join(os.path.dirname(__file__), '../render_prompt/templates/system_instructions.j2')
+        filename = os.path.join(os.path.dirname(__file__), '../agent/templates/system_instructions.j2')
     filename = os.path.abspath(filename)
     if not os.path.exists(filename):
         raise FileNotFoundError(f"Prompt file not found: {filename}")

janito/cli_chat_shell/session_manager.py

@@ -6,26 +6,22 @@ from datetime import datetime
 def load_last_summary(path='.janito/last_conversation.json'):
     if not os.path.exists(path):
         return None
-    try:
-        with open(path, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-        return data
-    except Exception:
-        return None
+    with open(path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    return data
+
 
 
 def load_last_conversation(path='.janito/last_conversation.json'):
     if not os.path.exists(path):
         return [], [], None
-    try:
-        with open(path, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-        messages = data.get('messages', [])
-        prompts = data.get('prompts', [])
-        usage = data.get('last_usage_info')
-        return messages, prompts, usage
-    except Exception:
-        return [], [], None
+    with open(path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    messages = data.get('messages', [])
+    prompts = data.get('prompts', [])
+    usage = data.get('last_usage_info')
+    return messages, prompts, usage
+
 
 
 def save_conversation(messages, prompts, usage_info=None, path='.janito/last_conversation.json'):

janito/cli_chat_shell/ui.py

@@ -30,10 +30,11 @@ def print_summary(console, data, continue_session):
         console.print("[bold yellow]Type /continue to restore the last saved conversation.[/bold yellow]")
 
 
-def print_welcome(console, version=None):
+def print_welcome(console, version=None, continued=False):
     version_str = f" (v{version})" if version else ""
     console.print(f"[bold green]Welcome to Janito{version_str}! Entering chat mode. Type /exit to exit.[/bold green]")
-    console.print("[yellow]To resume your previous conversation, type /continue at any time.[/yellow]")
+    if not continued:
+        console.print("[yellow]To resume your previous conversation, type /continue at any time.[/yellow]")
 
 
 def get_toolbar_func(messages_ref, last_usage_info_ref, last_elapsed_ref, model_name=None, role_ref=None):
@@ -68,10 +69,8 @@ def get_toolbar_func(messages_ref, last_usage_info_ref, last_elapsed_ref, model_
         from prompt_toolkit.application import get_app
 
         # Compose first line with Model and Role
-        try:
-            width = get_app().output.get_size().columns
-        except Exception:
-            width = 80  # fallback default
+        width = get_app().output.get_size().columns
+
 
         model_part = f" Model:  <model>{model_name}</model>" if model_name else ""
         role_part = ""
@@ -87,7 +86,7 @@ def get_toolbar_func(messages_ref, last_usage_info_ref, last_elapsed_ref, model_
             first_line_parts.append(role_part)
         first_line = " | ".join(first_line_parts)
 
-        help_part = "<b>/help</b> for help"
+        help_part = "<b>/help</b> for help | <b>F12</b>: just do it"
 
         total_len = len(left) + len(help_part) + 3  # separators and spaces
         if first_line:
@@ -110,6 +109,7 @@ def get_toolbar_func(messages_ref, last_usage_info_ref, last_elapsed_ref, model_
 
 
 def get_prompt_session(get_toolbar_func, mem_history):
+    from prompt_toolkit.key_binding import KeyBindings
     style = Style.from_dict({
         'bottom-toolbar': 'bg:#333333 #ffffff',
         'b': 'bold',
@@ -125,9 +125,18 @@ def get_prompt_session(get_toolbar_func, mem_history):
 '': 'bg:#000080 #ffffff',
     })
 
+    kb = KeyBindings()
+
+    @kb.add('f12')
+    def _(event):
+        """When F12 is pressed, send 'just do it' as input immediately."""
+        buf = event.app.current_buffer
+        buf.text = 'just do it'
+        buf.validate_and_handle()
+
     session = PromptSession(
         multiline=False,
-        key_bindings=KeyBindings(),
+        key_bindings=kb,
         editing_mode=EditingMode.EMACS,
         bottom_toolbar=get_toolbar_func,
         style=style,

janito/render_prompt.py

@@ -1,8 +1,10 @@
 import jinja2
 from pathlib import Path
 
+from janito.agent.runtime_config import unified_config
+
 def render_system_prompt(role: str) -> str:
-    template_loader = jinja2.FileSystemLoader(searchpath=str(Path(__file__).parent / "templates"))
+    template_loader = jinja2.FileSystemLoader(searchpath=str(Path(__file__).parent / "agent" / "templates"))
     env = jinja2.Environment(loader=template_loader)
     template = env.get_template("system_instructions.j2")
     return template.render(role=role)

janito/web/app.py

@@ -1,4 +1,4 @@
-from flask import Flask, request, render_template, Response, send_from_directory, session, jsonify
+from flask import Flask, request, Response, send_from_directory, session, jsonify
 from queue import Queue
 import json
 from janito.agent.queued_tool_handler import QueuedToolHandler
@@ -8,8 +8,15 @@ from janito.render_prompt import render_system_prompt
 import os
 import threading
 
-# Render system prompt once
-system_prompt = render_system_prompt("software engineer")
+from janito.agent.runtime_config import unified_config
+
+# Render system prompt from config
+role = unified_config.get("role", "software engineer")
+system_prompt_override = unified_config.get("system_prompt")
+if system_prompt_override:
+    system_prompt = system_prompt_override
+else:
+    system_prompt = render_system_prompt(role)
 
 app = Flask(
     __name__,
@@ -33,15 +40,59 @@ stream_queue = Queue()
 # Create a QueuedToolHandler with the queue
 queued_handler = QueuedToolHandler(stream_queue)
 
-# Instantiate the Agent with the custom tool handler
+# Instantiate the Agent with config-driven parameters
 agent = Agent(
-    api_key=get_api_key(),
+    api_key=unified_config.get("api_key"),
+    model=unified_config.get("model"),
+    base_url=unified_config.get("base_url"),
     tool_handler=queued_handler
 )
 
-@app.route('/get_model_name')
-def get_model_name():
-    return jsonify({"model": agent.model})
+@app.route('/get_config')
+def get_config():
+    # Expose full config for the web app: defaults, effective, runtime (mask api_key)
+    from janito.agent.runtime_config import unified_config
+    from janito.agent.config_defaults import CONFIG_DEFAULTS
+    # Start with defaults
+    config = dict(CONFIG_DEFAULTS)
+    # Overlay effective config
+    config.update(unified_config.effective_cfg.all())
+    # Overlay runtime config (highest priority)
+    config.update(unified_config.runtime_cfg.all())
+    api_key = config.get("api_key")
+    if api_key:
+        config["api_key"] = api_key[:4] + '...' + api_key[-4:] if len(api_key) > 8 else '***'
+    return jsonify(config)
+
+@app.route('/set_config', methods=['POST'])
+def set_config():
+    from janito.agent.runtime_config import runtime_config
+    from janito.agent.config import CONFIG_OPTIONS
+    from janito.agent.config_defaults import CONFIG_DEFAULTS
+    data = request.get_json()
+    key = data.get('key')
+    value = data.get('value')
+    if key not in CONFIG_OPTIONS:
+        return jsonify({'status': 'error', 'message': f'Invalid config key: {key}'}), 400
+    # Type coercion based on defaults
+    default = CONFIG_DEFAULTS.get(key)
+    if default is not None and value is not None:
+        try:
+            if isinstance(default, bool):
+                value = bool(value)
+            elif isinstance(default, int):
+                value = int(value)
+            elif isinstance(default, float):
+                value = float(value)
+            # else: leave as string or None
+        except Exception as e:
+            return jsonify({'status': 'error', 'message': f'Invalid value type for {key}: {e}'}), 400
+    runtime_config.set(key, value)
+    # Mask api_key in response
+    resp_value = value
+    if key == 'api_key' and value:
+        resp_value = value[:4] + '...' + value[-4:] if len(value) > 8 else '***'
+    return jsonify({'status': 'ok', 'key': key, 'value': resp_value})
 
 
 @app.route('/favicon.ico')
@@ -91,19 +142,25 @@ def execute_stream():
     conversation.append({"role": "user", "content": user_input})
 
     def run_agent():
-        response = agent.chat(
-            conversation,
-            on_content=lambda data: stream_queue.put({"type": "content", "content": data.get("content")})
-        )
-        if response and 'content' in response:
-            conversation.append({"role": "assistant", "content": response['content']})
         try:
-            os.makedirs(os.path.dirname(conversation_file), exist_ok=True)
-            with open(conversation_file, 'w') as f:
-                json.dump(conversation, f, indent=2)
+            response = agent.chat(
+                conversation,
+                on_content=lambda data: stream_queue.put({"type": "content", "content": data.get("content")})
+            )
+            if response and 'content' in response:
+                conversation.append({"role": "assistant", "content": response['content']})
+            try:
+                os.makedirs(os.path.dirname(conversation_file), exist_ok=True)
+                with open(conversation_file, 'w') as f:
+                    json.dump(conversation, f, indent=2)
+            except Exception as e:
+                print(f"Error saving conversation: {e}")
         except Exception as e:
-            print(f"Error saving conversation: {e}")
-        stream_queue.put(None)
+            import traceback
+            tb = traceback.format_exc()
+            stream_queue.put({"type": "error", "error": str(e), "traceback": tb})
+        finally:
+            stream_queue.put(None)
 
     threading.Thread(target=run_agent, daemon=True).start()