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

janito/cli_chat_shell/config_shell.py

@@ -0,0 +1,75 @@
+from janito.agent.config import local_config, global_config, CONFIG_OPTIONS
+from janito.agent.config_defaults import CONFIG_DEFAULTS
+from janito.agent.runtime_config import unified_config, runtime_config
+from janito.cli._print_config import print_config_items
+from rich import print
+import sys
+
+def handle_config_shell(console, *args, **kwargs):
+    """
+    /config show
+    /config set local key=value
+    /config set global key=value
+    /config reset local
+    /config reset global
+    """
+    if not args or args[0] not in ("show", "set", "reset"):
+        console.print("[bold red]Usage:[/bold red] /config show | /config set local|global key=value | /config reset local|global")
+        return
+
+    if args[0] == "show":
+        # Show config, unified with CLI
+        from janito.cli._print_config import print_full_config
+        print_full_config(local_config, global_config, unified_config, CONFIG_DEFAULTS, console=console)
+        return
+
+    if args[0] == "reset":
+        if len(args) < 2 or args[1] not in ("local", "global"):
+            console.print("[bold red]Usage:[/bold red] /config reset local|global")
+            return
+        import os
+        from pathlib import Path
+        scope = args[1]
+        if scope == "local":
+            local_path = Path('.janito/config.json')
+            if local_path.exists():
+                os.remove(local_path)
+                console.print(f"[green]Removed local config file:[/green] {local_path}")
+            else:
+                console.print(f"[yellow]Local config file does not exist:[/yellow] {local_path}")
+        elif scope == "global":
+            global_path = Path.home() / '.janito/config.json'
+            if global_path.exists():
+                os.remove(global_path)
+                console.print(f"[green]Removed global config file:[/green] {global_path}")
+            else:
+                console.print(f"[yellow]Global config file does not exist:[/yellow] {global_path}")
+        console.print("[bold yellow]Please use /restart for changes to take full effect.[/bold yellow]")
+        return
+
+    if args[0] == "set":
+        if len(args) < 3 or args[1] not in ("local", "global"):
+            console.print("[bold red]Usage:[/bold red] /config set local|global key=value")
+            return
+        scope = args[1]
+        try:
+            key, val = args[2].split("=", 1)
+        except ValueError:
+            console.print("[bold red]Invalid format, expected key=val[/bold red]")
+            return
+        key = key.strip()
+        if key not in CONFIG_OPTIONS:
+            console.print(f"[bold red]Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}")
+            return
+        val = val.strip()
+        if scope == "local":
+            local_config.set(key, val)
+            local_config.save()
+            runtime_config.set(key, val)
+            console.print(f"[green]Local config updated:[/green] {key} = {val}")
+        elif scope == "global":
+            global_config.set(key, val)
+            global_config.save()
+            runtime_config.set(key, val)
+            console.print(f"[green]Global config updated:[/green] {key} = {val}")
+        return

janito/cli_chat_shell/load_prompt.py

@@ -0,0 +1,15 @@
+import os
+
+def load_prompt(filename=None):
+    """
+    Load the system prompt from a file. If filename is None, use the default prompt file.
+    Returns the prompt string.
+    """
+    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.abspath(filename)
+    if not os.path.exists(filename):
+        raise FileNotFoundError(f"Prompt file not found: {filename}")
+    with open(filename, 'r', encoding='utf-8') as f:
+        return f.read()

janito/cli_chat_shell/session_manager.py

@@ -0,0 +1,60 @@
+import os
+import json
+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
+
+
+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
+
+
+def save_conversation(messages, prompts, usage_info=None, path='.janito/last_conversation.json'):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    data = {
+        'messages': messages,
+        'prompts': prompts,
+        'last_usage_info': usage_info
+    }
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2)
+
+
+def load_input_history():
+    history_dir = os.path.join('.janito', 'input_history')
+    os.makedirs(history_dir, exist_ok=True)
+    today_str = datetime.now().strftime('%y%m%d')
+    history_file = os.path.join(history_dir, f'{today_str}.json')
+    try:
+        with open(history_file, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return []
+
+
+def save_input_history(history_list):
+    history_dir = os.path.join('.janito', 'input_history')
+    os.makedirs(history_dir, exist_ok=True)
+    today_str = datetime.now().strftime('%y%m%d')
+    history_file = os.path.join(history_dir, f'{today_str}.json')
+    with open(history_file, 'w', encoding='utf-8') as f:
+        json.dump(history_list, f, indent=2)

janito/cli_chat_shell/ui.py

@@ -0,0 +1,136 @@
+from rich.console import Console
+from rich.markdown import Markdown
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.styles import Style
+from prompt_toolkit.history import InMemoryHistory
+
+
+def print_summary(console, data, continue_session):
+    if not data:
+        return
+    msgs = data.get('messages', [])
+    last_user = next((m['content'] for m in reversed(msgs) if m.get('role') == 'user'), None)
+    last_assistant = next((m['content'] for m in reversed(msgs) if m.get('role') == 'assistant'), None)
+    usage = data.get('last_usage_info', {})
+    console.print('[bold cyan]Last saved conversation:[/bold cyan]')
+    console.print(f"Messages: {len(msgs)}")
+    if last_user:
+        console.print(f"Last user: [italic]{last_user[:100]}{'...' if len(last_user)>100 else ''}[/italic]")
+    if last_assistant:
+        console.print(f"Last assistant: [italic]{last_assistant[:100]}{'...' if len(last_assistant)>100 else ''}[/italic]")
+    if usage:
+        ptok = usage.get('prompt_tokens')
+        ctok = usage.get('completion_tokens')
+        tot = (ptok or 0) + (ctok or 0)
+        console.print(f"Tokens - Prompt: {ptok}, Completion: {ctok}, Total: {tot}")
+    if not continue_session:
+        console.print("[bold yellow]Type /continue to restore the last saved conversation.[/bold yellow]")
+
+
+def print_welcome(console, version=None):
+    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]")
+
+
+def get_toolbar_func(messages_ref, last_usage_info_ref, last_elapsed_ref, model_name=None, role_ref=None):
+    def format_tokens(n):
+        if n is None:
+            return "?"
+        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 get_toolbar():
+        left = f' Messages:  <msg_count>{len(messages_ref())}</msg_count>'
+        usage = last_usage_info_ref()
+        last_elapsed = last_elapsed_ref()
+        if usage:
+            prompt_tokens = usage.get('prompt_tokens')
+            completion_tokens = usage.get('completion_tokens')
+            total_tokens = (prompt_tokens or 0) + (completion_tokens or 0)
+            speed = None
+            if last_elapsed and last_elapsed > 0:
+                speed = total_tokens / last_elapsed
+            left += (
+                f" | Tokens: In=<tokens_in>{format_tokens(prompt_tokens)}</tokens_in> / "
+                f"Out=<tokens_out>{format_tokens(completion_tokens)}</tokens_out> / "
+                f"Total=<tokens_total>{format_tokens(total_tokens)}</tokens_total>"
+            )
+            if speed is not None:
+                left += f", speed=<speed>{speed:.1f}</speed> tokens/sec"
+
+        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
+
+        model_part = f" Model:  <model>{model_name}</model>" if model_name else ""
+        role_part = ""
+        if role_ref:
+            role = role_ref()
+            if role:
+                role_part = f"Role: <b>{role}</b>"
+
+        first_line_parts = []
+        if model_part:
+            first_line_parts.append(model_part)
+        if role_part:
+            first_line_parts.append(role_part)
+        first_line = " | ".join(first_line_parts)
+
+        help_part = "<b>/help</b> for help"
+
+        total_len = len(left) + len(help_part) + 3  # separators and spaces
+        if first_line:
+            total_len += len(first_line) + 3
+
+        if total_len < width:
+            padding = ' ' * (width - total_len)
+            second_line = f"{left}{padding} | {help_part}"
+        else:
+            second_line = f"{left} | {help_part}"
+
+        if first_line:
+            toolbar_text = first_line + "\n" + second_line
+        else:
+            toolbar_text = second_line
+
+        return HTML(toolbar_text)
+
+    return get_toolbar
+
+
+def get_prompt_session(get_toolbar_func, mem_history):
+    style = Style.from_dict({
+        'bottom-toolbar': 'bg:#333333 #ffffff',
+        'b': 'bold',
+        'prompt': 'bold bg:#000080 #ffffff',
+        'model': 'bold bg:#005f5f #ffffff',  # distinct background/foreground
+        'msg_count': 'bg:#333333 #ffff00 bold',
+        'tokens_in': 'ansicyan bold',
+        'tokens_out': 'ansigreen bold',
+        'tokens_total': 'ansiyellow bold',
+        'speed': 'ansimagenta bold',
+'right': 'bg:#005f5f #ffffff',
+        'input': 'bg:#000080 #ffffff',
+'': 'bg:#000080 #ffffff',
+    })
+
+    session = PromptSession(
+        multiline=False,
+        key_bindings=KeyBindings(),
+        editing_mode=EditingMode.EMACS,
+        bottom_toolbar=get_toolbar_func,
+        style=style,
+        history=mem_history
+    )
+    return session

janito/render_prompt.py

@@ -0,0 +1,12 @@
+import jinja2
+from pathlib import Path
+
+def render_system_prompt(role: str) -> str:
+    template_loader = jinja2.FileSystemLoader(searchpath=str(Path(__file__).parent / "templates"))
+    env = jinja2.Environment(loader=template_loader)
+    template = env.get_template("system_instructions.j2")
+    return template.render(role=role)
+
+if __name__ == "__main__":
+    prompt = render_system_prompt("software engineer")
+    print(prompt)

janito/templates/system_instructions.j2

@@ -0,0 +1,36 @@
+You are a helpful {{ role }}.
+
+<context>
+Always review `docs/structure.md` before conducting file-specific searches.
+Unless specified otherwise, look for the files that match the questions context.
+Explore files that might be relevant to the current task.
+</context>
+
+<analysis>
+When analyzing issues, you might want to look into the git history for clues.
+When using read_file specific a minimum of 100 lines.
+</analysis>
+
+<editing>
+If in doubt during editing, use the `ask_user` function to get additional information; otherwise, proceed and inform the user of the decision made.
+
+When you need to make changes to a file, consider the following:
+
+- Use `file_str_replace` when you want to update or fix specific text fragments within a file without altering the rest of its content. It is preferred over full file replacement when:  
+    - Only small, targeted changes are needed.
+    - You want to avoid the risk of accidentally overwriting unrelated content.
+    - The file is large, and rewriting the entire file would be inefficient.
+    - You want to preserve formatting, comments, or code structure outside the replaced text.
+
+- When replacing files, review their current content before requesting the update.
+
+- When reorganizing, moving files, or functions, search for references in other files that might need to be updated accordingly.
+</editing>
+
+<finishing>
+After performing changes:
+
+- Review the README content if there are user-exposed or public API changes.
+- Use `git commit` to save the changes. Unless requested otherwise, review `git diff` when composing the commit message.
+- Review `docs/structure.md` considering discovered, created, or modified files.
+</finishing>

janito/web/__main__.py

@@ -0,0 +1,17 @@
+import sys
+from . import app
+
+
+def main():
+    port = 8000
+    if len(sys.argv) > 1:
+        try:
+            port = int(sys.argv[1])
+        except ValueError:
+            print(f"Invalid port number: {sys.argv[1]}")
+            sys.exit(1)
+    app.app.run(host='0.0.0.0', port=port, debug=True)
+
+
+if __name__ == '__main__':
+    main()

janito/web/app.py

@@ -0,0 +1,132 @@
+from flask import Flask, request, render_template, Response, send_from_directory, session, jsonify
+from queue import Queue
+import json
+from janito.agent.queued_tool_handler import QueuedToolHandler
+from janito.agent.agent import Agent
+from janito.agent.config import get_api_key
+from janito.render_prompt import render_system_prompt
+import os
+import threading
+
+# Render system prompt once
+system_prompt = render_system_prompt("software engineer")
+
+app = Flask(
+    __name__,
+    static_url_path='/static',
+    static_folder=os.path.join(os.path.dirname(__file__), 'static')
+)
+
+# Secret key for session management
+app.secret_key = 'replace_with_a_secure_random_secret_key'
+
+# Path for persistent conversation storage
+conversation_file = os.path.expanduser('~/.janito/last_conversation_web.json')
+
+# Initially no conversation loaded
+conversation = None
+
+
+# Global event queue for streaming
+stream_queue = Queue()
+
+# Create a QueuedToolHandler with the queue
+queued_handler = QueuedToolHandler(stream_queue)
+
+# Instantiate the Agent with the custom tool handler
+agent = Agent(
+    api_key=get_api_key(),
+    tool_handler=queued_handler
+)
+
+@app.route('/get_model_name')
+def get_model_name():
+    return jsonify({"model": agent.model})
+
+
+@app.route('/favicon.ico')
+def favicon():
+    return send_from_directory(
+        os.path.join(app.root_path, 'static'),
+        'favicon.ico',
+        mimetype='image/vnd.microsoft.icon'
+    )
+
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/load_conversation')
+def load_conversation():
+    global conversation
+    try:
+        with open(conversation_file, 'r') as f:
+            conversation = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        conversation = []
+    return jsonify({'status': 'ok', 'conversation': conversation})
+
+@app.route('/new_conversation', methods=['POST'])
+def new_conversation():
+    global conversation
+    conversation = []
+    return jsonify({'status': 'ok'})
+
+@app.route('/execute_stream', methods=['POST'])
+def execute_stream():
+    data = request.get_json()
+    user_input = data.get('input', '')
+
+    global conversation
+    if conversation is None:
+        # If no conversation loaded, start a new one
+        conversation = []
+
+    # Always start with the system prompt as the first message
+    if not conversation or conversation[0]['role'] != 'system':
+        conversation.insert(0, {"role": "system", "content": system_prompt})
+
+    # Append the new user message
+    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)
+        except Exception as e:
+            print(f"Error saving conversation: {e}")
+        stream_queue.put(None)
+
+    threading.Thread(target=run_agent, daemon=True).start()
+
+    def generate():
+        while True:
+            content = stream_queue.get()
+            if content is None:
+                break
+            if isinstance(content, tuple) and content[0] == 'tool_progress':
+                message = json.dumps({"type": "tool_progress", "data": content[1]})
+            else:
+                message = json.dumps(content)
+            yield f"data: {message}\n\n"
+            import sys
+            sys.stdout.flush()
+
+    return Response(
+        generate(),
+        mimetype='text/event-stream',
+        headers={
+            'Cache-Control': 'no-cache',
+            'X-Accel-Buffering': 'no',
+            'Connection': 'keep-alive',
+            'Transfer-Encoding': 'chunked'
+        }
+    )

janito-1.0.0.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 1.0.0
+Summary: An agent framework with built-in tools.
+Author-email: João Pinto <joao.pinto@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/joaompinto/janito
+Project-URL: repository, https://github.com/joaompinto/janito
+Keywords: agent,framework,tools,automation
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich
+Requires-Dist: openai
+Requires-Dist: flask
+Requires-Dist: pathspec
+Dynamic: license-file
+
+# 🚀 Janito: Natural Language Code Editing Agent
+
+## ⚡ Quick Start
+
+Run a one-off prompt:
+```bash
+python -m janito "Refactor the data processing module to improve readability."
+```
+
+Or start the interactive chat shell:
+```bash
+python -m janito
+```
+
+Launch the web UI:
+```bash
+python -m janito.web
+```
+
+---
+
+Janito is a command-line and web-based AI agent designed to **edit code and manage files** using natural language instructions.
+
+---
+
+## ✨ Key Features
+- 📝 **Code Editing via Natural Language:** Modify, create, or delete code files simply by describing the changes.
+- 📁 **File & Directory Management:** Navigate, create, move, or remove files and folders.
+- 🧠 **Context-Aware:** Understands your project structure for precise edits.
+- 💬 **Interactive User Prompts:** Asks for clarification when needed.
+- 🧩 **Extensible Tooling:** Built-in tools for file operations, shell commands, and more.
+- 🌐 **Web Interface (In Development):** Upcoming simple web UI for streaming responses and tool progress.
+
+---
+
+## 📦 Installation
+
+### Requirements
+- Python 3.8+
+
+### Install dependencies
+```bash
+pip install -e .
+```
+
+### Set your API key
+Janito uses OpenAI-compatible APIs (default: `openrouter/optimus-alpha`). Set your API key using the CLI:
+```bash
+python -m janito --set-api-key your_api_key_here
+```
+
+### Obtain an API key from openrouter.io
+1. Visit [https://openrouter.io/](https://openrouter.io/)
+2. Sign in or create a free account.
+3. Navigate to **API Keys** in your account dashboard.
+4. Click **Create new key**, provide a name, and save the generated key.
+5. Save it using the CLI:
+```bash
+python -m janito --set-api-key your_api_key_here
+```
+
+---
+
+## ⚙️ Configuration
+
+Janito supports multiple ways to configure API access, model, and behavior:
+
+### API Key
+
+- Set via CLI:
+  ```bash
+  python -m janito --set-api-key your_api_key_here
+  ```
+
+### Configurable Options
+
+| Key             | Description                                               | How to set                                                      | Default                                    |
+|-----------------|-----------------------------------------------------------|-----------------------------------------------------------------|--------------------------------------------|
+| `api_key`       | API key for OpenAI-compatible service                     | `--set-api-key`, config file                                    | _None_ (required)                          |
+| `model`         | Model name to use                                         | `--set-local-config model=...` or `--set-global-config`         | `openrouter/optimus-alpha`                 |
+| `base_url`      | API base URL (OpenAI-compatible endpoint)                 | `--set-local-config base_url=...` or `--set-global-config`      | `https://openrouter.ai/api/v1`            |
+| `role`          | Role description for system prompt                        | CLI `--role` or config                                          | "software engineer"                     |
+| `system_prompt` | Override the entire system prompt                         | CLI `--system-prompt` or config                                 | _Template-generated prompt_               |
+| `temperature`   | Sampling temperature (float, e.g., 0.0 - 2.0)            | CLI `--temperature` or config                                    | 0.2                                        |
+| `max_tokens`    | Maximum tokens for model response                        | CLI `--max-tokens` or config                                    | 200000                                     |
+
+### Config files
+
+- **Local config:** `.janito/config.json` (project-specific)
+- **Global config:** `~/.config/janito/config.json` (user-wide)
+
+Set values via:
+
+```bash
+python -m janito --set-local-config key=value
+python -m janito --set-global-config key=value
+```
+
+---
+
+## 🚀 Build and Release
+
+Janito provides scripts for automated build and release to PyPI:
+
+### Bash (Linux/macOS)
+
+```bash
+./tools/release.sh
+```
+
+### PowerShell (Windows)
+
+```powershell
+./tools/release.ps1
+```
+
+These scripts will:
+- Check for required tools (`hatch`, `twine`)
+- Validate the version in `pyproject.toml` against PyPI and git tags
+- Build the package
+- Upload to PyPI
+
+---