tabman 0.1.0__tar.gz

tabman-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Anshul Gada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tabman-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: tabman
+Version: 0.1.0
+Home-page: https://github.com/Anshulgada/brave-tab-manager
+Author: Anshul Gada
+License-File: LICENSE
+Requires-Dist: playwright
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: google-generativeai
+Requires-Dist: google-api-python-client
+Requires-Dist: tenacity
+Requires-Dist: openai
+Requires-Dist: python-dotenv
+Requires-Dist: ollama
+Requires-Dist: markdown

tabman-0.1.0/README.md

@@ -0,0 +1,141 @@
+# Tabman: Brave Tab Manager
+
+A command-line tool designed to streamline your browsing experience by intelligently organizing your open tabs from the Brave browser. `tabman` helps you categorize, tag, and save your browsing sessions, making it easier to find and revisit websites later.
+
+## Features
+
+- **Tab Retrieval:** Fetches all open tabs from Brave using its remote debugging interface.
+- **Intelligent Categorization:** Uses AI-powered language models to categorize your tabs:
+  - **Google Gemini:** Employs the Gemini 2.0 Flash model for advanced and fast categorization.
+  - **Mistral AI:** Leverages Mistral's large language models as an alternative to Gemini.
+  - **Ollama:** Enables local categorization using Ollama, supporting a variety of LLMs (e.g., Llama 2, Mistral).
+- **Dynamic Tagging:** Generates a list of concise and relevant keywords to describe the content of each tab.
+- **Flexible Saving:**
+  - Saves the tab data (title, URL, main category, and tags) as a JSON file, organized in date-based subfolders within the `data/` directory.
+  - Creates a Markdown version of each tab session, also stored in the date-based subfolders within the `data/` directory.
+  - Maintains a central `all_tabs.md` file in the `data/` directory, where all tab data is appended for easy access.
+- **Secure API Key Management:** Utilizes a `.env` file to securely store API keys, which can be set using command-line arguments.
+
+## Installation
+
+1.  **Clone the repository:**
+
+    ```bash
+    git clone https://github.com/Anshulgada/brave-tab-manager.git
+    ```
+
+
+2.  **Navigate to the project directory:**
+
+    ```bash
+    cd Brave Tab Manager
+    ```
+
+    This assumes that your project folder is named `Brave Tab Manager`.
+
+3.  **Install `pipx` (if you don't have it):**
+
+    ```bash
+    python -m pip install --user pipx
+    python -m pipx ensurepath
+    ```
+
+    This ensures that `pipx` is installed globally and its executables are present in your system's PATH. You may need to restart your terminal for these changes to take effect.
+
+4.  **Install `tabman` using `pipx`:**
+    ```bash
+    pipx install -e .
+    ```
+    This command installs your tool into an isolated environment and makes the `tabman` command accessible from anywhere. Make sure you run this command from the root of the project directory, i.e. `Brave Tab Manager`.
+
+## Usage
+
+1.  **Enable Remote Debugging in Brave:**
+    To allow `tabman` to connect with your Brave browser, you must enable remote debugging. Here's how:
+
+    - **Windows:**
+      1.  Right-click on the Brave shortcut in your Start Menu or Taskbar and select "Properties."
+      2.  In the "Target" field, add `--remote-debugging-port=9222` (or your preferred port number) to the end of the existing path, ensuring there's a space between the path and the flag. For example:
+          ```
+          "C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe" --remote-debugging-port=9222
+          ```
+      3.  Click "Apply" and "OK."
+    - **macOS/Linux:** Modify the Brave shortcut (or application launcher) to include the `--remote-debugging-port=9222` flag in the command line that launches Brave. Consult your system's documentation for the specific method.
+    - After enabling remote debugging, make sure that you have restarted your Brave browser.
+
+2.  **Run the `tabman` tool:**
+
+    ```bash
+    tabman [OPTIONS]
+    ```
+
+    You can use the following options:
+
+    - `-c`, `--categorize`: Categorize your open tabs using the selected LLM model, and save the data. This is not necessary when setting the api keys.
+    - `-v`, `--version`: Display the version of `tabman` and exits.
+    - `-m`, `--model <MODEL>`: Specify the LLM model for categorization:
+      - `gemini` (default): Uses Google Gemini.
+      - `mistral`: Uses Mistral AI.
+      - `ollama`: Uses a local LLM with Ollama.
+    - `--save-keys`: Save the provided API keys to the `.env` file. Use this in combination with `-mk` and `-gk` options to save the keys.
+    - `-mk`, `--mistral-key <KEY>`: Provide your Mistral AI API key.
+    - `-gk`, `--gemini-key <KEY>`: Provide your Google Gemini API key.
+    - `-om`, `--ollama-model <MODEL>`: Provide the Ollama model name (e.g., `llama2`, `mistral`). Default is `llama2`.
+
+**Examples:**
+
+- **Categorize tabs using the default Gemini model:**
+  ```bash
+  tabman -c
+  ```
+- **Categorize tabs using Mistral:**
+  ```bash
+  tabman -c -m mistral
+  ```
+- **Categorize tabs using a specific Ollama model:**
+  ```bash
+  tabman -c -m ollama -om llama3.2
+  ```
+- **Save API keys to the `.env` file:**
+
+  ```bash
+  tabman --save-keys -gk YOUR_GEMINI_API_KEY -mk YOUR_MISTRAL_API_KEY
+  ```
+  Replace `YOUR_GEMINI_API_KEY` and `YOUR_MISTRAL_API_KEY` with your actual API keys.
+
+- **Show help message:**
+  ```bash
+  tabman
+  ```
+
+## Configuration
+
+- **API Keys:** API keys for Gemini and Mistral can be provided either directly via command-line arguments or saved to a `.env` file for later use. The tool will read keys from environment variables, and then the command line arguments and the `.env` file when using the tool.
+- **Ollama:** If you select Ollama model, then you will have to install and run ollama on your system with your desired models.
+
+## Development and Testing
+
+- To avoid re-installing the package again and again, during local development, you should run the tool inside your virtual environment. For this you have to activate your environment and then run `pip install -e .` from the root directory. Now you can use the tool with the activated virtual environment. Whenever you want to update the global version then you have to uninstall the current version using `pipx uninstall tabman` and install again using `pipx install .`.
+
+- **Running tests:**
+  - The tests are located in the `tabman/tests` directory. You can run the tests using `pytest` rom the root of your project i.e. where `setup.py` exists.
+  ```bash
+  pytest -v -s tabman/tests
+  ```
+
+## Dependencies
+
+- `openai`
+- `ollama`
+- `markdown`
+- `requests`
+- `tenacity`
+- `playwright`
+- `python-dotenv`
+- `beautifulsoup4`
+- `google-generativeai`
+- `google-api-python-client`
+
+## License
+
+This project is licensed under the MIT License.

tabman-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tabman-0.1.0/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="tabman",
+    author="Anshul Gada",
+    version="0.1.0",
+    url="https://github.com/Anshulgada/brave-tab-manager",
+    packages=find_packages(),
+    install_requires=[
+        "playwright",
+        "requests",
+        "beautifulsoup4",
+        "google-generativeai",
+        "google-api-python-client",
+        "tenacity",
+        "openai",
+        "python-dotenv",
+        "ollama",
+        "markdown",
+    ],
+    entry_points={
+        "console_scripts": [
+            "tabman = tabman.main:entry_point",
+        ],
+    },
+)

tabman-0.1.0/tabman/categorizer.py

@@ -0,0 +1,259 @@
+import re
+import os
+import openai
+import ollama
+import asyncio
+import logging
+import google.generativeai as genai
+from dotenv import load_dotenv
+from asyncio import TimeoutError
+from urllib.parse import urlparse
+from typing import List, Dict, Optional
+from .tab_capture import get_brave_tabs
+from .content_fetcher import get_content_from_url
+from .tab_saver import save_tabs_to_json, convert_json_to_markdown
+from tenacity import retry, stop_after_attempt, wait_fixed, retry_if_exception_type
+
+
+# Silence the google-generativeai logs, has to be done before the config import
+logging.getLogger("google.generativeai").setLevel(logging.ERROR)
+load_dotenv()  # Load the environment variables
+
+# GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+gemini_model = genai.GenerativeModel("gemini-2.0-flash-exp")
+
+
+MAIN_CATEGORIES = {
+    "YouTube": ["youtube.com", "youtu.be"],
+    "Coding": ["github.com", "stackoverflow.com"],
+    "Articles": [],
+    "Social Media": ["facebook.com", "twitter.com", "instagram.com"],
+    "News": [],
+    "Personal": [],
+    "Other": [],
+}
+
+
+def get_main_category(url: str) -> str:
+    """
+    Determines the main category of a URL based on predefined rules.
+
+    Args:
+        url (str): The URL to analyze.
+
+    Returns:
+        str: The main category.
+    """
+    parsed_url = urlparse(url)
+    netloc = parsed_url.netloc
+
+    for category, domains in MAIN_CATEGORIES.items():
+        for domain in domains:
+            if domain in netloc:
+                return category
+    return "Other"
+
+
+def capitalize_tags(tags: List[str]) -> List[str]:
+    """Capitalizes the first letter of each word in the tag.
+
+    Args:
+        tags(list): list of tags
+
+    Returns:
+        list: capitalized tags
+    """
+    return [" ".join(word.capitalize() for word in tag.split()) for tag in tags]
+
+
+def post_process_tags(tags: List[str]) -> List[str]:
+    """
+    Post processes tags by removing empty string, duplicate tags, and extra text.
+
+    Args:
+        tags(list): List of tags
+
+    Returns:
+        list(str): A filtered list of tags.
+    """
+    filtered_tags = [tag for tag in tags if tag]  # Remove empty strings
+    filtered_tags = list(set(filtered_tags))  # Remove duplicates
+    filtered_tags = [
+        re.sub(
+            r"^(tag|tags|keyword|keywords|topic|topics|sub):?\s*",
+            "",
+            tag,
+            flags=re.IGNORECASE,
+        ).strip()
+        for tag in filtered_tags
+    ]  # remove extra text
+    return capitalize_tags(filtered_tags)
+
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_fixed(2),
+    retry=retry_if_exception_type(TimeoutError),
+)
+async def generate_tags(
+    content: Optional[str],
+    main_category: str,
+    model_type: str = "gemini",
+    ollama_model: str = "llama3.2",
+) -> Optional[List[str]]:
+    """
+    Generates a list of tags for the given content, using the Gemini, Mistral, or Ollama API.
+
+    Args:
+        content (str): The content to be tagged.
+        main_category (str): The main category of the content.
+        model_type(str): The model used to generate the tags (gemini or mistral or ollama)
+        ollama_model(str): The ollama model to use for generating tags
+
+    Returns:
+        list: A list of tags (or None if tag generation fails).
+    """
+    if not content:
+        return None
+    try:
+        prompt = f"""
+        Given the following text content:
+        {content}
+        And given that the main category is: {main_category}.
+        Generate a comma separated list of the most relevant and concise keywords to describe the content.
+        Do not use full sentences or phrases as tags.
+        Maximum 5 tags.
+        Only return the comma separated list of keywords. Do not add any extra text.
+        """
+        if model_type == "gemini":
+
+            async def generate_with_timeout():
+                return await asyncio.to_thread(gemini_model.generate_content, prompt)
+
+            response = await asyncio.wait_for(
+                generate_with_timeout(), timeout=10
+            )  # Run in thread to not block main thread and apply timeout
+        elif model_type == "mistral":
+            client = openai.OpenAI(api_key=os.getenv("MISTRAL_API_KEY"))
+
+            async def generate_with_timeout():
+                return await asyncio.to_thread(
+                    client.chat.completions.create,
+                    model="mistral-tiny",
+                    messages=[{"role": "user", "content": prompt}],
+                )
+
+            response = await asyncio.wait_for(generate_with_timeout(), timeout=10)
+            if response and response.choices:
+                return post_process_tags(
+                    [
+                        tag.strip()
+                        for tag in response.choices[0].message.content.split(",")
+                    ]
+                )
+            else:
+                return ["Other"]
+        elif model_type == "ollama":
+
+            async def generate_with_timeout():
+                return await asyncio.to_thread(
+                    ollama.generate, model=ollama_model, prompt=prompt
+                )
+
+            response = await asyncio.wait_for(generate_with_timeout(), timeout=10)
+            if response and response["response"]:
+                return post_process_tags(
+                    [tag.strip() for tag in response["response"].split(",")]
+                )
+            else:
+                return ["Other"]
+
+        else:
+            return ["Other"]
+        if response and response.text:
+            return post_process_tags([tag.strip() for tag in response.text.split(",")])
+        else:
+            return ["Other"]  # Return other if no proper response
+    except TimeoutError as e:
+        print(f"Error during tag generation, request timed out: {e}")
+        return None
+    except Exception as e:
+        print(f"Error during tag generation: {e}")
+        return None
+
+
+async def categorize_tabs(
+    tabs: List[Dict[str, str]],
+    model_type: str = "gemini",
+    ollama_model: str = "llama3.2",
+) -> List[Dict[str, str]]:
+    """
+    Categorizes a list of tabs based on their content.
+
+    Args:
+        tabs (list): A list of dictionaries, each with 'title' and 'url' keys.
+        model_type(str): The model used to generate the tags (gemini or mistral or ollama)
+        ollama_model(str): The ollama model to use for generating tags
+
+    Returns:
+         list: A list of dictionaries, each with 'title', 'url', 'main_category', and 'tags' keys.
+    """
+    categorized_tabs = []
+    for tab in tabs:
+        print(f"Categorizing tab: {tab['title']}")
+        url = tab["url"]
+        main_category = get_main_category(url)
+        content = await asyncio.to_thread(get_content_from_url, url)
+        if content:
+            tags = await generate_tags(content, main_category, model_type, ollama_model)
+            tab["main_category"] = main_category
+            tab["tags"] = tags if tags else ["Other"]
+        else:
+            tab["main_category"] = "Other"
+            tab["tags"] = ["Other"]
+
+        categorized_tabs.append(tab)
+    return categorized_tabs
+
+
+async def main_categorizer(
+    model_type: str = "gemini",
+    save_keys: bool = False,
+    mistral_key=None,
+    gemini_key=None,
+    ollama_model="llama3.2",
+):
+    """
+    Main function for categorizing and saving tabs
+    Args:
+        model_type(str): The model used to generate the tags (gemini or mistral or ollama)
+        save_keys (bool): If we want to save the keys
+        mistral_key (str): Mistral api key if we want to set using command line args
+        gemini_key (str): Gemini api key if we want to set using command line args
+        ollama_model (str): The ollama model to use for generating tags
+    """
+    if save_keys:
+        if gemini_key:
+            os.environ["GEMINI_API_KEY"] = gemini_key
+        if mistral_key:
+            os.environ["MISTRAL_API_KEY"] = mistral_key
+
+    tabs = await get_brave_tabs()
+    if tabs:
+        categorized_tabs = await categorize_tabs(tabs, model_type, ollama_model)
+        json_file = save_tabs_to_json(categorized_tabs)
+        print(f"Saved tabs to JSON: {json_file}")
+
+        markdown_file = convert_json_to_markdown(json_file)
+        print(f"Converted JSON to markdown: {markdown_file}")
+    else:
+        print("Could not get the tabs from brave browser.")
+
+
+if __name__ == "__main__":
+
+    async def main():
+        await main_categorizer()
+
+    asyncio.run(main())

tabman-0.1.0/tabman/content_fetcher.py

@@ -0,0 +1,156 @@
+import os
+import requests
+from typing import Optional
+from bs4 import BeautifulSoup
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+
+# from config import GEMINI_API_KEY
+from dotenv import load_dotenv
+
+load_dotenv()
+
+YOUTUBE_API_KEY = os.getenv(
+    "GEMINI_API_KEY"
+)  # For using Gemini API, reuse this api key
+
+
+def extract_limited_content(html_content: str) -> Optional[str]:
+    """
+    Extracts limited key text content from HTML (title, meta description, and initial content).
+
+    Args:
+        html_content (str): The HTML content as a string.
+
+    Returns:
+        str: The extracted text content, or None if extraction fails.
+    """
+    try:
+        soup = BeautifulSoup(html_content, "html.parser")
+
+        title = soup.title.string if soup.title else ""
+        meta_description = soup.find("meta", attrs={"name": "description"})
+        meta_description = (
+            meta_description.get("content", "") if meta_description else ""
+        )
+        main_content_elements = soup.find_all(["p", "h1", "h2", "h3", "h4"])
+        main_content = " ".join(
+            element.get_text(separator=" ", strip=True)
+            for element in main_content_elements[:5]
+        )
+
+        return f"{title}. {meta_description}. {main_content}"
+    except Exception as e:
+        print(f"Error extracting content from HTML: {e}")
+        return None
+
+
+def fetch_url_content(url: str) -> Optional[str]:
+    """
+    Fetches the HTML content from a given URL.
+
+    Args:
+        url (str): The URL to fetch.
+
+    Returns:
+        str: The HTML content or None if the request fails.
+    """
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()  # Raise an exception for bad status codes
+        return response.text
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching URL {url}: {e}")
+        return None
+
+
+def extract_youtube_data(video_id: str) -> Optional[str]:
+    """
+    Extracts the title and description from a YouTube video.
+
+    Args:
+        video_id (str): The YouTube video ID.
+
+    Returns:
+        str: The title and description of the youtube video or None if something goes wrong.
+    """
+    try:
+        youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
+        request = youtube.videos().list(part="snippet", id=video_id)
+        response = request.execute()
+        if not response or "items" not in response or not response["items"]:
+            return None
+        video_data = response["items"][0]["snippet"]
+        title = video_data.get("title", "")
+        description = video_data.get("description", "")
+        return f"{title}. {description}"
+    except HttpError as e:
+        print(f"An HTTP error {e.resp.status} occurred:\n{e.content}")
+        return None
+    except Exception as e:
+        print(f"An Error occurred: {e}")
+        return None
+
+
+def get_content_from_url(url: str) -> Optional[str]:
+    """
+    Helper function to extract content from both normal urls and youtube urls.
+
+    Args:
+        url (str): url to get content from
+
+    Returns:
+        str: The content of the url or None.
+    """
+    if "youtube.com" in url or "youtu.be" in url:
+        video_id = get_youtube_id(url)
+        if video_id:
+            return extract_youtube_data(video_id)
+        return None
+    html_content = fetch_url_content(url)
+    if html_content:
+        return extract_limited_content(
+            html_content
+        )  # Changed this to extract limited content
+    return None
+
+
+def get_youtube_id(url: str) -> Optional[str]:
+    """
+    Extracts the YouTube video ID from a URL.
+
+    Args:
+        url (str): The URL of the YouTube video.
+
+    Returns:
+        str: The video ID or None if not found
+    """
+    try:
+        if "youtube.com" in url:
+            from urllib.parse import urlparse, parse_qs
+
+            parsed_url = urlparse(url)
+            if parsed_url.query:
+                query_params = parse_qs(parsed_url.query)
+                if "v" in query_params:
+                    return query_params["v"][0]
+            if parsed_url.path.startswith("/watch/"):
+                return parsed_url.path.split("/")[2]
+        elif "youtu.be" in url:
+            from urllib.parse import urlparse
+
+            parsed_url = urlparse(url)
+            return parsed_url.path[1:]
+        return None
+    except Exception as e:
+        print(f"Error extracting youtube id: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    sample_url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
+    content = get_content_from_url(sample_url)
+    if content:
+        print(f"Content of url : {content[:200]} ...")
+    else:
+        print("Error fetching content")

tabman-0.1.0/tabman/main.py

@@ -0,0 +1,75 @@
+import os
+import asyncio
+import argparse
+from dotenv import load_dotenv, set_key
+from .categorizer import main_categorizer
+
+load_dotenv()
+
+
+async def main():
+    # Create argument parser for CLI usage
+    parser = argparse.ArgumentParser(description="Brave Tab Manager CLI Tool")
+    parser.add_argument(
+        "-c",
+        "--categorize",
+        action="store_true",
+        help="Categorize and save current open tabs.",
+    )
+    parser.add_argument("-v", "--version", action="version", version="%(prog)s 0.1.0")
+    parser.add_argument(
+        "-m",
+        "--model",
+        type=str,
+        choices=["gemini", "mistral", "ollama"],
+        default="gemini",
+        help="Specify the LLM model for categorization",
+    )
+    parser.add_argument(
+        "--save-keys",
+        action="store_true",
+        help="Save API keys to the .env file. Use this option with -gk or -mk to set the keys.",
+    )
+    parser.add_argument("-mk", "--mistral-key", type=str, help="Mistral AI API key.")
+    parser.add_argument("-gk", "--gemini-key", type=str, help="Google Gemini API key.")
+    parser.add_argument(
+        "-om",
+        "--ollama-model",
+        type=str,
+        default="llama3.2",
+        help="Ollama model to use for categorization (default: llama3.2)",
+    )
+    args = parser.parse_args()
+
+    # If we're saving keys, update environment and .env file
+    if args.save_keys:
+        env_path = ".env"
+        if args.gemini_key:
+            os.environ["GEMINI_API_KEY"] = args.gemini_key
+            set_key(env_path, "GEMINI_API_KEY", args.gemini_key)
+            print("Gemini key has been set")
+        if args.mistral_key:
+            os.environ["MISTRAL_API_KEY"] = args.mistral_key
+            set_key(env_path, "MISTRAL_API_KEY", args.mistral_key)
+            print("Mistral key has been set")
+
+    # Run categorization if requested
+    if args.categorize:
+        await main_categorizer(
+            args.model,
+            args.save_keys,
+            args.mistral_key,
+            args.gemini_key,
+            args.ollama_model,
+        )
+    elif not args.save_keys and not getattr(args, "version", False):
+        parser.print_help()
+
+
+def entry_point():
+    # Wrap async main in a synchronous entry point
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    entry_point()

tabman-0.1.0/tabman/tab_capture.py

@@ -0,0 +1,60 @@
+import asyncio
+from playwright.async_api import async_playwright
+
+BRAVE_DEBUG_PORT = 9222  # Define the debug port here
+
+
+async def get_browser_tabs(browser_url: str):
+    """
+    Retrieves a list of open tabs from the browser.
+
+    Args:
+        browser_url (str): The browser's http url.
+
+    Returns:
+        list[dict]: A list of dictionaries, each containing 'title' and 'url' keys.
+                   Returns empty list if it fails to connect to browser.
+    """
+    try:
+        async with async_playwright() as p:
+            browser = await p.chromium.connect_over_cdp(browser_url)
+
+            tabs = []
+            for context in browser.contexts:  # Iterate through contexts
+                for page in context.pages:  # Iterate through pages in each context
+                    title = await page.title()
+                    url = page.url
+                    tabs.append({"title": title, "url": url})
+            await browser.close()
+            return tabs
+    except Exception as e:
+        print(f"Failed to get browser tabs: {e}")
+        return []
+
+
+async def get_brave_tabs():
+    """
+    Helper function to get brave browser's http url using debug port.
+    Returns:
+        list[dict]: A list of dictionaries, each containing 'title' and 'url' keys.
+                   Returns empty list if it fails to get browser tabs.
+    """
+    try:
+        browser_url = f"http://127.0.0.1:{BRAVE_DEBUG_PORT}"
+        return await get_browser_tabs(browser_url)
+    except Exception as e:
+        print(f"Failed to get browser tabs: {e}")
+        return []
+
+
+if __name__ == "__main__":
+
+    async def main():
+        tabs = await get_brave_tabs()
+        if tabs:
+            for tab in tabs:
+                print(f"Title: {tab['title']}, URL: {tab['url']}")
+        else:
+            print("No tabs found.")
+
+    asyncio.run(main())

tabman-0.1.0/tabman/tab_saver.py

@@ -0,0 +1,151 @@
+import os
+import json
+import logging
+from datetime import datetime
+from typing import List, Dict
+
+# Silence the google-generativeai logs, has to be done before the config import
+logging.getLogger("google.generativeai").setLevel(logging.ERROR)
+
+
+def save_tabs_to_json(tabs: List[Dict[str, str]], data_dir: str = "data") -> str:
+    """
+    Saves tab data to a JSON file.
+
+    Args:
+        tabs (list): A list of dictionaries, each with 'title', 'url', 'main_category', and 'tags' keys.
+        data_dir (str): The directory to save the JSON file in
+
+    Returns:
+        str: The path to the saved JSON file
+    """
+    now = datetime.now()
+    date_str = now.strftime("%d-%m-%Y")
+    time_str = now.strftime("%H-%M-%S")
+    day_str = now.strftime("%A")
+    filename = f"tabs_{date_str}_{day_str}_{time_str}.json"
+
+    dated_dir = os.path.join(data_dir, date_str)
+    filepath = os.path.join(dated_dir, filename)
+
+    os.makedirs(dated_dir, exist_ok=True)
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        json.dump(tabs, f, indent=4)
+
+    all_tabs_filepath = os.path.join(data_dir, "all_tabs.md")
+    append_tabs_to_all_markdown(tabs, all_tabs_filepath)
+    return filepath
+
+
+def append_tabs_to_all_markdown(tabs: List[Dict[str, str]], filepath: str):
+    """
+    Appends tab data to the central all_tabs.md file.
+
+    Args:
+       tabs(list): A list of dictionaries, each with 'title', 'url', 'main_category', and 'tags' keys.
+       filepath(str): The path of the all_tabs.md file
+    """
+    with open(filepath, "a", encoding="utf-8") as f:
+        f.write("# Browser Tab Data\n\n")
+        for tab in tabs:
+            title = tab.get("title", "No Title")
+            url = tab.get("url", "No URL")
+            main_category = tab.get("main_category", "Other")
+            tags = tab.get("tags", [])
+
+            f.write(f"## {title}\n")
+            f.write(f"- **URL:** {url}\n")
+            f.write(f"- **Main Category:** {main_category}\n")
+            f.write(f"- **Tags:** {', '.join(tags)}\n\n")
+
+
+def convert_json_to_markdown(json_filepath: str, data_dir: str = "data") -> str:
+    """
+    Converts the saved JSON data to markdown format.
+
+    Args:
+        json_filepath(str): The path of the json file
+        data_dir(str): The directory where data is stored (used to get the markdown output folder path)
+
+    Returns:
+        str: The path of the created markdown file
+    """
+    with open(json_filepath, "r", encoding="utf-8") as f:
+        tabs = json.load(f)
+
+    now = datetime.now()
+    date_str = now.strftime("%d-%m-%Y")
+    time_str = now.strftime("%H-%M-%S")
+    day_str = now.strftime("%A")
+    markdown_dir = os.path.join(data_dir, date_str)
+    os.makedirs(markdown_dir, exist_ok=True)
+    markdown_file = os.path.join(
+        markdown_dir, f"tabs_{date_str}_{day_str}_{time_str}.md"
+    )
+    with open(markdown_file, "w", encoding="utf-8") as f:
+        f.write(f"# Tabs - {date_str} ({day_str})\n\n")
+        for tab in tabs:
+            title = tab.get("title", "No Title")
+            url = tab.get("url", "No URL")
+            main_category = tab.get("main_category", "Other")
+            tags = tab.get("tags", [])
+
+            f.write(f"## {title}\n")
+            f.write(f"- **URL:** {url}\n")
+            f.write(f"- **Main Category:** {main_category}\n")
+            f.write(f"- **Tags:** {', '.join(tags)}\n\n")
+    return markdown_file
+
+
+if __name__ == "__main__":
+
+    # Testing the functions
+    sample_tabs = [
+        {
+            "title": "Playwright Docs",
+            "url": "https://playwright.dev/docs/api/class-browsertype#browser-type-connect-over-cdp",
+            "main_category": "Other",
+            "tags": [
+                "Playwright",
+                "Browsertype",
+                "Connect",
+                "Browser Instance",
+                "Automation",
+            ],
+        },
+        {
+            "title": "Rick Astley - Never Gonna Give You Up",
+            "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+            "main_category": "YouTube",
+            "tags": [
+                "Music Video",
+                "Rick Astley",
+                "Official",
+                "Never Gonna Give You Up",
+                "1980s",
+            ],
+        },
+        {
+            "title": "Brave Tab Manager: Design Plan",
+            "url": "https://aistudio.google.com/u/3/prompts/1SyHQU8Re8fJ8Cga95N5jG5ptRmvV8BoL",
+            "main_category": "Other",
+            "tags": [
+                "Sign In",
+                "Guest Mode",
+                "Private Browsing",
+                "Forgot Email",
+                "Google Accounts",
+            ],
+        },
+        {
+            "title": "Github OAuth",
+            "url": "https://github.com/login/oauth/authorize?client_id=01ab8ac9400c4e429b23&redirect_uri=https%3A%2F%2Fvscode.dev%2Fredirect&scope=user%3Aemail&skip_account_picker=true&state=vscode%253A%252F%2Fvscode.github-authentication%252Fdid-authenticate%253Fnonce%253Db9147fedcf4304bb%2526windowId%253D1",
+            "main_category": "Coding",
+            "tags": ["Projects", "Software", "Passkey", "Coding", "Github"],
+        },
+    ]
+    json_file = save_tabs_to_json(sample_tabs)
+    print(f"Saved tabs to JSON: {json_file}")
+    markdown_file = convert_json_to_markdown(json_file)
+    print(f"Converted JSON to markdown: {markdown_file}")

tabman-0.1.0/tabman.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: tabman
+Version: 0.1.0
+Home-page: https://github.com/Anshulgada/brave-tab-manager
+Author: Anshul Gada
+License-File: LICENSE
+Requires-Dist: playwright
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: google-generativeai
+Requires-Dist: google-api-python-client
+Requires-Dist: tenacity
+Requires-Dist: openai
+Requires-Dist: python-dotenv
+Requires-Dist: ollama
+Requires-Dist: markdown

tabman-0.1.0/tabman.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+tabman/__init__.py
+tabman/categorizer.py
+tabman/content_fetcher.py
+tabman/main.py
+tabman/tab_capture.py
+tabman/tab_saver.py
+tabman.egg-info/PKG-INFO
+tabman.egg-info/SOURCES.txt
+tabman.egg-info/dependency_links.txt
+tabman.egg-info/entry_points.txt
+tabman.egg-info/requires.txt
+tabman.egg-info/top_level.txt

tabman-0.1.0/tabman.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tabman-0.1.0/tabman.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tabman = tabman.main:entry_point

tabman-0.1.0/tabman.egg-info/requires.txt

@@ -0,0 +1,10 @@
+playwright
+requests
+beautifulsoup4
+google-generativeai
+google-api-python-client
+tenacity
+openai
+python-dotenv
+ollama
+markdown

tabman-0.1.0/tabman.egg-info/top_level.txt

@@ -0,0 +1 @@
+tabman