doctoskills 1.0.0__tar.gz

doctoskills-1.0.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: doctoskills
+Version: 1.0.0
+Summary: Convert documentation pages into skill markdown files.
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: google-genai>=1.60.0
+Requires-Dist: markdownify>=0.11.6
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: selenium>=4.15.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: webdriver-manager>=4.0.0
+Requires-Dist: requests>=2.31.0

doctoskills-1.0.0/backend/__init__.py

@@ -0,0 +1,17 @@
+"""
+Doc2Skills Backend - Documentation to Markdown Converter
+Converts HTML documentation to structured markdown skill files
+"""
+from .config import ConverterConfig
+from .converter import (
+    DocumentationConverter,
+    convert_single_page
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    'ConverterConfig',
+    'DocumentationConverter',
+    'convert_single_page'
+]
+

doctoskills-1.0.0/backend/cli.py

@@ -0,0 +1,85 @@
+from typing import Optional
+
+import typer
+
+from .config import ConverterConfig
+from .converter import convert_single_page
+from .utils.file_manager import FileManager
+
+app = typer.Typer(help="Convert documentation pages into skill files.")
+
+
+def prompt_for_api_key(file_manager: FileManager) -> None:
+    api_key = ""
+    while not api_key:
+        api_key = typer.prompt("Enter gemini api key").strip()
+        if not api_key:
+            typer.echo("Gemini API key is required.")
+
+    file_manager.update_file_api_key(api_key)
+
+
+def ensure_config_api_key(file_manager: FileManager) -> None:
+    if not file_manager.config_file_exist():
+        file_manager.prepare_default_configfile()
+
+    config = file_manager.load_config()
+    if not config.api_key.strip():
+        prompt_for_api_key(file_manager)
+
+
+@app.command()
+def init() -> None:
+    """Create the default config file and save a Gemini API key."""
+    file_manager = FileManager(ConverterConfig())
+
+    if not file_manager.config_file_exist():
+        file_manager.prepare_default_configfile()
+        prompt_for_api_key(file_manager)
+        typer.echo("Config file created.")
+        return
+
+    config = file_manager.load_config()
+    if not config.api_key.strip():
+        prompt_for_api_key(file_manager)
+        typer.echo("Config file updated.")
+
+
+@app.command("update-api-key")
+def update_api_key() -> None:
+    """Update the Gemini API key in the config file."""
+    file_manager = FileManager(ConverterConfig())
+
+    if not file_manager.config_file_exist():
+        file_manager.prepare_default_configfile()
+
+    prompt_for_api_key(file_manager)
+    typer.echo("API key updated.")
+
+
+@app.command()
+def add(
+    page_url: str = typer.Argument(..., help="Documentation page URL to convert."),
+    output: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Directory where the generated skill file will be saved.",
+    ),
+) -> None:
+    """Convert one documentation page into a skill file."""
+    if not page_url.strip():
+        raise typer.BadParameter("Page URL is required.")
+
+    if output is None or not output.strip():
+        raise typer.BadParameter("Output directory is required. Use --output ./skills.")
+
+    file_manager = FileManager(ConverterConfig())
+    ensure_config_api_key(file_manager)
+
+    result = convert_single_page(page_url=page_url, output_dir=output)
+    if not result.get("success"):
+        typer.echo(result.get("error", "Conversion failed."), err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Skill file created: {result.get('output_file')}")

doctoskills-1.0.0/backend/config.py

@@ -0,0 +1,46 @@
+"""
+Configuration module for Doc2Skills converter
+"""
+import os
+from dataclasses import dataclass
+from typing import Optional
+from pathlib import Path
+from platformdirs import user_config_dir
+
+
+@dataclass
+class ConverterConfig:
+    """Configuration for the documentation converter"""
+    
+    
+    # Browser settings
+    headless: bool = True
+    window_size: str = "1920,1080"
+    page_load_timeout: int = 30
+    
+    # Extraction settings
+    output_base_dir: str = ""
+    
+    # HTML cleanup tags
+    cleanup_tags: tuple = ('nav', 'footer', 'script', 'style', 'header', 'aside')
+    
+    default_api_key = ""
+    default_max_content_size = 3500
+    default_model="gemma-4-31b-it"
+
+    config_dir = Path(user_config_dir("DocToSkill"))
+    config_file_path = config_dir / "config.json"
+    
+    # Chrome driver settings
+    chrome_driver_path: Optional[str] = None
+    
+    def get_output_dir(self, domain: str) -> str:
+        """Get the output directory for a specific domain"""
+        return os.path.join(self.output_base_dir, domain)
+    
+    def ensure_output_dir(self, domain: str) -> str:
+        """Create and return the output directory"""
+        output_dir = self.get_output_dir(domain)
+        os.makedirs(output_dir, exist_ok=True)
+        return output_dir
+

doctoskills-1.0.0/backend/converter.py

@@ -0,0 +1,165 @@
+"""
+Main converter module with both approaches:
+1. Full documentation conversion (all pages)
+2. Single page conversion (user-specified URL)
+
+Supports asynchronous processing for improved performance
+"""
+import time
+import asyncio
+from typing import Optional, List, Dict
+from concurrent.futures import ThreadPoolExecutor
+from .config import ConverterConfig
+from .utils import BrowserManager, ContentProcessor, FileManager
+from .models.SkillData import SkillData
+
+#(Changing here)  just keep single converter
+class DocumentationConverter:
+    """
+    Unified converter for documentation to markdown skills
+    Supports both full documentation and single page conversion
+    """
+    
+    def __init__(self, config: Optional[ConverterConfig] = None):
+        self.config = config or ConverterConfig()
+        self.browser_manager = BrowserManager(self.config)
+        self.content_processor = ContentProcessor(self.config)
+        self.file_manager = FileManager(self.config)
+        
+    def convert_single_page(self, page_url: str, output_dir: Optional[str] = None, 
+                           custom_title: Optional[str] = None) -> Dict[str, any]:
+        """
+        Convert a single documentation page to markdown
+        
+        Args:
+            page_url: URL of the specific page to convert
+            output_dir: Optional custom output directory name
+            custom_title: Optional custom title for the page
+            
+        Returns:
+            Dictionary with conversion result
+        """
+        result = {
+            'success': False,
+            'url': page_url,
+            'title': custom_title or 'Untitled',
+            'output_file': '',
+            'output_directory': ''
+        }
+        
+        try:
+            # Setup output directory
+            
+            print(f"[*] Starting Single Page Conversion")
+            print(f"[*] Source: {page_url}")
+            
+            with self.browser_manager as browser:
+                page_result = self._process_single_page(
+                    browser=browser,
+                    url=page_url,
+                    title=custom_title,
+                    output_dir=output_dir,
+                    extract_title=custom_title is None
+                )
+                
+                result.update(page_result)
+            
+            if result['success']:
+                print(f"\n[✓] Single Page Conversion Complete!")
+            
+        except Exception as e:
+            print(f"\n[✗] Conversion failed: {str(e)}")
+            result['error'] = str(e)
+        
+        return result
+    
+    
+    def _process_single_page(self, browser: BrowserManager, url: str,
+                            title: Optional[str], output_dir: str,
+                            page_num: Optional[int] = None,
+                            total_pages: Optional[int] = None,
+                            extract_title: bool = False) -> Dict[str, any]:
+        """
+        Internal method to process a single page
+        Shared by both conversion approaches
+        
+        Args:
+            browser: BrowserManager instance
+            url: Page URL
+            title: Page title (or None to extract from page)
+            output_dir: Output directory path
+            page_num: Current page number (for progress display)
+            total_pages: Total number of pages (for progress display)
+            extract_title: Whether to extract title from page content
+            
+        Returns:
+            Dictionary with page processing result
+        """
+        result = {
+            'success': False,
+            'url': url,
+            'title': title or 'Untitled',
+            'output_file': ''
+        }
+        
+        try:
+            # Display progress
+            if page_num and total_pages:
+                print(f"[{page_num}/{total_pages}] Processing: {result['title']}")
+            else:
+                print(f"[*] Processing: {url}")
+            
+            # Load the page
+            browser.load_page(url, wait_time=2.0)
+            
+            # Get page content
+            html_content = browser.get_page_source()
+
+            # Convert to markdown
+            markdown_content = self.content_processor.convert_to_markdown(html_content)
+            
+            skill_data : SkillData = self.content_processor.get_skill_metedata_with_ai(markdown_content)
+
+            # Format the document with metadata
+            formatted_content = self.content_processor.format_markdown_document(
+                skill_data,
+                content=markdown_content
+            )
+            
+            # Save to file
+            
+            output_file = self.file_manager.save_markdown_file(
+                output_dir,
+                skill_data.file_name,
+                formatted_content,
+            )
+            
+            result['output_file'] = output_file
+            result['success'] = True
+            
+        except Exception as e:
+            print(f"    [✗] Failed: {str(e)}")
+            result['error'] = str(e)
+        
+        return result
+
+
+
+def convert_single_page(page_url: str, config: Optional[ConverterConfig] = None,
+                       output_dir: Optional[str] = None,
+                       title: Optional[str] = None) -> Dict[str, any]:
+    """
+    Convert a single documentation page to markdown
+    
+    Args:
+        page_url: URL of the specific page to convert
+        config: Optional ConverterConfig instance
+        output_dir: Optional custom output directory name
+        title: Optional custom title for the page
+        
+    Returns:
+        Dictionary with conversion result
+    """
+    converter = DocumentationConverter(config)
+    return converter.convert_single_page(page_url, output_dir, title)
+

doctoskills-1.0.0/backend/models/Config.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+@dataclass
+class Config:
+    api_key:str
+    model:str
+    max_content_size:str
+

doctoskills-1.0.0/backend/models/SkillData.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+@dataclass
+class SkillData:
+    file_name: str
+    title: str
+    description: str

doctoskills-1.0.0/backend/models/__init__.py

@@ -0,0 +1,4 @@
+from .Config import Config
+from .SkillData import SkillData
+
+__all__ = ["Config", "SkillData"]

doctoskills-1.0.0/backend/utils/__init__.py

@@ -0,0 +1,9 @@
+"""
+Utilities package for Doc2Skills converter
+"""
+from .browser import BrowserManager
+from .content_processor import ContentProcessor
+from .file_manager import FileManager
+from .ai_skill_data_generator import AISkillDataGen
+
+__all__ = ['BrowserManager', 'ContentProcessor', 'FileManager','AISkillDataGen']

doctoskills-1.0.0/backend/utils/ai_skill_data_generator.py

@@ -0,0 +1,106 @@
+from google import genai
+from google.genai import types
+import json
+from ..models.SkillData import SkillData
+from ..models.Config import Config
+from .file_manager import FileManager
+
+
+SKILL_METADATA_PROMPT = """
+You are an AI agent skill metadata generator.
+Your task is to generate metadata for a skill based only on the provided documentation text.
+Rules:
+- Use only information explicitly present in the documentation.
+- Do not invent, assume, or add information from prior knowledge.
+- The title must clearly describe the main capability or topic of the skill.
+- Avoid generic titles such as:
+  - Documentation Overview
+  - Guide
+  - Introduction
+  - Reference
+- Maximum title length: 30 characters.
+- The description must:
+  - Explain what knowledge or capability this skill provides.
+  - Explain when an AI agent should use this skill.
+  - Mention the main topics covered.
+  - Must start with Use this skill when working
+- Maximum description length: 300 characters.
+- Generate a file_name suitable for storing the skill as a file.
+- file_name must:
+  - be lowercase
+  - use hyphens instead of spaces
+  - contain only letters, numbers, and hyphens
+  - not include a file extension
+Return JSON only.
+Output format:
+{
+  "file_name": "",
+  "title": "",
+  "description": ""
+}
+"""
+
+
+REQUIRED_FIELDS = ("file_name", "title", "description")
+
+class AISkillDataGen:
+    """Handles generation of skill metadata such as title and description."""
+    
+    @staticmethod
+    def get_gen_data(doc_text: str) -> SkillData:
+        AISkillDataGen._validate_doc_text(doc_text)
+
+        config: Config = FileManager().load_config()
+        resolved_api_key = config.api_key 
+        if not resolved_api_key:
+            raise ValueError("Google GenAI API key is required.") # you must edit the message error
+
+
+        doc_content = doc_text[:config.max_content_size]
+        client = genai.Client(api_key=resolved_api_key)
+        response = client.models.generate_content(
+            model=config.model,
+            contents=f"{SKILL_METADATA_PROMPT}\nDocumentation text:\n{doc_content}",
+            config=types.GenerateContentConfig(
+                response_mime_type="application/json",
+            )
+        )
+
+        data = AISkillDataGen._parse_response(response.text)
+        AISkillDataGen._validate_skill_data(data)
+        return SkillData(**data)
+
+
+    @staticmethod
+    def _parse_response(response_text) -> dict:
+        if not response_text or not response_text.strip():
+            raise RuntimeError("AI response was empty.")
+
+        try:
+            data = json.loads(response_text)
+        except json.JSONDecodeError as exc:
+            raise ValueError("AI response must be valid JSON.") from exc
+
+        if not isinstance(data, dict):
+            raise ValueError("AI response JSON must be an object.")
+
+        return data
+
+    @staticmethod
+    def _validate_doc_text(doc_text: str) -> None:
+        if not isinstance(doc_text, str) or not doc_text.strip():
+            raise ValueError("Documentation content is required.")
+
+    @staticmethod
+    def _validate_skill_data(data: dict) -> None:
+        missing_fields = [field for field in REQUIRED_FIELDS if field not in data]
+        if missing_fields:
+            raise ValueError(f"AI response missing required fields: {', '.join(missing_fields)}.")
+
+        for field in REQUIRED_FIELDS:
+            if not isinstance(data[field], str) or not data[field].strip():
+                raise ValueError(f"AI response field '{field}' must be a non-empty string.")
+            data[field] = data[field].strip()
+
+
+

doctoskills-1.0.0/backend/utils/browser.py

@@ -0,0 +1,81 @@
+"""
+Browser utilities for web scraping
+Shared functions for both full documentation and single page conversion
+"""
+import os
+import time
+from typing import Optional
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.common.by import By
+from ..config import ConverterConfig
+
+
+class BrowserManager:
+    """Manages browser instance and operations"""
+    
+    def __init__(self, config: ConverterConfig):
+        self.config = config
+        self.driver: Optional[webdriver.Chrome] = None
+    
+    #(Changing here) delete docker usage done
+    def initialize_driver(self) -> webdriver.Chrome:
+        """Initialize and return a Chrome WebDriver instance"""
+        chrome_options = Options()
+        
+        if self.config.headless:
+            chrome_options.add_argument("--headless")
+        
+        chrome_options.add_argument(f"--window-size={self.config.window_size}")
+        chrome_options.add_argument("--disable-blink-features=AutomationControlled")
+        chrome_options.add_argument("--no-sandbox")
+        chrome_options.add_argument("--disable-dev-shm-usage")
+        chrome_options.add_argument("--disable-gpu")
+        
+        try:
+                from webdriver_manager.chrome import ChromeDriverManager
+                service = Service(ChromeDriverManager().install())
+                print("[*] Using ChromeDriver from webdriver_manager")
+        except ImportError:
+                raise RuntimeError(
+                    "ChromeDriver not found. Either run in Docker or install webdriver-manager: "
+                    "pip install webdriver-manager"
+                )
+        
+        self.driver = webdriver.Chrome(service=service, options=chrome_options)
+        self.driver.set_page_load_timeout(self.config.page_load_timeout)
+        
+        return self.driver
+    
+    def load_page(self, url: str, wait_time: Optional[float] = None) -> None:
+        """Load a page and wait for it to render"""
+        if not self.driver:
+            raise RuntimeError("Driver not initialized. Call initialize_driver() first.")
+        
+        print(f"[*] Loading: {url}...")
+        self.driver.get(url)
+        time.sleep(wait_time or self.config.initial_load_wait)
+    
+    
+    def get_page_source(self) -> str:
+        """Get the current page source"""
+        if not self.driver:
+            raise RuntimeError("Driver not initialized.")
+        return self.driver.page_source
+    
+    def close(self) -> None:
+        """Close the browser"""
+        if self.driver:
+            self.driver.quit()
+            self.driver = None
+    
+    def __enter__(self):
+        """Context manager entry"""
+        self.initialize_driver()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close()
+

doctoskills-1.0.0/backend/utils/content_processor.py

@@ -0,0 +1,89 @@
+"""
+Content processing utilities
+Shared functions for HTML parsing and markdown conversion
+"""
+import re
+from typing import List, Optional, Tuple
+from bs4 import BeautifulSoup
+from markdownify import markdownify as md
+from ..config import ConverterConfig
+from .ai_skill_data_generator import AISkillDataGen
+from ..models import SkillData
+
+
+class ContentProcessor:
+    """Handles HTML parsing and markdown conversion"""
+    
+    def __init__(self, config: ConverterConfig):
+        self.config = config
+    
+    def parse_html(self, html_content: str) -> BeautifulSoup:
+        """Parse HTML content into BeautifulSoup object"""
+        return BeautifulSoup(html_content, 'html.parser')
+    
+    def cleanup_html(self, soup: BeautifulSoup) -> BeautifulSoup:
+        """Remove unwanted HTML elements and strip links while keeping their text."""
+
+        for tag in soup(self.config.cleanup_tags):
+            tag.decompose()
+
+        for a in soup.find_all("a"):
+            a.unwrap()
+
+        return soup
+    
+    def convert_to_markdown(self, html_content: str) -> str:
+        """Convert HTML to markdown format"""
+        soup = self.parse_html(html_content)
+        soup = self.cleanup_html(soup)
+        return md(str(soup), heading_style="ATX")
+    
+    def sanitize_filename(self, name: str, max_length: int = 100) -> str:
+        """
+        Convert a string into a safe filename with length limit
+        
+        Args:
+            name: Original name to sanitize
+            max_length: Maximum length for the filename (default: 100)
+            
+        Returns:
+            Sanitized filename with length limit
+        """
+        # Remove special characters and replace spaces with underscores
+        safe_name = re.sub(r'[^\w\s-]', '', name).strip()
+        safe_name = safe_name.replace(" ", "_")
+        
+        # Truncate if too long, keeping the most important part (beginning)
+        if len(safe_name) > max_length:
+            safe_name = safe_name[:max_length].rstrip('_')
+        
+        return safe_name
+    
+    @staticmethod
+    def get_skill_metedata_with_ai(doc_content_md:str) ->  SkillData:
+        data = AISkillDataGen().get_gen_data(doc_content_md)
+        return data
+
+    def format_markdown_document(self,skill_data:SkillData, content: str) -> str:
+        """
+        Format the final markdown document following 
+        
+        Args:
+            title: Page title
+            description: Brief description (2 lines)
+            content: Main markdown content
+            
+        Returns:
+            Formatted markdown skill 
+        """
+        
+        # Format YAML frontmatter skill format
+        header = f"""---
+            title: {skill_data.title}
+            description: {skill_data.description}
+---
+"""
+        
+        # Combine header with content (instructions section)
+        return f"{header}# \n\n{content}"
+

doctoskills-1.0.0/backend/utils/file_manager.py

@@ -0,0 +1,102 @@
+"""
+File management utilities
+Shared functions for file operations
+"""
+import os
+from typing import Optional
+from urllib.parse import urlparse
+from ..config import ConverterConfig
+from pathlib import Path
+from platformdirs import user_config_dir
+import json
+from ..models.Config import Config
+
+#(Changing here)  the files must not generated like this , it must be from config URI .
+class FileManager:
+    """Manages files operations """
+    
+    def __init__(self, config: Optional[ConverterConfig] = None):
+        self.config = config or ConverterConfig()
+        
+    def extract_library_name(self, url: str) -> str:
+        """
+        Extract library/package name from URL for metadata
+        Returns capitalized library name (e.g., 'React', 'I18next')
+        """
+        domain = self.extract_domain_from_url(url)
+        # Capitalize first letter of each word
+        return domain.replace('_', ' ').title().replace(' ', '')
+    
+
+    
+    def save_markdown_file(self, directory: str, filename: str, content: str) -> str:
+        """
+        Save markdown content to a file
+        Returns the full path of the saved file
+        """
+        # check and get the file full path for saving 
+        filepath = self.prepare_output_file_path(directory,filename)
+                
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        return filepath
+    
+    def prepare_output_file_path(self,directory:str,filename:str)->str:
+        """
+        Returns the full path and check
+        """
+        path = Path(directory).expanduser().resolve()
+
+        if path.exists() and path.is_file():
+            raise ValueError("Output path must be a directory.")
+        
+        path.mkdir(parents=True, exist_ok=True)
+
+        file_path = path / f"{filename}.md"
+        return str(file_path)
+    
+    def prepare_default_configfile(self)->bool:
+        config = {
+            "api_key": ConverterConfig.default_api_key,
+            "model": ConverterConfig.default_model,
+            "max_content_size": ConverterConfig.default_max_content_size
+        }
+
+        config_dir = Path(user_config_dir("DocToSkill"))
+
+        config_dir.mkdir(parents=True, exist_ok=True)
+
+        config_file = config_dir / "config.json"
+
+        with open(config_file, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=4)
+
+        return True
+    
+    def update_file_api_key(self,api_key:str):
+        with open(self.config.config_file_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+
+        config["api_key"] = api_key
+
+        with open(self.config.config_file_path, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=4)
+
+    def load_config(self)-> Config:
+        with open(self.config.config_file_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+        
+        return Config(**config)
+    
+    def config_file_exist(self) -> bool:
+        path = Path(self.config.config_file_path)
+        return path.exists() and path.is_file()
+
+        
+
+    
+    
+
+
+

doctoskills-1.0.0/doctoskills.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: doctoskills
+Version: 1.0.0
+Summary: Convert documentation pages into skill markdown files.
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: google-genai>=1.60.0
+Requires-Dist: markdownify>=0.11.6
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: selenium>=4.15.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: webdriver-manager>=4.0.0
+Requires-Dist: requests>=2.31.0

doctoskills-1.0.0/doctoskills.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+pyproject.toml
+backend/__init__.py
+backend/cli.py
+backend/config.py
+backend/converter.py
+backend/models/Config.py
+backend/models/SkillData.py
+backend/models/__init__.py
+backend/utils/__init__.py
+backend/utils/ai_skill_data_generator.py
+backend/utils/browser.py
+backend/utils/content_processor.py
+backend/utils/file_manager.py
+doctoskills.egg-info/PKG-INFO
+doctoskills.egg-info/SOURCES.txt
+doctoskills.egg-info/dependency_links.txt
+doctoskills.egg-info/entry_points.txt
+doctoskills.egg-info/requires.txt
+doctoskills.egg-info/top_level.txt

doctoskills-1.0.0/doctoskills.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

doctoskills-1.0.0/doctoskills.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+doctoskills = backend.cli:app

doctoskills-1.0.0/doctoskills.egg-info/requires.txt

@@ -0,0 +1,8 @@
+beautifulsoup4>=4.12.0
+google-genai>=1.60.0
+markdownify>=0.11.6
+platformdirs>=4.0.0
+selenium>=4.15.0
+typer>=0.12.0
+webdriver-manager>=4.0.0
+requests>=2.31.0

doctoskills-1.0.0/doctoskills.egg-info/top_level.txt

@@ -0,0 +1 @@
+backend

doctoskills-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "doctoskills"
+version = "1.0.0"
+description = "Convert documentation pages into skill markdown files."
+requires-python = ">=3.10"
+
+dependencies = [
+    "beautifulsoup4>=4.12.0",
+    "google-genai>=1.60.0",
+    "markdownify>=0.11.6",
+    "platformdirs>=4.0.0",
+    "selenium>=4.15.0",
+    "typer>=0.12.0",
+    "webdriver-manager>=4.0.0",
+    "requests>=2.31.0"
+]
+
+
+[project.scripts]
+doctoskills = "backend.cli:app"
+
+
+[tool.setuptools.packages.find]
+include = ["backend*"]

doctoskills-1.0.0/setup.cfg

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