sase 0.1.0__py3-none-any.whl

sase/__init__.py

@@ -0,0 +1,3 @@
+"""Structured Agentic Software Engineering."""
+
+__version__ = "0.1.0"

sase/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running the package as a module: python -m sase"""
+
+from sase.main.entry import main
+
+if __name__ == "__main__":
+    main()

sase/accept_workflow/__init__.py

@@ -0,0 +1,26 @@
+"""Accept workflow package for accepting proposed COMMITS entries."""
+
+from .conflict_check import ConflictCheckResult, ConflictPair, run_conflict_check
+from .parsing import (
+    expand_shorthand_proposals,
+    find_proposal_entry,
+    parse_proposal_entries,
+    parse_proposal_entries_with_shorthand,
+    parse_proposal_id,
+)
+from .renumber import renumber_commit_entries
+from .workflow import AcceptWorkflow, main
+
+__all__ = [
+    "AcceptWorkflow",
+    "ConflictCheckResult",
+    "ConflictPair",
+    "expand_shorthand_proposals",
+    "find_proposal_entry",
+    "main",
+    "parse_proposal_entries",
+    "parse_proposal_entries_with_shorthand",
+    "parse_proposal_id",
+    "renumber_commit_entries",
+    "run_conflict_check",
+]

sase/accept_workflow/conflict_check.py

@@ -0,0 +1,226 @@
+"""Conflict checking for accept workflow proposals."""
+
+from dataclasses import dataclass
+from itertools import combinations
+
+from sase.ace.changespec import CommitEntry
+from sase.commit_utils import apply_diffs_to_workspace, clean_workspace
+from sase.rich_utils import print_status
+
+
+@dataclass
+class ConflictPair:
+    """A pair of proposals that conflict with each other."""
+
+    proposal_a: tuple[int, str]  # (base_num, letter)
+    proposal_b: tuple[int, str]
+    error_message: str
+
+
+@dataclass
+class ConflictCheckResult:
+    """Result of a conflict check."""
+
+    success: bool
+    failed_proposal: tuple[int, str] | None
+    conflicting_pairs: list[ConflictPair]
+
+
+def _format_proposal_id(base_num: int, letter: str) -> str:
+    """Format a proposal ID for display.
+
+    Args:
+        base_num: The base number of the proposal.
+        letter: The proposal letter.
+
+    Returns:
+        Formatted proposal ID like "(2a)".
+    """
+    return f"({base_num}{letter})"
+
+
+def _apply_all_proposals(
+    workspace_dir: str,
+    proposals: list[tuple[int, str, CommitEntry]],
+) -> tuple[bool, str]:
+    """Apply all proposals together and check if they succeed.
+
+    Args:
+        workspace_dir: The workspace directory.
+        proposals: List of (base_num, letter, entry) tuples.
+
+    Returns:
+        Tuple of (success, error_message).
+    """
+    diff_paths = []
+    for _base_num, _letter, entry in proposals:
+        assert entry.diff is not None
+        diff_paths.append(entry.diff)
+
+    return apply_diffs_to_workspace(workspace_dir, diff_paths)
+
+
+def _find_conflicting_pairs(
+    workspace_dir: str,
+    proposals: list[tuple[int, str, CommitEntry]],
+) -> list[ConflictPair]:
+    """Find all unique pairs of proposals that conflict.
+
+    Tests each unique pair by applying both diffs together in a single command.
+
+    Args:
+        workspace_dir: The workspace directory.
+        proposals: List of (base_num, letter, entry) tuples.
+
+    Returns:
+        List of ConflictPair for each pair that conflicts.
+    """
+    conflicting_pairs: list[ConflictPair] = []
+
+    for (num_a, letter_a, entry_a), (num_b, letter_b, entry_b) in combinations(
+        proposals, 2
+    ):
+        # Clean workspace before each pair test
+        clean_workspace(workspace_dir)
+
+        # Apply both proposals together
+        assert entry_a.diff is not None
+        assert entry_b.diff is not None
+        success, error_msg = apply_diffs_to_workspace(
+            workspace_dir, [entry_a.diff, entry_b.diff]
+        )
+        if not success:
+            conflicting_pairs.append(
+                ConflictPair(
+                    proposal_a=(num_a, letter_a),
+                    proposal_b=(num_b, letter_b),
+                    error_message=error_msg,
+                )
+            )
+
+    return conflicting_pairs
+
+
+def run_conflict_check(
+    workspace_dir: str,
+    validated_proposals: list[tuple[int, str, str | None, CommitEntry]],
+    verbose: bool = True,
+) -> ConflictCheckResult:
+    """Run conflict check on a set of proposals.
+
+    This function tests whether all proposals can be applied together using
+    a single hg import command. If they fail and there are >2 proposals,
+    it identifies which specific pairs conflict.
+
+    Args:
+        workspace_dir: The workspace directory to test in.
+        validated_proposals: List of (base_num, letter, msg, entry) tuples.
+            The msg field is ignored for conflict checking.
+        verbose: If True, print progress messages.
+
+    Returns:
+        ConflictCheckResult indicating success or failure details.
+    """
+    # Edge case: 0-1 proposals can't conflict
+    if len(validated_proposals) <= 1:
+        return ConflictCheckResult(
+            success=True,
+            failed_proposal=None,
+            conflicting_pairs=[],
+        )
+
+    # Extract just what we need for conflict checking
+    proposals = [
+        (base_num, letter, entry)
+        for base_num, letter, _msg, entry in validated_proposals
+    ]
+
+    if verbose:
+        print_status(
+            f"Running conflict check on {len(proposals)} proposals...",
+            "progress",
+        )
+
+    # Try applying all proposals together
+    success, error_msg = _apply_all_proposals(workspace_dir, proposals)
+
+    # Clean workspace after test
+    clean_workspace(workspace_dir)
+
+    if success:
+        return ConflictCheckResult(
+            success=True,
+            failed_proposal=None,
+            conflicting_pairs=[],
+        )
+
+    # Proposals failed to apply together
+    if verbose:
+        print_status(
+            f"Conflict detected when applying proposals together: {error_msg}",
+            "error",
+        )
+
+    # For 2 proposals, no need to check pairs - we know they conflict
+    if len(proposals) == 2:
+        if verbose:
+            print_status(
+                "Accept aborted. Try accepting non-conflicting proposals separately.",
+                "error",
+            )
+        return ConflictCheckResult(
+            success=False,
+            failed_proposal=None,  # Can't determine which one failed
+            conflicting_pairs=[],
+        )
+
+    # For >2 proposals, find which specific pairs conflict
+    if verbose:
+        print_status("Checking which proposals conflict...", "progress")
+
+    conflicting_pairs = _find_conflicting_pairs(workspace_dir, proposals)
+
+    # Clean workspace after pair testing
+    clean_workspace(workspace_dir)
+
+    if verbose:
+        for pair in conflicting_pairs:
+            print_status(
+                f"Conflicting pair: {_format_proposal_id(*pair.proposal_a)} and "
+                f"{_format_proposal_id(*pair.proposal_b)}",
+                "error",
+            )
+        print_status(
+            "Accept aborted. Try accepting non-conflicting proposals separately.",
+            "error",
+        )
+
+    return ConflictCheckResult(
+        success=False,
+        failed_proposal=None,  # Can't determine which one failed
+        conflicting_pairs=conflicting_pairs,
+    )
+
+
+def format_conflict_message(result: ConflictCheckResult) -> str:
+    """Format conflict information for display.
+
+    Args:
+        result: The conflict check result.
+
+    Returns:
+        A formatted message describing the conflicts.
+    """
+    lines: list[str] = []
+
+    # Add conflicting pair messages (only if there are any)
+    for pair in result.conflicting_pairs:
+        lines.append(
+            f"Conflicting pair: {_format_proposal_id(*pair.proposal_a)} and "
+            f"{_format_proposal_id(*pair.proposal_b)}"
+        )
+
+    # Always add the abort message
+    lines.append("Accept aborted. Try accepting non-conflicting proposals separately.")
+
+    return "\n".join(lines)

sase/accept_workflow/parsing.py

@@ -0,0 +1,183 @@
+"""Proposal parsing and lookup functions for accept workflow."""
+
+import re
+
+from sase.ace.changespec import CommitEntry
+
+
+def parse_proposal_id(proposal_id: str) -> tuple[int, str] | None:
+    """Parse a proposal ID into base number and letter.
+
+    Args:
+        proposal_id: The proposal ID (e.g., "2a", "2b").
+
+    Returns:
+        Tuple of (base_number, letter) or None if invalid.
+    """
+    match = re.match(r"^(\d+)([a-z])$", proposal_id)
+    if not match:
+        return None
+    return int(match.group(1)), match.group(2)
+
+
+def parse_proposal_entries(args: list[str]) -> list[tuple[str, str | None]] | None:
+    """Parse proposal entry arguments into (id, msg) tuples.
+
+    Supports:
+    - New syntax: "2b(Add foobar field)" - id with optional message in parentheses
+    - Legacy syntax: "2b" followed by optional separate message argument
+
+    Args:
+        args: List of arguments (e.g., ["2a(msg)", "2b"] or ["2a", "msg"]).
+
+    Returns:
+        List of (id, msg) tuples or None if invalid format.
+    """
+    if not args:
+        return None
+
+    # Regex patterns
+    id_with_msg_pattern = re.compile(r"^(\d+[a-z])\((.+)\)$")  # "2a(msg)"
+    bare_id_pattern = re.compile(r"^(\d+[a-z])$")  # "2a"
+
+    entries: list[tuple[str, str | None]] = []
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        # Check for new syntax with message in parentheses: "2a(msg)"
+        match_with_msg = id_with_msg_pattern.match(arg)
+        if match_with_msg:
+            proposal_id = match_with_msg.group(1)
+            msg = match_with_msg.group(2)
+            entries.append((proposal_id, msg))
+            i += 1
+            continue
+
+        # Check for bare ID: "2a"
+        match_bare = bare_id_pattern.match(arg)
+        if match_bare:
+            proposal_id = match_bare.group(1)
+            # Check if next arg is a message (not another proposal ID)
+            if i + 1 < len(args):
+                next_arg = args[i + 1]
+                # If next arg doesn't look like a proposal ID (with or without msg),
+                # treat it as a legacy message
+                if not id_with_msg_pattern.match(
+                    next_arg
+                ) and not bare_id_pattern.match(next_arg):
+                    entries.append((proposal_id, next_arg))
+                    i += 2
+                    continue
+            entries.append((proposal_id, None))
+            i += 1
+            continue
+
+        # Invalid format
+        return None
+
+    return entries if entries else None
+
+
+def expand_shorthand_proposals(
+    args: list[str],
+    last_accepted_base: str | None,
+) -> list[str] | None:
+    """Expand shorthand proposal entries to full IDs.
+
+    Shorthand format:
+    - "a" -> "2a" (where 2 is last_accepted_base)
+    - "a(msg)" -> "2a(msg)"
+
+    Full format (pass through unchanged):
+    - "2a", "2b(msg)", etc.
+
+    Args:
+        args: List of arguments (may contain shorthand or full IDs).
+        last_accepted_base: The base number to prepend (e.g., "2").
+            If None, shorthand cannot be expanded.
+
+    Returns:
+        List of expanded arguments, or None if shorthand used but
+        last_accepted_base is not available or invalid format encountered.
+    """
+    # Regex patterns
+    shorthand_bare = re.compile(r"^([a-z])$")  # "a"
+    shorthand_with_msg = re.compile(r"^([a-z])\((.+)\)$")  # "a(msg)"
+    full_id_bare = re.compile(r"^\d+[a-z]$")  # "2a"
+    full_id_with_msg = re.compile(r"^\d+[a-z]\(.+\)$")  # "2a(msg)"
+
+    expanded: list[str] = []
+
+    for arg in args:
+        # Check if already full format
+        if full_id_bare.match(arg) or full_id_with_msg.match(arg):
+            expanded.append(arg)
+            continue
+
+        # Check for shorthand bare letter
+        match_bare = shorthand_bare.match(arg)
+        if match_bare:
+            if last_accepted_base is None:
+                return None  # Cannot expand without base
+            letter = match_bare.group(1)
+            expanded.append(f"{last_accepted_base}{letter}")
+            continue
+
+        # Check for shorthand letter with message
+        match_with_msg = shorthand_with_msg.match(arg)
+        if match_with_msg:
+            if last_accepted_base is None:
+                return None
+            letter = match_with_msg.group(1)
+            msg = match_with_msg.group(2)
+            expanded.append(f"{last_accepted_base}{letter}({msg})")
+            continue
+
+        # Invalid format
+        return None
+
+    return expanded
+
+
+def parse_proposal_entries_with_shorthand(
+    args: list[str],
+    last_accepted_base: str | None,
+) -> list[tuple[str, str | None]] | None:
+    """Parse proposal entries with shorthand expansion support.
+
+    Args:
+        args: List of arguments (shorthand or full format).
+        last_accepted_base: Base number for shorthand expansion.
+
+    Returns:
+        List of (id, msg) tuples or None if invalid.
+    """
+    expanded = expand_shorthand_proposals(args, last_accepted_base)
+    if expanded is None:
+        return None
+    return parse_proposal_entries(expanded)
+
+
+def find_proposal_entry(
+    commits: list[CommitEntry] | None,
+    base_number: int,
+    letter: str,
+) -> CommitEntry | None:
+    """Find a proposal entry in commits by base number and letter.
+
+    Args:
+        commits: List of commit entries.
+        base_number: The base number (e.g., 2 for "2a").
+        letter: The proposal letter (e.g., "a" for "2a").
+
+    Returns:
+        The matching CommitEntry or None if not found.
+    """
+    if not commits:
+        return None
+    for entry in commits:
+        if entry.number == base_number and entry.proposal_letter == letter:
+            return entry
+    return None