janito 0.15.0__tar.gz → 1.0.0__tar.gz

{janito-0.15.0 → janito-1.0.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [year] [copyright holder]
+Copyright (c) [year] [Full Name]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

janito-1.0.0/PKG-INFO

@@ -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
+
+---

janito-1.0.0/README.md

@@ -0,0 +1,123 @@
+# 🚀 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
+
+---

janito-1.0.0/janito/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

janito-1.0.0/janito/__main__.py

@@ -0,0 +1,5 @@
+from janito.cli.main import main
+
+
+if __name__ == "__main__":
+    main()

janito-1.0.0/janito/agent/__init__.py

@@ -0,0 +1 @@
+from . import tools

janito-1.0.0/janito/agent/agent.py

@@ -0,0 +1,96 @@
+"""Agent module: defines the core LLM agent with tool and conversation handling."""
+
+import os
+import json
+from openai import OpenAI
+from janito.agent.conversation import ConversationHandler
+from janito.agent.tool_handler import ToolHandler
+
+class Agent:
+    """LLM Agent capable of handling conversations and tool calls."""
+
+    REFERER = "www.janito.dev"
+    TITLE = "Janito"
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str = None,
+        system_prompt: str | None = None,
+        verbose_tools: bool = False,
+        tool_handler = None,
+        base_url: str = "https://openrouter.ai/api/v1"
+    ):
+        """
+        Initialize the Agent.
+
+        Args:
+            api_key: API key for OpenAI-compatible service.
+            model: Model name to use.
+            system_prompt: Optional system prompt override.
+            verbose_tools: Enable verbose tool call logging.
+            tool_handler: Optional custom ToolHandler instance.
+            base_url: API base URL.
+        """
+        self.api_key = api_key
+        self.model = model
+        self.system_prompt = system_prompt
+        if os.environ.get("USE_AZURE_OPENAI"):
+            from openai import AzureOpenAI
+            self.client = AzureOpenAI(
+                api_key=api_key,
+                azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
+                api_version=os.environ.get("AZURE_OPENAI_API_VERSION", "2023-05-15"),
+            )
+        else:
+            self.client = OpenAI(
+                base_url=base_url,
+                api_key=api_key,
+                default_headers={
+                    "HTTP-Referer": self.REFERER,
+                    "X-Title": self.TITLE
+                }
+            )
+        if tool_handler is not None:
+            self.tool_handler = tool_handler
+        else:
+            self.tool_handler = ToolHandler(verbose=verbose_tools)
+
+        self.conversation_handler = ConversationHandler(
+            self.client, self.model, self.tool_handler
+        )
+
+    def chat(self, messages, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None):
+        import time
+        from janito.agent.conversation import ProviderError
+
+        max_retries = 5
+        for attempt in range(1, max_retries + 1):
+            try:
+                return self.conversation_handler.handle_conversation(
+                    messages,
+                    max_tokens=max_tokens,
+                    on_content=on_content,
+                    on_tool_progress=on_tool_progress,
+                    verbose_response=verbose_response,
+                    spinner=spinner
+                )
+            except ProviderError as e:
+                error_data = getattr(e, 'error_data', {}) or {}
+                code = error_data.get('code', '')
+                # Retry only on 5xx errors
+                if isinstance(code, int) and 500 <= code < 600:
+                    pass
+                elif isinstance(code, str) and code.isdigit() and 500 <= int(code) < 600:
+                    code = int(code)
+                else:
+                    raise
+
+                if attempt < max_retries:
+                    print(f"ProviderError with 5xx code encountered (attempt {attempt}/{max_retries}). Retrying in 5 seconds...")
+                    time.sleep(5)
+                else:
+                    print("Max retries reached. Raising error.")
+                    raise
+            except Exception:
+                raise

janito-1.0.0/janito/agent/config.py

@@ -0,0 +1,113 @@
+import json
+import os
+from pathlib import Path
+from threading import Lock
+
+
+class SingletonMeta(type):
+    _instances = {}
+    _lock: Lock = Lock()
+
+    def __call__(cls, *args, **kwargs):
+        with cls._lock:
+            if cls not in cls._instances:
+                instance = super().__call__(*args, **kwargs)
+                cls._instances[cls] = instance
+        return cls._instances[cls]
+
+
+class BaseConfig:
+    def __init__(self):
+        self._data = {}
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def set(self, key, value):
+        self._data[key] = value
+
+    def all(self):
+        return self._data
+
+
+
+
+class FileConfig(BaseConfig):
+    def __init__(self, path):
+        super().__init__()
+        self.path = Path(path).expanduser()
+        self.load()
+
+    def load(self):
+        if self.path.exists():
+            try:
+                with open(self.path, 'r') as f:
+                    self._data = json.load(f)
+                    # Remove keys with value None (null in JSON)
+                    self._data = {k: v for k, v in self._data.items() if v is not None}
+            except Exception as e:
+                print(f"Warning: Failed to load config file {self.path}: {e}")
+                self._data = {}
+        else:
+            self._data = {}
+
+    def save(self):
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.path, 'w') as f:
+            json.dump(self._data, f, indent=2)
+
+
+CONFIG_OPTIONS = {
+    "api_key": "API key for OpenAI-compatible service (required)",
+    "model": "Model name to use (e.g., 'openrouter/optimus-alpha')",
+    "base_url": "API base URL (OpenAI-compatible endpoint)",
+    "role": "Role description for the system prompt (e.g., 'software engineer')",
+    "system_prompt": "Override the entire system prompt text",
+    "temperature": "Sampling temperature (float, e.g., 0.0 - 2.0)",
+    "max_tokens": "Maximum tokens for model response (int)"
+}
+
+# Import defaults for reference
+from .config_defaults import CONFIG_DEFAULTS
+
+class EffectiveConfig:
+    """Read-only merged view of local and global configs"""
+    def __init__(self, local_cfg, global_cfg):
+        self.local_cfg = local_cfg
+        self.global_cfg = global_cfg
+
+    def get(self, key, default=None):
+        from .config_defaults import CONFIG_DEFAULTS
+        for cfg in (self.local_cfg, self.global_cfg):
+            val = cfg.get(key)
+            if val is not None:
+                # Treat explicit None/null as not set
+                if val is None:
+                    continue
+                return val
+        # Use centralized defaults if no config found
+        if default is None and key in CONFIG_DEFAULTS:
+            return CONFIG_DEFAULTS[key]
+        return default
+
+    def all(self):
+        merged = {}
+        # Start with global, override with local
+        for cfg in (self.global_cfg, self.local_cfg):
+            merged.update(cfg.all())
+        return merged
+
+
+# Singleton instances
+
+local_config = FileConfig(Path('.janito/config.json'))
+global_config = FileConfig(Path.home() / '.janito/config.json')
+
+effective_config = EffectiveConfig(local_config, global_config)
+
+def get_api_key():
+    """Retrieve API key from config files (local, then global)."""
+    api_key = effective_config.get("api_key")
+    if api_key:
+        return api_key
+    raise ValueError("API key not found. Please configure 'api_key' in your config.")

janito-1.0.0/janito/agent/config_defaults.py

@@ -0,0 +1,10 @@
+# Centralized config defaults for Janito
+CONFIG_DEFAULTS = {
+    "api_key": None,  # Must be set by user
+    "model": "openrouter/optimus-alpha",    # Default model
+    "base_url": "https://openrouter.ai/api/v1",
+    "role": "software engineer",
+    "system_prompt": None,  # None means auto-generate from role
+    "temperature": 0.2,
+    "max_tokens": 200000,
+}

janito-1.0.0/janito/agent/conversation.py

@@ -0,0 +1,107 @@
+import json
+
+class MaxRoundsExceededError(Exception):
+    pass
+
+class EmptyResponseError(Exception):
+    pass
+
+class ProviderError(Exception):
+    def __init__(self, message, error_data):
+        self.error_data = error_data
+        super().__init__(message)
+
+class ConversationHandler:
+    def __init__(self, client, model, tool_handler):
+        self.client = client
+        self.model = model
+        self.tool_handler = tool_handler
+
+    def handle_conversation(self, messages, max_rounds=50, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None):
+        if not messages:
+            raise ValueError("No prompt provided in messages")
+
+        from rich.console import Console
+        console = Console()
+
+        from janito.agent.runtime_config import unified_config
+
+        # Resolve max_tokens priority: runtime param > config > default
+        resolved_max_tokens = max_tokens
+        if resolved_max_tokens is None:
+            resolved_max_tokens = unified_config.get('max_tokens', 200000)
+
+        for _ in range(max_rounds):
+            if spinner:
+                                # Calculate word count for all messages
+                word_count = sum(len(str(m.get('content', '')).split()) for m in messages if 'content' in m)
+                spinner_msg = f"[bold green]Waiting for AI response... ({word_count} words in conversation)"
+                with console.status(spinner_msg, spinner="dots") as status:
+                    response = self.client.chat.completions.create(
+                        model=self.model,
+                        messages=messages,
+                        tools=self.tool_handler.get_tool_schemas(),
+                        tool_choice="auto",
+                        temperature=0.2,
+                        max_tokens=resolved_max_tokens
+                    )
+                    status.stop()
+                    # console.print("\r\033[2K", end="")  # Clear the spinner line removed
+            else:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    tools=self.tool_handler.get_tool_schemas(),
+                    tool_choice="auto",
+                    temperature=0.2,
+                    max_tokens=resolved_max_tokens
+                )
+
+            if verbose_response:
+                import pprint
+                pprint.pprint(response)
+
+            # Check for provider errors
+            if hasattr(response, 'error') and response.error:
+                error_msg = response.error.get('message', 'Unknown provider error')
+                error_code = response.error.get('code', 'unknown')
+                raise ProviderError(f"Provider error: {error_msg} (Code: {error_code})", response.error)
+                
+            if not response.choices:
+                raise EmptyResponseError("The LLM API returned no choices in the response.")
+
+            choice = response.choices[0]
+
+            # Extract token usage info if available
+            usage = getattr(response, 'usage', None)
+            if usage:
+                usage_info = {
+                    'prompt_tokens': getattr(usage, 'prompt_tokens', None),
+                    'completion_tokens': getattr(usage, 'completion_tokens', None),
+                    'total_tokens': getattr(usage, 'total_tokens', None)
+                }
+            else:
+                usage_info = None
+
+            # Call the on_content callback if provided and content is not None
+            if on_content is not None and choice.message.content is not None:
+                on_content({"content": choice.message.content})
+
+            # If no tool calls, return the assistant's message and usage info
+            if not choice.message.tool_calls:
+                return {
+    "content": choice.message.content,
+    "usage": usage_info
+}
+
+            tool_responses = []
+            for tool_call in choice.message.tool_calls:
+                result = self.tool_handler.handle_tool_call(tool_call, on_progress=on_tool_progress)
+                tool_responses.append({"tool_call_id": tool_call.id, "content": result})
+
+            messages.append({"role": "assistant", "content": choice.message.content, "tool_calls": [tc.to_dict() for tc in choice.message.tool_calls]})
+
+            for tr in tool_responses:
+                messages.append({"role": "tool", "tool_call_id": tr["tool_call_id"], "content": tr["content"]})
+
+        raise MaxRoundsExceededError("Max conversation rounds exceeded")

janito-1.0.0/janito/agent/queued_tool_handler.py

@@ -0,0 +1,16 @@
+from janito.agent.tool_handler import ToolHandler
+
+class QueuedToolHandler(ToolHandler):
+    def __init__(self, queue, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._queue = queue
+
+    def handle_tool_call(self, tool_call, on_progress=None):
+        def enqueue_progress(data):
+            
+            self._queue.put(('tool_progress', data))
+
+        if on_progress is None:
+            on_progress = enqueue_progress
+
+        return super().handle_tool_call(tool_call, on_progress=on_progress)

janito-1.0.0/janito/agent/runtime_config.py

@@ -0,0 +1,30 @@
+from .config import BaseConfig, EffectiveConfig, effective_config
+
+class RuntimeConfig(BaseConfig):
+    """In-memory only config, reset on restart"""
+    pass
+
+runtime_config = RuntimeConfig()
+
+class UnifiedConfig:
+    """
+    Config lookup order:
+    1. runtime_config (in-memory, highest priority)
+    2. effective_config (local/global, read-only)
+    """
+    def __init__(self, runtime_cfg, effective_cfg):
+        self.runtime_cfg = runtime_cfg
+        self.effective_cfg = effective_cfg
+
+    def get(self, key, default=None):
+        val = self.runtime_cfg.get(key)
+        if val is not None:
+            return val
+        return self.effective_cfg.get(key, default)
+
+    def all(self):
+        merged = dict(self.effective_cfg.all())
+        merged.update(self.runtime_cfg.all())
+        return merged
+
+unified_config = UnifiedConfig(runtime_config, effective_config)