llama-github 0.1.4__tar.gz → 0.1.6__tar.gz

{llama_github-0.1.4 → llama_github-0.1.6}/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.6] - 2024-10-30
+
+### New Features
+- Enhanced PR content analysis with detailed commit information extraction
+- Improved issue linking detection with support for multiple reference formats
+  - Full GitHub URLs, #references, and keyword-based references
+  - Added validation for issue numbers
+
+### Improvements
+- Added detailed commit metadata extraction including stats and file changes
+- Enhanced error handling for commit fetching
+
+## [0.1.5] - 2024-10-14
+
+### Optimized
+- requirements.txt updated to more precise list
+
 ## [0.1.4] - 2024-10-14
 
 ### Improved

{llama_github-0.1.4/llama_github.egg-info → llama_github-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llama-github
-Version: 0.1.4
+Version: 0.1.6
 Summary: Llama-github is an open-source Python library that empowers LLM Chatbots, AI Agents, and Auto-dev Agents to conduct Retrieval from actively selected GitHub public projects. It Augments through LLMs and Generates context for any coding question, in order to streamline the development of sophisticated AI-driven applications.
 Home-page: https://github.com/JetXu-LLM/llama-github
 Author: Jet Xu
@@ -19,9 +19,16 @@ Requires-Dist: langchain
 Requires-Dist: numpy
 Requires-Dist: pydantic
 Requires-Dist: requests
-Requires-Dist: torch
 Requires-Dist: transformers
 Requires-Dist: urllib3
+Requires-Dist: sys
+Requires-Dist: platform
+Requires-Dist: subprocess
+Requires-Dist: pydantic_core
+Requires-Dist: langchain_openai
+Requires-Dist: langchain_mistralai
+Requires-Dist: httpx_sse
+Requires-Dist: tokenizers
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"
@@ -133,6 +140,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.6] - 2024-10-30
+
+### New Features
+- Enhanced PR content analysis with detailed commit information extraction
+- Improved issue linking detection with support for multiple reference formats
+  - Full GitHub URLs, #references, and keyword-based references
+  - Added validation for issue numbers
+
+### Improvements
+- Added detailed commit metadata extraction including stats and file changes
+- Enhanced error handling for commit fetching
+
+## [0.1.5] - 2024-10-14
+
+### Optimized
+- requirements.txt updated to more precise list
+
 ## [0.1.4] - 2024-10-14
 
 ### Improved

{llama_github-0.1.4 → llama_github-0.1.6}/llama_github/data_retrieval/github_entities.py

@@ -241,25 +241,79 @@ class Repository:
     
     def extract_related_issues(self, pr_data: Dict[str, Any]) -> List[int]:
         """
-        Extracts related issue numbers from the PR description and other fields.
-
-        :param pr_data: The pull request data dictionary.
-        :return: A list of related issue numbers.
+        Extracts related issue numbers from all PR data following GitHub's reference syntax.
+        
+        This function implements GitHub's official autolink reference formats to find:
+        1. Full GitHub issue/PR URLs
+        2. Numeric references (#123)
+        3. Keywords + issue references (fixes #123)
+        4. Repository cross-references (owner/repo#123)
+        
+        See: https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/autolinked-references-and-urls
+        
+        Args:
+            pr_data: Dict[str, Any] - The complete pull request data dictionary
+            
+        Returns:
+            List[int] - A sorted list of unique issue numbers found in the PR data
         """
+        # GitHub's official closing keywords
+        closing_keywords = (
+            'close', 'closes', 'closed',
+            'fix', 'fixes', 'fixed',
+            'resolve', 'resolves', 'resolved'
+        )
+
+        # Regex patterns for GitHub issue references
         patterns = [
-            rf'https://github\.com/{re.escape(self.full_name)}/issues/(\d+)',
-            r'(?:^|\s)#(\d+)',
-            r'(?:^|\s)(\d+)(?:\s|$)',
+            # Full GitHub issue/PR URL pattern
+            rf'(?:https?://)?github\.com/{re.escape(self.full_name)}/(?:issues|pull)/(\d+)',
+            
+            # Standard #123 reference with proper boundaries
+            r'(?:^|[^\w/])#(\d+)(?=[^\w/]|$)',
+            
+            # Closing keywords (fixes #123)
+            fr'(?:^|[^\w/])(?:{"|".join(closing_keywords)}):?\s+#(\d+)(?=[^\w/]|$)',
+            
+            # Cross-repo reference (owner/repo#123)
+            rf'{re.escape(self.full_name)}#(\d+)',
+            
+            # Issue keyword reference (issue #123 or issue: #123)
+            r'(?:^|[^\w/])(?:issue|bug|ticket|todo|task)s?:?\s+#?(\d+)(?=[^\w/]|$)'
         ]
+
         issues = set()
-        # Convert PR data to JSON string for pattern matching
-        pr_description = json.dumps(pr_data, default=str)
         
-        for pattern in patterns:
-            matches = re.findall(pattern, pr_description)
-            issues.update(int(match) for match in matches)
+        def extract_from_text(text: str) -> None:
+            """Helper function to extract issue numbers from text"""
+            if not isinstance(text, str):
+                return
+                
+            for pattern in patterns:
+                matches = re.findall(pattern, text, re.IGNORECASE | re.MULTILINE)
+                # Validate issue numbers (reasonable length and positive values)
+                valid_matches = [
+                    int(match) for match in matches 
+                    if match.isdigit() and len(match) <= 7 and int(match) > 0
+                ]
+                issues.update(valid_matches)
+
+        def process_value(value: Any) -> None:
+            """Recursively process dictionary values and extract issue numbers"""
+            if isinstance(value, dict):
+                for v in value.values():
+                    process_value(v)
+            elif isinstance(value, (list, tuple)):
+                for item in value:
+                    process_value(item)
+            elif isinstance(value, str):
+                extract_from_text(value)
+
+        # Process all data in pr_data recursively
+        process_value(pr_data)
         
-        return list(issues)
+        return sorted(list(issues))
+
 
     def get_issue_contents(self, issue_numbers: List[int], pr_number: int) -> List[Dict[str, Any]]:
         """
@@ -324,11 +378,34 @@ class Repository:
                                 "head_branch": pr.head.ref,
                             },
                             "related_issues": [],
+                            "commits": [],
                             "file_changes": [],
                             "ci_cd_results": [],
                             "interactions": []
                         }
 
+                        # Fetch and process commits
+                        try:
+                            commits = pr.get_commits()
+                            for commit in commits:
+                                commit_data = {
+                                    "sha": commit.sha,
+                                    "message": commit.commit.message,
+                                    "author": commit.commit.author.name,
+                                    "date": self.to_isoformat(commit.commit.author.date),
+                                    "stats": {
+                                        "additions": commit.stats.additions,
+                                        "deletions": commit.stats.deletions,
+                                        "total": commit.stats.total
+                                    },
+                                    "files": [f.filename for f in commit.files]  # Just keep changed file names
+                                }
+                                pr_data["commits"].append(commit_data)
+                        except GithubException as e:
+                            logger.exception(f"Error fetching commits for PR #{number}")
+                            pr_data["commits"] = []
+                            pr_data["commit_stats"] = {}
+
                         # Fetch CI/CD results
                         try:
                             last_commit = pr.get_commits().reversed[0]

{llama_github-0.1.4 → llama_github-0.1.6}/llama_github/github_rag.py

@@ -46,24 +46,26 @@ class GithubRAG:
         """
         Initialize the GithubRAG with the provided credentials and configuration.
 
-        Parameters:
-        - github_access_token (Optional[str]): GitHub access token for authentication.
-        - github_app_credentials (Optional[GitHubAppCredentials]): Credentials for GitHub App authentication.
-        - openai_api_key (Optional[str]): API key for OpenAI services -- recommend to use, GPT-4-turbo will be used.
-        - mistral_api_key (Optional[str]): API key for Mistral AI services.
-        - huggingface_token (Optional[str]): Token for Hugging Face services -- recommend to fill.
-        - jina_api_key (Optional[str]): API key for Jina AI services -- s.jina.ai API will be used
-        - open_source_models_hg_dir (Optional[str]): Name of open-source models from Hugging Face to replace OpenAI.
-        - embedding_model (Optional[str]): Name of Embedding model from Hugging Face, if you have preferred embedding model to be used.
-        - rerank_model (Optional[str]): Name of Rerank model from Hugging Face, if you have preferred rerank model to be used.
-        - llm (Any): Any kind of LangChain llm chat object - to replace OpenAI or open-source models from Hugging Face.
-        - simple_mode (bool): If True, skip embedding and rerank model initialization in LLMManager.
-        - **kwargs:
-            :param repo_cleanup_interval (Optional[int]): How often to run repo cleanup in seconds within RepositoryPool.
-            :param repo_max_idle_time (Optional[int]): Keep a repo in cache until max idle time if not used.
+        This constructor sets up the necessary components for GitHub integration,
+        RAG processing, and LLM capabilities. It handles authentication, initializes
+        the repository pool, and sets up the LLM manager.
 
-        Returns:
-        - None
+        Args:
+            github_access_token (Optional[str]): GitHub access token for authentication.
+            github_app_credentials (Optional[GitHubAppCredentials]): Credentials for GitHub App authentication.
+            openai_api_key (Optional[str]): API key for OpenAI services (GPT-4-turbo will be used).
+            mistral_api_key (Optional[str]): API key for Mistral AI services.
+            huggingface_token (Optional[str]): Token for Hugging Face services (recommended).
+            jina_api_key (Optional[str]): API key for Jina AI services (s.jina.ai API will be used).
+            open_source_models_hg_dir (Optional[str]): Directory for open-source models from Hugging Face.
+            embedding_model (Optional[str]): Name of the preferred embedding model from Hugging Face.
+            rerank_model (Optional[str]): Name of the preferred rerank model from Hugging Face.
+            llm (Any): Any LangChain LLM chat object to replace OpenAI or open-source models.
+            simple_mode (bool): If True, skip embedding and rerank model initialization in LLMManager.
+            **kwargs: Additional keyword arguments for repository pool configuration.
+
+        Raises:
+            Exception: If there's an error during initialization.
         """
         try:
             logger.info("Initializing GithubRAG...")
@@ -111,10 +113,23 @@ class GithubRAG:
             raise
 
     async def async_retrieve_context(self, query, simple_mode: Optional[bool] = None) -> List[str]:
-        # Implementation of the context retrieval process
-        # This will involve using the GitHub API to search for relevant information,
-        # augmenting the retrieved data through the RAG methodology, and
-        # enhancing it with LLM capabilities.
+        """
+        Asynchronously retrieve context based on the given query.
+
+        This method orchestrates the context retrieval process, including Google search,
+        code search, issue search, and repository search. It uses the RAG processor to
+        analyze the query and retrieve the most relevant contexts.
+
+        Args:
+            query (str): The query to retrieve context for.
+            simple_mode (Optional[bool]): If provided, overrides the instance's simple_mode setting.
+
+        Returns:
+            List[str]: A list of the most relevant context strings.
+
+        Raises:
+            Exception: If there's an error during context retrieval.
+        """
 
         if simple_mode is None:
             simple_mode = self.simple_mode
@@ -191,6 +206,10 @@ class GithubRAG:
         """
         Retrieve context from GitHub code, issue and repo search based on the input query.
 
+        This method serves as a wrapper for the async_retrieve_context method,
+        handling the asynchronous call in different runtime environments (e.g., Jupyter notebook,
+        asyncio event loop).
+
         Args:
             query (str): The query or question to retrieve context for.
             simple_mode (Optional[bool]): If provided, overrides the instance's simple_mode setting.
@@ -212,6 +231,24 @@ class GithubRAG:
         return self.loop.run_until_complete(self.async_retrieve_context(query, simple_mode=effective_simple_mode))
 
     async def code_search_retrieval(self, query, draft_answer: Optional[str] = None):
+        """
+        Perform a code search on GitHub based on the given query and draft answer.
+
+        This method uses the RAG processor to generate search criteria, then performs
+        a code search using the GitHub API. It filters and deduplicates the results
+        based on star count and relevance.
+
+        Args:
+            query (str): The main query for the code search.
+            draft_answer (Optional[str]): A draft answer to refine the search criteria.
+
+        Returns:
+            list: A list of unique, relevant code search results.
+
+        Raises:
+            Exception: If there's an error during the code search retrieval.
+        """
+        
         result = []
         try:
             logger.info("Retrieving code search...")
@@ -238,6 +275,24 @@ class GithubRAG:
         return result
 
     async def issue_search_retrieval(self, query, draft_answer: Optional[str] = None):
+        """
+        Perform an issue search on GitHub based on the given query and draft answer.
+
+        This method uses the RAG processor to generate search criteria, then performs
+        an issue search using the GitHub API. It deduplicates the results and transforms
+        the API URLs to official GitHub issue webpage URLs.
+
+        Args:
+            query (str): The main query for the issue search.
+            draft_answer (Optional[str]): A draft answer to refine the search criteria.
+
+        Returns:
+            list: A list of unique, relevant issue search results with transformed URLs.
+
+        Raises:
+            Exception: If there's an error during the issue search retrieval.
+        """
+
         result = []
         try:
             logger.info("Retrieving issue search...")
@@ -268,6 +323,23 @@ class GithubRAG:
         return result
 
     async def google_search_retrieval(self, query):
+        """
+        Perform a Google search for GitHub-related content based on the given query.
+
+        This method uses the Jina AI search API to perform a Google search limited to
+        GitHub.com. It then retrieves the content of the resulting GitHub URLs using
+        the GitHub API.
+
+        Args:
+            query (str): The query to search for on Google.
+
+        Returns:
+            list: A list of dictionaries containing the GitHub URL and its content.
+
+        Raises:
+            Exception: If there's an error during the Google search retrieval.
+        """
+
         result = []
         try:
             logger.info("Retrieving google search...")
@@ -304,15 +376,39 @@ class GithubRAG:
 
     def _get_repository_rag_info(self, repository: Repository):
         """
-        Helper method to get file content through a Repository object.
+        Retrieve RAG-related information for a given repository.
+
+        This helper method fetches the README content and a simple structure
+        of the repository using the Repository object.
+
+        Args:
+            repository (Repository): The Repository object to get information from.
 
-        :param code_search_result: A single code search result.
-        :return: Tuple containing the Repository object and the file content.
+        Returns:
+            tuple: A tuple containing the repository's README content and simple structure.
         """
-        # Assuming RepositoryPool is accessible and initialized somewhere in this class
+
         return repository.get_readme(), self.rag_processor.get_repo_simple_structure(repository)
 
     async def repo_search_retrieval(self, query, draft_answer: Optional[str] = None):
+        """
+        Perform a repository search on GitHub based on the given query and draft answer.
+
+        This method uses the RAG processor to generate search criteria, then performs
+        a repository search using the GitHub API. It retrieves README content and
+        simple structure for each relevant repository concurrently.
+
+        Args:
+            query (str): The main query for the repository search.
+            draft_answer (Optional[str]): A draft answer to refine the search criteria.
+
+        Returns:
+            list: A list of dictionaries containing repository information and content.
+
+        Raises:
+            Exception: If there's an error during the repository search retrieval.
+        """
+
         result = []
         results_with_index = []
         try:
@@ -370,18 +466,20 @@ class GithubRAG:
         """
         Generate an answer based on the given query and optional contexts.
 
-        This method can be called in different environments (Jupyter notebook, 
-        synchronous Python program, asynchronous Python program) and will 
-        handle the async call appropriately.
+        This method serves as a wrapper for the async_answer_with_context method,
+        handling the asynchronous call in different runtime environments (e.g., Jupyter notebook,
+        asyncio event loop).
 
         Args:
             query (str): The user's query.
             contexts (Optional[List[Dict[str, Any]]]): Optional list of context dictionaries.
                 Each dictionary should contain 'content' and 'url' keys.
+            simple_mode (bool): Whether to use simple mode for context retrieval.
 
         Returns:
             str: The generated answer.
         """
+
         self.loop = asyncio.get_event_loop()
         ipython = get_ipython()
         if ipython and ipython.has_trait('kernel'):
@@ -397,14 +495,19 @@ class GithubRAG:
         """
         Asynchronously generate an answer based on the given query and optional contexts.
 
+        This method retrieves contexts if not provided, extracts relevant information,
+        and uses the RAG processor's LLM handler to generate an answer.
+
         Args:
             query (str): The user's query.
             contexts (Optional[List[Dict[str, Any]]]): Optional list of context dictionaries.
                 Each dictionary should contain 'content' and 'url' keys.
+            simple_mode (bool): Whether to use simple mode for context retrieval.
 
         Returns:
             str: The generated answer.
         """
+        
         if contexts is None:
             contexts = await self.async_retrieve_context(query, simple_mode)
             logger.debug(f"Retrieved contexts: {contexts}")

{llama_github-0.1.4 → llama_github-0.1.6}/llama_github/llm_integration/initial_load.py

@@ -2,14 +2,17 @@
 from typing import Optional, Any
 from threading import Lock
 from langchain_openai import ChatOpenAI
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_community.cross_encoders import HuggingFaceCrossEncoder
 from langchain_mistralai.chat_models import ChatMistralAI
 
 from llama_github.config.config import config
 from llama_github.logger import logger
 
 class LLMManager:
+    """
+    Singleton class for managing Language Models and related components.
+    This class handles initialization and access to various models including LLMs,
+    embedding models, and reranking models.
+    """
     _instance_lock = Lock()
     _instance = None
     llm = None
@@ -20,6 +23,9 @@ class LLMManager:
     embedding_model = None
 
     def __new__(cls, *args, **kwargs):
+        """
+        Ensure only one instance of LLMManager is created (Singleton pattern).
+        """
         if cls._instance is None:  # First check (unlocked)
             with cls._instance_lock:  # Acquire lock
                 if cls._instance is None:  # Second check (locked)
@@ -36,6 +42,19 @@ class LLMManager:
                  rerank_model: Optional[str] = config.get("default_reranker"),
                  llm: Any = None,
                  simple_mode: bool = False):
+        """
+        Initialize the LLMManager with specified models and API keys.
+
+        Args:
+            openai_api_key (Optional[str]): API key for OpenAI.
+            mistral_api_key (Optional[str]): API key for Mistral AI.
+            huggingface_token (Optional[str]): Token for Hugging Face.
+            open_source_models_hg_dir (Optional[str]): Directory for open-source models.
+            embedding_model (Optional[str]): Name or path of the embedding model.
+            rerank_model (Optional[str]): Name or path of the reranking model.
+            llm (Any): Custom LLM instance if provided.
+            simple_mode (bool): If True, skip initialization of embedding and reranking models.
+        """
         with self._instance_lock:   # Prevent re-initialization
             if self._initialized:
                 return
@@ -43,7 +62,7 @@ class LLMManager:
 
         self.simple_mode = simple_mode
 
-        # Initialize for OpenAI GPT-4
+        # Initialize LLM based on provided API keys or custom LLM
         if llm is not None:
             self.llm = llm
             self.model_type = "Custom_langchain_llm"
@@ -61,33 +80,47 @@ class LLMManager:
         # Initialize for Open Source Models
         elif open_source_models_hg_dir is not None and open_source_models_hg_dir != "" and self.llm is None:
             logger.info(f"Initializing {open_source_models_hg_dir}...")
-            # load hugingface models
+            # load huggingface models
             self.model_type = "Hubgingface"
         elif self.llm is None:
             # default model is phi3_mini_128k
             self.model_type = "Hubgingface"
             
         if not self.simple_mode:
-            import torch
+            import sys
+            import platform
+            import subprocess
+
+            def get_device():
+                if sys.platform.startswith('darwin'):  # macOS
+                    # Check for Apple Silicon (M1/M2)
+                    if platform.machine() == 'arm64':
+                        return 'mps'
+                elif sys.platform.startswith('linux') or sys.platform.startswith('win'):
+                    # Check for NVIDIA GPU
+                    try:
+                        subprocess.run(['nvidia-smi'], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                        return 'cuda'
+                    except (subprocess.CalledProcessError, FileNotFoundError):
+                        pass
+                
+                # Default to CPU
+                return 'cpu'
+
+            # Usage
+            self.device = get_device()
+
             from transformers import AutoModel
             from transformers import AutoModelForSequenceClassification
             from transformers import AutoTokenizer
-            # initial model_kwargs
-            if torch.cuda.is_available():
-                self.device = torch.device('cuda')
-            elif torch.backends.mps.is_available():
-                self.device = torch.device('mps')
-            else:
-                self.device = torch.device('cpu')
-
-            # initial embedding_model
+            # Initialize embedding model
             if self.tokenizer is None:
                 logger.info(f"Initializing {embedding_model}...")
                 self.tokenizer = AutoTokenizer.from_pretrained(embedding_model)
                 self.embedding_model = AutoModel.from_pretrained(
                     embedding_model, trust_remote_code=True).to(self.device)
 
-            # initial rerank_model
+            # Initialize reranking model
             if self.rerank_model is None:
                 logger.info(f"Initializing {rerank_model}...")
                 self.rerank_model = AutoModelForSequenceClassification.from_pretrained(
@@ -97,16 +130,46 @@ class LLMManager:
             logger.info("Simple mode enabled. Skipping embedding and rerank model initialization.")
 
     def get_llm(self):
+        """
+        Get the main Language Model.
+
+        Returns:
+            The initialized Language Model.
+        """
         return self.llm
 
     def get_llm_simple(self):
+        """
+        Get the simplified Language Model.
+
+        Returns:
+            The initialized simplified Language Model.
+        """
         return self.llm_simple
 
     def get_tokenizer(self):
+        """
+        Get the tokenizer for the embedding model.
+
+        Returns:
+            The initialized tokenizer.
+        """
         return self.tokenizer
 
     def get_rerank_model(self):
+        """
+        Get the reranking model.
+
+        Returns:
+            The initialized reranking model.
+        """
         return self.rerank_model
 
     def get_embedding_model(self):
+        """
+        Get the embedding model.
+
+        Returns:
+            The initialized embedding model.
+        """
         return self.embedding_model

llama_github-0.1.6/llama_github/logger.py

@@ -0,0 +1,15 @@
+import logging
+
+logger = logging.getLogger('llama_github')
+
+def configure_logging(level=logging.INFO, handler=None):
+    logger.setLevel(level)
+    if handler:
+        logger.addHandler(handler)
+    else:
+        # default handler output to console
+        ch = logging.StreamHandler()
+        ch.setLevel(level)
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)

llama_github-0.1.6/llama_github/version.py

@@ -0,0 +1 @@
+__version__ = '0.1.6'

{llama_github-0.1.4 → llama_github-0.1.6/llama_github.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llama-github
-Version: 0.1.4
+Version: 0.1.6
 Summary: Llama-github is an open-source Python library that empowers LLM Chatbots, AI Agents, and Auto-dev Agents to conduct Retrieval from actively selected GitHub public projects. It Augments through LLMs and Generates context for any coding question, in order to streamline the development of sophisticated AI-driven applications.
 Home-page: https://github.com/JetXu-LLM/llama-github
 Author: Jet Xu
@@ -19,9 +19,16 @@ Requires-Dist: langchain
 Requires-Dist: numpy
 Requires-Dist: pydantic
 Requires-Dist: requests
-Requires-Dist: torch
 Requires-Dist: transformers
 Requires-Dist: urllib3
+Requires-Dist: sys
+Requires-Dist: platform
+Requires-Dist: subprocess
+Requires-Dist: pydantic_core
+Requires-Dist: langchain_openai
+Requires-Dist: langchain_mistralai
+Requires-Dist: httpx_sse
+Requires-Dist: tokenizers
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"
@@ -133,6 +140,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.6] - 2024-10-30
+
+### New Features
+- Enhanced PR content analysis with detailed commit information extraction
+- Improved issue linking detection with support for multiple reference formats
+  - Full GitHub URLs, #references, and keyword-based references
+  - Added validation for issue numbers
+
+### Improvements
+- Added detailed commit metadata extraction including stats and file changes
+- Enhanced error handling for commit fetching
+
+## [0.1.5] - 2024-10-14
+
+### Optimized
+- requirements.txt updated to more precise list
+
 ## [0.1.4] - 2024-10-14
 
 ### Improved

{llama_github-0.1.4 → llama_github-0.1.6}/llama_github.egg-info/requires.txt

@@ -6,9 +6,16 @@ langchain
 numpy
 pydantic
 requests
-torch
 transformers
 urllib3
+sys
+platform
+subprocess
+pydantic_core
+langchain_openai
+langchain_mistralai
+httpx_sse
+tokenizers
 
 [dev]
 pytest

{llama_github-0.1.4 → llama_github-0.1.6}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = llama-github
-version = 0.1.4
+version = 0.1.6
 author = Jet Xu
 author_email = Voldemort.xu@foxmail.com
 description = Llama-github is an open-source Python library that empowers LLM Chatbots, AI Agents, and Auto-dev Agents to conduct Retrieval from actively selected GitHub public projects. It Augments through LLMs and Generates context for any coding question, in order to streamline the development of sophisticated AI-driven applications.

llama_github-0.1.4/llama_github/logger.py

@@ -1,28 +0,0 @@
-import logging
-
-logger = logging.getLogger('llama_github')
-
-def configure_logging(level=logging.INFO, handler=None):
-    logger.setLevel(level)
-    if handler:
-        logger.addHandler(handler)
-    else:
-        # default handler output to console
-        ch = logging.StreamHandler()
-        ch.setLevel(level)
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        ch.setFormatter(formatter)
-        logger.addHandler(ch)
-
-## Logging Configuration
-# By default, `llama_github` does not configure logging to avoid interfering with your application's logging settings. If you want to see log outputs from `llama_github`, you can configure logging as follows:
-
-# ```python
-# import logging
-# import llama_github
-
-# # Configure the library's logger
-# llama_github.configure_logging(level=logging.INFO)
-
-# # Now you can see log outputs
-# logger = logging.getLogger('llama_github')

llama_github-0.1.4/llama_github/version.py

@@ -1 +0,0 @@
-__version__ = '0.1.4'