EX-343: refactored code, unnecessary components removed/ EX-344: fix jira comments post error, created new logic for git diff

Author: MUlanovych

main.py

@@ -336,7 +336,6 @@ def run_review_logic(
 
     logging.info("🧠 Performing smart dependency analysis to pre-populate context...")
 
-    
     final_context_content = dict(changed_files_content)
 
     full_project_structure = git_utils.get_file_structure(
@@ -451,8 +450,9 @@ def assess(
 
     logging.info("🔍 Gathering data for Jira assessment...")
     commit_messages = git_utils.get_commit_messages(repo_path, base_ref, head_ref)
-    diff_text = git_utils.get_diff(repo_path, base_ref, head_ref)
 
+    structured_diff_summary = git_utils.get_structured_diff_summary(repo_path, base_ref, head_ref)
+    logging.info(f"📊 Generated structured diff summary: {structured_diff_summary}")
     # Diagnostics
     logging.info(f"[Diag] BITBUCKET_BRANCH={os.environ.get('BITBUCKET_BRANCH')}")
     logging.info(f"[Diag] BITBUCKET_COMMIT_MESSAGE={os.environ.get('BITBUCKET_COMMIT_MESSAGE')!r}")
@@ -502,15 +502,14 @@ def assess(
     summary = summarizer.summarize_changes_for_jira(
         jira_details=jira_details_text,
         commit_messages=commit_messages,
-        diff_text=diff_text,
+        diff_summary=structured_diff_summary,
         llm_config=load_config(repo_path).get('llm', {})
     )
 
     if not summary:
         logging.warning("Summarizer agent failed to produce a result. Skipping Jira comment.")
         return
 
-
     jira_client.add_assessment_comment(task_id, summary)
 
 

src/code_review_agent/cli.py

@@ -25,55 +25,6 @@ def _query_tree(language, tree, query_string):
     return list(set(node.text.decode('utf8') for node, _ in captures))
 
 
-def extract_dependencies_from_content(file_path: str, file_content: str) -> List[str]:
-    """
-    Extracts dependencies using Tree-sitter for universal language analysis.
-    """
-    file_extension = os.path.splitext(file_path)
-    
-    if file_extension not in LANGUAGES:
-        return []
-
-    language = LANGUAGES[file_extension]
-    parser = Parser()
-    parser.set_language(language)
-    
-    tree = parser.parse(bytes(file_content, "utf8"))
-
-    queries = {
-        '.cs': """
-            (using_directive (name_colon_qualified_name) @import) ; for C# usings
-            (class_declaration base_list: (base_list (simple_base_type) @base)) ; for inheritance
-        """,
-        '.py': """
-            (import_statement name: (dotted_name) @import)
-            (from_import_statement module_name: (dotted_name) @import)
-        """,
-        '.ts': "(import_statement source: (string) @import)",
-        '.tsx': "(import_statement source: (string) @import)",
-        '.js': "(import_statement source: (string) @import)",
-    }
-
-    query_string = queries.get(file_extension, "")
-    if not query_string:
-        return []
-
-    raw_imports = _query_tree(language, tree, query_string)
-    
-
-    dependencies = set()
-    for imp in raw_imports:
-        clean_dep = imp.strip("'\"").strip()
-
-        final_part = os.path.basename(clean_dep)
-
-        final_part = final_part.split('.')[-1]
-
-        final_part = final_part.split(',')[0].strip()
-        
-        dependencies.add(final_part)
-        
-    return list(dependencies)
 
 def get_diff(repo_path: str, base_ref: str, head_ref: str) -> str:
     """Calculates the diff between two refs using the merge base strategy."""
@@ -233,39 +184,39 @@ def create_annotated_file(full_content: str, diff_content: str) -> str:
         return f"--- FULL FILE CONTENT ---\n{full_content}\n\n--- GIT DIFF ---\n{diff_content}"
 
 
-def extract_dependencies_from_content(file_path: str, file_content: str) -> List[str]:
+def get_structured_diff_summary(repo_path: str, base_ref: str, head_ref: str) -> dict:
     """
-    Extracts potential module/file dependencies from the content of a file
-    based on its extension, using regular expressions.
-
-    Returns a list of potential filenames or module names to search for.
+    Analyzes the diff and returns a structured summary of changes.
     """
-    dependencies = set()
-    file_extension = os.path.splitext(file_path)[1]
-    patterns = {
-        '.cs': [
-            re.compile(r'^\s*using\s+([\w\.]+);'),
-            re.compile(r'(?:class|record|interface)\s+\w+\s*:\s*([^\{]+)') 
-        ],
-        '.py': [
-            re.compile(r'^\s*import\s+([\w\.]+)'),
-            re.compile(r'^\s*from\s+([\w\.]+)\s+import')
-        ],
-        '.js': [re.compile(r'from\s+[\'"]([^\'"]+)[\'"]')],
-        '.ts': [re.compile(r'from\s+[\'"]([^\'"]+)[\'"]')],
-        '.tsx': [re.compile(r'from\s+[\'"]([^\'"]+)[\'"]')],
+    summary = {
+        "files_added": [],
+        "files_deleted": [],
+        "files_renamed": [],
+        "files_modified": [],
+        "total_insertions": 0,
+        "total_deletions": 0,
     }
+    try:
+        repo = git.Repo(repo_path, search_parent_directories=True)
+        base_commit = repo.commit(base_ref)
+        head_commit = repo.commit(head_ref)
 
-    if file_extension in patterns:
-        for line in file_content.splitlines():
-            for pattern in patterns[file_extension]:
-                match = pattern.search(line)
-                if match:
-                    matched_string = match.group(1)
-                    potential_deps = [d.strip() for d in matched_string.split(',')]
-                    for dep in potential_deps:
-                        clean_dep = os.path.basename(dep.replace('.', '/')).split('<')[0]
-                        if clean_dep:
-                            dependencies.add(clean_dep)
+        diff_index = base_commit.diff(head_commit)
 
-    return list(dependencies)
+        for diff in diff_index:
+            summary["total_insertions"] += diff.a_blob.size if diff.change_type == 'A' else diff.diff.count(b'+')
+            summary["total_deletions"] += diff.a_blob.size if diff.change_type == 'D' else diff.diff.count(b'-')
+
+            if diff.new_file:
+                summary["files_added"].append(diff.b_path)
+            elif diff.deleted_file:
+                summary["files_deleted"].append(diff.a_path)
+            elif diff.renamed_file:
+                summary["files_renamed"].append(f"{diff.a_path} -> {diff.b_path}")
+            else: # Modified
+                summary["files_modified"].append(diff.a_path)
+        
+        return summary
+    except Exception as e:
+        logger.error(f"Could not get structured diff summary: {e}", exc_info=True)
+        return {"error": "Could not generate summary."}

src/code_review_agent/git_utils.py

@@ -9,25 +9,22 @@
 def summarize_changes_for_jira(
     jira_details: str,
     commit_messages: str,
-    diff_text: str,
+    diff_summary: dict,
     llm_config: dict,
 ) -> MergeSummary | None:
 
     client = get_client(llm_config)
     model = llm_config.get('models', {}).get('summarizer', 'google/gemini-pro-1.5')
 
     system_prompt = """
-    You are an expert AI software analyst. Your task is to analyze a git diff and commit messages to produce a structured summary for a Jira ticket.
-
-    **Analysis Instructions:**
-    1.  **Relevance:** Read the Jira task details and the code changes. Rate from 0-100% how relevant the changes are to the task.
-    2.  **Database Changes:** Look for changes in database migration files, entity configurations, or DbContext files. Identify created or modified table names.
-    3.  **API Changes:** Look for changes in Controller files or route definitions. Identify added or modified API endpoints (e.g., "GET /api/users", "POST /api/products/{id}").
-    4.  **Commit Summary:** Read all commit messages and produce a single, concise, high-level summary of the work done.
-
-    **CRITICAL OUTPUT FORMATTING RULE:**
-    Your entire response MUST be a single, valid JSON object that adheres to the `MergeSummary` schema. Do not add any other text.
+    You are an expert AI software analyst. Your task is to analyze a structured summary of code changes and produce a high-level summary for a Jira ticket.
+    DO NOT analyze the code itself, only the provided metadata.
+    
+    CRITICAL OUTPUT FORMATTING RULE:
+    Your entire response MUST be a single, valid JSON object that adheres to the `MergeSummary` schema.
     """
+    
+    diff_summary_text = json.dumps(diff_summary, indent=2)
 
     user_prompt = f"""
     Please analyze the following data and provide a structured summary.
@@ -39,11 +36,12 @@ def summarize_changes_for_jira(
     {commit_messages}
     ```
 
-    **Full Git Diff:**
-    ```diff
-    {diff_text}
+    **Structured Summary of Code Changes:**
+    ```json
+    {diff_summary_text}
     ```
 
+    Based on this metadata, provide your assessment.
     Return your findings as a raw JSON object string.
     """
 

src/code_review_agent/summarizer.py

@@ -43,36 +43,6 @@ def test_get_commit_messages(test_repo):
     assert "Second commit" in messages
 
 
-def test_extract_dependencies_from_content_csharp():
-    """Tests Tree-sitter dependency extraction for C#."""
-    file_path = "MyService.cs"
-    file_content = """
-    using System.Text;
-    using Company.Core.Models;
-
-    namespace MyNamespace
-    {
-        public class MyService : IMyService, IDisposable
-        {
-            // ...
-        }
-    }
-    """
-    dependencies = git_utils.extract_dependencies_from_content(file_path, file_content)
-
-    assert set(dependencies) == {"Text", "Models", "IMyService", "IDisposable"}
-
-def test_extract_dependencies_from_content_python():
-    """Tests Tree-sitter dependency extraction for Python."""
-    file_path = "main.py"
-    file_content = """
-    import os
-    from my_project.utils import helper_function
-    """
-    dependencies = git_utils.extract_dependencies_from_content(file_path, file_content)
-    assert set(dependencies) == {"os", "utils"}
-
-
 
 def test_find_files_by_names(test_repo):
     repo_path, _, _ = test_repo