janito 3.14.2__tar.gz → 3.15.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.14.2
+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,35 +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
 
-# 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.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.2 → 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.2 → 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.2 → 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()

{janito-3.14.2 → janito-3.15.0}/janito/platform_discovery.py

@@ -24,13 +24,7 @@ class PlatformDiscovery:
             return f"Git Bash ({self.os_environ.get('MSYSTEM')})"
         return None
 
-    def _detect_wsl(self):
-        if self.os_environ.get("WSL_DISTRO_NAME"):
-            shell = self.os_environ.get("SHELL")
-            shell_name = shell.split("/")[-1] if shell else "unknown"
-            distro = self.os_environ.get("WSL_DISTRO_NAME")
-            return f"{shell_name} (WSL: {distro})"
-        return None
+
 
     def _detect_powershell(self):
         try:
@@ -87,7 +81,6 @@ class PlatformDiscovery:
         """
         shell_info = (
             self._detect_git_bash()
-            or self._detect_wsl()
             or self._detect_powershell()
             or self._detect_shell_env()
             or self._detect_comspec()

{janito-3.14.2 → janito-3.15.0}/janito/plugins/tools/local/adapter.py

@@ -76,10 +76,11 @@ class LocalToolsAdapter(ToolsAdapter):
             raise TypeError(
                 f"Tool '{tool_class.__name__}' must implement a callable 'run' method."
             )
-        tool_name = getattr(instance, "tool_name", None)
+        # Derive tool name from class name by convention
+        tool_name = instance.tool_name
         if not tool_name or not isinstance(tool_name, str):
             raise ValueError(
-                f"Tool '{tool_class.__name__}' must provide a class attribute 'tool_name' (str) for its registration name."
+                f"Tool '{tool_class.__name__}' must provide a valid tool_name property."
             )
         if tool_name in self._tools:
             raise ValueError(f"Tool '{tool_name}' is already registered.")