abstra 3.23.12__py3-none-any.whl → 3.24.0__py3-none-any.whl

abstra_internals/repositories/git/types.py

@@ -0,0 +1,267 @@
+"""
+Git types and data structures shared across implementations.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass
+class GitCommit:
+    hash: str
+    message: str
+    author: str
+    date: str
+
+
+@dataclass
+class AheadBehindInfo:
+    ahead: int = 0
+    behind: int = 0
+
+
+@dataclass
+class RemoteGitStatus:
+    success: bool
+    remote_commit: Optional[str] = None
+    branch: str = "main"
+    has_commits: bool = False
+    available_branches: List[str] = field(default_factory=list)
+    message: Optional[str] = None
+    ahead_behind: Optional[AheadBehindInfo] = None
+    has_remote_changes: Optional[bool] = None
+    has_conflicts: Optional[bool] = None
+
+
+@dataclass
+class GitFileChange:
+    path: str
+    status: str  # added, deleted, modified, renamed, untracked
+    status_code: str  # Git porcelain status code (e.g., "M ", "A ", "??")
+
+
+@dataclass
+class GitStatusResponse:
+    available: bool
+    branch: str
+    branches: List[str]
+    last_commit: Optional[GitCommit]
+    has_changes: bool
+    changed_files: List[str]
+    changed_files_with_status: List[GitFileChange]
+    remote_status: Optional[RemoteGitStatus] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "available": self.available,
+            "branch": self.branch,
+            "branches": self.branches,
+            "lastCommit": {
+                "hash": self.last_commit.hash,
+                "message": self.last_commit.message,
+                "author": self.last_commit.author,
+                "date": self.last_commit.date,
+            }
+            if self.last_commit
+            else None,
+            "hasChanges": self.has_changes,
+            "changedFiles": self.changed_files,
+            "changedFilesWithStatus": [
+                {
+                    "path": file_change.path,
+                    "status": file_change.status,
+                    "statusCode": file_change.status_code,
+                }
+                for file_change in self.changed_files_with_status
+            ],
+        }
+
+        if self.remote_status:
+            result["remoteStatus"] = {
+                "success": self.remote_status.success,
+                "remoteCommit": self.remote_status.remote_commit,
+                "hasRemoteChanges": self.remote_status.has_remote_changes or False,
+                "hasConflicts": self.remote_status.has_conflicts or False,
+                "message": self.remote_status.message,
+                "availableBranches": self.remote_status.available_branches,
+                "aheadBehind": {
+                    "ahead": self.remote_status.ahead_behind.ahead,
+                    "behind": self.remote_status.ahead_behind.behind,
+                }
+                if self.remote_status.ahead_behind
+                else None,
+            }
+        else:
+            result["remoteStatus"] = None
+
+        return result
+
+
+@dataclass
+class GitStatus:
+    available: bool
+    branch: str = ""
+    branches: List[str] = field(default_factory=list)
+    last_commit: Optional[GitCommit] = None
+    has_changes: bool = False
+    changed_files: List[str] = field(default_factory=list)
+    changed_files_with_status: List[GitFileChange] = field(default_factory=list)
+    remote_status: Optional[RemoteGitStatus] = None
+
+
+class GitRepositoryInterface(ABC):
+    """Abstract interface for Git repository implementations"""
+
+    def __init__(self, working_directory: Path):
+        self.working_directory = working_directory
+
+    @abstractmethod
+    def is_git_available(self) -> bool:
+        """Check if git functionality is available"""
+        pass
+
+    @abstractmethod
+    def is_git_repository(self) -> bool:
+        """Check if current directory is a git repository"""
+        pass
+
+    @abstractmethod
+    def find_git_root(self, start_path: Optional[Path] = None) -> Optional[Path]:
+        """Find the root directory of the git repository"""
+        pass
+
+    @abstractmethod
+    def configure_git_user(self, fallback_email: str, fallback_name: str):
+        """Ensure git user is configured for commits (required in CI environments)"""
+        pass
+
+    @abstractmethod
+    def get_current_branch(self) -> Optional[str]:
+        """Get the current branch name"""
+        pass
+
+    @abstractmethod
+    def get_all_branches(self) -> List[str]:
+        """Get all local branches"""
+        pass
+
+    @abstractmethod
+    def get_last_commit(self) -> Optional[GitCommit]:
+        """Get information about the last commit"""
+        pass
+
+    @abstractmethod
+    def get_commit_history(
+        self, limit: int = 10, offset: int = 0, branch: Optional[str] = None
+    ) -> List[GitCommit]:
+        """Get commit history with pagination"""
+        pass
+
+    @abstractmethod
+    def get_changed_files(self) -> List[str]:
+        """Get list of changed files"""
+        pass
+
+    @abstractmethod
+    def get_changed_files_with_status(self) -> List[GitFileChange]:
+        """Get list of changed files with their git status"""
+        pass
+
+    @abstractmethod
+    def has_uncommitted_changes(self) -> bool:
+        """Check if there are uncommitted changes"""
+        pass
+
+    @abstractmethod
+    def init_repository(self) -> bool:
+        """Initialize a new git repository"""
+        pass
+
+    @abstractmethod
+    def get_repository_status(self) -> GitStatus:
+        """Get comprehensive repository status"""
+        pass
+
+    @abstractmethod
+    def checkout_branch(self, branch_name: str) -> bool:
+        """Switch to a different branch"""
+        pass
+
+    @abstractmethod
+    def checkout_commit(self, commit_hash: str) -> bool:
+        """Switch to a specific commit (detached HEAD state)"""
+        pass
+
+    @abstractmethod
+    def pull_changes(
+        self,
+        strategy: str = "merge",
+        allow_unrelated: bool = True,
+        conflict_resolution: Optional[str] = "theirs",
+    ) -> bool:
+        """Pull changes from remote repository"""
+        pass
+
+    @abstractmethod
+    def commit_changes(self, message: str, add_all: bool = True) -> bool:
+        """Commit changes with a message"""
+        pass
+
+    @abstractmethod
+    def stash_changes(self, message: str = "WIP") -> bool:
+        """Stash uncommitted changes"""
+        pass
+
+    @abstractmethod
+    def get_remotes(self) -> List[str]:
+        """Get list of remote names"""
+        pass
+
+    @abstractmethod
+    def has_remote(self, remote_name: str) -> bool:
+        """Check if a remote exists"""
+        pass
+
+    @abstractmethod
+    def add_remote(self, remote_name: str, remote_url: str) -> bool:
+        """Add a remote to the repository"""
+        pass
+
+    @abstractmethod
+    def set_remote_url(self, remote_name: str, remote_url: str) -> bool:
+        """Set/update the URL for a remote"""
+        pass
+
+    @abstractmethod
+    def set_git_config(self, key: str, value: str, local: bool = True) -> bool:
+        """Set a git configuration value"""
+        pass
+
+    @abstractmethod
+    def get_git_config(self, key: str, local: bool = True) -> Optional[str]:
+        """Get a git configuration value"""
+        pass
+
+    @abstractmethod
+    def push_and_deploy(self, branch: str = "main") -> bool:
+        """Deploy to Abstra remote (push to abstra remote)"""
+        pass
+
+    @abstractmethod
+    def revert_commit(self, commit_hash: str) -> bool:
+        """Restore content from a previous commit by creating a new commit with that content"""
+        pass
+
+    @abstractmethod
+    def check_merge_conflicts(self, remote_commit: str) -> bool:
+        """Check if merging with remote commit would cause conflicts"""
+        pass
+
+    @abstractmethod
+    def get_ahead_behind_count(
+        self, local_commit: str, remote_commit: str
+    ) -> Tuple[int, int]:
+        """Calculate ahead/behind count between local and remote commits"""
+        pass

abstra_internals/repositories/linter/rules/env_in_bundle.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from abstra_internals.consts.filepaths import ABSTRA_IGNORE_FILEPATH
+from abstra_internals.consts.filepaths import GITIGNORE_FILEPATH
 from abstra_internals.repositories.linter.models import (
     LinterFix,
     LinterIssue,
@@ -10,11 +10,11 @@ from abstra_internals.services.fs import FileSystemService
 from abstra_internals.settings import Settings
 
 
-class AddEnvToAbstraIgnore(LinterFix):
-    label = "Add env to abstra ignore"
+class AddEnvToGitIgnore(LinterFix):
+    label = "Add env to git ignore"
 
     def fix(self):
-        abstraignore_file = Settings.root_path / ABSTRA_IGNORE_FILEPATH
+        abstraignore_file = Settings.root_path / GITIGNORE_FILEPATH
         with abstraignore_file.open("a") as file:
             file.write("\n.env")
 
@@ -22,7 +22,7 @@ class AddEnvToAbstraIgnore(LinterFix):
 class EnvInBundleFound(LinterIssue):
     def __init__(self) -> None:
         self.label = "You have not ignored the .env file"
-        self.fixes = [AddEnvToAbstraIgnore()]
+        self.fixes = [AddEnvToGitIgnore()]
 
 
 class EnvInBundle(LinterRule):

abstra_internals/repositories/linter/rules/env_in_bundle_test.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 
-from abstra_internals.consts.filepaths import ABSTRA_IGNORE_FILEPATH
+from abstra_internals.consts.filepaths import GITIGNORE_FILEPATH
 from abstra_internals.repositories.linter.rules.env_in_bundle import EnvInBundle
 from tests.fixtures import clear_dir, init_dir
 
@@ -21,21 +21,21 @@ class EnvInBundleTest(TestCase):
     def test_env_on_bundle_valid_with_env(self):
         rule = EnvInBundle()
         env_file = self.root / ".env"
-        abstraignore_file = self.root / ABSTRA_IGNORE_FILEPATH
+        abstraignore_file = self.root / GITIGNORE_FILEPATH
         abstraignore_file.write_text(".env")
         env_file.touch()
         self.assertEqual(len(rule.find_issues()), 0)
 
-    def tet_env_on_bundle_invalid_without_abstraignore_file(self):
+    def test_env_on_bundle_invalid_without_gitignore_file(self):
         env_file = self.root / ".env"
         env_file.touch()
         rule = EnvInBundle()
         self.assertEqual(len(rule.find_issues()), 1)
 
-    def test_env_on_bundle_invalid_with_abstraignore_file(self):
+    def test_env_on_bundle_invalid_with_gitignore_file(self):
         env_file = self.root / ".env"
         env_file.touch()
-        abstraignore_file = self.root / ABSTRA_IGNORE_FILEPATH
+        abstraignore_file = self.root / GITIGNORE_FILEPATH
         abstraignore_file.touch()
         rule = EnvInBundle()
         self.assertEqual(len(rule.find_issues()), 1)
@@ -47,7 +47,7 @@ class EnvInBundleTest(TestCase):
         self.assertEqual(len(rule.find_issues()), 1)
         rule.find_issues()[0].fixes[0].fix()
         self.assertEqual(len(rule.find_issues()), 0)
-        abstraignore_file = self.root / ABSTRA_IGNORE_FILEPATH
+        abstraignore_file = self.root / GITIGNORE_FILEPATH
         self.assertTrue(abstraignore_file.exists())
         with abstraignore_file.open("r") as file:
             content = file.read()

abstra_internals/repositories/linter/rules/venv_in_bundle.py

@@ -2,12 +2,13 @@ import sys
 from pathlib import Path
 from typing import List
 
-from abstra_internals.consts.filepaths import ABSTRA_IGNORE_FILEPATH
+from abstra_internals.consts.filepaths import GITIGNORE_FILEPATH
 from abstra_internals.repositories.linter.models import (
     LinterFix,
     LinterIssue,
     LinterRule,
 )
+from abstra_internals.services.fs import FileSystemService
 from abstra_internals.settings import Settings
 
 
@@ -30,14 +31,14 @@ def running_under_virtualenv() -> bool:
     return False
 
 
-class AddVenvToAbstraIgnore(LinterFix):
-    label = "Add virtual env to abstra ignore"
+class AddVenvToGitIgnore(LinterFix):
+    label = "Add virtual env to git ignore"
 
     def fix(self):
         root_path, prefix_path = get_root_and_prefix_path()
         venv_folder = prefix_path.replace(root_path, "").lstrip("/")
 
-        abstraignore_file = Settings.root_path / ABSTRA_IGNORE_FILEPATH
+        abstraignore_file = Settings.root_path / GITIGNORE_FILEPATH
         with abstraignore_file.open("a") as file:
             file.write("\n")
             file.write(venv_folder)
@@ -46,7 +47,7 @@ class AddVenvToAbstraIgnore(LinterFix):
 class VenvInBundleFound(LinterIssue):
     def __init__(self) -> None:
         self.label = "You have not ignored the virtualenv folder"
-        self.fixes = [AddVenvToAbstraIgnore()]
+        self.fixes = [AddVenvToGitIgnore()]
 
 
 class VenvInBundle(LinterRule):
@@ -57,19 +58,11 @@ class VenvInBundle(LinterRule):
         root_path, prefix_path = get_root_and_prefix_path()
         return prefix_path.startswith(root_path)
 
-    def virtualenv_in_abstraignore(self) -> bool:
-        abstraignore_file = Settings.root_path / ABSTRA_IGNORE_FILEPATH
-        if not abstraignore_file.exists():
-            return False
-
+    def virtualenv_ignored(self) -> bool:
         root_path, prefix_path = get_root_and_prefix_path()
         venv_folder = prefix_path.replace(root_path, "").lstrip("/")
 
-        for line in abstraignore_file.read_text(encoding="utf-8").split("\n"):
-            if line == venv_folder:
-                return True
-
-        return False
+        return FileSystemService.is_ignored(Path(venv_folder))
 
     def find_issues(self) -> List[LinterIssue]:
         if not running_under_virtualenv():
@@ -78,7 +71,7 @@ class VenvInBundle(LinterRule):
         if not self.virtualenv_inside_project():
             return []
 
-        if self.virtualenv_in_abstraignore():
+        if self.virtualenv_ignored():
             return []
 
         return [VenvInBundleFound()]

abstra_internals/server/blueprints/editor.py

@@ -11,6 +11,7 @@ from abstra_internals.server.routes import codebase as codebase_router
 from abstra_internals.server.routes import env_vars as envvars_router
 from abstra_internals.server.routes import executions as executions_router
 from abstra_internals.server.routes import forms as forms_router
+from abstra_internals.server.routes import git as git_router
 from abstra_internals.server.routes import hooks as hooks_router
 from abstra_internals.server.routes import jobs as jobs_router
 from abstra_internals.server.routes import linters as linters_router
@@ -104,6 +105,9 @@ def _get_api_bp(controller: MainController):
     web_editor_bp = web_editor_router.get_web_editor_bp(controller)
     bp.register_blueprint(web_editor_bp, url_prefix="/web-editor")
 
+    git_bp = git_router.get_editor_bp(controller)
+    bp.register_blueprint(git_bp, url_prefix="/git")
+
     return bp
 
 

abstra_internals/server/routes/git.py

@@ -0,0 +1,190 @@
+from typing import cast
+
+import flask
+
+from abstra_internals.controllers.git import EmailProvider, GitController
+from abstra_internals.controllers.main import MainController
+from abstra_internals.environment import EDITOR_MODE
+from abstra_internals.usage import editor_usage
+
+
+def get_editor_bp(controller: MainController):
+    bp = flask.Blueprint("editor_git", __name__)
+    if EDITOR_MODE == "local":
+        # `MainController` implements the get_email method at runtime, but the
+        # static type of `MainController` may not be recognized as an
+        # `EmailProvider` by the type checker.
+        git_controller = GitController(email_provider=cast(EmailProvider, controller))
+    else:
+        git_controller = GitController()
+
+    @bp.get("/status")
+    @editor_usage
+    def _get_git_status():
+        try:
+            status = git_controller.get_status()
+            return flask.jsonify(status)
+        except Exception as e:
+            return flask.jsonify({"available": False, "error": str(e)}), 500
+
+    @bp.post("/checkout")
+    @editor_usage
+    def _checkout_branch():
+        if not flask.request.json:
+            flask.abort(400)
+
+        branch_name = flask.request.json.get("branch")
+        commit_hash = flask.request.json.get("commitHash")
+
+        if not branch_name and not commit_hash:
+            return flask.jsonify(
+                {"success": False, "message": "Branch name or commit hash is required"}
+            ), 400
+
+        if branch_name and commit_hash:
+            return flask.jsonify(
+                {
+                    "success": False,
+                    "message": "Provide either branch or commit, not both",
+                }
+            ), 400
+
+        try:
+            if branch_name:
+                result = git_controller.checkout_branch(branch_name)
+            else:
+                result = git_controller.checkout_commit(commit_hash)
+
+            status_code = 200 if result["success"] else 400
+            return flask.jsonify(result), status_code
+        except Exception as e:
+            return flask.jsonify({"success": False, "message": str(e)}), 500
+
+    @bp.post("/pull")
+    @editor_usage
+    def _pull_changes():
+        try:
+            data = flask.request.json
+            if data is None:
+                flask.abort(400)
+
+            strategy = data.get("strategy", "merge")
+            allow_unrelated = data.get("allowUnrelated", True)
+            conflict_resolution = data.get("conflictResolution", "theirs")
+
+            result = git_controller.pull_changes(
+                strategy=strategy,
+                allow_unrelated=allow_unrelated,
+                conflict_resolution=conflict_resolution,
+            )
+            status_code = 200 if result["success"] else 400
+            return flask.jsonify(result), status_code
+        except Exception as e:
+            return flask.jsonify({"success": False, "message": str(e)}), 500
+
+    @bp.post("/commit")
+    @editor_usage
+    def _commit_changes():
+        if not flask.request.json:
+            flask.abort(400)
+
+        message = flask.request.json.get("message")
+        if not message:
+            return flask.jsonify(
+                {"success": False, "message": "Commit message is required"}
+            ), 400
+
+        try:
+            result = git_controller.commit_changes(message)
+            status_code = 200 if result["success"] else 400
+            return flask.jsonify(result), status_code
+        except Exception as e:
+            return flask.jsonify({"success": False, "message": str(e)}), 500
+
+    @bp.post("/stash")
+    @editor_usage
+    def _stash_changes():
+        try:
+            message = "Discarding WIP changes"
+
+            if flask.request.is_json and flask.request.json:
+                message = flask.request.json.get("message", "Discarding WIP changes")
+
+            result = git_controller.stash_changes(message)
+            status_code = 200 if result["success"] else 400
+            return flask.jsonify(result), status_code
+        except Exception as e:
+            return flask.jsonify({"success": False, "message": str(e)}), 500
+
+    @bp.get("/commits")
+    @editor_usage
+    def _get_commit_history():
+        try:
+            limit = int(flask.request.args.get("limit", 200))
+            offset = int(flask.request.args.get("offset", 0))
+            branch = flask.request.args.get("branch")
+
+            result = git_controller.get_commit_history(
+                limit=limit, offset=offset, branch=branch
+            )
+            return flask.jsonify(result), 200
+        except Exception as e:
+            return flask.jsonify(
+                {"commits": [], "hasMore": False, "error": str(e)}
+            ), 500
+
+    @bp.post("/deploy")
+    @editor_usage
+    def _deploy_to_abstra():
+        try:
+            controller.linter_repository.update_checks()
+            issues = controller.linter_repository.get_blocking_checks()
+
+            if len(issues) > 0:
+                return flask.jsonify(
+                    {
+                        "success": False,
+                        "message": "Please fix all linter issues before deploying your project.",
+                    }
+                ), 400
+
+            data = flask.request.get_json(silent=True)
+            branch = data.get("branch", "main") if data else "main"
+
+            result = git_controller.push_and_deploy(branch)
+            status_code = 200 if result["success"] else 400
+            return flask.jsonify(result), status_code
+        except Exception as e:
+            return flask.jsonify({"success": False, "message": str(e)}), 500
+
+    @bp.get("/remotes")
+    @editor_usage
+    def _get_remotes():
+        try:
+            result = git_controller.get_remotes()
+            return flask.jsonify(result), 200
+        except Exception as e:
+            return flask.jsonify(
+                {"remotes": [], "hasAbstraRemote": False, "error": str(e)}
+            ), 500
+
+    @bp.post("/revert")
+    @editor_usage
+    def _revert_commit():
+        if not flask.request.json:
+            flask.abort(400)
+
+        commit_hash = flask.request.json.get("commitHash")
+        if not commit_hash:
+            return flask.jsonify(
+                {"success": False, "message": "Commit hash is required"}
+            ), 400
+
+        try:
+            result = git_controller.revert_commit(commit_hash)
+            status_code = 200 if result["success"] else 400
+            return flask.jsonify(result), status_code
+        except Exception as e:
+            return flask.jsonify({"success": False, "message": str(e)}), 500
+
+    return bp

abstra_internals/server/routes/workspace.py

@@ -112,7 +112,7 @@ def get_editor_bp(controller: MainController):
     @bp.post("/deploy")
     @editor_usage
     def _deploy():
-        controller.deploy()
+        controller.deploy_without_git()
         return {"success": True}
 
     return bp