janito 2.21.0__py3-none-any.whl → 2.22.0__py3-none-any.whl

janito/agent/setup_agent.py

@@ -52,10 +52,40 @@ def _load_template_content(profile, templates_dir):
         with open(user_template_path, "r", encoding="utf-8") as file:
             return file.read(), user_template_path
 
-    # If nothing matched, raise an informative error
-    raise FileNotFoundError(
-        f"[janito] Could not find profile-specific template '{template_filename}' in {template_path} nor in janito.agent.templates.profiles package nor in user profiles directory {user_template_path}."
-    )
+    # If nothing matched, list available profiles and raise an informative error
+    from janito.cli.cli_commands.list_profiles import _gather_default_profiles, _gather_user_profiles
+    
+    default_profiles = _gather_default_profiles()
+    user_profiles = _gather_user_profiles()
+    
+    available_profiles = []
+    if default_profiles:
+        available_profiles.extend([(p, "default") for p in default_profiles])
+    if user_profiles:
+        available_profiles.extend([(p, "user") for p in user_profiles])
+    
+    # Normalize the input profile for better matching suggestions
+    normalized_input = re.sub(r"\s+", " ", profile.strip().lower())
+    
+    if available_profiles:
+        profile_list = "\n".join([f"  - {name} ({source})" for name, source in available_profiles])
+        
+        # Find close matches
+        close_matches = []
+        for name, source in available_profiles:
+            normalized_name = name.lower()
+            if normalized_input in normalized_name or normalized_name in normalized_input:
+                close_matches.append(name)
+        
+        suggestion = ""
+        if close_matches:
+            suggestion = f"\nDid you mean: {', '.join(close_matches)}?"
+        
+        error_msg = f"[janito] Could not find profile '{profile}'. Available profiles:\n{profile_list}{suggestion}"
+    else:
+        error_msg = f"[janito] Could not find profile '{profile}'. No profiles available."
+    
+    raise FileNotFoundError(error_msg)
     # Replace spaces in profile name with underscores for filename resolution
     sanitized_profile = re.sub(r"\\s+", "_", profile.strip()) if profile else profile
     """

janito/agent/templates/profiles/system_prompt_template_market_analyst.txt.j2

@@ -0,0 +1,10 @@
+You are: market analyst specializing in financial markets, business intelligence, and economic research
+
+Focus on providing market analysis, financial insights, and business intelligence. When analyzing data:
+
+ • Identify market trends and patterns
+ • Provide quantitative analysis with clear metrics
+ • Consider economic indicators and market sentiment
+ • Offer actionable insights for business decisions
+ • Use appropriate financial terminology and frameworks
+ • Reference relevant market data, benchmarks, and industry standards

janito/cli/chat_mode/session_profile_select.py

@@ -111,6 +111,7 @@ def select_profile():
     choices = [
         "Developer with Python Tools",
         "Developer",
+        "Market Analyst",
         "Custom system prompt...",
         "Raw Model Session (no tools, no context)",
     ]
@@ -146,9 +147,9 @@ def select_profile():
         from jinja2 import Template
         from janito.agent.setup_agent import _prepare_template_context
 
-        template_path = Path(
-            "./janito/agent/templates/profiles/system_prompt_template_Developer.txt.j2"
-        )
+        # Get the absolute path relative to the current script location
+        current_dir = Path(__file__).parent
+        template_path = current_dir / "../../agent/templates/profiles/system_prompt_template_developer.txt.j2"
         with open(template_path, "r", encoding="utf-8") as f:
             template_content = f.read()
 
@@ -156,4 +157,20 @@ def select_profile():
         context = _prepare_template_context("developer", "Developer", None)
         prompt = template.render(**context)
         return {"profile": "Developer", "profile_system_prompt": prompt}
+    elif answer == "Market Analyst":
+        # Return the content of the built-in Market Analyst profile prompt
+        from pathlib import Path
+        from jinja2 import Template
+        from janito.agent.setup_agent import _prepare_template_context
+
+        # Get the absolute path relative to the current script location
+        current_dir = Path(__file__).parent
+        template_path = current_dir / "../../agent/templates/profiles/system_prompt_template_market_analyst.txt.j2"
+        with open(template_path, "r", encoding="utf-8") as f:
+            template_content = f.read()
+
+        template = Template(template_content)
+        context = _prepare_template_context("market_analyst", "Market Analyst", None)
+        prompt = template.render(**context)
+        return {"profile": "Market Analyst", "profile_system_prompt": prompt}
     return answer

janito/cli/cli_commands/list_profiles.py

@@ -19,7 +19,35 @@ def _extract_profile_name(filename: str) -> str:
         filename = filename[len(_PREFIX) :]
     if filename.endswith(_SUFFIX):
         filename = filename[: -len(_SUFFIX)]
-    return filename.replace("_", " ")
+    
+    # Convert to title case for consistent capitalization, but handle common acronyms
+    name = filename.replace("_", " ")
+    
+    # Convert to proper title case with consistent capitalization
+    name = filename.replace("_", " ")
+    
+    # Handle special cases and acronyms
+    special_cases = {
+        "python": "Python",
+        "tools": "Tools",
+        "model": "Model",
+        "context": "Context",
+        "developer": "Developer",
+        "analyst": "Analyst",
+        "conversation": "Conversation",
+        "without": "Without"
+    }
+    
+    words = name.split()
+    capitalized_words = []
+    for word in words:
+        lower_word = word.lower()
+        if lower_word in special_cases:
+            capitalized_words.append(special_cases[lower_word])
+        else:
+            capitalized_words.append(word.capitalize())
+    
+    return " ".join(capitalized_words)
 
 
 def _gather_default_profiles():

janito/cli/cli_commands/show_system_prompt.py

@@ -60,7 +60,17 @@ def _load_template(profile, templates_dir):
             ).open("r", encoding="utf-8") as file:
                 template_content = file.read()
         except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            return template_filename, None
+            # Also check user profiles directory
+            from pathlib import Path
+            import os
+            user_profiles_dir = Path(os.path.expanduser("~/.janito/profiles"))
+            user_template_path = user_profiles_dir / template_filename
+            if user_template_path.exists():
+                with open(user_template_path, "r", encoding="utf-8") as file:
+                    template_content = file.read()
+            else:
+                template_content = None
+            return template_filename, template_content
     return template_filename, template_content
 
 
@@ -117,9 +127,40 @@ def handle_show_system_prompt(args):
 
     if not template_content:
         if profile:
-            raise FileNotFoundError(
-                f"[janito] Could not find profile-specific template '{template_filename}' in {templates_dir / template_filename} nor in janito.agent.templates.profiles package."
-            )
+            from janito.cli.cli_commands.list_profiles import _gather_default_profiles, _gather_user_profiles
+            import re
+            
+            default_profiles = _gather_default_profiles()
+            user_profiles = _gather_user_profiles()
+            
+            available_profiles = []
+            if default_profiles:
+                available_profiles.extend([(p, "default") for p in default_profiles])
+            if user_profiles:
+                available_profiles.extend([(p, "user") for p in user_profiles])
+            
+            # Normalize the input profile for better matching suggestions
+            normalized_input = re.sub(r"\s+", " ", profile.strip().lower())
+            
+            if available_profiles:
+                profile_list = "\n".join([f"  - {name} ({source})" for name, source in available_profiles])
+                
+                # Find close matches
+                close_matches = []
+                for name, source in available_profiles:
+                    normalized_name = name.lower()
+                    if normalized_input in normalized_name or normalized_name in normalized_input:
+                        close_matches.append(name)
+                
+                suggestion = ""
+                if close_matches:
+                    suggestion = f"\nDid you mean: {', '.join(close_matches)}?"
+                
+                error_msg = f"[janito] Could not find profile '{profile}'. Available profiles:\n{profile_list}{suggestion}"
+            else:
+                error_msg = f"[janito] Could not find profile '{profile}'. No profiles available."
+            
+            raise FileNotFoundError(error_msg)
         else:
             print(
                 f"[janito] Could not find {template_filename} in {templates_dir / template_filename} nor in janito.agent.templates.profiles package."

janito/providers/ibm/model_info.py

@@ -3,6 +3,15 @@
 from janito.llm.model import LLMModelInfo
 
 MODEL_SPECS = {
+    "openai/gpt-oss-120b": LLMModelInfo(
+        name="openai/gpt-oss-120b",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=True,
+        category="IBM WatsonX",
+    ),
     "ibm/granite-3-8b-instruct": LLMModelInfo(
         name="ibm/granite-3-8b-instruct",
         context=128000,

janito/tools/adapters/local/fetch_url.py

@@ -1,4 +1,8 @@
 import requests
+import time
+import os
+import json
+from pathlib import Path
 from bs4 import BeautifulSoup
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
@@ -18,6 +22,7 @@ class FetchUrlTool(ToolBase):
         max_length (int, optional): Maximum number of characters to return. Defaults to 5000.
         max_lines (int, optional): Maximum number of lines to return. Defaults to 200.
         context_chars (int, optional): Characters of context around search matches. Defaults to 400.
+        timeout (int, optional): Timeout in seconds for the HTTP request. Defaults to 10.
     Returns:
         str: Extracted text content from the web page, or a warning message. Example:
             - "<main text content...>"
@@ -28,15 +33,101 @@ class FetchUrlTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "fetch_url"
 
-    def _fetch_url_content(self, url: str) -> str:
+    def __init__(self):
+        super().__init__()
+        self.cache_dir = Path.home() / ".janito" / "cache" / "fetch_url"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.cache_file = self.cache_dir / "error_cache.json"
+        self._load_cache()
+
+    def _load_cache(self):
+        """Load error cache from disk."""
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, 'r', encoding='utf-8') as f:
+                    self.error_cache = json.load(f)
+            except (json.JSONDecodeError, IOError):
+                self.error_cache = {}
+        else:
+            self.error_cache = {}
+
+    def _save_cache(self):
+        """Save error cache to disk."""
+        try:
+            with open(self.cache_file, 'w', encoding='utf-8') as f:
+                json.dump(self.error_cache, f, indent=2)
+        except IOError:
+            pass  # Silently fail if we can't write cache
+
+    def _get_cached_error(self, url: str) -> tuple[str, bool]:
+        """
+        Check if we have a cached error for this URL.
+        Returns (error_message, is_cached) tuple.
+        """
+        if url not in self.error_cache:
+            return None, False
+        
+        entry = self.error_cache[url]
+        current_time = time.time()
+        
+        # Different expiration times for different status codes
+        if entry['status_code'] == 403:
+            # Cache 403 errors for 24 hours (more permanent)
+            expiration_time = 24 * 3600
+        elif entry['status_code'] == 404:
+            # Cache 404 errors for 1 hour (more temporary)
+            expiration_time = 3600
+        else:
+            # Cache other 4xx errors for 30 minutes
+            expiration_time = 1800
+            
+        if current_time - entry['timestamp'] > expiration_time:
+            # Cache expired, remove it
+            del self.error_cache[url]
+            self._save_cache()
+            return None, False
+            
+        return entry['message'], True
+
+    def _cache_error(self, url: str, status_code: int, message: str):
+        """Cache an HTTP error response."""
+        self.error_cache[url] = {
+            'status_code': status_code,
+            'message': message,
+            'timestamp': time.time()
+        }
+        self._save_cache()
+
+    def _fetch_url_content(self, url: str, timeout: int = 10) -> str:
         """Fetch URL content and handle HTTP errors."""
+        # Check cache first for known errors
+        cached_error, is_cached = self._get_cached_error(url)
+        if cached_error:
+            self.report_warning(
+                tr(
+                    "ℹ️ Using cached HTTP error for URL: {url}",
+                    url=url,
+                ),
+                ReportAction.READ,
+            )
+            return cached_error
+
         try:
-            response = requests.get(url, timeout=10)
+            response = requests.get(url, timeout=timeout)
             response.raise_for_status()
             return response.text
         except requests.exceptions.HTTPError as http_err:
             status_code = http_err.response.status_code if http_err.response else None
             if status_code and 400 <= status_code < 500:
+                error_message = tr(
+                    "Warning: HTTP {status_code} error for URL: {url}",
+                    status_code=status_code,
+                    url=url,
+                )
+                # Cache 403 and 404 errors
+                if status_code in [403, 404]:
+                    self._cache_error(url, status_code, error_message)
+                
                 self.report_error(
                     tr(
                         "❗ HTTP {status_code} error for URL: {url}",
@@ -45,11 +136,7 @@ class FetchUrlTool(ToolBase):
                     ),
                     ReportAction.READ,
                 )
-                return tr(
-                    "Warning: HTTP {status_code} error for URL: {url}",
-                    status_code=status_code,
-                    url=url,
-                )
+                return error_message
             else:
                 self.report_error(
                     tr(
@@ -123,6 +210,7 @@ class FetchUrlTool(ToolBase):
         max_length: int = 5000,
         max_lines: int = 200,
         context_chars: int = 400,
+        timeout: int = 10,
     ) -> str:
         if not url.strip():
             self.report_warning(tr("ℹ️ Empty URL provided."), ReportAction.READ)
@@ -131,7 +219,7 @@ class FetchUrlTool(ToolBase):
         self.report_action(tr("🌐 Fetch URL '{url}' ...", url=url), ReportAction.READ)
 
         # Fetch URL content
-        html_content = self._fetch_url_content(url)
+        html_content = self._fetch_url_content(url, timeout=timeout)
         if html_content.startswith("Warning:"):
             return html_content