naive-knowledge-base 0.1.0__py3-none-any.whl

agents/common/utils.py

@@ -0,0 +1,161 @@
+import os
+from pathlib import Path
+from typing import List, Optional, Any, Dict
+import json
+import re
+
+from smolagents import tool
+
+from .exceptions import FileOperationError, wrap_exceptions
+from .logging import get_logger
+
+logger = get_logger(__name__)
+
+@wrap_exceptions
+def save_content_to_file(content: str, source_directory: str, file_name: str) -> str:
+    """
+    Saves content to a file, creating parent directories if needed.
+    
+    Args:
+        content: The content to save
+        source_directory: The directory where the file will be saved
+        file_name: The name of the file
+        
+    Returns:
+        The absolute path to the saved file
+        
+    Raises:
+        FileOperationError: If there's an issue with the file operation
+    """
+    try:
+        path = Path(file_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+            
+        logger.debug(f"Content saved to {file_path}")
+        return str(path.absolute())
+    except Exception as e:
+        raise FileOperationError(f"Failed to save content to {file_path}: {str(e)}")
+
+@wrap_exceptions
+def read_file_content(file_path: str) -> str:
+    """
+    Reads content from a file.
+    
+    Args:
+        file_path: The path to the file
+        
+    Returns:
+        The file content as a string
+        
+    Raises:
+        FileOperationError: If there's an issue with the file operation
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        raise FileOperationError(f"Failed to read content from {file_path}: {str(e)}")
+
+@wrap_exceptions
+def delete_folder_or_file(path: str) -> bool:
+    """
+    Deletes a folder or file.
+    
+    Args:
+        path: The path to the folder or file
+        
+    Returns:
+        True if the deletion was successful, False otherwise
+        
+    Raises:
+        FileOperationError: If there's an issue with the file operation
+    """
+    try:
+        path_obj = Path(path)
+        
+        if path_obj.is_file():
+            path_obj.unlink()
+        elif path_obj.is_dir():
+            # Import here to avoid circular imports
+            import shutil
+            shutil.rmtree(path)
+        else:
+            logger.warning(f"Path {path} does not exist")
+            return False
+            
+        logger.debug(f"Deleted {path}")
+        return True
+    except Exception as e:
+        raise FileOperationError(f"Failed to delete {path}: {str(e)}")
+
+@wrap_exceptions
+def extract_code_blocks(markdown_content: str, language: Optional[str] = None) -> List[str]:
+    """
+    Extracts code blocks from markdown content.
+    
+    Args:
+        markdown_content: The markdown content
+        language: Optional language filter
+        
+    Returns:
+        List of extracted code blocks
+    """
+    if language:
+        pattern = r'```(?:' + language + r')?\s*([\s\S]*?)\s*```(?:\n|$)'
+    else:
+        pattern = r'```(?:\w*)?\s*([\s\S]*?)\s*```(?:\n|$)'
+        
+    return re.findall(pattern, markdown_content)
+
+@wrap_exceptions
+def load_json_file(file_path: str) -> Any:
+    """
+    Loads a JSON file.
+    
+    Args:
+        file_path: The path to the JSON file
+        
+    Returns:
+        The parsed JSON content
+        
+    Raises:
+        FileOperationError: If there's an issue with the file operation
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except json.JSONDecodeError as e:
+        raise FileOperationError(f"Invalid JSON in {file_path}: {str(e)}")
+    except Exception as e:
+        raise FileOperationError(f"Failed to read JSON from {file_path}: {str(e)}")
+
+@wrap_exceptions
+def save_json_file(content: Dict[str, Any], file_path: str, indent: int = 2) -> str:
+    """
+    Saves content as a JSON file.
+    
+    Args:
+        content: The content to save
+        file_path: The path to the file
+        indent: JSON indentation level
+        
+    Returns:
+        The absolute path to the saved file
+        
+    Raises:
+        FileOperationError: If there's an issue with the file operation
+    """
+    try:
+        path = Path(file_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(content, f, indent=indent)
+            
+        logger.debug(f"JSON content saved to {file_path}")
+        return str(path.absolute())
+    except Exception as e:
+        raise FileOperationError(f"Failed to save JSON content to {file_path}: {str(e)}")

agents/dependency_graph/__init__.py

@@ -0,0 +1,7 @@
+from .agent import generate_dependency_graph
+from .model import DependencyGraph
+
+__all__ = [
+    "generate_dependency_graph",
+    "DependencyGraph"
+]

agents/dependency_graph/agent.py

@@ -0,0 +1,205 @@
+from smolagents import tool
+from emerge.appear import Emerge
+from .model import DependencyGraph
+import os
+import json
+from toon_format import encode
+from tools import save_content_to_file, delete_folder_or_file
+
+@tool
+def generate_dependency_graph(source_directory: str, permit_file_extensions: list[str], ignore_directories_containing: list[str]) -> str:
+    """
+    Generates a dependency graph for the given source directory.
+    Args:
+        source_directory: The source directory to analyze.
+        permit_file_extensions: The file extensions to permit in the analysis.
+        ignore_directories_containing: The directories to ignore in the analysis.
+    Returns:
+        str: The dependency graph file path.
+    Raises:
+        ValueError: If the source directory does not exist or is not a directory.
+    """
+    # Check if the source directory exists
+    if not os.path.exists(source_directory):
+        raise ValueError(f"Source directory does not exist: {source_directory}")
+
+    # Check if the source directory is a directory
+    if not os.path.isdir(source_directory):
+        raise ValueError(f"Source path is not a directory: {source_directory}")
+    
+    export_directory = os.path.join(source_directory, "export")
+
+    # Create the Emerge configuration YAML file
+    yaml_content = _create_emerge_config_yaml(source_directory, export_directory, permit_file_extensions, ignore_directories_containing)
+    
+    # Write the YAML content to a file
+    yaml_file_path = _write_emerge_config_yaml(yaml_content)
+    
+    # Run Emerge with the generated YAML file
+    try:
+        _run_emerge(yaml_file_path)
+    except Exception as e:
+        raise ValueError(f"Failed to generate dependency graph: {e}")
+    
+    dependency_graph = _transform_graph(source_directory)
+
+    # Delete the Emerge configuration YAML file
+    try:
+        delete_folder_or_file(yaml_file_path)
+        delete_folder_or_file(export_directory)
+        print(f"Deleting Emerge configuration file: {yaml_file_path}")
+    except Exception as e:
+        raise ValueError(f"Failed to delete Emerge configuration file: {e}")
+    
+    # Transform the dependency graph into a more readable format
+    content = encode(dependency_graph)
+
+    file_path = save_content_to_file(
+        content=content,
+        source_directory=source_directory,
+        file_name="dependency_graph.toon"
+    )
+
+    return f"Dependency graph saved to {file_path}"
+    
+def _create_emerge_config_yaml(source_directory: str, export_dir: str, permit_file_extensions: list[str], ignore_directories_containing: list[str]) -> str:
+    """
+    Generates a sample YAML configuration for Emerge to be used by write_emerge_config_yaml.
+    Args:
+        source_directory: The source directory to analyze.
+        permit_file_extensions: The file extensions to permit in the analysis.
+        ignore_directories_containing: The directories to ignore in the analysis.
+    Returns:
+        str: The YAML configuration as a string.
+    """
+    export_directory = export_dir
+    if not os.path.exists(export_directory):
+        os.makedirs(export_directory)
+    return f"""
+---
+project_name: java_project_example
+loglevel: info
+analyses:
+- analysis_name: full typescript check
+  source_directory: {source_directory}
+  only_permit_file_extensions: {permit_file_extensions}
+  ignore_dependencies_containing:
+    - java
+    - javax
+    - org
+    - och
+    - lambda
+    - javafx
+    - jakarta
+    - io.cloudevents
+    - fasterxml
+    - lombok
+    - dtcloyalty.lib.idempotentconsumer
+    - dtcloyalty.lib.outboxpattern
+    - feign
+    - io
+    - lib.programawaredatasource
+    - lib.programproperties
+    - com.algolia
+  ignore_directories_containing: {ignore_directories_containing}
+  file_scan:
+  - number_of_methods
+  - source_lines_of_code
+  - dependency_graph
+  - fan_in_out
+  - louvain_modularity
+  - tfidf
+  export:
+  - directory: {export_directory}
+  - graphml
+  - json
+  - tabular_file
+  - tabular_console_overall
+  - d3
+    """
+        
+def _write_emerge_config_yaml(yaml_content: str) -> str:
+    """
+    Creates a YAML configuration file for Emerge to be used by run_emerge.
+    Args:
+        yaml_content: The content of the YAML configuration.
+    Returns:
+        str: The path to the generated YAML configuration file.
+    """
+    yaml_file_path = "/tmp/emerge_config.yaml"
+    with open(yaml_file_path, "w") as yaml_file:
+        yaml_file.write(yaml_content)
+    
+    return yaml_file_path
+
+def _run_emerge(yaml_file_path: str) -> None:
+    """
+    Runs Emerge on the given source path.
+    Args:
+        yaml_file_path: The yaml path to the YAML configuration file.
+    Returns:
+        str: The result of the Emerge analysis.
+    """
+    try:
+        emerge = Emerge()
+        emerge.load_config(yaml_file_path)
+        emerge.start_analyzing()
+    except Exception as e:
+        raise ValueError(f"Failed to run Emerge: {e}")
+    
+def _transform_graph(source_directory: str) -> list[DependencyGraph]:
+    """
+    Transforms the dependency graph into a more readable format.
+    Args:
+        source_directory: The source directory to transform the emerge-file_result_dependency_graph-data.json file.
+    Returns:
+        object: The transformed dependency graph.
+    """
+
+    emerge_file_path = os.path.join(source_directory, "export", "emerge-file_result_dependency_graph-data.json")
+    if not os.path.exists(emerge_file_path):
+        raise ValueError(f"Emerge file not found: {emerge_file_path}")
+    with open(emerge_file_path, "r") as emerge_file:
+        emerge_data = emerge_file.read()
+    
+    return _process_data(json.loads(emerge_data), source_directory)
+
+def _process_data(json_data, source_directory) -> list[DependencyGraph]:
+    # Step 1: Filter nodes with absolute_name
+    relevant_nodes = [node for node in json_data['nodes'] if 'absolute_name' in node]
+    
+    # Step 2: Map dependencies based on links
+    dependency_map = {}
+    
+    for link in json_data['links']:
+        if link['source'] not in dependency_map:
+            dependency_map[link['source']] = []
+        target = os.path.join(source_directory, link['target'])
+        dependency_map[link['source']].append(target)
+    
+    # Step 3: Create the final array
+    result = []
+    for node in relevant_nodes:
+        absolute_name = node['absolute_name']
+        file_path = os.path.join(source_directory, absolute_name.split('/', 1)[1])
+        
+        
+        # Get metrics (with proper error handling for missing values)
+        fan_in = node.get('metric_fan-in-dependency-graph', 0)
+        fan_out = node.get('metric_fan-out-dependency-graph', 0)
+        modularity_level = node.get('metric_file_result_dependency_graph_louvain-modularity-in-file', 0)
+        number_of_methods = node.get('metric_number-of-methods-in-file', 0)
+        source_lines_of_code = node.get('metric_sloc-in-file', 0)
+        
+        result.append({
+            "absolutePath": str(file_path),
+            "fanIn": fan_in,
+            "fanOut": fan_out,
+            "sourceLinesOfCode": source_lines_of_code,
+            "numberOfMethods": number_of_methods,
+            "louvainModularity": modularity_level,
+            "displayName": node.get('display_name', ''),
+            "dependencies":dependency_map.get(absolute_name, [])
+        })
+
+    return result

agents/dependency_graph/model.py

@@ -0,0 +1,38 @@
+import pydantic
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+from pydantic.networks import AnyUrl
+
+class DependencyGraph(BaseModel):
+    """
+    A class representing a dependency graph for a software project.
+    """
+
+    absolutePath: str = Field(
+        ...,
+        description="The absolute path to the project directory.",
+    )
+    fanIn: int = Field(
+        ...,
+        description="The number of incoming dependencies for the project.",
+    )
+    fanOut: int = Field(
+        ...,
+        description="The number of outgoing dependencies for the project.",
+    )
+    numberOfMethods: int = Field(
+        ...,
+        description="The number of methods in the project.",
+    )
+    sourceLinesOfCode: int = Field(
+        ...,
+        description="The number of source lines of code in the project.",
+    )
+    louvainModularity: float = Field(
+        ...,
+        description="The Louvain modularity score of the project.",
+    )
+    dependencies: List[str] = Field(
+        ...,
+        description="A list of dependencies for the project.",
+    )

api_models/__init__.py

@@ -0,0 +1,3 @@
+from .flow_api_model import FlowApiModel, ModelConfig
+
+__all__ = ['FlowApiModel', 'ModelConfig']