pop-python 1.0.0__py3-none-any.whl → 1.0.3__py3-none-any.whl

POP/POP.py

@@ -0,0 +1,392 @@
+import re
+import json
+import requests
+from dotenv import load_dotenv
+from os import getenv, path
+from .LLMClient import LLMClient, OpenAIClient, GeminiClient, DeepseekClient, LocalPyTorchClient, DoubaoClient, OllamaClient
+
+# Load environment variables
+load_dotenv()
+default_model = {
+    "OpenAIClient": "gpt-5-nano",
+    "GeminiClient": "gemini-2.5-flash",
+    "DeepseekClient": "deepseek-chat",
+    "DoubaoClient": "doubao-seed-1-6-flash-250715",
+    "OllamaClient": "mistral:7b",
+}
+client_map = {
+            "openai": OpenAIClient,
+            "gemini": GeminiClient,
+            "local": LocalPyTorchClient,
+            "deepseek": DeepseekClient,
+            "doubao": DoubaoClient,
+            "ollama": OllamaClient
+        }
+
+##############################################
+# PromptFunction Class
+##############################################
+
+class PromptFunction:
+    """
+    A class representing a reusable prompt function.
+    """
+    def __init__(self, 
+                 sys_prompt: str = "", 
+                 prompt: str = "",
+                 client: LLMClient | str = None):
+        """
+        Initializes a new prompt function.
+        
+        Args:
+            prompt (str): The base prompt template.
+            sys_prompt (str): The system prompt for additional context.
+            client (LLMClient | str): An instance of an LLM client or a string identifier. Defaults to OpenAIClient. ("openai", "gemini", "local", "deepseek")
+        """
+        self.prompt = prompt
+        self.sys_prompt = sys_prompt
+        self.placeholders = self._get_place_holder()
+        self.client = None
+        
+        if isinstance(client, LLMClient):
+            self.client = client
+        elif isinstance(client, str):
+            self.client = client_map.get(client, None)
+            if self.client:
+                self.client = self.client() # instantiate LLMClient if user passed a string
+
+        # gpt-5/mini/nano only supports temperature 1
+        self.temperature = 1 if self.client.__class__.__name__ == "OpenAIClient" and default_model[self.client.__class__.__name__] in ["gpt-5-nano", "gpt-5-mini", "gpt-5"] else 0.0
+        self.last_response = None
+        self.default_model_name = default_model[self.client.__class__.__name__]
+        print(f"[PromptFunction] Using client: {self.client.__class__.__name__}, default model: {self.default_model_name}")
+
+    def execute(self, *args, **kwargs) -> str:
+        """
+        Executes the prompt function with dynamic argument injection.
+        
+        Special keys in kwargs:
+            - model: Model name (defaults to self.default_model_name).
+            - sys: Additional system instructions.
+            - fmt: Response format/schema.
+            - tools: List of function tools to use (for function calling).
+            - temp: Temperature.
+            - ADD_BEFORE: Text to prepend.
+            - ADD_AFTER: Text to append.
+        
+        Args:
+            *args: Positional arguments to add to the prompt.
+            **kwargs: Keyword arguments for placeholder replacement or extra context.
+        
+        Returns:
+            str: The LLM-generated response.
+        """
+        model = kwargs.pop("model", self.default_model_name)
+        system_extra = kwargs.pop("sys", "")
+        fmt = kwargs.pop("fmt", None)
+        tools = kwargs.pop("tools", None)
+        temp = kwargs.pop("temp", self.temperature)
+        images = kwargs.pop("images", None)
+
+        # Prepare the prompt with dynamic injections.
+        formatted_prompt = self._prepare_prompt(*args, **kwargs)
+
+        # Build the message payload.
+        system_message = {
+            "role": "system",
+            "content": (
+                f"You are a general-purpose helpful assistant that is responsible for executing Prompt Functions, you will receive instructions and return as ordered. "
+                f"Since your return is expected to be read by code most of the time, DO NOT wrap your returns in '```' tags unless user explicitly asks for markdown or similar format. "
+                f"Base system prompt:\n{self.sys_prompt}\n\n"
+                f"Additional instructions:\n{system_extra}"
+            )
+        }
+        user_message = {"role": "user", "content": f"<if no user message, check system prompt.> {formatted_prompt}"}
+        messages = [system_message, user_message]
+
+        try:
+            # Call the LLM client.
+            raw_response = self.client.chat_completion(
+                messages=messages, 
+                model=model, 
+                temperature=temp, 
+                response_format=fmt,
+                tools=tools,
+                images=images
+            )
+        except Exception as e:
+            verbose = True
+            if verbose:
+                print(f"Error occurred while executing prompt function: {e}\nparameters:\nmodel: {model}\ntemperature: {temp}\nprompt: {formatted_prompt}\nsys: {system_extra}\nformat: {fmt}\ntools: {tools}\nimages: {images}")
+            # raise RuntimeError(f"Error occurred while executing prompt function: {e}\n")
+            print(f"Error occurred while executing prompt function: {e}\n")
+            return ""
+
+        # Save entire response
+        self.last_response = raw_response
+
+        # default to message content
+        reply_content = raw_response.choices[0].message.content
+
+        # if it is a function call, extract the arguments
+        if raw_response.choices[0].message.tool_calls:
+            tool_call = raw_response.choices[0].message.tool_calls[0]
+            reply_content = tool_call.function.arguments
+
+        return reply_content
+
+    def _prepare_prompt(self, *args, **kwargs) -> str:
+        """
+        Prepares the prompt by injecting dynamic arguments into placeholders.
+        Special keys: "ADD_BEFORE" and "ADD_AFTER".
+        """
+        before = kwargs.pop("ADD_BEFORE", "")
+        after = kwargs.pop("ADD_AFTER", "")
+
+        # Start with the base prompt. If empty, fallback to sys_prompt or join args.
+        prompt = self.prompt
+        if not prompt:
+            if self.sys_prompt: # In the case of sys_prompt provided, construct prompt from user input
+                prompt = "User instruction:"
+                if kwargs:
+                    prompt += "\n" + "\n".join(f"{k}: {v}" for k, v in kwargs.items())
+            else:
+                raise ValueError("No prompt or system prompt provided.")
+                
+        # Append any positional arguments
+        if args:
+            prompt = prompt + "\n" + "\n".join(args)
+
+        # Replace placeholders detected in the prompt (not system prompt).
+        for placeholder in self.placeholders:
+            if placeholder in kwargs:
+                prompt = prompt.replace(f"<<<{placeholder}>>>", str(kwargs.pop(placeholder)))
+        
+        # Second pass: Replace any remaining kwargs.
+        for key, value in kwargs.items():
+            prompt = prompt.replace(f"<<<{key}>>>", str(value))
+        
+        # Prepend or append additional text if provided.
+        if before:
+            prompt = before + "\n" + prompt
+        if after:
+            prompt = prompt + "\n" + after
+
+
+        return prompt
+
+    def _improve_prompt(self, replace: bool = False, use_prompt: str = "fabric", instruction: str = None, user_instruction: str = None) -> str:
+        """
+        Improves the prompt using a metaprompt.
+        
+        Args:
+            replace (bool): Whether to replace the existing prompt.
+            use_prompt (str): Identifier for which metaprompt to use.
+            instruction (str): Custom instruction if provided.
+            user_instruction (str): Additional user instruction.
+        
+        Returns:
+            str: The improved prompt.
+        """
+        if use_prompt == "fabric":
+            # Dynamically build an absolute path based on where POP.py is located
+            current_dir = path.dirname(path.abspath(__file__)) ## __file__ refers to the current file
+            file = path.join(current_dir, "prompts", "fabric-improve_prompt.md")
+
+            try:
+                with open(file, 'r', encoding='utf-8') as f:
+                    instruction = f.read()
+            except FileNotFoundError:
+                raise FileNotFoundError(f"File not found: {file}")
+
+        meta_instruction = (
+            f"\nAdditional instruction:\n{user_instruction}\n"
+            "Ensure that original placeholders (<<<placeholder>>>) are preserved in the improved prompt and placed in a clear position."
+            "do not use any '<<<'  or '>>>' in the improved prompt other than the original placeholder, and you have to show the placehold in the exact same order and amount of times as in the original prompt."
+        )
+        
+        improved_prompt = self.execute(ADD_BEFORE=meta_instruction, 
+                                       model="gpt-5", 
+                                       sys=f"You are asked to improve the above 'Base system prompt' using the following instruction:\n{instruction}")
+        
+        if use_prompt == "fabric":
+            improved_prompt = improved_prompt.split("# OUTPUT\n\n")[-1]
+        
+        if replace:
+            self.sys_prompt = improved_prompt
+        return improved_prompt
+
+    def set_temperature(self, temperature: float) -> None:
+        """
+        Sets the temperature for the LLM.
+        """
+        self.temperature = temperature
+
+    def save(self, file_path: str) -> None:
+        """
+        Saves the prompt to a file.
+        """
+        with open(file_path, "w", encoding='utf-8') as file:
+            file.write(self.prompt)
+
+    def _get_place_holder(self) -> list:
+        """
+        Extracts placeholders (of the format <<<placeholder>>>) from the prompt or system prompt.
+        """
+        target_text = self.prompt if self.prompt else self.sys_prompt
+        if not target_text:
+            print("No prompt or system prompt provided.")
+            return []
+        placeholders = re.findall(r"<<<(.*?)>>>", target_text)
+        if placeholders:
+            print("Placeholders found:", placeholders)
+        else:
+            print("No placeholders found.")
+        return placeholders
+
+    def generate_schema(self, 
+                        description: str = None,
+                        meta_prompt: str = None,
+                        meta_schema: dict = None,
+                        model: str = "gpt-5-mini",
+                        save: bool = True
+                       ) -> dict:
+        """
+        Instance method to generate a function schema from a natural language description
+        using the PromptFunction's prompt if no explicit description is given.
+        Also stores the generated schema to functions/ by default.
+
+        Args:
+            description (str): What the function should do.
+            meta_prompt (str): Optionally override the meta prompt, path to file.
+            meta_schema (dict): Optionally override the meta schema, path to file.
+            model (str): Which model to use.
+            save (bool): whether to store to functions/ directory
+
+        Returns:
+            dict: A valid OpenAI function tool schema.
+        """
+
+        # fallback to self.prompt if no description
+        if not description:
+            if self.prompt:
+                description = self.prompt
+            else:
+                raise ValueError(
+                    "Description or instance prompt must be provided to generate a function schema."
+                )
+        print(description)
+        # fallback meta prompt from file
+        if meta_prompt is None:
+            try:
+                meta_prompt = PromptFunction.load_prompt(
+                    "prompts/openai-json_schema_generator.md"
+                )
+            except FileNotFoundError:
+                raise FileNotFoundError(
+                    "Meta prompt file 'prompts/openai-json_schema_generator.md' not found. "
+                    "Either place it there or pass meta_prompt manually."
+                )
+        else:
+            meta_prompt = PromptFunction.load_prompt(meta_prompt)
+
+        # fallback meta schema from file
+        if meta_schema is None:
+            pass
+        else:   
+            with open(meta_schema, "r", encoding="utf-8") as f:
+                meta_schema = json.load(f)
+
+        completion = self.client.chat_completion(
+            model=model,
+            response_format=meta_schema,
+            temperature=self.temperature,
+            messages=[
+                {
+                    "role": "system",
+                    "content": meta_prompt,
+                },
+                {
+                    "role": "user",
+                    "content": "Description:\n" + description,
+                },
+            ],
+        )
+        parsed_schema = json.loads(completion.choices[0].message.content)
+
+        # store to disk if requested
+        if save:
+            import os
+            os.makedirs("schemas", exist_ok=True)
+            
+            prompts_name = parsed_schema["name"] if "name" in parsed_schema else "generated_schema"
+            safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", prompts_name)
+            file_path = os.path.join("schemas", f"{safe_name}.json")
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(parsed_schema, f, indent=2)
+            print(f"[generate_schema] Function schema saved to {file_path}")
+
+        return parsed_schema
+
+    @staticmethod
+    def load_prompt(file: str) -> str:
+        """
+        Loads a prompt from a file.
+        """
+        with open(file, 'r', encoding='utf-8') as f:
+            return f.read()
+
+##############################################
+# Utility Function
+##############################################
+
+def get_text_snapshot(web_url: str, 
+                      use_api_key: bool = True, 
+                      return_format: str = "default", 
+                      timeout: int = 0, 
+                      target_selector: list = None, 
+                      wait_for_selector: list = None, 
+                      exclude_selector: list = None, 
+                      remove_image: bool = False, 
+                      links_at_end: bool = False, 
+                      images_at_end: bool = False, 
+                      json_response: bool = False, 
+                      image_caption: bool = False,
+                      cookie: str = None) -> str:
+    """
+    Fetch a text snapshot of the webpage using r.jina.ai.
+    """
+    target_selector = target_selector or []
+    wait_for_selector = wait_for_selector or []
+    exclude_selector = exclude_selector or []
+
+    headers = {}
+    api_key = 'Bearer ' + getenv("JINAAI_API_KEY") if use_api_key else None
+
+    header_values = {
+        "Authorization": api_key,
+        "X-Return-Format": None if return_format == "default" else return_format,
+        "X-Timeout": timeout if timeout > 0 else None,
+        "X-Target-Selector": ",".join(target_selector) if target_selector else None,
+        "X-Wait-For-Selector": ",".join(wait_for_selector) if wait_for_selector else None,
+        "X-Remove-Selector": ",".join(exclude_selector) if exclude_selector else None,
+        "X-Retain-Images": "none" if remove_image else None,
+        "X-With-Links-Summary": "true" if links_at_end else None,
+        "X-With-Images-Summary": "true" if images_at_end else None,
+        "Accept": "application/json" if json_response else None,
+        "X-With-Generated-Alt": "true" if image_caption else None,
+        "X-Set-Cookie": cookie if cookie else None
+    }
+
+    for key, value in header_values.items():
+        if value is not None:
+            headers[key] = value
+
+    try:
+        api_url = f"https://r.jina.ai/{web_url}"
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+        return response.text
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching text snapshot: {e}"

POP/__init__.py

@@ -0,0 +1,22 @@
+from .POP import PromptFunction, get_text_snapshot
+from .Embedder import Embedder
+from .LLMClient import (
+    LLMClient,
+    OpenAIClient,
+    GeminiClient,
+    DeepseekClient,
+    LocalPyTorchClient,
+    DoubaoClient,
+)
+
+__all__ = [
+    "PromptFunction",
+    "get_text_snapshot",    
+    "Embedder",
+    "LLMClient",
+    "OpenAIClient",
+    "GeminiClient",
+    "DeepseekClient",
+    "LocalPyTorchClient",
+    "DoubaoClient",
+]

POP/prompts/2024-11-19-content_finder.md

@@ -0,0 +1,46 @@
+```markdown
+
+Given a webpage URL, your task is to analyze its content and identify categories that are relevant for bedtime stories. Follow these instructions carefully:
+0. First focus on all the urls in the given snapshot. Choose those which corresponding to stories.
+
+1. **Extract Categories**: Look for content on the webpage that fits into common bedtime story themes.
+
+2. **Criteria for Selection**:
+   - The categories must be well-suited for bedtime reading to children.
+   - Each category should be broad enough to encompass multiple stories but specific enough to offer a clear theme or genre.
+   - The categories must be present in the website (i.e. need a url to access it)
+   - The url for each category should lead to a page of stories of that kind.
+   - It's usual for a website to have only 1 or 2 categories of story
+   - Some story website group stories by their audience's age, this can also work if no better choice (e.g. age 1-3, age 3-10, etc.)
+
+3. **Handling Unsuitable Content**:
+   - If the webpage content does not align with bedtime story themes or contains very few relevant stories, classify it as unsuitable.
+   - For webpages with no suitable content, use the response format: `{"error": "Refused: No suitable bedtime stories found."}`
+
+4. **Error Handling**:
+   - If the webpage URL is invalid or the content is inaccessible, provide an appropriate error message in the response.
+   - Make sure that you **do not** make up such urls, it must be on the websnap (very important).
+
+5. **Output Format**:
+   - Present your findings in a JSON object format.
+   - The key should be `categories`, followed by a list of identified categories relevant to bedtime stories.
+   - Ensure the output is clean, with categories listed clearly and concisely.
+
+**Example Output for a Suitable Webpage**:
+
+```json
+{
+    "categories": {"Fairy Tales": "url to page", "Fables": "url to page", "Mythology": "url to page"}
+}
+```
+
+**Example Output for an Unsuitable Webpage**:
+
+```json
+{
+    "error": "Refused: No suitable bedtime stories found."
+}
+```
+
+Remember, your analysis should focus on identifying themes that will captivate and engage young listeners at bedtime, ensuring a delightful and imaginative end to their day.
+```

POP/prompts/2024-11-19-get_content.md

@@ -0,0 +1,71 @@
+### Enhanced AI Prompt for Story Extraction from Webpage Snapshots
+
+**System Instructions:**
+You are an advanced assistant tasked with extracting the core narrative content from webpage snapshots. Your input will be a textual snapshot of a webpage. Your goal is to meticulously identify and return the main story in a structured, clean format, while systematically ignoring extraneous sections such as advertisements, navigation links, or user comments. Specifically, you are to extract the title, author (when available), the main body of the story adhering to the structure provided below. Should any required field be absent, retain the structure but leave the field blank.
+
+**Desired Output Structure:**
+```json
+{
+  "title": "[Identify and insert the story's title here, if discernible.]",
+  "author": "[Insert the author's name here, if specified.]",
+  "content": "[Extract and format the main story text here, ensuring it is presented in clear paragraphs.]",
+}
+```
+
+
+### Detailed Guidelines:
+1. **Title Extraction:**  
+   Pinpoint and extract the most dominant heading (typically marked as `<h1>` in HTML) as the story's title.
+
+2. **Author Identification:**  
+   Search for explicit mentions of the author's name, often indicated by "By [Author Name]" or contained within metadata elements.
+
+3. **Main Story Content:**  
+   Concentrate on extracting the primary coherent text block, excluding standard sections like headers, footers, or "related articles" links.
+
+4. **Precision in Parsing:**  
+   Employ robust parsing techniques to ensure the exclusion of irrelevant content (e.g., ads, comments) from the `story` field, maintaining focus on the narrative content.
+
+---
+
+**Enhanced System Instructions for AI Processing:**
+Upon receiving a webpage snapshot, your objectives are:
+1. Accurately identify and extract the title of the story, if it is explicitly mentioned.
+2. Locate and extract the author's name if it is clearly stated.
+3. Diligently extract the main story content, ensuring it is devoid of unrelated elements such as advertisements or user comments.
+4. If you decide this page doesn't actually contains stories, return empty str.
+
+Format your findings into a JSON object as follows:
+```json
+{
+  "title": "[Identify and insert the story's title here, if discernible.]",
+  "author": "[Insert the author's name here, if specified.]",
+  "content": "[Extract and format the main story text here, ensuring it is presented in clear paragraphs.]",
+}
+
+Ensure accuracy by omitting fields that lack clear data. Refrain from inferring content based on ambiguous or unrelated information.
+
+**Example User Input:**
+```
+Title: The Brave Little Tailor
+By: Brothers Grimm
+
+Once upon a time, a tailor was eating jam on toast by his window when a swarm of flies landed on it. He swatted them with his cloth, killing seven at once. Overjoyed, he made a belt reading "Seven at one blow."...
+
+Related Stories:
+- The Frog Prince
+- Hansel and Gretel
+```
+
+**Expected Refined Output:**
+```json
+{
+  "title": "The Brave Little Tailor",
+  "author": "Brothers Grimm",
+  "content": "Once upon a time, a tailor was eating jam on toast by his window when a swarm of flies landed on it. He swatted them with his cloth, killing seven at once. Overjoyed, he made a belt reading 'Seven at one blow.'...",
+}
+
+
+## fetch next page
+Although **unlikely**, sometimes stories can be across multiple pages. If you checked the page and decide there's more of this story on next pages, store it in the next_page key. Other wise just leave it blank.
+```

POP/prompts/2024-11-19-get_title_and_url.md

@@ -0,0 +1,62 @@
+```markdown
+# Extracting Bedtime Stories and URLs from Webpage Text
+
+## Goal
+To accurately extract and organize bedtime story information from a given text version of a webpage, focusing on the story titles and their corresponding URLs, including the URL for the next page if available.
+
+## Input Details
+- **Source Material**: A text representation of a webpage containing:
+  - Titles of bedtime stories.
+  - The original URLs for these stories.
+  - URLs to additional pages (e.g., "page 1", "page 2", or "next page"), if present.
+- **Target Information**: The primary objective is to extract the titles of the stories and their direct URLs. Additionally, capture the URL for the next page when applicable.
+
+## Extraction Guidelines
+1. **Title and URL**:
+   - Isolate and retrieve only the titles of stories and their respective URLs, excluding any site navigation elements, advertisements, or non-relevant content.
+   - Trim any superfluous whitespace surrounding the titles or URLs.
+   - Make sure ALL of the URL and titles except those in ads or recommendation fields are obtained.
+
+2. **Guide line for locating next page**:
+   - Identify and include the URL for the next page of stories, if such exists. Usually those are corresponding to a number (2,3,4,etc) or some text such as "next page". **Do not** choose from other source instead of leaving it blank.
+   - **Don't return any urls that is not present in the text snapshot given you. **
+   - Look for hint for the last page, such as: no next page, and there's no url for any page number larger than the current page. if so return empty str
+
+3. **Handling Exceptions**:
+   - Should the text lack identifiable story titles, return a specific error message: `"Refused: No suitable bedtime stories found."`
+   - Bypass any story URLs that redirect incorrectly (e.g., back to the homepage) instead of to the actual story content.
+
+4. **Output Presentation**:
+   - Format the extracted data as a JSON object.
+   - Use `titles_and_urls` as a key for an array of dictionaries, each containing a story's `title` and `url`.
+   - Maintain clarity and conciseness in listing titles and URLs.
+   - Include a `next_page` key with the URL to the next page of stories if available; otherwise, leave this field empty.
+   - make sure the url to next page is actually links to next page. 
+
+**Example Output for Valid Webpage Content**:
+
+```json
+{
+  "titles_and_urls": [
+    {
+      "title": "Cinderella (Classic)",
+      "url": "https://storiestogrowby.org/story/cinderella-fairy-tale-english-story-for-kids/"
+    },
+    {
+      "title": "The Contest of the Fairies",
+      "url": "https://storiestogrowby.org/story/rosanella-contest-fairies/"
+    }
+    // Additional stories here
+  ],
+  "next_page": ""
+}
+```
+
+**Example Output for Invalid Webpage Content**:
+
+```json
+{
+    "error": "Refused: No suitable bedtime stories found."
+}
+```
+```

POP/prompts/CLI_AI_helper.md

@@ -0,0 +1,75 @@
+# Guide to Building an Effective CLI AI Assistant
+
+## 1. Purpose Clarity
+- **Define Capabilities**: Clearly outline the assistant's abilities and limitations.
+- **Help Messages**: Offer concise, informative help messages via `--help` or `-h`.
+- **Avoid Ambiguity**: Ensure outputs are clear and unambiguous.
+
+## 2. User-Friendly Interface
+- **Simplicity**: Maintain a simple, intuitive interface.
+- **Natural Commands**: Use natural language for commands and options.
+  - **Example**: `ask_GPT -f file.txt "Analyze this code"` instead of complex syntax.
+- **Usage Examples**: Include examples in help messages for typical use cases.
+
+## 3. Error Handling
+- **Input Validation**: Check inputs and provide clear error messages.
+  - **Example**: For invalid file paths, return: "Error: File not found. Please verify the path."
+- **Stability**: Prevent crashes from invalid commands or inputs.
+
+## 4. Flexibility
+- **Input Variability**: Accept text queries, file inputs, and stdin reading (e.g., `cat file.txt | ask_GPT`).
+- **Configuration Options**: Support settings through environment variables or command-line arguments.
+
+## 5. Responsiveness
+- **Quick Feedback**: Minimize response times.
+- **Processing Indicators**: Inform users of longer processing times for extensive tasks.
+
+## 6. Transparency
+- **Activity Insights**: Show backend processes when useful (e.g., "Querying GPT..." or "Analyzing 'input.txt'...").
+- **Configuration Visibility**: Allow users to view (but not expose) sensitive settings like API keys.
+
+## 7. Customization
+- **User Preferences**: Enable customization of output verbosity (`--verbose`), prompts, API parameters, and model settings.
+
+## 8. Security
+- **Protect Sensitive Data**: Avoid revealing sensitive information in logs or error messages.
+- **Input Sanitization**: Guard against exploits through proper input checks.
+- **Data Handling Disclosure**: Clearly explain data processing practices to users.
+
+## 9. Output Quality
+- **Readable Formatting**: Ensure terminal outputs are easy to read, with options for JSON or YAML formats for scripting.
+- **Consistency and Actionability**: Provide uniform and useful responses.
+
+## 10. Integrability
+- **CLI Ecosystem Compatibility**: Design for seamless integration with other CLI tools, supporting piping and redirection.
+- **Script-Friendly Outputs**: Offer outputs that can be easily parsed by scripts.
+
+## 11. Accessibility
+- **Inclusive Design**: Cater to both novices and experts with straightforward commands and advanced options.
+- **Comprehensive Documentation**: Provide clear, accessible help documentation.
+
+## 12. Proactive Assistance
+- **Error Correction Suggestions**: Offer fixes for common mistakes (e.g., "Did you mean '--file' instead of '--flie'?").
+- **Insightful Recommendations**: Based on queries, suggest enhancements like code optimization tips.
+
+## 13. Extendability
+- **Open for Extensions**: Facilitate the addition of new features or integrations by developers.
+- **Well-Documented Codebase**: Ensure clear documentation for easy maintenance and extension.
+
+### Example Usage
+
+```bash
+$ ask_GPT "What's the square root of 256?"
+Response: 16
+
+$ ask_GPT -f "example.py" "How can I improve this code?"
+Processing file: example.py
+Response:
+- Add type hints for better readability.
+- Avoid global variables to simplify debugging.
+- Refactor `calculate_sum` for improved modularity.
+
+$ cat large_text.txt | ask_GPT "Summarize this text"
+Processing input from stdin...
+Response: Highlights the role of CLI assistants in boosting developer efficiency.
+```