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

janito/config/profiles/definitions.py

@@ -0,0 +1,38 @@
+"""
+Predefined parameter profiles for Janito.
+"""
+from typing import Dict, Any
+
+# Predefined parameter profiles
+PROFILES = {
+    "precise": {
+        "temperature": 0.2,
+        "top_p": 0.85,
+        "top_k": 20,
+        "description": "Factual answers, documentation, structured data, avoiding hallucinations"
+    },
+    "balanced": {
+        "temperature": 0.5,
+        "top_p": 0.9,
+        "top_k": 40,
+        "description": "Professional writing, summarization, everyday tasks with moderate creativity"
+    },
+    "conversational": {
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "top_k": 45,
+        "description": "Natural dialogue, educational content, support conversations"
+    },
+    "creative": {
+        "temperature": 0.9,
+        "top_p": 0.95,
+        "top_k": 70,
+        "description": "Storytelling, brainstorming, marketing copy, poetry"
+    },
+    "technical": {
+        "temperature": 0.3,
+        "top_p": 0.95,
+        "top_k": 15,
+        "description": "Code generation, debugging, decision analysis, technical problem-solving"
+    }
+}

janito/config/profiles/manager.py

@@ -0,0 +1,80 @@
+"""
+Profile management functions for Janito configuration.
+"""
+from typing import Dict, Any
+
+from .definitions import PROFILES
+
+def get_available_profiles() -> Dict[str, Dict[str, Any]]:
+    """
+    Get all available predefined profiles.
+    
+    Returns:
+        Dictionary of profile names to profile settings
+    """
+    return PROFILES
+
+def get_profile(profile_name: str) -> Dict[str, Any]:
+    """
+    Get a specific profile by name.
+    
+    Args:
+        profile_name: Name of the profile to retrieve
+        
+    Returns:
+        Dict containing the profile settings
+        
+    Raises:
+        ValueError: If the profile name is not recognized
+    """
+    profile_name = profile_name.lower()
+    if profile_name not in PROFILES:
+        valid_profiles = ", ".join(PROFILES.keys())
+        raise ValueError(f"Unknown profile: {profile_name}. Valid profiles are: {valid_profiles}")
+    
+    return PROFILES[profile_name]
+
+def create_custom_profile(name: str, temperature: float, description: str = None) -> Dict[str, Any]:
+    """
+    Create a custom profile with the given parameters.
+    
+    Args:
+        name: Name for the custom profile
+        temperature: Temperature value (0.0 to 1.0)
+        description: Optional description for the profile
+        
+    Returns:
+        Dict containing the profile settings
+        
+    Raises:
+        ValueError: If temperature is not between 0.0 and 1.0
+    """
+    if temperature < 0.0 or temperature > 1.0:
+        raise ValueError("Temperature must be between 0.0 and 1.0")
+    
+    # Determine top_p and top_k based on temperature
+    if temperature <= 0.3:
+        top_p = 0.85
+        top_k = 15
+    elif temperature <= 0.6:
+        top_p = 0.9
+        top_k = 40
+    else:
+        top_p = 0.95
+        top_k = 60
+    
+    # Use provided description or generate a default one
+    if description is None:
+        if temperature <= 0.3:
+            description = "Custom precise profile"
+        elif temperature <= 0.6:
+            description = "Custom balanced profile"
+        else:
+            description = "Custom creative profile"
+    
+    return {
+        "temperature": temperature,
+        "top_p": top_p,
+        "top_k": top_k,
+        "description": description
+    }

janito/data/instructions_template.txt

@@ -1,28 +1,34 @@
 You are a {{ role }}, using the name Janito .
 You will be assisting an user using a computer system on a {{ platform }} platform.
 You can find more about the current project using the tools in the workspace directory.
-If the question is related to the project, use the tools using the relative path  "." .
+If the question is related to the project, use the tools using the relative path, ./filename instead of /filename.
 
 If creating or editing files with a large number of lines, organize them into smaller files.
 If creating or editing files in an existing directory check surrounding files for the used patterns.
 
-# Structure Discovery (./docs/STRUCTURE.md)
-Always start exploring the project by viewing for the file ./docs/STRUCTURE.md.
+# Structure Discovery (docs/STRUCTURE.md from current directory)
+Always start exploring the project by viewing for the file docs/STRUCTURE.md.
 Do not track files or directories wich are in .gitignore in the structure.
 At the end of responding to the user, update the structure file based on the files and directories you have interacted with,
 be precise focusing on the most important files and directories, avoid adding extra information like architecture or design patterns.
 
 # Tools
 The bash tool does not support commands which will require user input.
+Use the bash tool to get the current date or time when needed.
 Prefer the str_replace_editor tool to view directories and file contents.
 
-</IMPORTANT>
+<IMPORTANT>
 Call the user_prompt tool when:
 - There are multiple options to apply a certain change
 - The next operation risk is moderated or high
 - The implementation plan is complex, requiring a review
 Proceed according to the user answer.
-<IMPORTANT/>
+</IMPORTANT>
 
 When changing code in Python files, be mindful about the need to review the imports specially when new type hints are used (eg. Optional, Tuple, List, Dict, etc).
-After performing changes to a project in interfaces which are exposed to the user, provide a short summary on how to verify the changes. eg. "run cmd xpto"
+After performing changes to a project in interfaces which are exposed to the user, respond to the user with a short summary on how to verify the changes. eg. "run cmd xpto", prefer to provide a command to run instead of a description.
+When displaying commands in instructions to the user, consider their platform.
+When creating html pages which refer to images that should be manually placed by the user, instead of broken links provide a frame with a placeholder image.
+
+If STRUCTURE.md was updated add it to the list of files to be committed.
+After significant changes, run git commit with a message describing the changes made.

janito/tools/__init__.py

@@ -10,11 +10,12 @@ from .replace_file import replace_file
 from .prompt_user import prompt_user
 from .move_file import move_file
 from janito.tools.fetch_webpage import fetch_webpage
+from .think import think
 from .usage_tracker import get_tracker, reset_tracker, print_usage_stats
 from janito.config import get_config
 
 __all__ = ["str_replace_editor", "find_files", "delete_file", "search_text", "replace_file", 
-           "prompt_user", "move_file", "fetch_webpage", "get_tools", 
+           "prompt_user", "move_file", "fetch_webpage", "think", "get_tools", 
            "get_tracker", "reset_tracker", "print_usage_stats"]
 
 def get_tools():
@@ -23,10 +24,15 @@ def get_tools():
     
     Returns:
         List of tool functions (excluding str_replace_editor which is passed separately)
+        If no_tools mode is enabled, returns an empty list
         If ask_mode is enabled, only returns tools that don't perform changes
     """
+    # If no_tools mode is enabled, return an empty list
+    if get_config().no_tools:
+        return []
+        
     # Tools that only read or view but don't modify anything
-    read_only_tools = [find_files, search_text, prompt_user, fetch_webpage]
+    read_only_tools = [find_files, search_text, prompt_user, fetch_webpage, think]
     
     # Tools that modify the filesystem
     write_tools = [delete_file, replace_file, move_file]

janito/tools/bash/bash.py

@@ -3,6 +3,9 @@ from typing import Tuple
 import threading
 import platform
 import re
+import queue
+import signal
+import time
 from janito.config import get_config
 from janito.tools.usage_tracker import get_tracker
 from janito.tools.rich_console import console, print_info
@@ -16,6 +19,42 @@ else:
 # Global instance of PersistentBash to maintain state between calls
 _bash_session = None
 _session_lock = threading.RLock()  # Use RLock to allow reentrant locking
+_current_bash_thread = None
+_command_interrupted = False
+
+def _execute_bash_command(command, result_queue):
+    """
+    Execute a bash command in a separate thread.
+    
+    Args:
+        command: The bash command to execute
+        result_queue: Queue to store the result
+    """
+    global _bash_session, _command_interrupted
+    
+    try:
+        # Execute the command - output will be printed to console in real-time
+        output = _bash_session.execute(command)
+        
+        # Put the result in the queue if the command wasn't interrupted
+        if not _command_interrupted:
+            result_queue.put((output, False))
+    except Exception as e:
+        # Handle any exceptions that might occur
+        error_message = f"Error executing bash command: {str(e)}"
+        console.print(error_message, style="red bold")
+        result_queue.put((error_message, True))
+
+def _keyboard_interrupt_handler(signum, frame):
+    """
+    Handle keyboard interrupt (Ctrl+C) by setting the interrupt flag.
+    """
+    global _command_interrupted
+    _command_interrupted = True
+    console.print("\n[bold red]Command interrupted by user (Ctrl+C)[/bold red]")
+    
+    # Restore the default signal handler
+    signal.signal(signal.SIGINT, original_sigint_handler)
 
 def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]:
     """
@@ -23,6 +62,7 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
     The appropriate implementation (Windows or Unix) is selected based on the detected platform.
     When in ask mode, only read-only commands are allowed.
     Output is printed to the console in real-time as it's received.
+    Command runs in a background thread, allowing Ctrl+C to interrupt just the command.
     
     Args:
         command: The bash command to execute
@@ -37,7 +77,9 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
     # Only print command if not in trust mode
     if not get_config().trust_mode:
         print_info(f"{command}", "Bash Run")
-    global _bash_session
+    
+    global _bash_session, _current_bash_thread, _command_interrupted, original_sigint_handler
+    _command_interrupted = False
     
     # Check if in ask mode and if the command might modify files
     if get_config().ask_mode:
@@ -65,20 +107,51 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
             _bash_session = PersistentBash(bash_path=gitbash_path)
         
         try:
-            # Execute the command - output will be printed to console in real-time
-            output = _bash_session.execute(command)
+            # Create a queue to get the result from the thread
+            result_queue = queue.Queue()
+            
+            # Save the original SIGINT handler
+            original_sigint_handler = signal.getsignal(signal.SIGINT)
+            
+            # Set our custom SIGINT handler
+            signal.signal(signal.SIGINT, _keyboard_interrupt_handler)
+            
+            # Create and start the thread
+            _current_bash_thread = threading.Thread(
+                target=_execute_bash_command,
+                args=(command, result_queue)
+            )
+            _current_bash_thread.daemon = True
+            _current_bash_thread.start()
+            
+            # Wait for the thread to complete or for an interrupt
+            while _current_bash_thread.is_alive() and not _command_interrupted:
+                _current_bash_thread.join(0.1)  # Check every 100ms
+            
+            # If the command was interrupted, return a message
+            if _command_interrupted:
+                # Restore the original signal handler
+                signal.signal(signal.SIGINT, original_sigint_handler)
+                return ("Command was interrupted by Ctrl+C", True)
+            
+            # Get the result from the queue
+            output, is_error = result_queue.get(timeout=1)
+            
+            # Restore the original signal handler
+            signal.signal(signal.SIGINT, original_sigint_handler)
             
             # Track bash command execution
             get_tracker().increment('bash_commands')
             
-            # Always assume execution was successful
-            is_error = False
-            
-            # Return the output as a string (even though it was already printed in real-time)
+            # Return the output
             return output, is_error
             
         except Exception as e:
             # Handle any exceptions that might occur
             error_message = f"Error executing bash command: {str(e)}"
             console.print(error_message, style="red bold")
+            
+            # Restore the original signal handler
+            signal.signal(signal.SIGINT, original_sigint_handler)
+            
             return error_message, True

janito/tools/bash/unix_persistent_bash.py

@@ -132,7 +132,38 @@ class PersistentBash:
         start_time = time.time()
         max_wait = timeout if timeout is not None else 3600  # Default to 1 hour if no timeout
         
+        # Check if we're being run from the main bash_tool function
+        # which will handle interruption
+        try:
+            from janito.tools.bash.bash import _command_interrupted
+        except ImportError:
+            _command_interrupted = False
+        
         while time.time() - start_time < max_wait + 5:  # Add buffer time
+            # Check if we've been interrupted
+            if '_command_interrupted' in globals() and _command_interrupted:
+                # Send Ctrl+C to the running process
+                if self.process and self.process.poll() is None:
+                    try:
+                        # Send interrupt signal to the process group
+                        import os
+                        import signal
+                        pgid = os.getpgid(self.process.pid)
+                        os.killpg(pgid, signal.SIGINT)
+                    except:
+                        pass
+                
+                # Add message to output
+                interrupt_msg = "Command interrupted by user (Ctrl+C)"
+                console.print(f"[bold red]{interrupt_msg}[/bold red]")
+                output_lines.append(interrupt_msg)
+                
+                # Reset the bash session
+                self.close()
+                self.start_process()
+                
+                break
+                
             try:
                 line = self.process.stdout.readline().rstrip('\r\n')
                 if end_marker in line:
@@ -152,7 +183,7 @@ class PersistentBash:
                 continue
             
         # Check for timeout
-        if time.time() - start_time >= max_wait + 5:
+        if time.time() - start_time >= max_wait + 5 and not _command_interrupted:
             timeout_msg = f"Error: Command timed out after {max_wait} seconds"
             console.print(timeout_msg, style="red bold")
             output_lines.append(timeout_msg)

janito/tools/bash/win_persistent_bash.py

@@ -216,7 +216,40 @@ class PersistentBash:
         start_time = time.time()
         max_wait = timeout if timeout is not None else 3600  # Default to 1 hour if no timeout
         
+        # Check if we're being run from the main bash_tool function
+        # which will handle interruption
+        try:
+            from janito.tools.bash.bash import _command_interrupted
+        except ImportError:
+            _command_interrupted = False
+        
         while time.time() - start_time < max_wait + 5:  # Add buffer time
+            # Check if we've been interrupted
+            if '_command_interrupted' in globals() and _command_interrupted:
+                # Send Ctrl+C to the running process
+                if self.process and self.process.poll() is None:
+                    try:
+                        # On Windows, we need to use CTRL_C_EVENT
+                        import signal
+                        self.process.send_signal(signal.CTRL_C_EVENT)
+                    except:
+                        # If that fails, try to terminate the process
+                        try:
+                            self.process.terminate()
+                        except:
+                            pass
+                
+                # Add message to output
+                interrupt_msg = "Command interrupted by user (Ctrl+C)"
+                console.print(f"[bold red]{interrupt_msg}[/bold red]")
+                output_lines.append(interrupt_msg)
+                
+                # Reset the bash session
+                self.close()
+                self.start_process()
+                
+                break
+                
             try:
                 line = self.stdout.readline().rstrip('\r\n')
                 if end_marker in line:
@@ -243,7 +276,7 @@ class PersistentBash:
                 continue
             
         # Check for timeout
-        if time.time() - start_time >= max_wait + 5:
+        if time.time() - start_time >= max_wait + 5 and not _command_interrupted:
             timeout_msg = f"Error: Command timed out after {max_wait} seconds"
             console.print(timeout_msg, style="red bold")
             output_lines.append(timeout_msg)

janito/tools/fetch_webpage/__init__.py

@@ -1,34 +1,23 @@
-"""
-Webpage Content Extractor Package
-
-A comprehensive tool for extracting clean, relevant content from web pages
-for processing with LLMs. Features include:
-- General content extraction with multiple methods
-- Specialized handling for news aggregator sites
-- Targeted extraction based on specific search strings
-- Chunking for large content
-- Structured content extraction
-
-Dependencies:
-- requests
-- beautifulsoup4
-- trafilatura
-- newspaper3k
-
-Author: Claude (Anthropic)
-"""
-
-from janito.tools.fetch_webpage.core import fetch_webpage, fetch_and_extract
-from janito.tools.fetch_webpage.news import fetch_and_extract_news_aggregator
-from janito.tools.fetch_webpage.extractors import extract_clean_text, extract_targeted_content, extract_structured_content
-from janito.tools.fetch_webpage.chunking import chunk_large_content
-
-__all__ = [
-    'fetch_webpage',
-    'fetch_and_extract',
-    'fetch_and_extract_news_aggregator',
-    'extract_clean_text',
-    'extract_targeted_content',
-    'extract_structured_content',
-    'chunk_large_content'
+"""
+Webpage Content Extractor Package
+
+A simplified tool for extracting clean, relevant content from web pages
+for processing with LLMs. Features include:
+- Streamlined content extraction using BeautifulSoup
+- Clean HTML text extraction
+- Efficient content chunking
+
+Dependencies:
+- requests
+- beautifulsoup4
+
+Author: Claude (Anthropic)
+"""
+
+from janito.tools.fetch_webpage.core import fetch_webpage, fetch_and_extract, chunk_content
+
+__all__ = [
+    'fetch_webpage',
+    'fetch_and_extract',
+    'chunk_content'
 ]