ngpt 3.4.5__py3-none-any.whl → 3.5.0__py3-none-any.whl

ngpt/utils/web_search.py

@@ -1,5 +1,5 @@
 """
-Web search utilities for nGPT using duckduckgo-search and trafilatura.
+Web search utilities for nGPT using duckduckgo-search and BeautifulSoup4.
 
 This module provides functionality to search the web and extract
 information from search results to enhance AI prompts.
@@ -12,6 +12,9 @@ from urllib.parse import urlparse
 import requests
 import sys
 import datetime
+from bs4 import BeautifulSoup
+from bs4.element import Comment, Declaration, Doctype, ProcessingInstruction
+import json
 
 # Get actual logger from global context instead of using standard logging
 from . import log
@@ -58,9 +61,10 @@ def perform_web_search(query: str, max_results: int = 5) -> List[Dict[str, Any]]
         logger.info("Web search encountered an issue, but will continue with available results")
         return []
 
-def extract_article_content(url: str, max_chars: int = 2000) -> Optional[str]:
+def extract_article_content(url: str, max_chars: int = 5000) -> Optional[str]:
     """
-    Extract and clean content from a webpage URL.
+    Extract and clean content from a webpage URL using a hybrid approach
+    inspired by trafilatura and readability algorithms.
     
     Args:
         url: The URL to extract content from
@@ -81,82 +85,336 @@ def extract_article_content(url: str, max_chars: int = 2000) -> Optional[str]:
             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
             'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
             'Accept-Language': 'en-US,en;q=0.5',
+            'DNT': '1',  # Do Not Track
             'Connection': 'keep-alive',
             'Upgrade-Insecure-Requests': '1',
+            'Cache-Control': 'max-age=0',
+            'Sec-Fetch-Dest': 'document',
+            'Sec-Fetch-Mode': 'navigate',
+            'Sec-Fetch-Site': 'none',
+            'Pragma': 'no-cache',
         }
         
         logger.info(f"Fetching content from {url}")
         
         try:
-            # Try using trafilatura
-            import trafilatura
+            # Fetch the page content
+            response = requests.get(url, headers=headers, timeout=15)
             
-            # Download with correct parameters
-            # trafilatura handles user-agent internally
-            downloaded = trafilatura.fetch_url(url)
-            
-            if downloaded:
-                # Extract main content
-                content = trafilatura.extract(downloaded, include_comments=False, 
-                                             include_tables=False, 
-                                             no_fallback=False)
+            if response.status_code == 200:
+                # Try to detect the encoding if not properly specified
+                if response.encoding == 'ISO-8859-1':
+                    # Try to detect encoding from content
+                    possible_encoding = re.search(r'charset=["\'](.*?)["\']', response.text)
+                    if possible_encoding:
+                        response.encoding = possible_encoding.group(1)
+                    else:
+                        # Default to UTF-8 if we can't detect
+                        response.encoding = 'utf-8'
+                
+                # Parse with BeautifulSoup using lxml parser for better results if available
+                try:
+                    soup = BeautifulSoup(response.text, 'lxml')
+                except ImportError:
+                    soup = BeautifulSoup(response.text, 'html.parser')
+                
+                # Extract main content using multiple strategies
+                extracted_content = None
+                
+                # ---------- PREPROCESSING ----------
+                # Clone the soup before preprocessing
+                processed_soup = BeautifulSoup(str(soup), 'lxml' if 'lxml' in str(type(soup.parser)) else 'html.parser')
+                
+                # Remove all script, style tags and comments
+                for element in processed_soup.find_all(['script', 'style', 'noscript']):
+                    element.decompose()
+                
+                # Remove HTML comments
+                for comment in processed_soup.find_all(text=lambda text: isinstance(text, Comment)):
+                    comment.extract()
+                
+                # Remove hidden elements
+                for hidden in processed_soup.find_all(style=lambda s: s and isinstance(s, str) and ('display:none' in s.lower() or 'visibility:hidden' in s.lower())):
+                    hidden.decompose()
+                for hidden in processed_soup.find_all(hidden=True):
+                    hidden.decompose()
+                for hidden in processed_soup.find_all(class_=lambda c: c and isinstance(c, str) and any(x in c.lower() for x in ['hidden', 'invisible'])):
+                    hidden.decompose()
+                
+                # Handle iframes and frames
+                for frame in processed_soup.find_all(['iframe', 'frame']):
+                    frame.decompose()
+                
+                # ---------- SITE-SPECIFIC HANDLING ----------
+                domain = parsed_url.netloc.lower()
+                
+                # Wikipedia-specific extraction
+                if 'wikipedia.org' in domain:
+                    content_div = processed_soup.select_one('#mw-content-text')
+                    if content_div:
+                        # Remove tables, references, navigation elements
+                        for unwanted in content_div.select('table, .reference, .reflist, .navbox, .vertical-navbox, .thumbcaption, .mw-editsection, .mw-headline, .toc, #toc'):
+                            unwanted.decompose()
+                        extracted_content = content_div.get_text(separator=' ', strip=True)
+                
+                # News site specific handling
+                news_sites = {
+                    'cnn.com': ['article', '.article__content', '.l-container', '.body-text', '#body-text'],
+                    'bbc.com': ['.article__body-content', '.story-body__inner', '[data-component="text-block"]'],
+                    'nytimes.com': ['article', '.meteredContent', '.StoryBodyCompanionColumn', '.article-body'],
+                    'reuters.com': ['article', '.ArticleBody__content___3MtHP', '.article-body'],
+                    'theguardian.com': ['.article-body-commercial-selector', '.content__article-body', '.dcr-1cas96z'],
+                    'washingtonpost.com': ['.article-body', '.teaser-content'],
+                    'apnews.com': ['.Article', '.RichTextStoryBody'],
+                    'indiatimes.com': ['.article-body', '.article_content', '.article-desc', '.Normal'],
+                    'cnbc.com': ['.ArticleBody-articleBody', '.group-article-body', '.article-body'],
+                    'thehindu.com': ['.article-body', '.article-text', '#content-body-14269002']
+                }
+                
+                if not extracted_content:
+                    # Check if we're on a known news site
+                    for site, selectors in news_sites.items():
+                        if site in domain:
+                            for selector in selectors:
+                                content_element = processed_soup.select_one(selector)
+                                if content_element:
+                                    # Clean the news content
+                                    for unwanted in content_element.select('aside, figure, .ad, .ads, .advertisement, .social, .share, .related, .newsletter, .more-on, .read-more, .promotions'):
+                                        unwanted.decompose()
+                                    extracted_content = content_element.get_text(separator=' ', strip=True)
+                                    break
+                            if extracted_content:
+                                break
+                
+                # ---------- JSON-LD EXTRACTION ----------
+                if not extracted_content:
+                    # Look for structured data in JSON-LD format
+                    json_ld = processed_soup.find_all('script', type='application/ld+json')
+                    for script in json_ld:
+                        try:
+                            script_content = script.string
+                            if not script_content:  # Skip empty scripts
+                                continue
+                                
+                            # Clean the JSON string (some sites have invalid JSON)
+                            script_content = re.sub(r'[\n\t\r]', '', script_content)
+                            script_content = script_content.strip()
+                            
+                            data = json.loads(script_content)
+                            # Handle both single objects and arrays of objects
+                            if isinstance(data, list):
+                                data_list = data
+                            else:
+                                data_list = [data]
+                            
+                            for item in data_list:
+                                article_body = None
+                                # Try to find articleBody or various content fields
+                                if isinstance(item, dict):
+                                    # Check for common content fields directly
+                                    for field in ['articleBody', 'description', 'text', 'mainEntityOfPage']:
+                                        if field in item and isinstance(item[field], str) and len(item[field]) > 200:
+                                            article_body = item[field]
+                                            break
+                                    
+                                    # Check in nested objects
+                                    if not article_body and '@graph' in item and isinstance(item['@graph'], list):
+                                        for graph_item in item['@graph']:
+                                            if isinstance(graph_item, dict):
+                                                for field in ['articleBody', 'description', 'text']:
+                                                    if field in graph_item and isinstance(graph_item[field], str) and len(graph_item[field]) > 200:
+                                                        article_body = graph_item[field]
+                                                        break
+                                                if article_body:
+                                                    break
+                                
+                                if article_body:
+                                    extracted_content = article_body
+                                    break
+                            
+                            if extracted_content:
+                                break
+                        except (json.JSONDecodeError, TypeError, AttributeError, ValueError) as e:
+                            logger.debug(f"Error parsing JSON-LD: {str(e)}")
+                            continue
+                
+                # ---------- META DESCRIPTION EXTRACTION ----------
+                meta_description = None
+                meta_tag = processed_soup.find('meta', attrs={'name': 'description'}) or processed_soup.find('meta', attrs={'property': 'og:description'})
+                if meta_tag and meta_tag.get('content'):
+                    meta_description = meta_tag.get('content')
                 
-                if content:
-                    # Clean up content if needed
-                    content = content.strip()
+                # ---------- CONTENT ANALYSIS ----------
+                if not extracted_content:
+                    # Get all content blocks (divs, sections, articles)
+                    content_blocks = []
                     
-                    # Truncate if needed
-                    if len(content) > max_chars:
-                        content = content[:max_chars] + "..."
+                    # Prioritize semantic tags
+                    for tag in ['article', 'main', 'section', 'div']:
+                        blocks = processed_soup.find_all(tag)
                         
-                    return content
-            
-            # If trafilatura failed, try direct requests
-            logger.info(f"Trafilatura extraction failed for {url}, trying fallback method")
-            response = requests.get(url, headers=headers, timeout=10)
-            
-            if response.status_code == 200:
-                # Very basic HTML cleaning
-                html_content = response.text
-                # Remove HTML tags
-                text = re.sub(r'<[^>]+>', ' ', html_content)
-                # Remove excess whitespace
-                text = re.sub(r'\s+', ' ', text).strip()
+                        for block in blocks:
+                            # Skip if too small
+                            text = block.get_text(strip=True)
+                            if len(text) < 200:
+                                continue
+                                
+                            # Calculate content metrics
+                            char_count = len(text)
+                            link_density = calculate_link_density(block)
+                            p_count = len(block.find_all('p'))
+                            p_text_length = sum(len(p.get_text(strip=True)) for p in block.find_all('p'))
+                            p_density = p_text_length / char_count if char_count > 0 else 0
+                            
+                            # Skip blocks with high link density (likely navigation)
+                            if link_density > 0.5:
+                                continue
+                            
+                            # Calculate readability scores
+                            text_density = char_count / (len(str(block)) + 1)  # Text to HTML ratio
+                            
+                            # Score content blocks
+                            score = 0
+                            
+                            # Prefer blocks with many paragraphs
+                            score += min(p_count * 5, 50)  # Max 50 points for paragraphs
+                            
+                            # Prefer blocks with high paragraph text density
+                            score += min(int(p_density * 100), 50)  # Max 50 points for paragraph density
+                            
+                            # Penalize high link density
+                            score -= int(link_density * 100)
+                            
+                            # Boost for high text density
+                            score += min(int(text_density * 30), 30)  # Max 30 points for text density
+                            
+                            # Boost for certain attributes and classes
+                            content_indicators = ['content', 'article', 'story', 'post', 'text', 'body', 'entry']
+                            
+                            # Check class and id attributes
+                            for attr in ['class', 'id']:
+                                attr_val = block.get(attr, '')
+                                if attr_val:
+                                    if isinstance(attr_val, list):
+                                        attr_val = ' '.join(attr_val)
+                                    for indicator in content_indicators:
+                                        if indicator in attr_val.lower():
+                                            score += 30
+                                            break
+                            
+                            # Penalty for boilerplate indicators
+                            boilerplate_indicators = ['sidebar', 'menu', 'nav', 'banner', 'ad', 'footer', 'header', 'comment', 'share', 'related']
+                            for attr in ['class', 'id']:
+                                attr_val = block.get(attr, '')
+                                if attr_val:
+                                    if isinstance(attr_val, list):
+                                        attr_val = ' '.join(attr_val)
+                                    for indicator in boilerplate_indicators:
+                                        if indicator in attr_val.lower():
+                                            score -= 50
+                                            break
+                            
+                            # Add to content blocks if score is positive
+                            if score > 0:
+                                content_blocks.append({
+                                    'element': block,
+                                    'score': score,
+                                    'char_count': char_count,
+                                    'text': text
+                                })
+                    
+                    # Sort content blocks by score
+                    if content_blocks:
+                        content_blocks.sort(key=lambda x: x['score'], reverse=True)
+                        best_block = content_blocks[0]['element']
+                        
+                        # Clean up the best block
+                        for unwanted in best_block.find_all(['aside', 'nav', 'footer', 'header']):
+                            unwanted.decompose()
+                            
+                        extracted_content = best_block.get_text(separator=' ', strip=True)
                 
-                if text:
-                    if len(text) > max_chars:
-                        text = text[:max_chars] + "..."
-                    return text
+                # ---------- PARAGRAPH EXTRACTION FALLBACK ----------
+                if not extracted_content:
+                    # Get all paragraphs with substantial content
+                    paragraphs = []
+                    for p in processed_soup.find_all('p'):
+                        text = p.get_text(strip=True)
+                        if len(text) > 40:  # Only consider substantial paragraphs
+                            # Calculate link density
+                            link_density = calculate_link_density(p)
+                            if link_density < 0.25:  # Skip if too many links
+                                paragraphs.append(text)
+                    
+                    if paragraphs:
+                        extracted_content = ' '.join(paragraphs)
                 
+                # If we have content, clean it up
+                if extracted_content:
+                    # Clean whitespace
+                    extracted_content = re.sub(r'\s+', ' ', extracted_content).strip()
+                    
+                    # Remove URLs
+                    extracted_content = re.sub(r'https?://\S+', '', extracted_content)
+                    
+                    # Remove email addresses
+                    extracted_content = re.sub(r'\S+@\S+', '', extracted_content)
+                    
+                    # Remove social media handles
+                    extracted_content = re.sub(r'@\w+', '', extracted_content)
+                    
+                    # Replace multiple spaces with single space
+                    extracted_content = re.sub(r' +', ' ', extracted_content)
+                    
+                    # Normalize quotes and apostrophes
+                    extracted_content = extracted_content.replace('"', '"').replace('"', '"')
+                    extracted_content = extracted_content.replace("'", "'").replace("'", "'")
+                    
+                    # Remove any remaining HTML entities
+                    extracted_content = re.sub(r'&[a-zA-Z]+;', ' ', extracted_content)
+                    
+                    # Remove short lines that are likely navigation/menu items
+                    lines = extracted_content.split('\n')
+                    extracted_content = ' '.join([line for line in lines if len(line) > 40 or '.' in line])
+                    
+                    # Combine with meta description if available and content is short
+                    if meta_description and len(extracted_content) < 500:
+                        extracted_content = meta_description + " " + extracted_content
+                    
+                    # Truncate if needed
+                    if len(extracted_content) > max_chars:
+                        # Try to break at a sentence boundary
+                        cutoff_point = max_chars
+                        for i in range(max_chars - 1, max_chars - 300, -1):
+                            if i < len(extracted_content) and extracted_content[i] in ['.', '!', '?']:
+                                cutoff_point = i + 1
+                                break
+                        
+                        extracted_content = extracted_content[:cutoff_point]
+                    
+                    return extracted_content
+                else:
+                    # Return meta description if nothing else was found
+                    if meta_description:
+                        return meta_description
+                    
+                    logger.error(f"No content extracted from {url}")
+                    return None
             else:
                 logger.error(f"Request to {url} returned status code {response.status_code}")
-                
-        except ImportError:
-            logger.error("Trafilatura not installed. Install with 'pip install trafilatura'")
-            # Try direct requests only
-            try:
-                response = requests.get(url, headers=headers, timeout=10)
-                if response.status_code == 200:
-                    # Very basic HTML cleaning
-                    html_content = response.text
-                    text = re.sub(r'<[^>]+>', ' ', html_content)
-                    text = re.sub(r'\s+', ' ', text).strip()
-                    
-                    if text:
-                        if len(text) > max_chars:
-                            text = text[:max_chars] + "..."
-                        return text
-            except Exception as req_error:
-                logger.error(f"Direct request fallback failed: {str(req_error)}")
+                return None
                 
         except Exception as e:
-            logger.error(f"Error extracting content with trafilatura: {str(e)}")
-            # Try the requests fallback
+            logger.error(f"Error extracting content with hybrid approach: {str(e)}")
+            # Try a basic fallback
             try:
                 response = requests.get(url, headers=headers, timeout=10)
                 if response.status_code == 200:
-                    html_content = response.text
-                    text = re.sub(r'<[^>]+>', ' ', html_content)
+                    soup = BeautifulSoup(response.text, 'html.parser')
+                    # Just get the text without images, scripts, styles, etc.
+                    for tag in soup(['script', 'style', 'img', 'nav', 'footer', 'header']):
+                        tag.decompose()
+                    text = soup.get_text(separator=' ', strip=True)
                     text = re.sub(r'\s+', ' ', text).strip()
                     
                     if text:
@@ -164,14 +422,40 @@ def extract_article_content(url: str, max_chars: int = 2000) -> Optional[str]:
                             text = text[:max_chars] + "..."
                         return text
             except Exception as req_error:
-                logger.error(f"Direct request fallback failed: {str(req_error)}")
+                logger.error(f"Basic fallback failed: {str(req_error)}")
             
         return None
     except Exception as e:
         logger.error(f"Error extracting content from {url}: {str(e)}")
         return None
 
-def get_web_search_results(query: str, max_results: int = 3, max_chars_per_result: int = 2000) -> Dict[str, Any]:
+def calculate_link_density(element):
+    """
+    Calculate the ratio of link text to all text in an element.
+    Used to identify navigation-heavy areas.
+    
+    Args:
+        element: BeautifulSoup element
+        
+    Returns:
+        Float between 0 and 1 indicating link density
+    """
+    try:
+        if element is None:
+            return 0
+            
+        text_length = len(element.get_text(strip=True))
+        if text_length == 0:
+            return 0
+            
+        links = element.find_all('a')
+        link_text_length = sum(len(a.get_text(strip=True)) for a in links)
+        
+        return link_text_length / text_length
+    except Exception:
+        return 0
+
+def get_web_search_results(query: str, max_results: int = 5, max_chars_per_result: int = 5000) -> Dict[str, Any]:
     """
     Get formatted web search results ready to be included in AI prompts.
     

{ngpt-3.4.5.dist-info → ngpt-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 3.4.5
+Version: 3.5.0
 Summary: Swiss army knife for LLMs: powerful CLI and interactive chatbot in one package. Seamlessly work with OpenAI, Ollama, Groq, Claude, Gemini, or any OpenAI-compatible API to generate code, craft git commits, rewrite text, and execute shell commands.
 Project-URL: Homepage, https://github.com/nazdridoy/ngpt
 Project-URL: Repository, https://github.com/nazdridoy/ngpt
@@ -28,12 +28,12 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.8
+Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: duckduckgo-search>=3.0.0
 Requires-Dist: prompt-toolkit>=3.0.0
 Requires-Dist: pyperclip>=1.8.0
 Requires-Dist: requests>=2.31.0
 Requires-Dist: rich>=10.0.0
-Requires-Dist: trafilatura>=1.6.0
 Description-Content-Type: text/markdown
 
 # nGPT
@@ -62,10 +62,10 @@ Description-Content-Type: text/markdown
 
 - ✅ **Versatile**: Powerful and easy-to-use CLI tool for various AI tasks
 - 🪶 **Lightweight**: Minimal dependencies with everything you need included
-- 🔄 **API Flexibility**: Works with OpenAI, Ollama, Groq, Claude, Gemini, and any compatible endpoint
+- 🔄 **API Flexibility**: Works with OpenAI, Ollama, Groq, Claude, Gemini, and any OpenAI-compatible endpoint
 - 💬 **Interactive Chat**: Continuous conversation with memory in modern UI
 - 📊 **Streaming Responses**: Real-time output for better user experience
-- 🔍 **Web Search**: Enhance any model with contextual information from the web
+- 🔍 **Web Search**: Enhance any model with contextual information from the web, using advanced content extraction to identify the most relevant information from web pages
 - 📥 **Stdin Processing**: Process piped content by using `{}` placeholder in prompts
 - 🎨 **Markdown Rendering**: Beautiful formatting of markdown and code with syntax highlighting
 - ⚡ **Real-time Markdown**: Stream responses with live updating syntax highlighting and formatting
@@ -85,37 +85,47 @@ See the [Feature Overview](https://nazdridoy.github.io/ngpt/overview/) for more
 
 
 ## Table of Contents
-- [Quick Start](#quick-start)
 - [Features](#features)
-- [Documentation](#documentation)
 - [Installation](#installation)
+- [Quick Start](#quick-start)
 - [Usage](#usage)
+  - [Command Line Options](#command-line-options)
   - [Documentation](https://nazdridoy.github.io/ngpt/)
-  - [CLI Tool](#as-a-cli-tool)
+- [Documentation](#documentation)
 - [Configuration](#configuration)
-  - [Command Line Options](#command-line-options)
+  - [API Key Setup](#api-key-setup)
+  - [OpenAI API Key](#openai-api-key)
+  - [Google Gemini API Key](#google-gemini-api-key)
   - [CLI Configuration](#cli-configuration)
   - [Interactive Configuration](#interactive-configuration)
   - [Configuration File](#configuration-file)
   - [Configuration Priority](#configuration-priority)
-  - [API Key Setup](#api-key-setup)
-  - [OpenAI API Key](#openai-api-key)
-  - [Google Gemini API Key](#google-gemini-api-key)
 - [Contributing](#contributing)
 - [License](#license)
 
-## Quick Start
+## Installation
 
 ```bash
-# Install with pip
+# Installation with pip
 pip install ngpt
 
-# Or install with uv (faster)
+# Or install with uv (faster installation)
 uv pip install ngpt
 
-# Or install globally as a CLI tool (recommended)
+# Or install globally as a CLI tool (recommended for command-line usage)
 uv tool install ngpt
 
+# Arch Linux: install from AUR
+paru -S ngpt
+```
+
+Requires Python 3.8 or newer.
+
+For detailed installation instructions, see the [Installation Guide](https://nazdridoy.github.io/ngpt/installation/).
+
+## Quick Start
+
+```bash
 # Chat with default settings
 ngpt "Tell me about quantum computing"
 
@@ -200,58 +210,6 @@ ngpt --provider Groq "Explain quantum computing"
 # Compare outputs from different providers
 ngpt --provider OpenAI "Explain quantum physics" > openai_response.txt
 ngpt --provider Ollama "Explain quantum physics" > ollama_response.txt
-```
-
-For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage/).
-
-## Documentation
-
-Comprehensive documentation, including usage guides and examples, is available at:
-
-**[https://nazdridoy.github.io/ngpt/](https://nazdridoy.github.io/ngpt/)**
-
-Key documentation sections:
-- [Installation Guide](https://nazdridoy.github.io/ngpt/installation/)
-- [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage/)
-- [Configuration Guide](https://nazdridoy.github.io/ngpt/configuration/)
-- [Examples & Tutorials](https://nazdridoy.github.io/ngpt/examples/basic/)
-
-## Installation
-
-```bash
-# Installation with pip
-pip install ngpt
-
-# Or install with uv (faster installation)
-uv pip install ngpt
-
-# Or install globally as a CLI tool (recommended for command-line usage)
-uv tool install ngpt
-
-# Arch Linux: install from AUR
-paru -S ngpt
-```
-
-Requires Python 3.8 or newer.
-
-For detailed installation instructions, see the [Installation Guide](https://nazdridoy.github.io/ngpt/installation/).
-
-## Usage
-
-### As a CLI Tool
-
-```bash
-# Basic chat (default mode)
-ngpt "Hello, how are you?"
-
-# Interactive chat session with conversation history
-ngpt -i
-
-# Log conversation to a file
-ngpt --interactive --log conversation.log
-
-# Use custom system prompt to guide AI behavior
-ngpt --preprompt "You are a Python programming tutor" "Explain decorators"
 
 # Show all API configurations
 ngpt --show-config --all
@@ -277,47 +235,16 @@ ngpt -s "list all files in current directory"
 # On Windows generates: dir
 # On Linux/macOS generates: ls -la
 
-# Generate clean code (using -c or --code flag)
-# Returns only code without markdown formatting or explanations
+# Generate code (using -c or --code flag)
 ngpt -c "create a python function that calculates fibonacci numbers"
 
 # Use multiline text editor for complex prompts (using -t or --text flag)
-# Opens an interactive editor with syntax highlighting and intuitive controls
 ngpt -t
 ```
 
-For more CLI examples and detailed usage information, see the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage/).
-
-## Configuration
-
-### API Key Setup
-
-#### OpenAI API Key
-1. Create an account at [OpenAI](https://platform.openai.com/)
-2. Navigate to API keys: https://platform.openai.com/api-keys
-3. Click "Create new secret key" and copy your API key
-4. Configure nGPT with your key:
-   ```bash
-   ngpt --config
-   # Enter provider: OpenAI
-   # Enter API key: your-openai-api-key
-   # Enter base URL: https://api.openai.com/v1/
-   # Enter model: gpt-3.5-turbo (or other model)
-   ```
+For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage/).
 
-#### Google Gemini API Key
-1. Create or use an existing Google account
-2. Go to [Google AI Studio](https://aistudio.google.com/)
-3. Navigate to API keys in the left sidebar (or visit https://aistudio.google.com/app/apikey)
-4. Create an API key and copy it
-5. Configure nGPT with your key:
-   ```bash
-   ngpt --config
-   # Enter provider: Gemini
-   # Enter API key: your-gemini-api-key
-   # Enter base URL: https://generativelanguage.googleapis.com/v1beta/openai
-   # Enter model: gemini-2.0-flash
-   ```
+## Usage
 
 ### Command Line Options
 
@@ -326,8 +253,8 @@ For more CLI examples and detailed usage information, see the [CLI Usage Guide](
 usage: ngpt [-h] [-v] [--language LANGUAGE] [--config [CONFIG]] [--config-index CONFIG_INDEX] [--provider PROVIDER]
             [--remove] [--show-config] [--all] [--list-models] [--list-renderers] [--cli-config [COMMAND ...]]
             [--api-key API_KEY] [--base-url BASE_URL] [--model MODEL] [--web-search] [--temperature TEMPERATURE]
-            [--top_p TOP_P] [--max_tokens MAX_TOKENS] [--log [FILE]] [--preprompt PREPROMPT] [--no-stream] [--prettify]
-            [--stream-prettify] [--renderer {auto,rich,glow}] [--rec-chunk] [--diff [FILE]] [--chunk-size CHUNK_SIZE]
+            [--top_p TOP_P] [--max_tokens MAX_TOKENS] [--log [FILE]] [--preprompt PREPROMPT] [--no-stream | --prettify |
+            --stream-prettify] [--renderer {auto,rich,glow}] [--rec-chunk] [--diff [FILE]] [--chunk-size CHUNK_SIZE]
             [--analyses-chunk-size ANALYSES_CHUNK_SIZE] [--max-msg-lines MAX_MSG_LINES]
             [--max-recursion-depth MAX_RECURSION_DEPTH] [-i | -s | -c | -t | -p | -r | -g]
             [prompt]
@@ -346,12 +273,10 @@ options::
 
 Configuration Options::
 
---config [CONFIG]                   Path to a custom config file or, if no value provided, enter interactive
-                                    configuration mode to create a new config
+--config [CONFIG]                   Path to a custom config file or, if no value provided, enter interactive configuration mode to create a new config
 --config-index CONFIG_INDEX         Index of the configuration to use or edit (default: 0)
 --provider PROVIDER                 Provider name to identify the configuration to use
---remove                            Remove the configuration at the specified index (requires --config and
-                                    --config-index or --provider)
+--remove                            Remove the configuration at the specified index (requires --config and --config-index or --provider)
 --show-config                       Show the current configuration(s) and exit
 --all                               Show details for all configurations (requires --show-config)
 --list-models                       List all available models for the current configuration and exit
@@ -363,30 +288,28 @@ Global Options::
 --api-key API_KEY                   API key for the service
 --base-url BASE_URL                 Base URL for the API
 --model MODEL                       Model to use
---web-search                        Enable web search capability (Note: Your API endpoint must support this
-                                    feature)
+--web-search                        Enable web search capability using DuckDuckGo to enhance prompts with relevant information
 --temperature TEMPERATURE           Set temperature (controls randomness, default: 0.7)
 --top_p TOP_P                       Set top_p (controls diversity, default: 1.0)
 --max_tokens MAX_TOKENS             Set max response length in tokens
---log [FILE]                        Set filepath to log conversation to, or create a temporary log file if no path
-                                    provided
+--log [FILE]                        Set filepath to log conversation to, or create a temporary log file if no path provided
 --preprompt PREPROMPT               Set custom system prompt to control AI behavior
---no-stream                         Return the whole response without streaming
---prettify                          Render markdown responses and code with syntax highlighting and formatting
---stream-prettify                   Enable streaming with markdown rendering (automatically uses Rich renderer)
---renderer {auto,rich,glow}         Select which markdown renderer to use with --prettify (auto, rich, or glow)
+--renderer {auto,rich,glow}         Select which markdown renderer to use with --prettify or --stream-prettify (auto, rich, or glow)
+
+Output Display Options (mutually exclusive)::
+
+--no-stream                         Return the whole response without streaming or formatting
+--prettify                          Render complete response with markdown and code formatting (non-streaming)
+--stream-prettify                   Stream response with real-time markdown rendering (default)
 
 Git Commit Message Options::
 
 --rec-chunk                         Process large diffs in chunks with recursive analysis if needed
---diff [FILE]                       Use diff from specified file instead of staged changes. If used without a path,
-                                    uses the path from CLI config.
+--diff [FILE]                       Use diff from specified file instead of staged changes. If used without a path, uses the path from CLI config.
 --chunk-size CHUNK_SIZE             Number of lines per chunk when chunking is enabled (default: 200)
---analyses-chunk-size ANALYSES_CHUNK_SIZE
-                                    Number of lines per chunk when recursively chunking analyses (default: 200)
+--analyses-chunk-size ANALYSES_CHUNK_SIZE Number of lines per chunk when recursively chunking analyses (default: 200)
 --max-msg-lines MAX_MSG_LINES       Maximum number of lines in commit message before condensing (default: 20)
---max-recursion-depth MAX_RECURSION_DEPTH
-                                    Maximum recursion depth for commit message condensing (default: 3)
+--max-recursion-depth MAX_RECURSION_DEPTH Maximum recursion depth for commit message condensing (default: 3)
 
 Modes (mutually exclusive)::
 
@@ -394,15 +317,62 @@ Modes (mutually exclusive)::
 -s, --shell                         Generate and execute shell commands
 -c, --code                          Generate code
 -t, --text                          Enter multi-line text input (submit with Ctrl+D)
--p, --pipe                          Read from stdin and use content with prompt. Use {} in prompt as placeholder
-                                    for stdin content
+-p, --pipe                          Read from stdin and use content with prompt. Use {} in prompt as placeholder for stdin content
 -r, --rewrite                       Rewrite text from stdin to be more natural while preserving tone and meaning
 -g, --gitcommsg                     Generate AI-powered git commit messages from staged changes or diff file
 ```
 
 > **Note**: For better visualization of conventional commit messages on GitHub, you can use the [GitHub Commit Labels](https://greasyfork.org/en/scripts/526153-github-commit-labels) userscript, which adds colorful labels to your commits.
 
-For a complete reference of all available options, see the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage/).
+For a complete reference of all available options, detailed CLI examples and usage information, see the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage/).
+
+
+## Documentation
+
+Comprehensive documentation, including usage guides and examples, is available at:
+
+**[https://nazdridoy.github.io/ngpt/](https://nazdridoy.github.io/ngpt/)**
+
+Key documentation sections:
+- [Installation Guide](https://nazdridoy.github.io/ngpt/installation/)
+- [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage/)
+- [Configuration Guide](https://nazdridoy.github.io/ngpt/configuration/)
+- [Examples & Tutorials](https://nazdridoy.github.io/ngpt/examples/basic/)
+- [Git Commit Message Guide](https://nazdridoy.github.io/ngpt/usage/gitcommsg/)
+
+
+## Configuration
+
+### API Key Setup
+
+#### OpenAI API Key
+1. Create an account at [OpenAI](https://platform.openai.com/)
+2. Navigate to API keys: https://platform.openai.com/api-keys
+3. Click "Create new secret key" and copy your API key
+4. Configure nGPT with your key:
+   ```bash
+   ngpt --config
+   # Enter provider: OpenAI
+   # Enter API key: your-openai-api-key
+   # Enter base URL: https://api.openai.com/v1/
+   # Enter model: gpt-3.5-turbo (or other model)
+   ```
+
+#### Google Gemini API Key
+1. Create or use an existing Google account
+2. Go to [Google AI Studio](https://aistudio.google.com/)
+3. Navigate to API keys in the left sidebar (or visit https://aistudio.google.com/app/apikey)
+4. Create an API key and copy it
+5. Configure nGPT with your key:
+   ```bash
+   ngpt --config
+   # Enter provider: Gemini
+   # Enter API key: your-gemini-api-key
+   # Enter base URL: https://generativelanguage.googleapis.com/v1beta/openai
+   # Enter model: gemini-2.0-flash
+   ```
+
+For more detailed information, refer to the [API Key Setup documentation](https://nazdridoy.github.io/ngpt/configuration/#api-key-setup).
 
 ### CLI Configuration
 

{ngpt-3.4.5.dist-info → ngpt-3.5.0.dist-info}/RECORD

@@ -20,9 +20,9 @@ ngpt/utils/__init__.py,sha256=qu_66I1Vtav2f1LDiPn5J3DUsbK7o1CSScMcTkYqxoM,1179
 ngpt/utils/cli_config.py,sha256=Ug8cECBTIuzOwkBWidLTfs-OAdOsCMJ2bNa70pOADfw,11195
 ngpt/utils/config.py,sha256=wsArA4osnh8fKqOvtsPqqBxAz3DpdjtaWUFaRtnUdyc,10452
 ngpt/utils/log.py,sha256=f1jg2iFo35PAmsarH8FVL_62plq4VXH0Mu2QiP6RJGw,15934
-ngpt/utils/web_search.py,sha256=yvCUDNhwcIcKZ_hWESFQQ-vB-LKsDDCDT17YFzFcGR4,12598
-ngpt-3.4.5.dist-info/METADATA,sha256=ofAuga74DmRxU0xIJ_FNHMYIEu-wAzVZPpjpiKwPHqw,24585
-ngpt-3.4.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ngpt-3.4.5.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
-ngpt-3.4.5.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
-ngpt-3.4.5.dist-info/RECORD,,
+ngpt/utils/web_search.py,sha256=_e78fk-6WDVqHDIaAMP9CDoX4FyOWM9XhdSZcr5KasI,29163
+ngpt-3.5.0.dist-info/METADATA,sha256=BEcmK1bv4EZ_Q6W7MDnDPo304e-_L0zk1bDgH4mmp8Q,23926
+ngpt-3.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-3.5.0.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
+ngpt-3.5.0.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-3.5.0.dist-info/RECORD,,