janito 3.14.1__tar.gz → 3.15.0__tar.gz

{janito-3.14.1/janito.egg-info → janito-3.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.14.1
+Version: 3.15.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -40,7 +40,7 @@ Dynamic: license-file
 $ janito --help
 Usage: janito <command>
 
-Interact with Nine API resources. See https://docs.nineapis.ch for the full API docs.
+A command-line tool for managing your projects.
 
 Run "janito <command> --help" for more information on a command.
 ```
@@ -48,38 +48,15 @@ Run "janito <command> --help" for more information on a command.
 ## Setup
 
 ```bash
-# If you have go already installed
-go install github.com/ninech/janito@latest
+# Install using pip
+pip install janito
 
-# Homebrew
-brew install ninech/taps/janito
-
-# Debian/Ubuntu
-echo "deb [trusted=yes] https://repo.nine.ch/deb/ /" | sudo tee /etc/apt/sources.list.d/repo.nine.ch.list
-sudo apt-get update
-sudo apt-get install janito
-
-# Fedora/RHEL
-cat <<EOF > /etc/yum.repos.d/repo.nine.ch.repo
-[repo.nine.ch]
-name=Nine Repo
-baseurl=https://repo.nine.ch/yum/
-enabled=1
-gpgcheck=0
-EOF
-dnf install janito
-
-# Arch
-# Install yay: https://github.com/Jguer/yay#binary
-yay --version
-yay -S janito-bin
+# Or install from source
+git clone https://github.com/yourusername/janito.git
+cd janito
+pip install -e .
 ```
 
-For Windows users, janito is also built for arm64 and amd64. You can download the
-latest exe file from the [releases](https://github.com/ninech/janito/releases) and
-install it.
-
 ## Getting started
 
-* login to the API using `janito auth login`
-* run `janito --help` to get a list of all available commands
+* Run `janito --help` to get a list of all available commands

janito-3.15.0/README.md

@@ -0,0 +1,26 @@
+# Janito
+
+```bash
+$ janito --help
+Usage: janito <command>
+
+A command-line tool for managing your projects.
+
+Run "janito <command> --help" for more information on a command.
+```
+
+## Setup
+
+```bash
+# Install using pip
+pip install janito
+
+# Or install from source
+git clone https://github.com/yourusername/janito.git
+cd janito
+pip install -e .
+```
+
+## Getting started
+
+* Run `janito --help` to get a list of all available commands

{janito-3.14.1 → janito-3.15.0}/docs/deepseek-setup.md

@@ -1,69 +1,62 @@
-# Configuring Janito for DeepSeek
-
-Janito supports DeepSeek as an LLM provider. This guide explains how to configure Janito to use DeepSeek models.
-
-## 1. Obtain a DeepSeek API Key
-
-- Sign up or log in at [DeepSeek](https://deepseek.com/) to get your API key.
-
-## 2. Set Your DeepSeek API Key in Janito
-
-You must specify both the API key and the provider name when configuring Janito for DeepSeek:
-
-```bash
-janito --set-api-key YOUR_DEEPSEEK_API_KEY -p deepseek
-```
-
-Replace `YOUR_DEEPSEEK_API_KEY` with your actual DeepSeek API key.
-
-## 3. Select DeepSeek as the Provider
-
-You can set DeepSeek as your default provider:
-
-```bash
-janito --set provider=deepseek
-```
-
-Or specify it per command:
-
-```bash
-janito -p deepseek "Your prompt here"
-```
-
-## 4. Choose a DeepSeek Model
-
-Janito supports the following DeepSeek models:
-
-- `deepseek-chat` (default) - General purpose chat model (8K context)
-- `deepseek-reasoner` - Specialized for complex reasoning tasks (8K context)
-- `deepseek-v3.1` - Latest V3.1 model with 128K context window
-- `deepseek-v3.1-base` - Base V3.1 model with 128K context window
-- `deepseek-r1` - R1 model with 128K context window
-
-To select a model:
-
-```bash
-janito -p deepseek -m deepseek-reasoner "Your prompt here"
-
-# Or use the latest models:
-janito -p deepseek -m deepseek-v3.1 "Your prompt here"
-janito -p deepseek -m deepseek-r1 "Your prompt here"
-```
-
-## 5. Verify Your Configuration
-
-Show your current configuration (the config file path will be shown at the top):
-
-```bash
-janito --show-config
-```
-
-## 6. Troubleshooting
-
-- Ensure your API key is correct and active.
-- If you encounter issues, use `janito --list-providers` to verify DeepSeek is available.
-- For more help, see the main [Configuration Guide](guides/configuration.md) or run `janito --help`.
-
----
-
-For more details on supported models and features, see [Supported Providers & Models](supported-providers-models.md).
+# Configuring Janito for DeepSeek
+
+Janito supports DeepSeek as an LLM provider. This guide explains how to configure Janito to use DeepSeek models.
+
+## 1. Obtain a DeepSeek API Key
+
+- Sign up or log in at [DeepSeek](https://deepseek.com/) to get your API key.
+
+## 2. Set Your DeepSeek API Key in Janito
+
+You must specify both the API key and the provider name when configuring Janito for DeepSeek:
+
+```bash
+janito --set-api-key YOUR_DEEPSEEK_API_KEY -p deepseek
+```
+
+Replace `YOUR_DEEPSEEK_API_KEY` with your actual DeepSeek API key.
+
+## 3. Select DeepSeek as the Provider
+
+You can set DeepSeek as your default provider:
+
+```bash
+janito --set provider=deepseek
+```
+
+Or specify it per command:
+
+```bash
+janito -p deepseek "Your prompt here"
+```
+
+## 4. Choose a DeepSeek Model
+
+Janito supports the following DeepSeek models:
+
+- `deepseek-chat` (default) - General purpose chat model (128K context)
+- `deepseek-reasoner` - Specialized for complex reasoning tasks (128K context)
+
+To select a model:
+
+```bash
+janito -p deepseek -m deepseek-reasoner "Your prompt here"
+```
+
+## 5. Verify Your Configuration
+
+Show your current configuration (the config file path will be shown at the top):
+
+```bash
+janito --show-config
+```
+
+## 6. Troubleshooting
+
+- Ensure your API key is correct and active.
+- If you encounter issues, use `janito --list-providers` to verify DeepSeek is available.
+- For more help, see the main [Configuration Guide](guides/configuration.md) or run `janito --help`.
+
+---
+
+For more details on supported models and features, see [Supported Providers & Models](supported-providers-models.md).

janito-3.15.0/docs/guides/releasing.md

@@ -0,0 +1,87 @@
+# Releasing Janito
+
+This guide explains the release process for Janito, including how to create new releases and what the automated release script does.
+
+## Prerequisites
+
+Before you can create a release, you need to:
+
+1. Set up a GitHub Personal Access Token (PAT):
+
+   - Go to GitHub Settings → Developer settings → Personal access tokens
+   - Generate a new token with `repo` scope
+   - Store it securely
+
+2. Set the GITHUB_TOKEN environment variable:
+   ```bash
+   export GITHUB_TOKEN="your-token-here"
+   ```
+
+3. Install required Python packages:
+   ```bash
+   pip install requests twine build
+   ```
+
+## Release Process
+
+The release process is automated through the `tools/release.py` script. Here's how it works:
+
+### 1. Create a Git Tag
+
+First, create a new git tag following semantic versioning (vX.Y.Z):
+
+```bash
+# Check current latest tag
+git tag -l "v*" --sort=-v:refname | head -n 1
+
+# Create new tag (increment patch version)
+git tag vX.Y.Z
+
+# Push the tag to remote
+git push origin vX.Y.Z
+```
+
+### 2. Run the Release Script
+
+Execute the release script:
+
+```bash
+python tools/release.py
+```
+
+The script will:
+
+- Verify you have the required tools installed
+- Check that there are no uncommitted changes
+- Get the version from the latest git tag
+- Verify the tag points to the current commit
+- Build the package
+- Upload to PyPI
+- Create a GitHub release
+
+### 3. What the GitHub Release Includes
+
+The automated GitHub release will:
+
+- Use the tag name as the release title
+- Include a basic changelog message linking to CHANGELOG.md
+- Be marked as a production release (not draft or prerelease)
+
+## Build Only Mode
+
+If you want to build the package without uploading it, use:
+
+```bash
+python tools/release.py --build-only
+```
+
+This is useful for testing the build process locally.
+
+## Troubleshooting
+
+Common issues and solutions:
+
+- **GITHUB_TOKEN not set**: Make sure you've exported the environment variable
+- **Tag doesn't point to current commit**: Make sure you're on the correct commit before tagging
+- **Version already exists on PyPI**: Increment the version number in your tag
+- **Uncommitted changes**: Commit or stash your changes before releasing

{janito-3.14.1 → janito-3.15.0}/docs/guides/terminal-shell.md

@@ -10,7 +10,7 @@ Janito works best with modern Unicode-capable terminals. **Windows Terminal is t
 
 Janito includes built-in support for executing shell commands across platforms:
 
-- **Bash commands** (`run_bash_command`) - Execute bash shell commands on Linux, macOS, and Windows (via WSL/Git Bash)
+- **Bash commands** (`run_bash_command`) - Execute bash shell commands on Linux, macOS, and Windows (via Git Bash)
 - **PowerShell commands** (`run_powershell_command`) - Execute PowerShell commands on Windows and cross-platform (requires PowerShell Core)
 
 These tools can be enabled/disabled via configuration and provide live output streaming, timeout handling, and security controls.

{janito-3.14.1 → janito-3.15.0}/docs/index.md

@@ -59,5 +59,6 @@ Explore our comprehensive documentation:
 - [Supported Models](models/supported_models.md)
 - [Tools & Plugins](tools.md)
 - [Developer Guide](guides/developing.md)
+- [Releasing Guide](guides/releasing.md)
 
 > **Note**: The list of supported models is automatically generated from the codebase. When new models are added, this documentation updates automatically.*

{janito-3.14.1 → janito-3.15.0}/docs/models/supported_models.md

@@ -92,11 +92,8 @@ This document lists all supported large language models (LLMs) across providers,
 
 | Model Name | Context Window | Max Tokens | Description |
 |------------|----------------|------------|-------------|
-| `deepseek-chat` | 8,192 | 4,096 | DeepSeek Chat Model (OpenAI-compatible) |
-| `deepseek-reasoner` | 8,192 | 4,096 | DeepSeek Reasoner Model (OpenAI-compatible) |
-| `deepseek-v3.1` | 131,072 | 4,096 | DeepSeek V3.1 Model (128K context, OpenAI-compatible) |
-| `deepseek-v3.1-base` | 131,072 | 4,096 | DeepSeek V3.1 Base Model (128K context, OpenAI-compatible) |
-| `deepseek-r1` | 131,072 | 4,096 | DeepSeek R1 Model (128K context, OpenAI-compatible) |
+| `deepseek-chat` | 131,072 | 4,096 | DeepSeek Chat Model (OpenAI-compatible) |
+| `deepseek-reasoner` | 131,072 | 32,768 | DeepSeek Reasoner Model (OpenAI-compatible) |
 
 ## Moonshot
 

{janito-3.14.1 → janito-3.15.0}/docs/supported-providers-models.md

@@ -41,11 +41,8 @@ This page lists the supported providers and their available models, organized by
 
 ### DeepSeek
 
-- **DeepSeek Chat** (default) - General purpose chat model (8K context)
-- **DeepSeek Reasoner** - Specialized for complex reasoning tasks (8K context)
-- **DeepSeek V3.1** - Latest V3.1 model with 128K context window
-- **DeepSeek V3.1 Base** - Base V3.1 model with 128K context window
-- **DeepSeek R1** - R1 model with 128K context window (reasoning-focused)
+- **DeepSeek Chat** (default) - General purpose chat model (128K context)
+- **DeepSeek Reasoner** - Specialized for complex reasoning tasks (128K context)
 
 ### Mistral
 

{janito-3.14.1 → janito-3.15.0}/examples/loop_protection_tool_example.py

@@ -1,147 +1,145 @@
-#!/usr/bin/env python3
-"""
-Example showing how to add loop protection to a custom tool.
-
-This example demonstrates how to create a custom tool with loop protection
-using the @protect_against_loops decorator.
-"""
-
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.loop_protection_decorator import protect_against_loops
-from janito.plugins.tools.local.adapter import register_local_tool
-
-
-@register_local_tool
-class CustomFileAnalyzerTool(ToolBase):
-    """
-    Example custom tool that analyzes files with loop protection.
-
-    This tool demonstrates how to use the @protect_against_loops decorator
-    to prevent excessive operations on the same file.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "custom_file_analyzer"
-
-    @protect_against_loops(max_calls=5, time_window=10.0)
-    def run(self, path: str, analysis_type: str = "basic") -> str:
-        """
-        Analyze a file with the specified analysis type.
-
-        Args:
-            path (str): Path to the file to analyze
-            analysis_type (str): Type of analysis to perform ("basic" or "detailed")
-
-        Returns:
-            str: Analysis results
-        """
-        self.report_action(f"Analyzing '{path}' with {analysis_type} analysis")
-
-        try:
-            # Simulate file analysis
-            with open(path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            # Perform analysis based on type
-            if analysis_type == "basic":
-                lines = len(content.splitlines())
-                words = len(content.split())
-                chars = len(content)
-                result = f"Basic analysis of {path}:\n"
-                result += f"  Lines: {lines}\n"
-                result += f"  Words: {words}\n"
-                result += f"  Characters: {chars}\n"
-            else:
-                # Detailed analysis could include more metrics
-                result = f"Detailed analysis of {path}:\n"
-                result += f"  Content preview: {content[:100]}...\n"
-
-            self.report_success(f"Analysis of {path} completed")
-            return result
-
-        except FileNotFoundError:
-            self.report_error(f"File not found: {path}")
-            return f"Error: File '{path}' not found"
-        except Exception as e:
-            self.report_error(f"Error analyzing {path}: {e}")
-            return f"Error analyzing file: {e}"
-
-
-@register_local_tool
-class BatchFileProcessorTool(ToolBase):
-    """
-    Example tool that processes multiple files with loop protection.
-
-    This tool demonstrates how to use the @protect_against_loops decorator
-    with tools that operate on multiple files.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "batch_file_processor"
-
-    @protect_against_loops(max_calls=5, time_window=10.0)
-    def run(self, file_paths: list, operation: str = "count") -> str:
-        """
-        Process multiple files with the specified operation.
-
-        Args:
-            file_paths (list): List of file paths to process
-            operation (str): Operation to perform ("count", "uppercase", etc.)
-
-        Returns:
-            str: Processing results
-        """
-        self.report_action(
-            f"Processing {len(file_paths)} files with {operation} operation"
-        )
-
-        results = []
-        for path in file_paths:
-            try:
-                with open(path, "r", encoding="utf-8") as f:
-                    content = f.read()
-
-                if operation == "count":
-                    lines = len(content.splitlines())
-                    words = len(content.split())
-                    results.append(f"{path}: {lines} lines, {words} words")
-                elif operation == "uppercase":
-                    results.append(f"{path}: {content.upper()}")
-
-            except FileNotFoundError:
-                results.append(f"{path}: File not found")
-            except Exception as e:
-                results.append(f"{path}: Error - {e}")
-
-        self.report_success(f"Processed {len(file_paths)} files")
-        return "\n".join(results)
-
-
-def usage_examples():
-    """Show how to use the custom tools with loop protection."""
-    print("=== Custom Tool with Loop Protection Examples ===\n")
-    print("Example 1: CustomFileAnalyzerTool")
-    print("  @protect_against_loops()")
-    print("  def run(self, path: str, analysis_type: str = 'basic') -> str:")
-    print("      # Implementation here")
-    print()
-
-    print("Example 2: BatchFileProcessorTool")
-    print("  @protect_against_loops('file_paths')")
-    print("  def run(self, file_paths: list, operation: str = 'count') -> str:")
-    print("      # Implementation here")
-    print()
-
-    print("To use these tools in your application:")
-    print("1. Import the tool classes")
-    print("2. Register them with the tools adapter")
-    print("3. Call them like any other tool")
-    print()
-    print("The loop protection will automatically prevent:")
-    print("- More than 5 operations on the same file within 10 seconds")
-    print("- Excessive resource consumption from repeated file access")
-    print("- Potential infinite loops in tool execution")
-
-
-if __name__ == "__main__":
-    usage_examples()
+#!/usr/bin/env python3
+"""
+Example showing how to add loop protection to a custom tool.
+
+This example demonstrates how to create a custom tool with loop protection
+using the @protect_against_loops decorator.
+"""
+
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.tools.loop_protection_decorator import protect_against_loops
+from janito.plugins.tools.local.adapter import register_local_tool
+
+
+@register_local_tool
+class CustomFileAnalyzerTool(ToolBase):
+    """
+    Example custom tool that analyzes files with loop protection.
+
+    This tool demonstrates how to use the @protect_against_loops decorator
+    to prevent excessive operations on the same file.
+    """
+
+    permissions = ToolPermissions(read=True)
+
+    @protect_against_loops(max_calls=5, time_window=10.0)
+    def run(self, path: str, analysis_type: str = "basic") -> str:
+        """
+        Analyze a file with the specified analysis type.
+
+        Args:
+            path (str): Path to the file to analyze
+            analysis_type (str): Type of analysis to perform ("basic" or "detailed")
+
+        Returns:
+            str: Analysis results
+        """
+        self.report_action(f"Analyzing '{path}' with {analysis_type} analysis")
+
+        try:
+            # Simulate file analysis
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Perform analysis based on type
+            if analysis_type == "basic":
+                lines = len(content.splitlines())
+                words = len(content.split())
+                chars = len(content)
+                result = f"Basic analysis of {path}:\n"
+                result += f"  Lines: {lines}\n"
+                result += f"  Words: {words}\n"
+                result += f"  Characters: {chars}\n"
+            else:
+                # Detailed analysis could include more metrics
+                result = f"Detailed analysis of {path}:\n"
+                result += f"  Content preview: {content[:100]}...\n"
+
+            self.report_success(f"Analysis of {path} completed")
+            return result
+
+        except FileNotFoundError:
+            self.report_error(f"File not found: {path}")
+            return f"Error: File '{path}' not found"
+        except Exception as e:
+            self.report_error(f"Error analyzing {path}: {e}")
+            return f"Error analyzing file: {e}"
+
+
+@register_local_tool
+class BatchFileProcessorTool(ToolBase):
+    """
+    Example tool that processes multiple files with loop protection.
+
+    This tool demonstrates how to use the @protect_against_loops decorator
+    with tools that operate on multiple files.
+    """
+
+    permissions = ToolPermissions(read=True)
+
+    @protect_against_loops(max_calls=5, time_window=10.0)
+    def run(self, file_paths: list, operation: str = "count") -> str:
+        """
+        Process multiple files with the specified operation.
+
+        Args:
+            file_paths (list): List of file paths to process
+            operation (str): Operation to perform ("count", "uppercase", etc.)
+
+        Returns:
+            str: Processing results
+        """
+        self.report_action(
+            f"Processing {len(file_paths)} files with {operation} operation"
+        )
+
+        results = []
+        for path in file_paths:
+            try:
+                with open(path, "r", encoding="utf-8") as f:
+                    content = f.read()
+
+                if operation == "count":
+                    lines = len(content.splitlines())
+                    words = len(content.split())
+                    results.append(f"{path}: {lines} lines, {words} words")
+                elif operation == "uppercase":
+                    results.append(f"{path}: {content.upper()}")
+
+            except FileNotFoundError:
+                results.append(f"{path}: File not found")
+            except Exception as e:
+                results.append(f"{path}: Error - {e}")
+
+        self.report_success(f"Processed {len(file_paths)} files")
+        return "\n".join(results)
+
+
+def usage_examples():
+    """Show how to use the custom tools with loop protection."""
+    print("=== Custom Tool with Loop Protection Examples ===\n")
+    print("Example 1: CustomFileAnalyzerTool")
+    print("  @protect_against_loops()")
+    print("  def run(self, path: str, analysis_type: str = 'basic') -> str:")
+    print("      # Implementation here")
+    print()
+
+    print("Example 2: BatchFileProcessorTool")
+    print("  @protect_against_loops('file_paths')")
+    print("  def run(self, file_paths: list, operation: str = 'count') -> str:")
+    print("      # Implementation here")
+    print()
+
+    print("To use these tools in your application:")
+    print("1. Import the tool classes")
+    print("2. Register them with the tools adapter")
+    print("3. Call them like any other tool")
+    print()
+    print("The loop protection will automatically prevent:")
+    print("- More than 5 operations on the same file within 10 seconds")
+    print("- Excessive resource consumption from repeated file access")
+    print("- Potential infinite loops in tool execution")
+
+
+if __name__ == "__main__":
+    usage_examples()