Change reorganization logic

Author: Ekarerina-Ulyanova

osa_tool/config/prompts/repo_organization.toml

@@ -0,0 +1,177 @@
+[prompts]
+plan_prompt = """
+You are an expert software architect analyzing repository structures. Generate a reorganization plan as JSON.
+
+# REPOSITORY NAME
+{repo_name}
+
+# REPOSITORY STRUCTURE
+{tree_structure}
+
+# ANALYSIS GUIDELINES
+
+## 1. Determine Project Type & Standards
+- **Python**: Should have tests/, pyproject.toml/setup.py, __init__.py in packages
+- **JavaScript/Node**: Should have src/, package.json
+- **Go**: Should have cmd/, pkg/, internal/, go.mod
+- **Java**: Should have src/main/java/, src/test/java/
+- **LaTeX**: Should have latex/, figures/, references/, data/ folders
+- **Generic**: Logical grouping, clear separation of concerns
+
+## 2. Evaluate Current Structure (1-5 scale)
+- 5: Perfect - follows all conventions
+- 4: Good - minor improvements possible
+- 3: Acceptable - works but could be better
+- 2: Poor - scattered files, confusing structure
+- 1: Chaotic - no clear organization
+
+## 3. Critical Issues to Always Fix
+- Missing essential files (__init__.py in Python packages, .gitignore)
+- Configuration files in wrong locations
+- Source files mixed with documentation/tests
+- Invalid file extensions
+- Duplicate or redundant files
+- Empty directories with no purpose
+
+## 4. Reorganization Principles
+- **Minimal changes**: Only reorganize if clear benefit exists
+- **Follow conventions**: Use standard patterns for the project type
+- **Preserve build/config**: Don't break build scripts or configuration paths
+- **Group similar files**: When many files of the same type need to be moved, use a single `move_files` action with a glob pattern instead of listing each file individually.
+- **Move directories**: To move an entire directory, use `move_directory` action.
+
+## 5. Repository Name Suggestions
+- Based on the project type and purpose visible from the structure, suggest **up to 3 alternative names** that would better reflect the content.
+- Provide suggestions only if the current name seems ambiguous or non‑standard.
+
+# DECISION RULES
+1. If structure is already good (score 4-5), return empty actions list
+2. Only suggest moving files if they're clearly in wrong location
+3. Always fix critical issues regardless of overall structure quality
+4. Preserve build scripts and deployment configurations
+5. Use `move_files` for bulk operations (e.g., all .png, all .sty) to keep the plan concise.
+6. Use `move_directory` for moving whole folders (e.g., a dataset folder to data/).
+
+# TASK
+Analyze the repository and generate a JSON object with reorganization actions. If no changes are needed, return {{"actions": []}}. Optionally, suggest better repository names.
+
+# RESPONSE FORMAT
+Return ONLY valid JSON without any additional text.
+
+{{
+  "analysis_summary": {{
+    "project_type": "python|javascript|go|java|latex|mixed|unknown",
+    "quality_score": 1-5,
+    "critical_issues_count": number,
+    "recommendation": "no_changes|minor_fixes|moderate_reorg|major_reorg"
+  }},
+  "actions": [
+    {{
+      "type": "create_directory",
+      "path": "relative/path/to/folder",
+      "reason": "Standard convention for project type"
+    }},
+    {{
+      "type": "move_files",
+      "source_pattern": "*.png",
+      "destination_dir": "figures/",
+      "reason": "Group all figure images in figures/ folder"
+    }},
+    {{
+      "type": "move_directory",
+      "source": "Dataset_Extendido1_FigPaper",
+      "destination": "data/Dataset_Extendido1_FigPaper",
+      "reason": "Move dataset folder under data/ for better organization"
+    }},
+    {{
+      "type": "move_file",
+      "source": "current/path/to/file.ext",
+      "destination": "new/path/to/file.ext",
+      "reason": "File belongs with similar functionality files"
+    }},
+    {{
+      "type": "delete_file",
+      "path": "path/to/obsolete/file.ext",
+      "reason": "Duplicate/obsolete file"
+    }},
+    {{
+      "type": "delete_directory",
+      "path": "path/to/empty/directory",
+      "reason": "Empty directory with no purpose"
+    }},
+    {{
+      "type": "create_file",
+      "path": "path/to/new/file.ext",
+      "content": "File content here",
+      "reason": "Missing essential project file"
+    }},
+    {{
+      "type": "rename_file",
+      "old_path": "current/path/to/file.ext",
+      "new_path": "new/path/to/file.ext",
+      "reason": "Incorrect file extension or naming"
+    }}
+  ],
+  "suggested_names": [
+    "alternative_name_1",
+    "alternative_name_2",
+    "alternative_name_3"
+  ]
+}}
+"""
+
+validation_prompt = """
+You are a senior software engineer validating repository reorganization plans.
+
+# ORIGINAL REPOSITORY STRUCTURE
+{tree_structure}
+
+# PROPOSED REORGANIZATION PLAN
+{proposed_plan}
+
+# TASK
+Validate the plan based only on structural information (file paths, names, extensions). If you find issues, return a corrected plan. The corrected plan must follow the same JSON format as the original plan. If the plan is already correct, return it unchanged.
+
+# RESPONSE FORMAT
+Return ONLY valid JSON without any additional text.
+
+{{
+  "corrected_plan": {{
+    "analysis_summary": {{ ... }},
+    "actions": [ ... ],
+    "suggested_names": [ ... ]
+  }}
+}}
+"""
+
+fix_prompt = """
+You are an expert software engineer tasked with fixing compilation/syntax errors in a codebase. You will receive error output and the content of relevant files. Your goal is to produce corrected file content that resolves the errors.
+
+# Project Type
+{project_type}
+
+# Error Output
+{error_output}
+
+
+# File Contents
+{files_context}
+
+# Instructions
+- Analyze the errors and the provided file contents.
+- For each file that needs changes, provide the corrected full content.
+- Do not change unrelated parts of the code.
+- Ensure your fixes are minimal and correct.
+- Return a JSON object containing a list of fixes.
+
+# Response Format
+Return ONLY valid JSON without any additional text.
+{{
+  "fixes": [
+    {{
+      "file": "relative/path/to/file",
+      "new_content": "corrected file content"
+    }}
+  ]
+}}
+"""

osa_tool/organization/core/__init__.py

@@ -0,0 +1,147 @@
+"""Base analyzer class for all language-specific analyzers."""
+
+import os
+from pathlib import Path
+from typing import Dict, List, Set, Tuple
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from osa_tool.utils.logger import logger
+
+
+class BaseAnalyzer:
+    """
+    Abstract base class for all language‑specific analyzers.
+
+    This class provides a common interface and shared functionality for analyzing
+    source code files in different programming languages. Subclasses must implement
+    language-specific methods for discovering files, extracting imports, and
+    updating import statements.
+
+    Attributes:
+        base_path (Path): Root directory path for analysis
+        file_extensions (List[str]): List of file extensions this analyzer handles
+        discovered_files (List[str]): List of discovered files relative to base_path
+        import_map (Dict[str, Set[str]]): Mapping from module names to files that import them
+    """
+
+    def __init__(self, base_path: str):
+        """
+        Initialize the BaseAnalyzer with a base path.
+
+        Args:
+            base_path: Root directory path for analysis
+        """
+        self.base_path = Path(base_path)
+        self.file_extensions: List[str] = []
+        self.discovered_files: List[str] = []
+        self.import_map: Dict[str, Set[str]] = {}
+
+    def discover_files(self) -> List[str]:
+        """
+        Walk the base_path and collect all files with the configured extensions.
+        Hidden directories (starting with '.') are skipped.
+
+        Returns:
+            List[str]: List of discovered file paths relative to base_path
+        """
+        self.discovered_files = []
+        for ext in self.file_extensions:
+            for path in self.base_path.rglob(f"*{ext}"):
+                if path.is_file() and not any(part.startswith(".") for part in path.parts):
+                    rel_path = str(path.relative_to(self.base_path))
+                    self.discovered_files.append(rel_path)
+        return self.discovered_files
+
+    def extract_imports(self, file_path: str) -> Set[str]:
+        """
+        Return a set of imported module names found in the given file.
+
+        Args:
+            file_path: Path to the file relative to base_path
+
+        Returns:
+            Set[str]: Set of module names imported in the file
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses
+        """
+        raise NotImplementedError
+
+    def get_import_key(self, file_path: str) -> str:
+        """
+        Return a canonical key (e.g. dotted module path) for the file.
+
+        Args:
+            file_path: Path to the file relative to base_path
+
+        Returns:
+            str: Canonical import key for the file
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses
+        """
+        raise NotImplementedError
+
+    def update_imports_in_file(self, file_path: str, old_import: str, new_import: str) -> str | None:
+        """
+        Return the updated content of the file with old_import replaced by new_import,
+        or None if no changes were made.
+
+        Args:
+            file_path: Path to the file relative to base_path
+            old_import: Original import string to replace
+            new_import: New import string to use
+
+        Returns:
+            Optional[str]: Updated file content or None if no changes needed
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses
+        """
+        raise NotImplementedError
+
+    def build_import_map(self):
+        """
+        Populate import_map: for each imported module, list of files that import it.
+        Uses parallel processing with ThreadPoolExecutor for performance.
+        """
+        import_map = defaultdict(set)
+
+        def process_file(fpath: str) -> Tuple[str, Set[str]]:
+            """
+            Process a single file to extract its imports.
+
+            Args:
+                fpath: File path relative to base_path
+
+            Returns:
+                Tuple[str, Set[str]]: File path and its imports
+            """
+            try:
+                imports = self.extract_imports(fpath)
+                return fpath, imports
+            except Exception as e:
+                logger.error(f"Error extracting imports from {fpath}: {e}")
+                return fpath, set()
+
+        with ThreadPoolExecutor(max_workers=os.cpu_count()) as executor:
+            future_to_file = {executor.submit(process_file, f): f for f in self.discovered_files}
+            for future in as_completed(future_to_file):
+                fpath, imports = future.result()
+                for imp in imports:
+                    import_map[imp].add(fpath)
+
+        self.import_map = dict(import_map)
+
+    def get_files_importing_module(self, module_path: str) -> Set[str]:
+        """
+        Return all files that import the given module.
+
+        Args:
+            module_path: Module path to look up
+
+        Returns:
+            Set[str]: Set of file paths that import the module
+        """
+        return self.import_map.get(module_path, set())