abstra 3.24.2__py3-none-any.whl → 3.24.4__py3-none-any.whl

abstra_internals/repositories/project/project_test.py

@@ -205,3 +205,282 @@ class ProjectTests(TestCase):
         self.assertEqual(p.get_next_stages_ids(form2.id), [])
 
         self.assertEqual(p.get_previous_stages_ids(form2.id), [form1.id])
+
+    def test_deduplicate_transitions_on_load(self):
+        """Test that duplicate transitions are removed when loading a project from JSON"""
+        # Create a project with a script that has duplicate transitions
+        script1 = ScriptStage(
+            file="script1.py",
+            id="script1",
+            is_initial=True,
+            title="Script 1",
+            workflow_position=(0, 0),
+            workflow_transitions=[],
+        )
+
+        script2 = ScriptStage(
+            file="script2.py",
+            id="script2",
+            is_initial=False,
+            title="Script 2",
+            workflow_position=(100, 100),
+            workflow_transitions=[],
+        )
+
+        # Add the same transition multiple times (simulating corrupted data)
+        duplicate_transition = WorkflowTransition(
+            id="transition1",
+            target_id=script2.id,
+            target_type=script2.type_name,
+            type="task",
+            task_type="test_task",
+        )
+
+        script1.workflow_transitions.append(duplicate_transition)
+        script1.workflow_transitions.append(duplicate_transition)
+        script1.workflow_transitions.append(duplicate_transition)
+
+        project = self.project_repository.load()
+        project.add_stage(script1)
+        project.add_stage(script2)
+        self.project_repository.save(project)
+
+        # Manually add duplicates to the JSON file to simulate corrupted data
+        import json
+
+        json_path = self.project_repository.get_file_path()
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        # Verify duplicates were saved (as expected from the in-memory structure)
+        self.assertEqual(len(data["scripts"][0]["transitions"]), 3)
+
+        # Load the project - this should deduplicate the transitions
+        loaded_project = self.project_repository.load()
+
+        loaded_script1 = loaded_project.get_script(script1.id)
+        self.assertIsNotNone(loaded_script1)
+        assert loaded_script1 is not None  # Type narrowing for pyright
+
+        # Verify that only one transition remains after deduplication
+        self.assertEqual(len(loaded_script1.workflow_transitions), 1)
+        self.assertEqual(loaded_script1.workflow_transitions[0].id, "transition1")
+        self.assertEqual(loaded_script1.workflow_transitions[0].target_id, script2.id)
+
+    def test_deduplicate_multiple_unique_transitions(self):
+        """Test that unique transitions are preserved while duplicates are removed"""
+        script1 = ScriptStage(
+            file="script1.py",
+            id="script1",
+            is_initial=True,
+            title="Script 1",
+            workflow_position=(0, 0),
+            workflow_transitions=[],
+        )
+
+        script2 = ScriptStage(
+            file="script2.py",
+            id="script2",
+            is_initial=False,
+            title="Script 2",
+            workflow_position=(100, 100),
+            workflow_transitions=[],
+        )
+
+        script3 = ScriptStage(
+            file="script3.py",
+            id="script3",
+            is_initial=False,
+            title="Script 3",
+            workflow_position=(200, 200),
+            workflow_transitions=[],
+        )
+
+        # Create unique and duplicate transitions
+        transition1 = WorkflowTransition(
+            id="transition1",
+            target_id=script2.id,
+            target_type=script2.type_name,
+            type="task",
+        )
+
+        transition2 = WorkflowTransition(
+            id="transition2",
+            target_id=script3.id,
+            target_type=script3.type_name,
+            type="task",
+        )
+
+        # Add transitions: 2 unique, but transition1 is duplicated
+        script1.workflow_transitions.append(transition1)
+        script1.workflow_transitions.append(transition2)
+        script1.workflow_transitions.append(transition1)  # duplicate
+
+        project = self.project_repository.load()
+        project.add_stage(script1)
+        project.add_stage(script2)
+        project.add_stage(script3)
+        self.project_repository.save(project)
+
+        # Load and verify deduplication
+        loaded_project = self.project_repository.load()
+        loaded_script1 = loaded_project.get_script(script1.id)
+
+        self.assertIsNotNone(loaded_script1)
+        assert loaded_script1 is not None  # Type narrowing for pyright
+        self.assertEqual(len(loaded_script1.workflow_transitions), 2)
+
+        # Verify both unique transitions are present
+        transition_ids = [t.id for t in loaded_script1.workflow_transitions]
+        self.assertIn("transition1", transition_ids)
+        self.assertIn("transition2", transition_ids)
+
+    def test_deduplicate_transitions_with_same_source_target(self):
+        """Test that multiple transitions with same source→target (but different IDs) are deduplicated"""
+        # Create stages
+        script1 = ScriptStage(
+            file="script1.py",
+            id="script1",
+            is_initial=True,
+            title="Script 1",
+            workflow_position=(0, 0),
+            workflow_transitions=[],
+        )
+
+        script2 = ScriptStage(
+            file="script2.py",
+            id="script2",
+            is_initial=False,
+            title="Script 2",
+            workflow_position=(100, 100),
+            workflow_transitions=[],
+        )
+
+        # Add DIFFERENT transitions with SAME source→target
+        # This simulates corrupted data where multiple transitions point same direction
+        transition_a = WorkflowTransition(
+            id="trans-a",
+            target_id=script2.id,
+            target_type=script2.type_name,
+            type="task",
+            task_type="type1",
+        )
+
+        transition_b = WorkflowTransition(
+            id="trans-b",
+            target_id=script2.id,  # SAME target as trans-a
+            target_type=script2.type_name,
+            type="task",
+            task_type="type2",
+        )
+
+        transition_c = WorkflowTransition(
+            id="trans-c",
+            target_id=script2.id,  # SAME target as trans-a
+            target_type=script2.type_name,
+            type="task",
+            task_type="type3",
+        )
+
+        script1.workflow_transitions.append(transition_a)
+        script1.workflow_transitions.append(transition_b)
+        script1.workflow_transitions.append(transition_c)
+
+        project = self.project_repository.load()
+        project.add_stage(script1)
+        project.add_stage(script2)
+        self.project_repository.save(project)
+
+        # Manually verify JSON has all 3 transitions
+        import json
+
+        json_path = self.project_repository.get_file_path()
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        # All 3 transitions are saved
+        self.assertEqual(len(data["scripts"][0]["transitions"]), 3)
+
+        # Load the project - should deduplicate by source→target
+        loaded_project = self.project_repository.load()
+        loaded_script1 = loaded_project.get_script(script1.id)
+
+        self.assertIsNotNone(loaded_script1)
+        assert loaded_script1 is not None  # Type narrowing for pyright
+
+        # Should keep only ONE transition (first occurrence)
+        self.assertEqual(
+            len(loaded_script1.workflow_transitions),
+            1,
+            f"Expected 1 transition after deduplication, got {len(loaded_script1.workflow_transitions)}",
+        )
+
+        # Should be the first one (trans-a)
+        self.assertEqual(loaded_script1.workflow_transitions[0].id, "trans-a")
+        self.assertEqual(loaded_script1.workflow_transitions[0].target_id, script2.id)
+
+    def test_deduplicate_allows_bidirectional_transitions(self):
+        """Test that bidirectional transitions (a→b and b→a) are both preserved"""
+        # Create stages
+        script1 = ScriptStage(
+            file="script1.py",
+            id="script1",
+            is_initial=True,
+            title="Script 1",
+            workflow_position=(0, 0),
+            workflow_transitions=[],
+        )
+
+        script2 = ScriptStage(
+            file="script2.py",
+            id="script2",
+            is_initial=False,
+            title="Script 2",
+            workflow_position=(100, 100),
+            workflow_transitions=[],
+        )
+
+        # Add bidirectional transitions: script1→script2 and script2→script1
+        forward = WorkflowTransition(
+            id="forward",
+            target_id=script2.id,
+            target_type=script2.type_name,
+            type="task",
+            task_type="forward_type",
+        )
+
+        backward = WorkflowTransition(
+            id="backward",
+            target_id=script1.id,
+            target_type=script1.type_name,
+            type="task",
+            task_type="backward_type",
+        )
+
+        script1.workflow_transitions.append(forward)
+        script2.workflow_transitions.append(backward)
+
+        project = self.project_repository.load()
+        project.add_stage(script1)
+        project.add_stage(script2)
+        self.project_repository.save(project)
+
+        # Load and verify both directions are preserved
+        loaded_project = self.project_repository.load()
+        loaded_script1 = loaded_project.get_script(script1.id)
+        loaded_script2 = loaded_project.get_script(script2.id)
+
+        self.assertIsNotNone(loaded_script1)
+        self.assertIsNotNone(loaded_script2)
+        assert loaded_script1 is not None
+        assert loaded_script2 is not None
+
+        # script1 should have forward transition
+        self.assertEqual(len(loaded_script1.workflow_transitions), 1)
+        self.assertEqual(loaded_script1.workflow_transitions[0].id, "forward")
+        self.assertEqual(loaded_script1.workflow_transitions[0].target_id, script2.id)
+
+        # script2 should have backward transition
+        self.assertEqual(len(loaded_script2.workflow_transitions), 1)
+        self.assertEqual(loaded_script2.workflow_transitions[0].id, "backward")
+        self.assertEqual(loaded_script2.workflow_transitions[0].target_id, script1.id)

abstra_internals/server/routes/mcp.py

@@ -59,5 +59,6 @@ def get_editor_bp(main_controller: MainController):
             requires_approval(workflow_controller.fix_positions_with_autolayout),
             pysa_controller.analyze_python_syntax,
             requires_approval(main_controller.linter_repository.fix_issue_in_codebase),
+            requires_approval(main_controller.add_and_install_requirement),
         ]
     )

abstra_internals/services/fs.py

@@ -1,13 +1,131 @@
 import fnmatch
 import os
+import threading
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
 
 from abstra_internals.consts.filepaths import GITIGNORE_FILEPATH
+from abstra_internals.repositories.git import create_git_repository
 from abstra_internals.settings import Settings
+from abstra_internals.utils.fs_cache import get_path_cache
 
 
 class FileSystemService:
+    # Cache for git check-ignore results
+    _git_ignore_cache: Dict[Path, bool] = {}
+    _git_ignore_cache_lock = threading.Lock()
+    _git_repository = None
+
+    # Fallback cache for Python .gitignore parsing (when git unavailable)
+    _gitignore_cache: Dict[Path, List[str]] = {}
+    _gitignore_cache_lock = threading.Lock()
+
+    @staticmethod
+    def _get_git_repository():
+        """Get or create the git repository instance."""
+        if FileSystemService._git_repository is None:
+            FileSystemService._git_repository = create_git_repository(
+                Settings.root_path
+            )
+        return FileSystemService._git_repository
+
+    @staticmethod
+    def _is_git_available() -> bool:
+        """Check if git is available and we're in a git repository."""
+        git_repo = FileSystemService._get_git_repository()
+        return git_repo.is_git_repository()
+
+    @staticmethod
+    def _check_git_ignore_batch(paths: List[Path]) -> Dict[Path, bool]:
+        """
+        Check multiple paths at once using git check-ignore --stdin.
+        Much more efficient than checking one at a time.
+        """
+        if not FileSystemService._is_git_available():
+            return {path: False for path in paths}
+
+        results = {}
+        uncached_paths = []
+
+        # Check cache first
+        with FileSystemService._git_ignore_cache_lock:
+            for path in paths:
+                if path in FileSystemService._git_ignore_cache:
+                    results[path] = FileSystemService._git_ignore_cache[path]
+                else:
+                    uncached_paths.append(path)
+
+        if not uncached_paths:
+            return results
+
+        # Use git repository to check in batch
+        git_repo = FileSystemService._get_git_repository()
+        batch_results = git_repo.check_ignore_batch(uncached_paths)
+
+        # Update cache
+        with FileSystemService._git_ignore_cache_lock:
+            for path, is_ignored in batch_results.items():
+                FileSystemService._git_ignore_cache[path] = is_ignored
+                results[path] = is_ignored
+
+        return results
+
+    @staticmethod
+    def _check_git_ignore(path: Path) -> bool:
+        """
+        Use git check-ignore to determine if a path should be ignored.
+        Much faster than parsing .gitignore files manually.
+        """
+        # Quick cache check
+        if path in FileSystemService._git_ignore_cache:
+            return FileSystemService._git_ignore_cache[path]
+
+        # Use batch method for single path (still efficient due to caching)
+        result = FileSystemService._check_git_ignore_batch([path])
+        return result.get(path, False)
+
+    @staticmethod
+    def _get_gitignore_patterns(directory: Path) -> Optional[List[str]]:
+        """
+        Get cached .gitignore patterns for a directory.
+        Returns None if no .gitignore file exists.
+        """
+        # Quick check without lock
+        if directory in FileSystemService._gitignore_cache:
+            return FileSystemService._gitignore_cache[directory]
+
+        with FileSystemService._gitignore_cache_lock:
+            # Double-check after acquiring lock
+            if directory in FileSystemService._gitignore_cache:
+                return FileSystemService._gitignore_cache[directory]
+
+            ignore_file = directory / GITIGNORE_FILEPATH
+            patterns = None
+
+            # Check if .gitignore exists and read it
+            try:
+                if ignore_file.exists():
+                    patterns = ignore_file.read_text().splitlines()
+            except (IOError, UnicodeDecodeError):
+                pass
+
+            # Cache the result (None if file doesn't exist)
+            FileSystemService._gitignore_cache[directory] = patterns if patterns else []
+            return FileSystemService._gitignore_cache[directory]
+
+    @staticmethod
+    def clear_gitignore_cache():
+        """Clear all gitignore-related caches. Use when .gitignore files are modified."""
+        with FileSystemService._git_ignore_cache_lock:
+            FileSystemService._git_ignore_cache.clear()
+
+        # Also clear the old pattern cache if it exists (for fallback mode)
+        if hasattr(FileSystemService, "_gitignore_cache"):
+            FileSystemService._gitignore_cache.clear()
+
+        # Clear git repository cache to avoid using stale repository instances
+        FileSystemService._git_repository = None
+
     @staticmethod
     def venv_path() -> Optional[Path]:
         str_path = os.getenv("VIRTUAL_ENV") or os.getenv("CONDA_PREFIX")
@@ -66,6 +184,99 @@ class FileSystemService:
         if not dirpath.is_dir():
             raise ValueError(f"Provided path {dirpath} is not a directory.")
 
+        # If using git ignore, collect all paths first and check in one batch
+        if use_ignore and FileSystemService._is_git_available():
+            return FileSystemService._list_paths_with_git(
+                dirpath,
+                include_dirs=include_dirs,
+                allowed_suffixes=allowed_suffixes,
+                recursive=recursive,
+            )
+
+        # Fallback to old method if git not available
+        return FileSystemService._list_paths_recursive(
+            dirpath,
+            include_dirs=include_dirs,
+            use_ignore=use_ignore,
+            allowed_suffixes=allowed_suffixes,
+            recursive=recursive,
+        )
+
+    @staticmethod
+    def _list_paths_with_git(
+        dirpath: Path,
+        *,
+        include_dirs: bool = True,
+        allowed_suffixes: Optional[List[str]] = None,
+        recursive: bool = True,
+    ) -> List[Path]:
+        """
+        Optimized version that collects all paths first, then checks git ignore in one batch.
+        """
+        all_paths = []
+        path_info = {}  # Map path to (is_directory, should_check_suffix)
+
+        # Collect all paths recursively without checking ignore
+        def collect_paths(current_dir: Path):
+            try:
+                with os.scandir(current_dir) as entries:
+                    for entry in entries:
+                        try:
+                            is_directory = entry.is_dir(follow_symlinks=False)
+                        except OSError:
+                            continue
+
+                        child = Path(entry.path)
+                        all_paths.append(child)
+                        path_info[child] = (
+                            is_directory,
+                            not is_directory or include_dirs,
+                        )
+
+                        if is_directory and recursive:
+                            collect_paths(child)
+            except PermissionError:
+                pass
+
+        collect_paths(dirpath)
+
+        # Check all paths at once with git
+        ignore_results = FileSystemService._check_git_ignore_batch(all_paths)
+
+        # Filter results
+        matches = []
+        if include_dirs and not dirpath.is_symlink():
+            matches.append(dirpath)
+
+        for path in all_paths:
+            # Skip ignored
+            if ignore_results.get(path, False):
+                continue
+
+            is_directory, should_include = path_info[path]
+
+            # Check suffix filter
+            if not is_directory and not FileSystemService._suffix_allowed(
+                path, allowed_suffixes
+            ):
+                continue
+
+            # Include based on type
+            if should_include:
+                matches.append(path)
+
+        return sorted(matches, key=lambda p: p.as_posix())
+
+    @staticmethod
+    def _list_paths_recursive(
+        dirpath: Path,
+        *,
+        include_dirs: bool = True,
+        use_ignore: bool = True,
+        allowed_suffixes: Optional[List[str]] = None,
+        recursive: bool = True,
+    ) -> List[Path]:
+        """Fallback recursive implementation when git is not available."""
         if use_ignore and (FileSystemService.is_ignored(dirpath)):
             return []
 
@@ -73,23 +284,42 @@ class FileSystemService:
         if include_dirs and not dirpath.is_symlink():
             matches.append(dirpath)
 
-        for child in dirpath.iterdir():
-            if use_ignore and (FileSystemService.is_ignored(child)):
-                continue
-            if child.is_dir() or FileSystemService._suffix_allowed(
-                child, allowed_suffixes
-            ):
-                matches.append(child)
-            if child.is_dir() and recursive:
-                matches.extend(
-                    FileSystemService.list_paths(
-                        child,
-                        include_dirs=include_dirs,
-                        use_ignore=use_ignore,
-                        allowed_suffixes=allowed_suffixes,
-                        recursive=True,
-                    )
-                )
+        try:
+            with os.scandir(dirpath) as entries:
+                for entry in entries:
+                    try:
+                        is_directory = entry.is_dir(follow_symlinks=False)
+                    except OSError:
+                        continue
+
+                    child = Path(entry.path)
+
+                    # Check if ignored
+                    if use_ignore and FileSystemService._is_ignored_with_stat(
+                        child, is_directory
+                    ):
+                        continue
+
+                    # Check if we should include this entry
+                    if is_directory or FileSystemService._suffix_allowed(
+                        child, allowed_suffixes
+                    ):
+                        matches.append(child)
+
+                    # Recurse into directories
+                    if is_directory and recursive:
+                        matches.extend(
+                            FileSystemService._list_paths_recursive(
+                                child,
+                                include_dirs=include_dirs,
+                                use_ignore=use_ignore,
+                                allowed_suffixes=allowed_suffixes,
+                                recursive=True,
+                            )
+                        )
+        except PermissionError:
+            pass
+
         return sorted(matches, key=lambda p: p.as_posix())
 
     @staticmethod
@@ -168,10 +398,60 @@ class FileSystemService:
             return True
         return any(path.suffix.lower() == suffix.lower() for suffix in allowed_suffixes)
 
+    @staticmethod
+    def _is_ignored_with_stat(path: Path, is_directory: bool):
+        """
+        Optimized version of is_ignored that accepts pre-computed is_directory flag
+        to avoid redundant stat calls when using os.scandir().
+        Uses git check-ignore when available for best performance.
+        """
+        # Try using git check-ignore first (much faster)
+        # Don't resolve path yet - let git handle it as-is
+        if FileSystemService._is_git_available():
+            return FileSystemService._check_git_ignore(path)
+
+        # Fallback: resolve path for Python implementation
+        path = get_path_cache().get_resolved_path(path)
+
+        # Fallback to Python implementation
+        # Use the pre-computed is_directory flag instead of calling path.is_file()
+        current_dir = path if is_directory else path.parent
+
+        project_root = Settings.root_path
+        while (
+            current_dir != current_dir.parent and current_dir != project_root.parent
+        ):  # Stop at project root
+            # Get cached patterns for this directory
+            patterns = FileSystemService._get_gitignore_patterns(current_dir)
+
+            if patterns:
+                for pattern in patterns:
+                    pattern = pattern.strip()
+                    if pattern and not pattern.startswith("#"):
+                        if FileSystemService._matches_gitignore_pattern(
+                            path, pattern, current_dir
+                        ):
+                            return True
+
+            current_dir = current_dir.parent
+
+        return False
+
     @staticmethod
     def is_ignored(path: Path):
-        path = path.resolve()
+        """
+        Check if a path should be ignored according to .gitignore rules.
+        Uses git check-ignore for performance when available, falls back to Python implementation.
+        """
+        # Try using git check-ignore first (much faster)
+        # Don't resolve path yet - let git handle it as-is
+        if FileSystemService._is_git_available():
+            return FileSystemService._check_git_ignore(path)
+
+        # Fallback: resolve path for Python implementation
+        path = get_path_cache().get_resolved_path(path)
 
+        # Fallback to Python implementation if git is not available
         # Look for ignore file starting from the path's directory up to the root
         # For files that don't exist, we need to check if it would be a file based on the path structure
         # If the path has a suffix or ends with a filename-like component, treat it as a file
@@ -187,19 +467,18 @@ class FileSystemService:
         while (
             current_dir != current_dir.parent and current_dir != project_root.parent
         ):  # Stop at project root
-            ignore_file = current_dir / GITIGNORE_FILEPATH
-            if ignore_file.exists():
-                try:
-                    patterns = ignore_file.read_text().splitlines()
-                    for pattern in patterns:
-                        pattern = pattern.strip()
-                        if pattern and not pattern.startswith("#"):
-                            if FileSystemService._matches_gitignore_pattern(
-                                path, pattern, current_dir
-                            ):
-                                return True
-                except (IOError, UnicodeDecodeError):
-                    continue
+            # Get cached patterns for this directory
+            patterns = FileSystemService._get_gitignore_patterns(current_dir)
+
+            if patterns:
+                for pattern in patterns:
+                    pattern = pattern.strip()
+                    if pattern and not pattern.startswith("#"):
+                        if FileSystemService._matches_gitignore_pattern(
+                            path, pattern, current_dir
+                        ):
+                            return True
+
             current_dir = current_dir.parent
 
         return False