janito 3.4.0__py3-none-any.whl → 3.5.1__py3-none-any.whl

janito/tools/loop_protection_decorator.py

@@ -1,143 +1,140 @@
 import functools
 import time
 import threading
-from typing import Callable, Any
-from janito.tools.loop_protection import LoopProtection
-from janito.tools.tool_use_tracker import normalize_path
-
+from typing import Any, Tuple
 
 # Global tracking for decorator-based loop protection
 _decorator_call_tracker = {}
 _decorator_call_tracker_lock = threading.Lock()
 
 
+def _normalize_key_value(key_field: str, key_value: Any) -> Any:
+    """Normalize key values, especially paths, so different representations map to the same key."""
+    if key_value is None:
+        return None
+
+    try:
+        if isinstance(key_field, str) and "path" in key_field.lower():
+            from janito.tools.tool_use_tracker import (
+                normalize_path as _norm,  # reuse existing normalization
+            )
+
+            if isinstance(key_value, str):
+                return _norm(key_value)
+            if isinstance(key_value, (list, tuple)):
+                return tuple(_norm(v) if isinstance(v, str) else v for v in key_value)
+    except Exception:
+        # Best-effort normalization – fall back to original value
+        pass
+
+    return key_value
+
+
+def _get_param_value(func, args, kwargs, key_field: str):
+    """Extract the watched parameter value from args/kwargs using function signature."""
+    if key_field in kwargs:
+        return kwargs[key_field]
+
+    # Handle positional arguments by mapping to parameter names
+    if len(args) > 1:  # args[0] is self
+        import inspect
+
+        try:
+            sig = inspect.signature(func)
+            param_names = list(sig.parameters.keys())
+            if key_field in param_names:
+                idx = param_names.index(key_field)
+                if idx < len(args):
+                    return args[idx]
+        except Exception:
+            return None
+
+    return None
+
+
+def _determine_operation_name(func, args, kwargs, key_field: str) -> str:
+    """Build the operation name for rate limiting, optionally including a normalized key value."""
+    if key_field:
+        raw_value = _get_param_value(func, args, kwargs, key_field)
+        if raw_value is not None:
+            norm_value = _normalize_key_value(key_field, raw_value)
+            return f"{func.__name__}_{norm_value}"
+    return func.__name__
+
+
+def _check_and_record(
+    op_name: str,
+    current_time: float,
+    time_window: float,
+    max_calls: int,
+    tool_instance: Any,
+) -> Tuple[bool, str]:
+    """Check loop limits for op_name and record the call. Returns (exceeded, message)."""
+    with _decorator_call_tracker_lock:
+        # Clean old timestamps
+        if op_name in _decorator_call_tracker:
+            _decorator_call_tracker[op_name] = [
+                ts
+                for ts in _decorator_call_tracker[op_name]
+                if current_time - ts <= time_window
+            ]
+
+        # Check limit
+        if (
+            op_name in _decorator_call_tracker
+            and len(_decorator_call_tracker[op_name]) >= max_calls
+        ):
+            if all(
+                current_time - ts <= time_window
+                for ts in _decorator_call_tracker[op_name]
+            ):
+                msg = (
+                    f"Loop protection: Too many {op_name} operations in a short time period "
+                    f"({max_calls} calls in {time_window}s). Please try a different approach or wait before retrying."
+                )
+                if hasattr(tool_instance, "report_error"):
+                    try:
+                        tool_instance.report_error(msg)
+                    except Exception:
+                        pass
+                return True, msg
+
+        # Record this call
+        if op_name not in _decorator_call_tracker:
+            _decorator_call_tracker[op_name] = []
+        _decorator_call_tracker[op_name].append(current_time)
+
+    return False, ""
+
+
 def protect_against_loops(
     max_calls: int = 5, time_window: float = 10.0, key_field: str = None
 ):
     """
     Decorator that adds loop protection to tool run methods.
 
-    This decorator monitors tool executions and prevents excessive calls within
-    a configurable time window. It helps prevent infinite loops or excessive
-    resource consumption when tools are called repeatedly.
-
-    When the configured limits are exceeded, the decorator raises a RuntimeError
-    with a descriptive message. This exception will propagate up the call stack
-    unless caught by a try/except block in the calling code.
-
-    The decorator works by:
-    1. Tracking the number of calls to the decorated function
-    2. Checking if the calls exceed the configured limits
-    3. Raising a RuntimeError if a potential loop is detected
-    4. Allowing the method to proceed normally if the operation is safe
-
-    Args:
-        max_calls (int): Maximum number of calls allowed within the time window.
-                        Defaults to 5 calls.
-        time_window (float): Time window in seconds for detecting excessive calls.
-                            Defaults to 10.0 seconds.
-        key_field (str, optional): The parameter name to use for key matching instead of function name.
-                                 If provided, the decorator will track calls based on the value of this
-                                 parameter rather than the function name. Useful for tools that operate
-                                 on specific files or resources.
-
-    Example:
-        >>> @protect_against_loops(max_calls=3, time_window=5.0)
-        >>> def run(self, path: str) -> str:
-        >>>     # Implementation here
-        >>>     pass
-
-        >>> @protect_against_loops(max_calls=10, time_window=30.0)
-        >>> def run(self, file_paths: list) -> str:
-        >>>     # Implementation here
-        >>>     pass
-
-        >>> @protect_against_loops(max_calls=5, time_window=10.0, key_field='path')
-        >>> def run(self, path: str) -> str:
-        >>>     # This will track calls per unique path value
-        >>>     pass
-
-    Note:
-        When loop protection is triggered, a RuntimeError will be raised with a
-        descriptive message. This exception will propagate up the call stack
-        unless caught by a try/except block in the calling code.
+    Tracks calls within a sliding time window and prevents excessive repeated operations.
+    When key_field is provided, the limit is applied per unique normalized value of that parameter
+    (e.g., per-path protection for file tools).
     """
 
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            # Get the tool instance (self)
+            # Methods should always have self; if not, execute directly.
             if not args:
-                # This shouldn't happen in normal usage as methods need self
                 return func(*args, **kwargs)
 
-            # Determine the operation key
-            if key_field:
-                # Use the key_field parameter value as the operation key
-                key_value = None
-                if key_field in kwargs:
-                    key_value = kwargs[key_field]
-                elif len(args) > 1:
-                    # Handle positional arguments - need to map parameter names
-                    import inspect
-
-                    try:
-                        sig = inspect.signature(func)
-                        param_names = list(sig.parameters.keys())
-                        if key_field in param_names:
-                            field_index = param_names.index(key_field)
-                            if field_index < len(args):
-                                key_value = args[field_index]
-                    except (ValueError, TypeError):
-                        pass
-
-                if key_value is not None:
-                    op_name = f"{func.__name__}_{key_value}"
-                else:
-                    op_name = func.__name__
-            else:
-                # Use the function name as the operation name
-                op_name = func.__name__
-
-            # Check call limits
-            current_time = time.time()
-
-            with _decorator_call_tracker_lock:
-                # Clean up old entries outside the time window
-                if op_name in _decorator_call_tracker:
-                    _decorator_call_tracker[op_name] = [
-                        timestamp
-                        for timestamp in _decorator_call_tracker[op_name]
-                        if current_time - timestamp <= time_window
-                    ]
-
-                # Check if we're exceeding the limit
-                if op_name in _decorator_call_tracker:
-                    if len(_decorator_call_tracker[op_name]) >= max_calls:
-                        # Check if all recent calls are within the time window
-                        if all(
-                            current_time - timestamp <= time_window
-                            for timestamp in _decorator_call_tracker[op_name]
-                        ):
-                            # Return loop protection message as string instead of raising exception
-                            error_msg = f"Loop protection: Too many {op_name} operations in a short time period ({max_calls} calls in {time_window}s). Please try a different approach or wait before retrying."
-
-                            # Try to report the error through the tool's reporting mechanism
-                            tool_instance = args[0] if args else None
-                            if hasattr(tool_instance, "report_error"):
-                                try:
-                                    tool_instance.report_error(error_msg)
-                                except Exception:
-                                    pass  # If reporting fails, we still return the message
-
-                            return error_msg
-
-                # Record this call
-                if op_name not in _decorator_call_tracker:
-                    _decorator_call_tracker[op_name] = []
-                _decorator_call_tracker[op_name].append(current_time)
-
-            # Proceed with the original function
+            op_name = _determine_operation_name(func, args, kwargs, key_field)
+            exceeded, msg = _check_and_record(
+                op_name=op_name,
+                current_time=time.time(),
+                time_window=time_window,
+                max_calls=max_calls,
+                tool_instance=args[0],
+            )
+            if exceeded:
+                return msg
             return func(*args, **kwargs)
 
         return wrapper

janito-3.5.1.dist-info/METADATA

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 3.5.1
+Summary: A new Python package called janito.
+Author-email: João Pinto <janito@ikignosis.org>
+Project-URL: Homepage, https://github.com/ikignosis/janito
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs==25.3.0
+Requires-Dist: rich==14.0.0
+Requires-Dist: pathspec==0.12.1
+Requires-Dist: setuptools>=61.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jinja2>=3.0.0
+Requires-Dist: prompt_toolkit>=3.0.51
+Requires-Dist: lxml>=5.4.0
+Requires-Dist: requests>=2.32.4
+Requires-Dist: bs4>=0.0.2
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: openai>=1.68.0
+Requires-Dist: Pillow>=10.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: ruff==0.11.9; extra == "dev"
+Requires-Dist: detect-secrets==1.4.0; extra == "dev"
+Requires-Dist: codespell==2.4.1; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: questionary>=2.0.1; extra == "dev"
+Requires-Dist: setuptools_scm>=8.0; extra == "dev"
+Provides-Extra: coder
+Dynamic: license-file
+
+# Janito CLI
+
+A powerful command-line tool for running LLM-powered workflows with built-in tool execution capabilities.
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install janito
+```
+
+### First-Time Setup
+
+1. **Get your API key**: Sign up at [Moonshot AI](https://platform.moonshot.cn/) and get your API key
+2. **Set your API key**:
+   ```bash
+   janito --set-api-key YOUR_MOONSHOT_API_KEY -p moonshot
+   ```
+
+### Basic Usage
+
+**Moonshot (Recommended - Default Provider)**
+```bash
+# Using the default provider (moonshot) and model
+janito "Create a Python script that reads a CSV file"
+
+# Using a specific Moonshot model
+janito -m kimi-k1-8k "Explain quantum computing"
+```
+
+**Other Providers**
+```bash
+# OpenAI
+janito -p openai -m gpt-4 "Write a React component"
+
+# Anthropic
+janito -p anthropic -m claude-3-5-sonnet-20241022 "Analyze this code"
+
+# Google
+janito -p google -m gemini-2.0-flash-exp "Generate unit tests"
+```
+
+### Interactive Chat Mode
+
+Start an interactive session (default mode):
+```bash
+janito
+```
+
+Or explicitly:
+```bash
+janito --chat
+```
+
+In chat mode, you can:
+
+- Have multi-turn conversations
+- Execute code and commands
+- Read and write files
+- Use built-in tools
+
+### Available Commands
+
+- `janito --list-providers` - List all supported providers
+- `janito --list-models` - List all available models
+- `janito --list-tools` - List available tools
+- `janito --show-config` - Show current configuration
+
+### Configuration
+
+Set default provider and model:
+```bash
+janito --set provider=moonshot
+janito --set model=kimi-k1-8k
+```
+
+## Providers
+
+### Moonshot (Recommended)
+
+- **Models**: kimi-k1-8k, kimi-k1-32k, kimi-k1-128k, kimi-k2-turbo-preview
+- **Strengths**: Excellent Chinese/English support, competitive pricing, fast responses
+- **Setup**: Get API key from [Moonshot AI Platform](https://platform.moonshot.cn/)
+
+### OpenAI
+
+- **Models**: gpt-5, gpt-4.1, gpt-4o, gpt-4-turbo, gpt-3.5-turbo
+- **Setup**: Get API key from [OpenAI Platform](https://platform.openai.com/)
+
+### Anthropic
+
+- **Models**: claude-3-7-sonnet-20250219, claude-3-5-sonnet-20241022, claude-3-opus-20250514
+- **Setup**: Get API key from [Anthropic Console](https://console.anthropic.com/)
+
+### IBM WatsonX
+
+- **Models**: ibm/granite-3-8b-instruct, ibm/granite-3-2b-instruct, meta-llama/llama-3-1-8b-instruct, meta-llama/llama-3-1-70b-instruct, mistralai/mistral-large
+- **Strengths**: Enterprise-grade AI, IBM Granite models, hosted Llama and Mistral models
+- **Setup**: Get API key and project ID from [IBM Cloud](https://cloud.ibm.com/)
+
+### Google
+
+- **Models**: gemini-2.5-flash, gemini-2.5-pro, gemini-2.5-flash-lite-preview-06-17
+- **Setup**: Get API key from [Google AI Studio](https://makersuite.google.com/)
+
+## Advanced Features
+
+### 🚀 New in v3.1.0: Enter Key Cancellation
+**Chat Mode Enhancement**: Press **Enter** at any time to instantly cancel long-running requests in interactive chat mode. No more waiting for stuck requests!
+
+### Tool Usage
+
+Janito includes powerful built-in tools for:
+
+- File operations (read, write, search)
+- Code execution
+- Web scraping
+- System commands
+- And more...
+
+### Profiles
+Use predefined system prompts:
+```bash
+janito --developer "Create a REST API"  # Same as --profile developer
+janito --market "Analyze market trends"   # Same as --profile market-analyst
+```
+
+### Environment Variables
+You can also configure via environment variables:
+
+**Moonshot:**
+```bash
+export MOONSHOT_API_KEY=your_key_here
+export JANITO_PROVIDER=moonshot
+export JANITO_MODEL=kimi-k1-8k
+```
+
+**OpenAI:**
+```bash
+export OPENAI_API_KEY=your_key_here
+export JANITO_PROVIDER=openai
+export JANITO_MODEL=gpt-5
+```
+
+**IBM WatsonX:**
+```bash
+export WATSONX_API_KEY=your_key_here
+export WATSONX_PROJECT_ID=your_project_id
+export WATSONX_SPACE_ID=your_space_id  # optional
+export JANITO_PROVIDER=ibm
+export JANITO_MODEL=ibm/granite-3-8b-instruct
+```
+
+**Anthropic:**
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+export JANITO_PROVIDER=anthropic
+export JANITO_MODEL=claude-3-7-sonnet-20250219
+```
+
+**Google:**
+```bash
+export GOOGLE_API_KEY=your_key_here
+export JANITO_PROVIDER=google
+export JANITO_MODEL=gemini-2.5-flash
+```
+
+## Examples
+
+### Code Generation
+```bash
+janito "Create a Python FastAPI application with user authentication"
+```
+
+### File Analysis
+```bash
+janito "Analyze the performance bottlenecks in my_app.py"
+```
+
+### Data Processing
+```bash
+janito "Process this CSV file and generate summary statistics"
+```
+
+### Web Development
+```bash
+janito "Create a responsive landing page with Tailwind CSS"
+```
+
+## Support
+
+- **Documentation**: Check individual provider directories for detailed setup guides
+- **Issues**: Report bugs and feature requests on GitHub
+- **Discord**: Join our community for help and discussions