agentic-devtools 0.2.29__tar.gz → 0.2.31__tar.gz

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-devtools
-Version: 0.2.29
+Version: 0.2.31
 Summary: AI assistant helper commands for the Dragonfly platform
 Author: Dragonfly Team
 License-Expression: MIT

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.29'
-__version_tuple__ = version_tuple = (0, 2, 29)
+__version__ = version = '0.2.31'
+__version_tuple__ = version_tuple = (0, 2, 31)
 
 __commit_id__ = commit_id = None

agentic_devtools-0.2.31/agentic_devtools/agdt_gitignore.py

@@ -0,0 +1,45 @@
+"""
+Manages the ``.agdt/.gitignore`` file that prevents runtime state from being
+committed on code branches.
+
+The constant ``AGDT_GITIGNORE_ENTRIES`` is the single source of truth for:
+1. The entries written to ``.agdt/.gitignore``.
+2. The paths unstaged by ``stage_changes()`` in ``cli/git/operations.py``.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+# Paths (relative to .agdt/) that must be git-ignored on code branches.
+# Used both for writing .agdt/.gitignore and for defense-in-depth unstaging
+# in stage_changes().
+AGDT_GITIGNORE_ENTRIES = ("runtime-bootstrap.json", "workflows/")
+
+AGDT_GITIGNORE_HEADER = (
+    "# Managed by agentic-devtools — do not edit manually.\n"
+    "# Ignores runtime state; tracked config/scripts remain visible.\n"
+)
+
+
+def ensure_agdt_gitignore(git_root: Optional[Path]) -> bool:
+    """Write (or overwrite) ``.agdt/.gitignore`` with the managed entries.
+
+    Args:
+        git_root: Repository/worktree root.  When ``None`` (not in a git
+            repo) the call is a silent no-op.
+
+    Returns:
+        ``True`` when the file was successfully created/updated,
+        ``False`` when *git_root* is ``None`` or a write error occurred.
+    """
+    if git_root is None:
+        return False
+
+    content = AGDT_GITIGNORE_HEADER + "\n".join(AGDT_GITIGNORE_ENTRIES) + "\n"
+    gitignore_path = git_root / ".agdt" / ".gitignore"
+    try:
+        gitignore_path.parent.mkdir(parents=True, exist_ok=True)
+        gitignore_path.write_text(content, encoding="utf-8")
+        return True
+    except OSError:
+        return False

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/azure_devops/__init__.py

@@ -141,6 +141,9 @@ from .review_attribution import (
     should_use_emoji,
 )
 
+# Review scaffold exports
+from .review_scaffold import build_pr_base_url
+
 # Review state exports
 from .review_state import (
     COMPLETE_STATUSES,
@@ -174,6 +177,7 @@ from .run_details_commands import get_run_details, wait_for_run
 # Status cascade exports
 from .status_cascade import (
     PatchOperation,
+    cascade_overall_summary_update,
     cascade_status_update,
     derive_overall_status,
     execute_cascade,
@@ -325,10 +329,13 @@ __all__ = [
     "build_commit_pr_url",
     "get_model_icon",
     "render_attribution_line",
+    # Review scaffold
+    "build_pr_base_url",
     # Status cascade
     "PatchOperation",
     "derive_overall_status",
     "cascade_status_update",
+    "cascade_overall_summary_update",
     "execute_cascade",
     # Suggestion commands (sync)
     "confirm_suggestion_addressed",

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/azure_devops/review_commands.py

@@ -105,19 +105,25 @@ def checkout_and_sync_branch(
     source_branch: str,
     pull_request_id: Optional[int] = None,
     save_files_on_branch: bool = False,
+    dry_run: bool = False,
 ) -> tuple[bool, Optional[str], Set[str]]:
     """
-    Checkout the PR source branch, fetch main, and rebase onto it.
+    Checkout the PR source branch, sync it with origin, and rebase onto main.
 
     This prepares the local working copy for the review by:
     1. Checking out the source branch
-    2. Fetching the latest from origin/main
-    3. Rebasing onto main (continues even if conflicts, with warning)
+    2. Fetching the source branch from origin and hard-resetting to origin/<branch>
+       so the local copy reflects the author's latest pushed commits
+    3. Fetching the latest from origin/main
+    4. Rebasing onto main (continues even if conflicts, with warning)
 
     Args:
         source_branch: The PR source branch name (without refs/heads/)
         pull_request_id: Optional PR ID for saving files_on_branch to JSON
         save_files_on_branch: Whether to save files_on_branch to JSON file
+        dry_run: If True, skip destructive git operations (checkout, fetch,
+            reset, rebase) — the function will still compute changed files
+            based on the current HEAD.
 
     Returns:
         Tuple of (success, error_message, files_on_branch)
@@ -127,14 +133,16 @@ def checkout_and_sync_branch(
     """
     from ..git.operations import (
         checkout_branch,
+        fetch_branch,
         fetch_main,
         get_files_changed_on_branch,
         rebase_onto_main,
+        reset_branch_to_origin,
     )
 
     # Step 1: Checkout the source branch
     print(f"\nChecking out PR source branch: {source_branch}...")
-    checkout_result = checkout_branch(source_branch)
+    checkout_result = checkout_branch(source_branch, dry_run=dry_run)
 
     if not checkout_result.is_success:
         if checkout_result.needs_user_action:
@@ -155,15 +163,31 @@ def checkout_and_sync_branch(
             set(),
         )
 
+    # Step 1b: Fetch source branch from origin to get latest changes
+    if not fetch_branch(source_branch, dry_run=dry_run):
+        return (
+            False,
+            f"Failed to fetch origin/{source_branch}. Cannot proceed with review on potentially stale code.",
+            set(),
+        )
+
+    # Step 1c: Reset local branch to match origin
+    if not reset_branch_to_origin(source_branch, dry_run=dry_run):
+        return (
+            False,
+            f"Failed to reset branch to origin/{source_branch}. "
+            "See the messages above for details and resolution steps.",
+            set(),
+        )
+
     # Step 2: Fetch latest from main
-    print("\nFetching latest from origin/main...")
-    fetch_success = fetch_main()
+    fetch_success = fetch_main(dry_run=dry_run)
     if not fetch_success:
         print("Warning: Could not fetch from origin/main, continuing without rebase...")
     else:
         # Step 3: Rebase onto main (continue even on conflicts)
         print("Rebasing onto origin/main...")
-        rebase_result = rebase_onto_main()
+        rebase_result = rebase_onto_main(dry_run=dry_run)
 
         if rebase_result.is_success:
             print("Branch is synced with main.")
@@ -667,6 +691,47 @@ def setup_pull_request_review() -> None:
 
     jira_issue_key = get_value("jira.issue_key")
     include_reviewed = str(get_value("include_reviewed", "")).lower() in ("true", "1", "yes")
+    review_model_id = get_value("review.model_id")
+    dry_run_val = get_value("dry_run")
+
+    # Bootstrap identity + worktree_key before fetching PR details / generating
+    # artifacts so they land in the identity-scoped directory from the start.
+    # Note: get_value() calls above still resolve against the old state dir;
+    # the bootstrap call below re-seeds those keys into the scoped state.
+    try:
+        import uuid
+
+        from ...state import set_bootstrap_state, set_value
+
+        set_bootstrap_state(worktree_key=f"PR{pull_request_id}")
+
+        # Re-set context keys that were read from the old (_unscoped) state
+        # directory.  set_bootstrap_state() may have changed the resolved
+        # state dir, so downstream commands (e.g., get_pull_request_details)
+        # that call get_value() would find an empty scoped state.json.
+        set_value("pull_request_id", str(pull_request_id))
+        if jira_issue_key:
+            set_value("jira.issue_key", jira_issue_key)
+        if include_reviewed:
+            set_value("include_reviewed", "true")
+        if review_model_id:
+            set_value("review.model_id", review_model_id)
+        if dry_run_val is not None:
+            set_value("dry_run", str(dry_run_val))
+
+        # Generate agdt_run_id (same pattern as initiate_workflow in base.py)
+        # so that persist_if_dirty() can commit workflow state to a -agdt branch.
+        run_id = uuid.uuid4().hex[:12]
+        set_value("agdt_run_id", run_id)
+
+        # NOTE: versionControl.currentBranch is intentionally NOT set here.
+        # This function checks out the PR source branch below (Step 3), so
+        # the branch at this point is stale.  persist_if_dirty() resolves the
+        # current branch from git when needed.
+    except Exception as exc:
+        # Bootstrap is best-effort: review proceeds using _unscoped if this
+        # fails (e.g., not in a git repo).  Log the error for debugging.
+        print(f"WARNING: bootstrap state init failed: {exc}", file=sys.stderr)
 
     # Step 1: Fetch Jira issue details if we have a key
     if jira_issue_key:
@@ -696,7 +761,7 @@ def setup_pull_request_review() -> None:
     if source_branch:
         print(f"\nChecking out source branch '{source_branch}' and syncing with main...")
         checkout_success, checkout_error, files_on_branch = checkout_and_sync_branch(
-            source_branch, pull_request_id, save_files_on_branch=True
+            source_branch, pull_request_id, save_files_on_branch=True, dry_run=is_dry_run()
         )
 
         if not checkout_success:

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/azure_devops/review_scaffold.py

@@ -75,7 +75,7 @@ def _get_file_name(file_path: str) -> str:
     return normalized.split("/")[-1]
 
 
-def _build_pr_base_url(config: AzureDevOpsConfig, pull_request_id: int) -> str:
+def build_pr_base_url(config: AzureDevOpsConfig, pull_request_id: int) -> str:
     """Build the PR web URL for building discussion links.
 
     Args:
@@ -93,6 +93,10 @@ def _build_pr_base_url(config: AzureDevOpsConfig, pull_request_id: int) -> str:
     return f"{org}/{encoded_project}/_git/{encoded_repo}/pullrequest/{pull_request_id}"
 
 
+# Backward-compatible alias for internal callers
+_build_pr_base_url = build_pr_base_url
+
+
 def _post_thread(
     requests_module: Any,
     headers: Dict[str, str],

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/azure_devops/status_cascade.py

@@ -100,13 +100,45 @@ def cascade_status_update(
             thread_id=state.overallSummary.threadId,
             comment_id=state.overallSummary.commentId,
             new_content=overall_content,
-            thread_status=_THREAD_STATUS_MAP[new_overall_status],
+            thread_status=_THREAD_STATUS_MAP.get(new_overall_status, "active"),
         )
     )
 
     return ops
 
 
+def cascade_overall_summary_update(
+    state: ReviewState,
+    base_url: str,
+) -> List[PatchOperation]:
+    """Compute PATCH operations for the overall PR summary without a file context.
+
+    Used at workflow completion to ensure the overall summary reflects the
+    final derived status. Unlike cascade_status_update(), this does not
+    require a file_path argument.
+
+    Args:
+        state: Full ReviewState (mutated in-place with new overall status).
+        base_url: PR root URL for generating markdown content.
+
+    Returns:
+        List of PatchOperation objects to execute via execute_cascade.
+    """
+    new_overall_status = derive_overall_status(state)
+    state.overallSummary.status = new_overall_status
+
+    overall_content = render_overall_summary(state, base_url)
+    return [
+        PatchOperation(
+            thread_id=state.overallSummary.threadId,
+            comment_id=state.overallSummary.commentId,
+            new_content=overall_content,
+            # Default to "active" for non-final statuses (unreviewed, in-progress)
+            thread_status=_THREAD_STATUS_MAP.get(new_overall_status, "active"),
+        )
+    ]
+
+
 def execute_cascade(
     patch_operations: List[PatchOperation],
     requests_module,

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/git/__init__.py

@@ -50,9 +50,11 @@ from .operations import (
     CheckoutResult,
     RebaseResult,
     checkout_branch,
+    fetch_branch,
     fetch_main,
     get_files_changed_on_branch,
     rebase_onto_main,
+    reset_branch_to_origin,
 )
 
 __all__ = [
@@ -84,8 +86,10 @@ __all__ = [
     # Branch operations
     "checkout_branch",
     "CheckoutResult",
+    "fetch_branch",
     "fetch_main",
     "rebase_onto_main",
     "RebaseResult",
+    "reset_branch_to_origin",
     "get_files_changed_on_branch",
 ]

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/git/core.py

@@ -67,6 +67,7 @@ def run_git(*args: str, check: bool = True) -> CompletedProcess:
         cmd,
         capture_output=True,
         text=True,
+        shell=False,
     )
 
     if check and result.returncode != 0:

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/git/operations.py

@@ -8,8 +8,12 @@ This module provides the individual git operations:
 - Branch state detection
 """
 
+import sys
+from pathlib import Path
 from typing import Optional
 
+from agentic_devtools.agdt_gitignore import AGDT_GITIGNORE_ENTRIES
+
 from .core import get_current_branch, run_git, temp_message_file
 
 # Auto-generated files that must never be staged or committed.
@@ -18,35 +22,57 @@ STAGE_EXCLUDE_FILES = [
     "agentic_devtools/_version.py",
 ]
 
-AGDT_WORKFLOWS_DIR = ".agdt/workflows/"
-
 
 def stage_changes(dry_run: bool) -> None:
     """
     Stage all changes (git add .), then unstage any auto-generated files.
 
     Auto-generated files listed in STAGE_EXCLUDE_FILES are always unstaged
-    after the initial `git add .` so they are never included in commits.
+    after the initial ``git add .`` so they are never included in commits.
+
+    On branches that do **not** end with ``-agdt``, every entry from
+    ``AGDT_GITIGNORE_ENTRIES`` is unstaged (as ``.agdt/{entry}``) to prevent
+    runtime state from being accidentally committed to code branches.
 
-    On branches that do **not** end with ``-agdt``, the ``.agdt/workflows/``
-    directory is also unstaged to prevent workflow artifacts from being
-    accidentally committed to code branches.  On ``-agdt`` branches the
-    directory stays staged.
+    On ``-agdt`` branches, ``.agdt/.gitignore`` is deleted **before**
+    ``git add .`` so that previously-ignored runtime state files become
+    visible to git and are included in the commit.
 
     Args:
         dry_run: If True, only print what would happen
     """
+    branch = get_current_branch()
+    is_agdt_branch = branch.endswith("-agdt")
+
     if dry_run:
         print("[DRY RUN] Would stage all changes (git add .)")
         for excluded in STAGE_EXCLUDE_FILES:
             print(f"[DRY RUN] Would unstage auto-generated file: {excluded}")
-        branch = get_current_branch()
-        if not branch.endswith("-agdt"):
-            print(f"[DRY RUN] Would unstage {AGDT_WORKFLOWS_DIR} (not on -agdt branch)")
+        if not is_agdt_branch:
+            for entry in AGDT_GITIGNORE_ENTRIES:
+                print(f"[DRY RUN] Would unstage .agdt/{entry} (not on -agdt branch)")
         else:
-            print(f"[DRY RUN] {AGDT_WORKFLOWS_DIR} will stay staged (on -agdt branch)")
+            print("[DRY RUN] Would remove .agdt/.gitignore (on -agdt branch)")
+            print("[DRY RUN] .agdt/ entries will stay staged (on -agdt branch)")
         return
 
+    # On -agdt branches, remove .agdt/.gitignore BEFORE `git add .`
+    # so that previously-ignored state files become visible to git.
+    if is_agdt_branch:
+        try:
+            toplevel = run_git("rev-parse", "--show-toplevel", check=False)
+            if toplevel.returncode == 0 and toplevel.stdout.strip():
+                gitignore_path = Path(toplevel.stdout.strip()) / ".agdt" / ".gitignore"
+                if gitignore_path.is_file():
+                    gitignore_path.unlink()
+                    print("Removed .agdt/.gitignore (on -agdt branch, state will be committed)")
+        except OSError as exc:
+            print(
+                f"Warning: Failed to remove .agdt/.gitignore "
+                f"(state files may remain ignored and not be committed): {exc}",
+                file=sys.stderr,
+            )
+
     print("Staging all changes...")
     run_git("add", ".")
 
@@ -55,11 +81,11 @@ def stage_changes(dry_run: bool) -> None:
         if result.returncode == 0 and result.stdout.strip():  # pragma: no cover
             print(f"Unstaged auto-generated file: {excluded}")
 
-    branch = get_current_branch()
-    if not branch.endswith("-agdt"):
-        result = run_git("reset", "HEAD", "--", AGDT_WORKFLOWS_DIR, check=False)
-        if result.returncode == 0 and result.stdout.strip():  # pragma: no cover
-            print(f"Unstaged workflow artifacts: {AGDT_WORKFLOWS_DIR}")
+    if not is_agdt_branch:
+        for entry in AGDT_GITIGNORE_ENTRIES:
+            result = run_git("reset", "HEAD", "--", f".agdt/{entry}", check=False)
+            if result.returncode == 0 and result.stdout.strip():  # pragma: no cover
+                print(f"Unstaged runtime state: .agdt/{entry}")
 
     print("Changes staged.")
 
@@ -505,6 +531,84 @@ def fetch_branch(branch_name: str, dry_run: bool = False) -> bool:
     return True
 
 
+def reset_branch_to_origin(branch_name: str, dry_run: bool = False) -> bool:
+    """
+    Reset the current branch to match origin/<branch_name>.
+
+    Verifies that HEAD is on ``branch_name`` before proceeding —
+    returns ``False`` with an actionable message if a different branch
+    is checked out.
+
+    Guards against data loss by:
+    - Checking for uncommitted or untracked working tree changes.
+    - Checking for unpushed local commits before performing the hard reset.
+
+    If any safety condition is detected, the reset is aborted with a
+    descriptive message so the reviewer can resolve manually.
+
+    Args:
+        branch_name: Name of the branch to reset to
+        dry_run: If True, only print what would happen
+
+    Returns:
+        True if reset succeeded, False otherwise
+    """
+    if dry_run:
+        print(f"[DRY RUN] Would reset to origin/{branch_name}")
+        return True
+
+    # Guard: check for uncommitted/untracked working tree changes
+    if has_local_changes():
+        print("Error: You have uncommitted local changes.")
+        print("Aborting reset to avoid losing work. Commit, stash, or discard your changes, then retry.")
+        return False
+
+    # Guard: verify we are on the expected branch
+    head_result = run_git("rev-parse", "--abbrev-ref", "HEAD", check=False)
+    if head_result.returncode == 0:
+        current_branch = head_result.stdout.strip()
+        if current_branch != branch_name:
+            print(f"Error: Expected to be on branch '{branch_name}' but HEAD is on '{current_branch}'.")
+            print("Aborting reset to avoid resetting the wrong branch.")
+            return False
+    else:
+        print("Warning: Could not determine current branch. Aborting reset as a safety precaution.")
+        if head_result.stderr:
+            print(f"  {head_result.stderr.strip()}")
+        return False
+
+    # Guard: check for unpushed local commits before hard reset
+    ahead_result = run_git("rev-list", "--count", f"origin/{branch_name}..HEAD", check=False)
+    if ahead_result.returncode == 0:
+        count_text = ahead_result.stdout.strip()
+        try:
+            ahead = int(count_text)
+        except ValueError:
+            print(f"Warning: Could not parse rev-list output ({count_text!r}), aborting reset as a safety precaution.")
+            return False
+        if ahead > 0:
+            print(f"Warning: Local branch has {ahead} unpushed commit(s) ahead of origin/{branch_name}.")
+            print("Aborting reset to avoid losing local work. Push or discard your local commits, then retry.")
+            return False
+    else:
+        print(f"Warning: Could not check for unpushed commits (rev-list exited {ahead_result.returncode}).")
+        if ahead_result.stderr:
+            print(f"  {ahead_result.stderr.strip()}")
+        print("Aborting reset as a safety precaution.")
+        return False
+
+    print(f"Resetting branch to origin/{branch_name}...")
+    result = run_git("reset", "--hard", f"origin/{branch_name}", check=False)
+    if result.returncode != 0:
+        print(f"Warning: Failed to reset to origin/{branch_name}")
+        if result.stderr:
+            print(result.stderr.strip())
+        return False
+
+    print(f"Reset to origin/{branch_name} successfully.")
+    return True
+
+
 def fetch_main(main_branch: str = "main", dry_run: bool = False) -> bool:
     """
     Fetch the latest from origin for the main branch.

{agentic_devtools-0.2.29 → agentic_devtools-0.2.31}/agentic_devtools/cli/setup/commands.py

@@ -483,6 +483,19 @@ def setup_cmd() -> None:
 
     any_required_missing = any(s.required and not s.found for s in statuses)
 
+    # Ensure .agdt/.gitignore exists in the current repo (if any)
+    from agentic_devtools.agdt_gitignore import ensure_agdt_gitignore
+    from agentic_devtools.state import _get_git_repo_root
+
+    git_root = _get_git_repo_root()
+    if ensure_agdt_gitignore(git_root):
+        print(
+            "  ✓ Ensured .agdt/.gitignore — commit this file to propagate to all worktrees"
+            "\n    (if your root .gitignore ignores .agdt/, add '!.agdt/.gitignore' so git tracks it)"
+        )
+    elif git_root is not None:
+        print("  ⚠ Failed to create/update .agdt/.gitignore — check directory permissions", file=sys.stderr)
+
     print()
     if not copilot_ok or not gh_ok or any_required_missing:
         print("Setup complete with warnings. See above for details.")