datasecops-cli 0.4.8__tar.gz → 0.4.9__tar.gz

{datasecops_cli-0.4.8 → datasecops_cli-0.4.9}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to the DataSecOps CLI are documented in this file.
 
+## [0.4.9] - 2026-05-21
+
+### Added
+
+- **Remove from test** — new git menu option to remove a branch from the test integration branch. Displays squash-merged branches by name and drops the selected commit from test's history via rebase, then force-pushes. The test branch is never deleted.
+- **Branch cleanup** — new option in branch management to delete all local branches (except main, test, and current) and prune stale remote tracking references in one step.
+- **Git operations documentation** — `docs/git-operations.md` documenting the full branch strategy, menu structure, and behaviour of each operation.
+- **Ticket integration plan** — `plans/ticket-integration-plan.md` specifying the design for Azure DevOps, Jira, and GitHub Projects ticket fetching during branch creation.
+
+### Changed
+
+- **Squash merge into test rebases onto main first** — prevents drift by rebasing the test branch onto `origin/main` before squash-merging, ensuring test always has main as its base with squash commits layered on top.
+- **Branch creation uses configured `branch_format`** — branch names are now built using the `branch_format` field from the framework's SOURCE_CONTROL config instead of a hardcoded pattern.
+- **Deploy to prod enforced from main only** — production deployments are hardcoded to `force=False` and can only originate from the main branch.
+- **Protected branches** — `main` and `test` cannot be deleted via delete, cleanup, or reset operations.
+- **Stash/restore on branch-switching operations** — squash merge and remove from test now stash uncommitted changes before switching branches and restore them afterward, preventing dirty-tree errors.
+- **Test branch auto-creation** — if neither local nor remote `test` branch exists, it is created from `origin/main` automatically during squash merge or remove operations.
+
 ## [0.4.8] - 2026-05-20
 
 ### Added

{datasecops_cli-0.4.8 → datasecops_cli-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datasecops-cli
-Version: 0.4.8
+Version: 0.4.9
 Summary: DataSecOps Framework CLI for Snowflake Native App
 License-Expression: MIT
 License-File: LICENSE

datasecops_cli-0.4.9/docs/git-operations.md

@@ -0,0 +1,205 @@
+# Git Operations
+
+The CLI provides a structured git workflow designed around a branching strategy where feature branches are squash-merged into a `test` branch for integration testing, and only `main` is deployed to production.
+
+## Branch Strategy
+
+```
+main ─────────────────────────────────────── prod
+  │
+  ├── feature/ticket_name ──┐
+  ├── bugfix/ticket_name  ──┤── squash merge ──► test
+  └── hotfix/ticket_name  ──┘
+```
+
+- `main` is the source of truth and the only branch that deploys to production
+- `test` is an integration branch built on top of main (rebased to prevent drift)
+- Feature/bugfix/hotfix branches are created from main and squash-merged into test
+- Branches can be removed from test without affecting main or other branches on test
+
+## Main Menu
+
+| Option | Name | Description |
+|--------|------|-------------|
+| 1 | Branching | Manage branches (create, checkout, switch, delete, prune, cleanup, reset) |
+| 2 | Commit | Stage all changes and commit with a message, then push |
+| 3 | Push | Push current branch to remote |
+| 4 | Pull | Pull latest changes from remote for current branch |
+| 5 | Rebase | Rebase current branch with main |
+| 6 | Deploy | Deploy to an environment branch (e.g. test, prod) |
+| 7 | Squash to test | Squash merge current branch into test |
+| 8 | Remove from test | Remove a branch's changes from test |
+
+---
+
+## Operations Detail
+
+### 1. Branching
+
+Submenu for branch management operations.
+
+| Option | Name | Description |
+|--------|------|-------------|
+| 1 | New | Create a new branch from main |
+| 2 | Checkout | Checkout a remote branch locally |
+| 3 | Switch | Switch to an existing local branch |
+| 4 | Delete | Delete a local branch (and its remote) |
+| 5 | Prune | Remove stale remote tracking references |
+| 6 | Cleanup | Delete all local branches (except main, test, current) and prune remote |
+| 7 | Reset | Hard reset to main and delete all local branches |
+
+#### New Branch
+
+Creates a branch using the naming convention `{type}/{ticket}_{name}`:
+- Prompts for branch type (feature, bugfix, hotfix — or configured types)
+- Prompts for ticket number (required or optional based on config)
+- Prompts for branch name
+- Creates from `origin/main`, checks out, and pushes with upstream tracking
+
+#### Delete Branch
+
+- Cannot delete the current branch
+- Cannot delete protected branches (`main`, `test`)
+- Deletes both the local branch and the remote branch
+
+#### Cleanup
+
+- Deletes all local branches except `main`, `test`, and the current branch
+- Prunes stale remote tracking references
+
+#### Reset to Main
+
+- Checks out main and hard resets to `origin/main`
+- Deletes all local branches except `main` and `test`
+
+---
+
+### 2. Commit
+
+- Detects uncommitted changes (modified and untracked files)
+- Displays a summary of changed files
+- Prompts for a commit message
+- Stages all changes, commits, and pushes to remote
+
+---
+
+### 3. Push
+
+Pushes the current branch to its remote counterpart.
+
+---
+
+### 4. Pull
+
+Pulls the latest changes from remote for the current branch.
+
+---
+
+### 5. Rebase
+
+Submenu for rebase operations.
+
+| Option | Name | Description |
+|--------|------|-------------|
+| 1 | Rebase | Standard rebase of current branch onto `origin/main` |
+| 2 | Squash & rebase | Squash all commits into one, then rebase onto main |
+| 3 | Continue | Continue rebase after resolving conflicts |
+| 4 | Abort | Abort an in-progress rebase |
+
+#### Standard Rebase
+
+Fetches from origin and rebases the current branch onto `origin/main`. If conflicts occur, you can resolve them and use "continue" or "abort".
+
+#### Squash & Rebase
+
+Soft-resets to the main branch point, creates a single squash commit, then rebases onto `origin/main`. This gives you a clean single commit on top of main.
+
+---
+
+### 6. Deploy
+
+Pushes the current branch to a configured deployment branch.
+
+**Production rules:**
+- Production deployments can only come from the `main` branch
+- If not on main, the CLI will offer to switch to main first
+- Production pushes are never force-pushed
+
+**Non-production environments:**
+- Any branch can be pushed to non-production environments
+- Force-push is used for non-production deployments
+
+---
+
+### 7. Squash to Test
+
+Squash merges the current feature branch into the `test` integration branch.
+
+**Pre-flight checks (before merge):**
+
+1. **Branch must be up to date with main** — if your branch is behind `origin/main`, the merge is rejected. Rebase with main first.
+2. **File conflict detection** — checks if any files modified on your branch are also modified by another branch's squash-merge commit currently on test:
+   - If the conflicting branch **still exists on remote** → merge is **rejected**. You must resolve with the branch owner or remove that branch from test first.
+   - If the conflicting branch **no longer exists** (stale) → the stale commit is **automatically removed** from test before proceeding.
+
+**What it does (after pre-flight passes):**
+1. Stashes any uncommitted changes
+2. Fetches latest from origin
+3. Checks out the `test` branch (creates it from `origin/main` if it doesn't exist)
+4. Pulls latest test
+5. Rebases test onto `origin/main` to prevent drift from main
+6. Squash merges the feature branch into test
+7. Commits with message: `squash merge: {branch_name} into test`
+8. Force-pushes test (required due to the rebase)
+9. Checks out the original branch and restores stashed changes
+
+**Key behaviours:**
+- The test branch always has `main` as its base — squash commits are layered on top
+- Force-push is used because the rebase rewrites test's history to stay aligned with main
+- The commit message naming convention enables the "remove from test" feature
+- File overlap detection prevents two active branches from silently overwriting each other's changes on test
+
+---
+
+### 8. Remove from Test
+
+Removes a previously squash-merged branch from the test branch by dropping its commit from history.
+
+**What it does:**
+1. Fetches latest and lists all squash-merge commits on test (identified by commit message prefix `squash merge:`)
+2. Displays the branches currently on test by name
+3. User selects which branch to remove
+4. Stashes any uncommitted changes
+5. Checks out test
+6. Rebases test, dropping the selected commit: `git rebase --onto <commit>^ <commit> test`
+7. Force-pushes test
+8. Checks out the original branch and restores stashed changes
+
+**Key behaviours:**
+- The commit is completely removed from test's history (not reverted)
+- All other branches on test remain intact
+- The test branch itself is never deleted
+- If the rebase fails (e.g. conflicts), it aborts and returns to the original branch
+
+---
+
+## Protected Branches
+
+The following branches are protected and cannot be deleted:
+- `main` — source of truth, deploys to production
+- `test` — integration branch for testing
+
+These are protected across all operations: delete, cleanup, and reset.
+
+## Error Handling
+
+All operations that switch branches follow a safe pattern:
+1. Stash uncommitted changes before switching
+2. Perform the operation
+3. Switch back to the original branch
+4. Restore stashed changes
+
+If any step fails, the error handler will:
+- Abort any in-progress rebase/revert
+- Switch back to the original branch
+- Restore stashed changes

{datasecops_cli-0.4.8 → datasecops_cli-0.4.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datasecops-cli"
-version = "0.4.8"
+version = "0.4.9"
 description = "DataSecOps Framework CLI for Snowflake Native App"
 readme = "README.md"
 requires-python = ">=3.10"

{datasecops_cli-0.4.8 → datasecops_cli-0.4.9}/src/datasecops_cli/menus/git_operations.py

@@ -15,7 +15,7 @@ class GitOperationsMenu:
         self.source_control = source_control
         self.deployment_branches = deployment_branches
         self.profile_name = profile_name
-    
+
     def show(self) -> None:
         self._menu()
         option = get_input_number("Choose an option: ")
@@ -36,9 +36,11 @@ class GitOperationsMenu:
                 self._squash_merge_test()
             elif option == 8:
                 self._cherry_pick_test()
+            elif option == 9:
+                self._deploy_prod()
             self._menu()
             option = get_input_number("Choose an option: ")
-    
+
     def _menu(self) -> None:
         clear()
         section_header("Git Operations", self.profile_name, self.git.get_current_branch())
@@ -49,9 +51,10 @@ class GitOperationsMenu:
         menu_option(5, "rebase            - Rebase with main")
         menu_option(6, "deploy            - Deploy to environment")
         menu_option(7, "squash to test    - Squash merge into test")
-        menu_option(8, "cherry-pick test  - Cherry-pick commits from test")
+        menu_option(8, "remove from test  - Remove a branch from test")
+        menu_option(9, "deploy to prod    - Deploy main to production")
         menu_option(0, "back              - Return to main menu")
-    
+
     def _branch_menu(self) -> None:
         clear()
         display_action_header("Branch Management")
@@ -60,7 +63,8 @@ class GitOperationsMenu:
         menu_option(3, "switch   - Switch to local branch")
         menu_option(4, "delete   - Delete local branch")
         menu_option(5, "prune    - Prune remote branches")
-        menu_option(6, "reset    - Reset to main")
+        menu_option(6, "cleanup  - Delete local branches & prune remote")
+        menu_option(7, "reset    - Reset to main")
         menu_option(0, "back     - Return to git menu")
         option = get_input_number("Choose an option: ")
         if option == 1:
@@ -86,19 +90,21 @@ class GitOperationsMenu:
         elif option == 5:
             self.git.prune_remote_branches()
         elif option == 6:
+            self.git.cleanup_branches()
+        elif option == 7:
             if get_input_true_false("This will delete all local branches. Continue?", "n"):
                 self.git.reset_to_main()
         complete_action()
-    
+
     def _create_branch(self) -> None:
         branch_types = {bt.name: bt.name for bt in self.source_control.branch_types}
         if not branch_types:
             branch_types = {"feature": "feature", "bugfix": "bugfix", "hotfix": "hotfix"}
-        
+
         selected_type = select_from_dict(branch_types, "branch type")
         if selected_type == "back":
             return
-        
+
         ticket = ""
         if self.source_control.ticket_number_required:
             ticket = get_input_string("Enter ticket number: ")
@@ -106,51 +112,59 @@ class GitOperationsMenu:
                 return
         else:
             ticket = get_input_string("Enter ticket number (or press Enter to skip): ", allow_empty=True)
-        
+
         name = get_input_string("Enter branch name: ")
         if name == "0":
             return
-        
-        self.git.create_branch(selected_type, ticket, name.replace(" ", "-").lower())
-    
+
+        branch_name = name.replace(" ", "-").lower()
+        fmt = self.source_control.branch_format
+        if ticket:
+            full_name = fmt.format(branch_type=selected_type, branch_name=f"{ticket}_{branch_name}")
+        else:
+            full_name = fmt.format(branch_type=selected_type, branch_name=branch_name)
+
+        self.git.create_branch(full_name)
+
     def _commit(self) -> None:
         display_action_header("Commit Changes")
         if not self.git.is_dirty():
             info_line("No changes to commit")
             complete_action()
             return
-        
+
         info_line(f"{self.git.get_uncommitted_file_count()} change(s) detected")
         for f in self.git.get_changed_files():
             info_line(f"  M {f.file}")
         for f in self.git.get_new_files():
             info_line(f"  + {f.file}")
-        
+
         message = get_input_string("Enter commit message (0 to cancel): ")
         if message == "0":
             return
-        
+
         self.git.commit_changes(message)
         self.git.push_branch()
         complete_action()
-    
+
     def _push(self) -> None:
         display_action_header("Push")
         self.git.push_branch()
         complete_action()
-    
+
     def _pull(self) -> None:
         display_action_header("Pull")
         self.git.pull_branch()
         complete_action()
-    
+
     def _rebase_menu(self) -> None:
         clear()
         display_action_header("Rebase Options")
         menu_option(1, "rebase           - Standard rebase with main")
         menu_option(2, "squash & rebase  - Squash commits then rebase")
-        menu_option(3, "continue         - Continue after resolving conflicts")
-        menu_option(4, "abort            - Abort rebase")
+        menu_option(3, "squash           - Squash all commits into one")
+        menu_option(4, "continue         - Continue after resolving conflicts")
+        menu_option(5, "abort            - Abort rebase")
         menu_option(0, "back             - Return to git menu")
         option = get_input_number("Choose an option: ")
         if option == 1:
@@ -158,56 +172,113 @@ class GitOperationsMenu:
         elif option == 2:
             self.git.squash_and_rebase()
         elif option == 3:
-            self.git.rebase_continue()
+            self.git.squash_commits()
         elif option == 4:
+            self.git.rebase_continue()
+        elif option == 5:
             self.git.rebase_abort()
         complete_action()
-    
+
     def _deploy(self) -> None:
         display_action_header("Deploy to Environment")
-        if not self.deployment_branches:
+        
+        # Build environment list from framework config, filtering non-deployable environments
+        excluded = {"unit-test", "ci", "local-dev", "prod", "test"}
+        environments = {}
+        if self.source_control.environments:
+            for env in self.source_control.environments:
+                if env.branch_name and env.branch_name.lower() not in excluded:
+                    environments[env.branch_name] = env.branch_name
+        
+        # Fall back to deployment_branches if no framework environments configured
+        if not environments:
+            environments = {
+                k: v for k, v in self.deployment_branches.items()
+                if k.lower() not in excluded
+            }
+        
+        if not environments:
             error_line("No deployment branches configured")
             complete_action()
             return
-        
-        selected = select_from_dict(self.deployment_branches, "environment")
+
+        selected = select_from_dict(environments, "environment")
         if selected == "back":
             return
-        
+
+        current = self.git.get_current_branch()
+        info_line(f"This will squash {current} and force-push to {selected}")
+        if get_input_true_false("Continue?", "n"):
+            self.git.squash_push_to_destination(selected)
+        complete_action()
+    
+    def _deploy_prod(self) -> None:
+        display_action_header("Deploy to Production")
         current = self.git.get_current_branch()
-        if selected.lower() == "prod" and current.lower() != "main":
+        if current.lower() != "main":
             warning_line("Production deployments must come from the main branch")
             if get_input_true_false("Switch to main and deploy?", "n"):
                 self.git.checkout_branch("main")
                 self.git.pull_branch()
             else:
+                complete_action()
                 return
-        
-        force = selected.lower() != "prod"
-        self.git.push_branch_to_destination(selected, force=force)
+        info_line("This will push main to prod (no force-push)")
+        if get_input_true_false("Continue?", "n"):
+            self.git.push_branch_to_destination("prod", force=False)
         complete_action()
-    
+
     def _squash_merge_test(self) -> None:
         display_action_header("Squash Merge into Test")
         current = self.git.get_current_branch()
         info_line(f"This will squash merge {current} into the test branch")
+        
+        # Check current branch is up to date with main
+        if not self.git.is_branch_up_to_date_with_main():
+            error_line("Your branch is not up to date with main. Rebase with main first.")
+            complete_action()
+            return
+        
+        # Check for file overlaps with other branches on test
+        conflicts = self.git.get_test_file_conflicts()
+        if conflicts:
+            # If conflicting branch still exists, reject
+            active_conflicts = [c for c in conflicts if c["branch_exists"]]
+            if active_conflicts:
+                error_line("Cannot merge: files overlap with active branches on test:")
+                for c in active_conflicts:
+                    warning_line(f"  {c['branch']}:")
+                    for f in c["files"]:
+                        info_line(f"    - {f}")
+                error_line("Resolve with the branch owner or remove that branch from test first.")
+                complete_action()
+                return
+            
+            # Conflicting branches no longer exist — remove their stale commits and proceed
+            stale_conflicts = [c for c in conflicts if not c["branch_exists"]]
+            if stale_conflicts:
+                for c in stale_conflicts:
+                    warning_line(f"Removing stale branch {c['branch']} from test (branch no longer exists)")
+                    self.git.revert_from_test(c["sha"], c["branch"])
+        
         if get_input_true_false("Continue?", "n"):
             self.git.squash_merge_into_test()
         complete_action()
-    
+
     def _cherry_pick_test(self) -> None:
-        display_action_header("Cherry-pick from Test")
+        display_action_header("Remove Branch from Test")
         commits = self.git.get_test_commits()
         if not commits:
-            info_line("No commits found on test branch")
+            info_line("No branch merges found on test branch")
             complete_action()
             return
-        
-        info_line("Recent commits on test:")
+
+        info_line("Branches currently on test:")
         for i, c in enumerate(commits):
-            info_line(f"  [{i+1}] {c['sha'][:8]} - {c['message'][:60]}")
-        
-        choice = get_input_number("Select commit number (0 to cancel): ")
+            info_line(f"  [{i+1}] {c['branch']}  ({c['sha'][:8]})")
+
+        choice = get_input_number("Select branch to remove (0 to cancel): ")
         if 0 < choice <= len(commits):
-            self.git.cherry_pick_from_test(commits[choice-1]["sha"])
+            selected = commits[choice-1]
+            self.git.revert_from_test(selected["sha"], selected["branch"])
         complete_action()

datasecops_cli-0.4.9/src/datasecops_cli/services/git_service.py

@@ -0,0 +1,399 @@
+from pathlib import Path
+from typing import Optional
+from git import Repo, GitCommandError
+
+from datasecops_cli.models.git_helpers import GitCommitHelper
+from datasecops_cli.utilities.display import info_line, error_line, success_line, warning_line
+
+
+class GitService:
+    """Git operations via GitPython."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo = Repo(repo_path)
+    
+    def get_current_branch(self) -> str:
+        try:
+            return self.repo.active_branch.name
+        except TypeError:
+            return "DETACHED HEAD"
+    
+    def is_dirty(self) -> bool:
+        return self.repo.is_dirty(untracked_files=True)
+    
+    def get_uncommitted_file_count(self) -> int:
+        return len(self.repo.index.diff(None)) + len(self.repo.untracked_files)
+    
+    def get_changed_files(self) -> list[GitCommitHelper]:
+        return [GitCommitHelper(file=d.a_path) for d in self.repo.index.diff(None)]
+    
+    def get_new_files(self) -> list[GitCommitHelper]:
+        return [GitCommitHelper(file=f) for f in self.repo.untracked_files]
+    
+    def get_local_branches(self) -> dict[str, str]:
+        return {b.name: b.name for b in self.repo.branches}
+    
+    def get_remote_branches(self) -> dict[str, str]:
+        self.repo.remotes.origin.fetch()
+        return {
+            ref.remote_head: ref.remote_head
+            for ref in self.repo.remotes.origin.refs
+            if ref.remote_head != "HEAD"
+        }
+    
+    def create_branch(self, branch_name: str) -> None:
+        info_line(f"Creating branch: {branch_name}")
+        self.repo.remotes.origin.fetch()
+        new_branch = self.repo.create_head(branch_name, "origin/main")
+        new_branch.checkout()
+        self.repo.remotes.origin.push(branch_name, set_upstream=True)
+        success_line(f"Branch {branch_name} created and checked out")
+    
+    def checkout_branch(self, remote_name: str) -> None:
+        info_line(f"Checking out: {remote_name}")
+        self.repo.remotes.origin.fetch()
+        try:
+            self.repo.git.checkout(remote_name)
+        except GitCommandError:
+            self.repo.git.checkout("-b", remote_name, f"origin/{remote_name}")
+        success_line(f"Switched to {remote_name}")
+    
+    def switch_branch(self, name: str) -> None:
+        self.repo.branches[name].checkout()
+        success_line(f"Switched to {name}")
+    
+    def delete_branch(self, name: str) -> None:
+        if name == self.get_current_branch():
+            error_line("Cannot delete the current branch")
+            return
+        if name in ("main", "test"):
+            error_line(f"Cannot delete protected branch '{name}'")
+            return
+        self.repo.delete_head(name, force=True)
+        try:
+            self.repo.remotes.origin.push(refspec=f":{name}")
+        except GitCommandError:
+            pass
+        success_line(f"Deleted branch {name}")
+    
+    def commit_changes(self, message: str) -> None:
+        self.repo.git.add(A=True)
+        self.repo.index.commit(message)
+        success_line(f"Committed: {message}")
+    
+    def push_branch(self) -> None:
+        branch = self.get_current_branch()
+        info_line(f"Pushing {branch}...")
+        self.repo.remotes.origin.push(branch)
+        success_line(f"Pushed {branch}")
+    
+    def pull_branch(self) -> None:
+        branch = self.get_current_branch()
+        info_line(f"Pulling {branch}...")
+        self.repo.remotes.origin.pull(branch)
+        success_line(f"Pulled {branch}")
+    
+    def push_branch_to_destination(self, destination: str, force: bool = False) -> None:
+        current = self.get_current_branch()
+        info_line(f"Pushing {current} to {destination}...")
+        refspec = f"{current}:{destination}"
+        self.repo.remotes.origin.push(refspec=refspec, force=force)
+        success_line(f"Pushed to {destination}")
+    
+    def squash_push_to_destination(self, destination: str) -> None:
+        """Squash all commits on the current branch into one and force-push to destination."""
+        current = self.get_current_branch()
+        stashed = False
+        try:
+            if self.repo.is_dirty(untracked_files=True):
+                self.repo.git.stash("push", "-u")
+                stashed = True
+            self.repo.remotes.origin.fetch()
+            main_commit = self.repo.commit("origin/main")
+            # Create a squashed commit on a temporary detached state
+            self.repo.git.reset("--soft", main_commit.hexsha)
+            self.repo.index.commit(f"deploy: {current} to {destination}")
+            # Force-push to destination
+            refspec = f"HEAD:{destination}"
+            self.repo.remotes.origin.push(refspec=refspec, force=True)
+            # Restore the branch to its original state
+            self.repo.git.reset("--soft", f"origin/{current}")
+            if stashed:
+                self.repo.git.stash("pop")
+            success_line(f"Squash deployed {current} to {destination}")
+        except GitCommandError as e:
+            error_line(f"Squash deploy failed: {e}")
+            try:
+                self.repo.git.reset("--soft", f"origin/{current}")
+            except Exception:
+                pass
+            if stashed:
+                try:
+                    self.repo.git.stash("pop")
+                except Exception:
+                    pass
+    
+    def rebase_with_main(self) -> bool:
+        try:
+            self.repo.remotes.origin.fetch()
+            self.repo.git.rebase("origin/main")
+            success_line("Rebase with main completed")
+            return True
+        except GitCommandError as e:
+            error_line(f"Rebase conflict: {e}")
+            warning_line("Resolve conflicts then use 'rebase continue' or 'rebase abort'")
+            return False
+    
+    def rebase_continue(self) -> None:
+        self.repo.git.rebase("--continue")
+        success_line("Rebase continued")
+    
+    def rebase_abort(self) -> None:
+        self.repo.git.rebase("--abort")
+        success_line("Rebase aborted")
+    
+    def squash_and_rebase(self) -> bool:
+        try:
+            self.repo.remotes.origin.fetch()
+            main_commit = self.repo.commit("origin/main")
+            current = self.get_current_branch()
+            self.repo.git.reset("--soft", main_commit.hexsha)
+            self.repo.index.commit(f"squash: {current}")
+            self.repo.git.rebase("origin/main")
+            success_line("Squash and rebase completed")
+            return True
+        except GitCommandError as e:
+            error_line(f"Squash rebase failed: {e}")
+            return False
+    
+    def squash_commits(self) -> bool:
+        """Squash all commits on the current branch into a single commit and force-push."""
+        stashed = False
+        try:
+            if self.repo.is_dirty(untracked_files=True):
+                self.repo.git.stash("push", "-u")
+                stashed = True
+            self.repo.remotes.origin.fetch()
+            main_commit = self.repo.commit("origin/main")
+            current = self.get_current_branch()
+            # Collect all commit messages from the branch
+            commits = list(self.repo.iter_commits(f"origin/main..HEAD"))
+            messages = [c.message.strip() for c in reversed(commits)]
+            squash_message = f"squash: {current}\n\n" + "\n".join(f"- {m}" for m in messages)
+            self.repo.git.reset("--soft", main_commit.hexsha)
+            self.repo.index.commit(squash_message)
+            self.repo.remotes.origin.push(current, force=True)
+            if stashed:
+                self.repo.git.stash("pop")
+            success_line(f"Squashed {len(commits)} commits on {current} and force-pushed")
+            return True
+        except GitCommandError as e:
+            error_line(f"Squash failed: {e}")
+            if stashed:
+                try:
+                    self.repo.git.stash("pop")
+                except Exception:
+                    pass
+            return False
+    
+    def _checkout_test(self) -> None:
+        """Checkout the test branch, creating from origin/test or origin/main if needed."""
+        try:
+            self.repo.git.checkout("test")
+        except GitCommandError:
+            try:
+                self.repo.git.checkout("-b", "test", "origin/test")
+            except GitCommandError:
+                self.repo.git.checkout("-b", "test", "origin/main")
+    
+    def is_branch_up_to_date_with_main(self) -> bool:
+        """Check if the current branch contains all commits from origin/main."""
+        try:
+            self.repo.remotes.origin.fetch()
+            # If merge-base of HEAD and origin/main equals origin/main, we're up to date
+            merge_base = self.repo.git.merge_base("HEAD", "origin/main")
+            main_sha = self.repo.commit("origin/main").hexsha
+            return merge_base.strip() == main_sha
+        except Exception:
+            return False
+    
+    def squash_merge_into_test(self) -> bool:
+        current = self.get_current_branch()
+        stashed = False
+        try:
+            if self.repo.is_dirty(untracked_files=True):
+                self.repo.git.stash("push", "-u")
+                stashed = True
+            self.repo.remotes.origin.fetch()
+            self._checkout_test()
+            try:
+                self.repo.remotes.origin.pull("test")
+            except GitCommandError:
+                pass
+            # Rebase test onto main to prevent drift
+            self.repo.git.rebase("origin/main")
+            self.repo.git.merge("--squash", current)
+            self.repo.index.commit(f"squash merge: {current} into test")
+            self.repo.remotes.origin.push("test", set_upstream=True, force=True)
+            self.repo.git.checkout(current)
+            if stashed:
+                self.repo.git.stash("pop")
+            success_line(f"Squash merged {current} into test")
+            return True
+        except GitCommandError as e:
+            error_line(f"Squash merge failed: {e}")
+            try:
+                self.repo.git.rebase("--abort")
+            except Exception:
+                pass
+            try:
+                self.repo.git.checkout(current)
+            except Exception:
+                pass
+            if stashed:
+                try:
+                    self.repo.git.stash("pop")
+                except Exception:
+                    pass
+            return False
+    
+    def revert_from_test(self, commit_sha: str, branch_name: str) -> bool:
+        current = self.get_current_branch()
+        stashed = False
+        short_sha = commit_sha[:8]
+        try:
+            if self.repo.is_dirty(untracked_files=True):
+                self.repo.git.stash("push", "-u")
+                stashed = True
+            self.repo.remotes.origin.fetch()
+            self._checkout_test()
+            try:
+                self.repo.remotes.origin.pull("test")
+            except GitCommandError:
+                pass
+            # Verify commit has exactly one parent (not a merge commit)
+            target = self.repo.commit(commit_sha)
+            if len(target.parents) != 1:
+                error_line(f"Cannot remove {branch_name} ({short_sha}): commit has multiple parents")
+                self.repo.git.checkout(current)
+                if stashed:
+                    self.repo.git.stash("pop")
+                return False
+            self.repo.git.rebase("--onto", f"{commit_sha}^", commit_sha, "test")
+            self.repo.remotes.origin.push("test", force=True)
+            self.repo.git.checkout(current)
+            if stashed:
+                self.repo.git.stash("pop")
+            success_line(f"Removed {branch_name} from test")
+            return True
+        except GitCommandError as e:
+            error_line(f"Remove failed for {branch_name} ({short_sha}): {e}")
+            try:
+                self.repo.git.rebase("--abort")
+            except Exception:
+                pass
+            try:
+                self.repo.git.checkout(current)
+            except Exception:
+                pass
+            if stashed:
+                try:
+                    self.repo.git.stash("pop")
+                except Exception:
+                    pass
+            return False
+    
+    def get_test_file_conflicts(self) -> list[dict]:
+        """Check if files on current branch overlap with existing squash-merge commits on test.
+        
+        Returns list of conflicts with branch name, files, sha, and whether the branch still exists.
+        """
+        try:
+            self.repo.remotes.origin.fetch()
+            current = self.get_current_branch()
+            # Files changed on current branch vs main
+            branch_files = set(
+                self.repo.git.diff("--name-only", "origin/main...HEAD").splitlines()
+            )
+            if not branch_files:
+                return []
+            
+            # Get remote branches for existence check
+            remote_branches = {
+                ref.remote_head for ref in self.repo.remotes.origin.refs
+                if ref.remote_head != "HEAD"
+            }
+            
+            # Check each squash-merge commit on test for overlapping files
+            conflicts = []
+            for c in self.repo.iter_commits("origin/test", max_count=100):
+                msg = c.message.strip()
+                if msg.startswith("squash merge:"):
+                    other_branch = msg.replace("squash merge: ", "", 1).replace(" into test", "")
+                    if other_branch == current:
+                        continue
+                    # Files touched by this commit
+                    commit_files = set(
+                        self.repo.git.diff_tree("--no-commit-id", "--name-only", "-r", c.hexsha).splitlines()
+                    )
+                    overlap = branch_files & commit_files
+                    if overlap:
+                        conflicts.append({
+                            "branch": other_branch,
+                            "sha": c.hexsha,
+                            "files": sorted(overlap),
+                            "branch_exists": other_branch in remote_branches,
+                        })
+            return conflicts
+        except Exception:
+            return []
+    
+    def get_test_commits(self, limit: int = 20) -> list[dict]:
+        try:
+            self.repo.remotes.origin.fetch()
+            commits = []
+            for c in self.repo.iter_commits("origin/test", max_count=100):
+                msg = c.message.strip()
+                if msg.startswith("squash merge:"):
+                    branch_name = msg.replace("squash merge: ", "", 1).replace(" into test", "")
+                    commits.append({
+                        "sha": c.hexsha,
+                        "message": msg,
+                        "branch": branch_name,
+                        "author": str(c.author),
+                        "date": str(c.committed_datetime),
+                    })
+                if len(commits) >= limit:
+                    break
+            return commits
+        except Exception:
+            return []
+    
+    def prune_remote_branches(self) -> None:
+        self.repo.remotes.origin.fetch(prune=True)
+        success_line("Pruned remote branches")
+    
+    def cleanup_branches(self) -> None:
+        current = self.get_current_branch()
+        protected = {"main", "test", current}
+        deleted = []
+        for branch in list(self.repo.branches):
+            if branch.name not in protected:
+                self.repo.delete_head(branch, force=True)
+                deleted.append(branch.name)
+        self.repo.remotes.origin.fetch(prune=True)
+        if deleted:
+            success_line(f"Deleted local branches: {', '.join(deleted)}")
+        else:
+            info_line("No local branches to delete")
+        success_line("Pruned remote tracking branches")
+    
+    def reset_to_main(self) -> None:
+        self.repo.remotes.origin.fetch()
+        self.repo.git.checkout("main")
+        self.repo.git.reset("--hard", "origin/main")
+        # Delete all local branches except main and test
+        for branch in self.repo.branches:
+            if branch.name not in ("main", "test"):
+                self.repo.delete_head(branch, force=True)
+        success_line("Reset to main completed")

datasecops_cli-0.4.8/src/datasecops_cli/services/git_service.py

@@ -1,183 +0,0 @@
-from pathlib import Path
-from typing import Optional
-from git import Repo, GitCommandError
-
-from datasecops_cli.models.git_helpers import GitCommitHelper
-from datasecops_cli.utilities.display import info_line, error_line, success_line, warning_line
-
-
-class GitService:
-    """Git operations via GitPython."""
-    
-    def __init__(self, repo_path: Path):
-        self.repo = Repo(repo_path)
-    
-    def get_current_branch(self) -> str:
-        try:
-            return self.repo.active_branch.name
-        except TypeError:
-            return "DETACHED HEAD"
-    
-    def is_dirty(self) -> bool:
-        return self.repo.is_dirty(untracked_files=True)
-    
-    def get_uncommitted_file_count(self) -> int:
-        return len(self.repo.index.diff(None)) + len(self.repo.untracked_files)
-    
-    def get_changed_files(self) -> list[GitCommitHelper]:
-        return [GitCommitHelper(file=d.a_path) for d in self.repo.index.diff(None)]
-    
-    def get_new_files(self) -> list[GitCommitHelper]:
-        return [GitCommitHelper(file=f) for f in self.repo.untracked_files]
-    
-    def get_local_branches(self) -> dict[str, str]:
-        return {b.name: b.name for b in self.repo.branches}
-    
-    def get_remote_branches(self) -> dict[str, str]:
-        self.repo.remotes.origin.fetch()
-        return {
-            ref.remote_head: ref.remote_head
-            for ref in self.repo.remotes.origin.refs
-            if ref.remote_head != "HEAD"
-        }
-    
-    def create_branch(self, branch_type: str, ticket: str, name: str) -> None:
-        branch_name = f"{branch_type}/{ticket}_{name}" if ticket else f"{branch_type}/{name}"
-        info_line(f"Creating branch: {branch_name}")
-        self.repo.remotes.origin.fetch()
-        new_branch = self.repo.create_head(branch_name, "origin/main")
-        new_branch.checkout()
-        self.repo.remotes.origin.push(branch_name, set_upstream=True)
-        success_line(f"Branch {branch_name} created and checked out")
-    
-    def checkout_branch(self, remote_name: str) -> None:
-        info_line(f"Checking out: {remote_name}")
-        self.repo.remotes.origin.fetch()
-        try:
-            self.repo.git.checkout(remote_name)
-        except GitCommandError:
-            self.repo.git.checkout("-b", remote_name, f"origin/{remote_name}")
-        success_line(f"Switched to {remote_name}")
-    
-    def switch_branch(self, name: str) -> None:
-        self.repo.branches[name].checkout()
-        success_line(f"Switched to {name}")
-    
-    def delete_branch(self, name: str) -> None:
-        if name == self.get_current_branch():
-            error_line("Cannot delete the current branch")
-            return
-        self.repo.delete_head(name, force=True)
-        try:
-            self.repo.remotes.origin.push(refspec=f":{name}")
-        except GitCommandError:
-            pass
-        success_line(f"Deleted branch {name}")
-    
-    def commit_changes(self, message: str) -> None:
-        self.repo.git.add(A=True)
-        self.repo.index.commit(message)
-        success_line(f"Committed: {message}")
-    
-    def push_branch(self) -> None:
-        branch = self.get_current_branch()
-        info_line(f"Pushing {branch}...")
-        self.repo.remotes.origin.push(branch)
-        success_line(f"Pushed {branch}")
-    
-    def pull_branch(self) -> None:
-        branch = self.get_current_branch()
-        info_line(f"Pulling {branch}...")
-        self.repo.remotes.origin.pull(branch)
-        success_line(f"Pulled {branch}")
-    
-    def push_branch_to_destination(self, destination: str, force: bool = False) -> None:
-        current = self.get_current_branch()
-        info_line(f"Pushing {current} to {destination}...")
-        refspec = f"{current}:{destination}"
-        self.repo.remotes.origin.push(refspec=refspec, force=force)
-        success_line(f"Pushed to {destination}")
-    
-    def rebase_with_main(self) -> bool:
-        try:
-            self.repo.remotes.origin.fetch()
-            self.repo.git.rebase("origin/main")
-            success_line("Rebase with main completed")
-            return True
-        except GitCommandError as e:
-            error_line(f"Rebase conflict: {e}")
-            warning_line("Resolve conflicts then use 'rebase continue' or 'rebase abort'")
-            return False
-    
-    def rebase_continue(self) -> None:
-        self.repo.git.rebase("--continue")
-        success_line("Rebase continued")
-    
-    def rebase_abort(self) -> None:
-        self.repo.git.rebase("--abort")
-        success_line("Rebase aborted")
-    
-    def squash_and_rebase(self) -> bool:
-        try:
-            self.repo.remotes.origin.fetch()
-            main_commit = self.repo.commit("origin/main")
-            current = self.get_current_branch()
-            self.repo.git.reset("--soft", main_commit.hexsha)
-            self.repo.index.commit(f"squash: {current}")
-            self.repo.git.rebase("origin/main")
-            success_line("Squash and rebase completed")
-            return True
-        except GitCommandError as e:
-            error_line(f"Squash rebase failed: {e}")
-            return False
-    
-    def squash_merge_into_test(self) -> bool:
-        current = self.get_current_branch()
-        try:
-            self.repo.remotes.origin.fetch()
-            self.repo.git.checkout("test")
-            self.repo.remotes.origin.pull("test")
-            self.repo.git.merge("--squash", current)
-            self.repo.index.commit(f"squash merge: {current} into test")
-            self.repo.remotes.origin.push("test")
-            self.repo.git.checkout(current)
-            success_line(f"Squash merged {current} into test")
-            return True
-        except GitCommandError as e:
-            error_line(f"Squash merge failed: {e}")
-            try:
-                self.repo.git.checkout(current)
-            except Exception:
-                pass
-            return False
-    
-    def cherry_pick_from_test(self, commit_sha: str) -> bool:
-        try:
-            self.repo.git.cherry_pick(commit_sha)
-            success_line(f"Cherry-picked {commit_sha[:8]}")
-            return True
-        except GitCommandError as e:
-            error_line(f"Cherry-pick failed: {e}")
-            return False
-    
-    def get_test_commits(self, limit: int = 20) -> list[dict]:
-        try:
-            self.repo.remotes.origin.fetch()
-            commits = list(self.repo.iter_commits("origin/test", max_count=limit))
-            return [{"sha": c.hexsha, "message": c.message.strip(), "author": str(c.author), "date": str(c.committed_datetime)} for c in commits]
-        except Exception:
-            return []
-    
-    def prune_remote_branches(self) -> None:
-        self.repo.remotes.origin.fetch(prune=True)
-        success_line("Pruned remote branches")
-    
-    def reset_to_main(self) -> None:
-        self.repo.remotes.origin.fetch()
-        self.repo.git.checkout("main")
-        self.repo.git.reset("--hard", "origin/main")
-        # Delete all local branches except main
-        for branch in self.repo.branches:
-            if branch.name != "main":
-                self.repo.delete_head(branch, force=True)
-        success_line("Reset to main completed")