up-cli 0.2.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

up/commands/bisect.py

@@ -0,0 +1,343 @@
+"""up bisect - Automated bug hunting with git bisect.
+
+Finds the commit that introduced a bug using binary search.
+Runs in O(log n) steps regardless of history length.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from up.git.utils import is_git_repo, run_git
+
+console = Console()
+
+
+def _get_last_tag(path: Path) -> Optional[str]:
+    """Get most recent tag."""
+    result = subprocess.run(
+        ["git", "describe", "--tags", "--abbrev=0"],
+        cwd=path,
+        capture_output=True,
+        text=True
+    )
+    if result.returncode == 0:
+        return result.stdout.strip()
+    return None
+
+
+def _get_commit_info(path: Path, commit: str) -> dict:
+    """Get information about a commit."""
+    format_str = "%H%n%an%n%ae%n%ad%n%s"
+    result = subprocess.run(
+        ["git", "log", "-1", f"--format={format_str}", commit],
+        cwd=path,
+        capture_output=True,
+        text=True
+    )
+    
+    if result.returncode != 0:
+        return {}
+    
+    lines = result.stdout.strip().split("\n")
+    if len(lines) < 5:
+        return {}
+    
+    return {
+        "sha": lines[0],
+        "author": lines[1],
+        "email": lines[2],
+        "date": lines[3],
+        "message": lines[4],
+    }
+
+
+def _get_diff(path: Path, commit: str) -> str:
+    """Get diff for a commit."""
+    result = subprocess.run(
+        ["git", "show", "--stat", commit],
+        cwd=path,
+        capture_output=True,
+        text=True
+    )
+    return result.stdout if result.returncode == 0 else ""
+
+
+@click.command("bisect")
+@click.option("--test", "-t", "test_cmd", help="Test command to run (exit 0 = good, 1 = bad)")
+@click.option("--good", "-g", help="Known good commit (default: last tag or HEAD~50)")
+@click.option("--bad", "-b", default="HEAD", help="Known bad commit (default: HEAD)")
+@click.option("--script", "-s", type=click.Path(exists=True), help="Path to test script")
+@click.option("--start", is_flag=True, help="Start interactive bisect session")
+@click.option("--reset", is_flag=True, help="Reset/abort current bisect")
+def bisect_cmd(test_cmd: str, good: str, bad: str, script: str, start: bool, reset: bool):
+    """Find the commit that introduced a bug.
+    
+    Uses binary search through Git history to find the exact commit
+    that introduced a bug. Runs in O(log n) steps.
+    
+    \b
+    Examples:
+      up bisect --test "pytest tests/auth.py"
+      up bisect --script ./test_regression.sh
+      up bisect --good v1.0.0 --bad HEAD --test "npm test"
+      up bisect --start              # Interactive mode
+      up bisect --reset              # Abort bisect
+    
+    \b
+    Test Script Requirements:
+      - Exit 0: Bug NOT present (good commit)
+      - Exit 1: Bug IS present (bad commit)
+      - Exit 125: Skip this commit (can't test)
+    """
+    cwd = Path.cwd()
+    
+    if not is_git_repo(cwd):
+        console.print("[red]Error:[/] Not a git repository")
+        sys.exit(1)
+    
+    # Reset mode
+    if reset:
+        result = subprocess.run(
+            ["git", "bisect", "reset"],
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            console.print("[green]✓[/] Bisect session reset")
+        else:
+            console.print("[yellow]No bisect session active[/]")
+        return
+    
+    # Interactive start mode
+    if start:
+        _start_interactive_bisect(cwd, good, bad)
+        return
+    
+    # Need test command or script
+    if not test_cmd and not script:
+        console.print("[yellow]Provide a test command or script[/]")
+        console.print("\nUsage:")
+        console.print('  up bisect --test "pytest tests/auth.py"')
+        console.print("  up bisect --script ./test_regression.sh")
+        console.print("  up bisect --start  # Interactive mode")
+        return
+    
+    # Determine good commit
+    if not good:
+        # Try last tag
+        good = _get_last_tag(cwd)
+        if not good:
+            # Fall back to N commits ago
+            good = "HEAD~50"
+        console.print(f"[dim]Using good commit: {good}[/]")
+    
+    # Build test script
+    if script:
+        test_script = Path(script).read_text()
+    else:
+        test_script = f"""#!/bin/bash
+# Auto-generated bisect test script
+
+# Run the test command
+{test_cmd}
+exit $?
+"""
+    
+    # Write test script
+    script_path = cwd / ".bisect_test.sh"
+    script_path.write_text(test_script)
+    script_path.chmod(0o755)
+    
+    console.print(Panel.fit(
+        f"[bold]Git Bisect - Bug Hunter[/]\n\n"
+        f"Good: {good}\n"
+        f"Bad: {bad}\n"
+        f"Test: {test_cmd or script}",
+        border_style="blue"
+    ))
+    
+    try:
+        # Start bisect
+        console.print("\n[dim]Starting bisect...[/]")
+        
+        subprocess.run(["git", "bisect", "start"], cwd=cwd, capture_output=True)
+        subprocess.run(["git", "bisect", "bad", bad], cwd=cwd, capture_output=True)
+        
+        result = subprocess.run(
+            ["git", "bisect", "good", good],
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            console.print(f"[red]Error:[/] Failed to set good commit")
+            console.print(f"[dim]{result.stderr}[/]")
+            subprocess.run(["git", "bisect", "reset"], cwd=cwd, capture_output=True)
+            return
+        
+        # Run automated bisect
+        console.print("[dim]Running automated bisect (this may take a while)...[/]")
+        console.print()
+        
+        result = subprocess.run(
+            ["git", "bisect", "run", str(script_path)],
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        # Parse result to find culprit
+        output = result.stdout + result.stderr
+        
+        # Look for the culprit commit
+        culprit = None
+        for line in output.split("\n"):
+            if "is the first bad commit" in line:
+                # Extract commit SHA
+                parts = line.split()
+                if parts:
+                    culprit = parts[0]
+                break
+        
+        if culprit:
+            _display_culprit(cwd, culprit)
+        else:
+            console.print("[yellow]Could not determine culprit commit[/]")
+            console.print("[dim]Bisect output:[/]")
+            console.print(output[-500:] if len(output) > 500 else output)
+        
+        # Reset bisect
+        subprocess.run(["git", "bisect", "reset"], cwd=cwd, capture_output=True)
+        
+    finally:
+        # Cleanup
+        if script_path.exists():
+            script_path.unlink()
+
+
+def _start_interactive_bisect(cwd: Path, good: str, bad: str):
+    """Start an interactive bisect session."""
+    
+    if not good:
+        good = _get_last_tag(cwd) or "HEAD~20"
+    
+    console.print(Panel.fit(
+        "[bold]Interactive Bisect Session[/]\n\n"
+        "You'll be guided through testing commits.\n"
+        "For each commit, run your test and mark as good/bad.",
+        border_style="blue"
+    ))
+    
+    # Start bisect
+    subprocess.run(["git", "bisect", "start"], cwd=cwd, capture_output=True)
+    subprocess.run(["git", "bisect", "bad", bad], cwd=cwd, capture_output=True)
+    result = subprocess.run(
+        ["git", "bisect", "good", good],
+        cwd=cwd,
+        capture_output=True,
+        text=True
+    )
+    
+    console.print(f"\n[dim]Bisect started: good={good}, bad={bad}[/]")
+    console.print("\n[bold]Commands:[/]")
+    console.print("  [cyan]git bisect good[/]  - Mark current commit as good")
+    console.print("  [cyan]git bisect bad[/]   - Mark current commit as bad")
+    console.print("  [cyan]git bisect skip[/]  - Skip current commit")
+    console.print("  [cyan]up bisect --reset[/] - Abort bisect")
+    console.print("\n[dim]Run your test, then mark the commit.[/]")
+
+
+def _display_culprit(cwd: Path, commit: str):
+    """Display information about the culprit commit."""
+    info = _get_commit_info(cwd, commit)
+    
+    console.print(Panel.fit(
+        f"[bold red]🐛 Bug-Introducing Commit Found![/]",
+        border_style="red"
+    ))
+    console.print()
+    
+    table = Table(show_header=False, box=None)
+    table.add_column("Key", style="dim")
+    table.add_column("Value")
+    
+    table.add_row("Commit", f"[cyan]{info.get('sha', commit)[:12]}[/]")
+    table.add_row("Author", info.get('author', 'Unknown'))
+    table.add_row("Date", info.get('date', 'Unknown'))
+    table.add_row("Message", info.get('message', 'No message'))
+    
+    console.print(table)
+    
+    # Show diff stats
+    diff = _get_diff(cwd, commit)
+    if diff:
+        console.print("\n[bold]Changes in this commit:[/]")
+        # Only show the stat part
+        lines = diff.split("\n")
+        for line in lines:
+            if line.startswith(" ") and ("|" in line or "changed" in line):
+                console.print(f"  {line}")
+    
+    console.print("\n[bold]Next steps:[/]")
+    console.print(f"  1. View full diff: [cyan]git show {commit[:8]}[/]")
+    console.print(f"  2. Check this commit: [cyan]git checkout {commit[:8]}[/]")
+    console.print(f"  3. Revert if needed: [cyan]git revert {commit[:8]}[/]")
+
+
+# Also add a 'history' command for viewing commit history with context
+
+@click.command("history")
+@click.option("--limit", "-n", default=20, help="Number of commits to show")
+@click.option("--since", help="Show commits since date/ref")
+@click.option("--author", help="Filter by author")
+@click.option("--grep", "grep_pattern", help="Filter by message pattern")
+def history_cmd(limit: int, since: str, author: str, grep_pattern: str):
+    """Show commit history with context.
+    
+    Displays recent commits with author, date, and message.
+    Useful for finding commits to bisect from.
+    """
+    cwd = Path.cwd()
+    
+    if not is_git_repo(cwd):
+        console.print("[red]Error:[/] Not a git repository")
+        return
+    
+    # Build git log command
+    cmd = ["git", "log", f"-{limit}", "--pretty=format:%h|%an|%ar|%s"]
+    
+    if since:
+        cmd.append(f"--since={since}")
+    if author:
+        cmd.append(f"--author={author}")
+    if grep_pattern:
+        cmd.append(f"--grep={grep_pattern}")
+    
+    result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        console.print("[red]Error:[/] Failed to get history")
+        return
+    
+    table = Table(title=f"Recent Commits (last {limit})")
+    table.add_column("SHA", style="cyan")
+    table.add_column("Author")
+    table.add_column("When")
+    table.add_column("Message")
+    
+    for line in result.stdout.strip().split("\n"):
+        if "|" in line:
+            parts = line.split("|", 3)
+            if len(parts) >= 4:
+                table.add_row(parts[0], parts[1], parts[2], parts[3][:50])
+    
+    console.print(table)

up/commands/branch.py

@@ -0,0 +1,350 @@
+"""up branch - Branch hierarchy management.
+
+Implements a tiered branch model for AI-assisted development:
+- main: Stable, production-ready code
+- develop: Integration branch for features
+- feature/*: Feature branches from develop
+- agent/*: AI worktree branches
+
+Changes flow upward: agent/* → feature/* → develop → main
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Optional, List
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.tree import Tree
+
+console = Console()
+
+
+# Branch hierarchy configuration
+BRANCH_HIERARCHY = {
+    "main": {
+        "level": 0,
+        "description": "Production-ready code",
+        "allows_from": ["develop", "hotfix/*"],
+        "protected": True,
+    },
+    "develop": {
+        "level": 1,
+        "description": "Integration branch",
+        "allows_from": ["feature/*", "agent/*"],
+        "protected": False,
+    },
+    "feature/*": {
+        "level": 2,
+        "description": "Feature branches",
+        "allows_from": ["agent/*"],
+        "protected": False,
+    },
+    "agent/*": {
+        "level": 3,
+        "description": "AI worktree branches",
+        "allows_from": [],
+        "protected": False,
+    },
+    "hotfix/*": {
+        "level": 1,
+        "description": "Emergency fixes",
+        "allows_from": [],
+        "protected": False,
+    },
+}
+
+
+def _is_git_repo(path: Path) -> bool:
+    """Check if path is a git repository."""
+    result = subprocess.run(
+        ["git", "rev-parse", "--git-dir"],
+        cwd=path,
+        capture_output=True
+    )
+    return result.returncode == 0
+
+
+def _get_current_branch(path: Path) -> str:
+    """Get current branch name."""
+    result = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=path,
+        capture_output=True,
+        text=True
+    )
+    return result.stdout.strip() if result.returncode == 0 else ""
+
+
+def _get_all_branches(path: Path) -> List[str]:
+    """Get all branch names."""
+    result = subprocess.run(
+        ["git", "branch", "-a", "--format=%(refname:short)"],
+        cwd=path,
+        capture_output=True,
+        text=True
+    )
+    if result.returncode == 0:
+        return [b.strip() for b in result.stdout.strip().split("\n") if b.strip()]
+    return []
+
+
+def _get_branch_pattern(branch: str) -> str:
+    """Get the pattern that matches a branch name."""
+    if branch == "main" or branch == "master":
+        return "main"
+    if branch == "develop" or branch == "development":
+        return "develop"
+    if branch.startswith("feature/"):
+        return "feature/*"
+    if branch.startswith("agent/"):
+        return "agent/*"
+    if branch.startswith("hotfix/"):
+        return "hotfix/*"
+    return branch
+
+
+def _can_merge(source: str, target: str) -> tuple[bool, str]:
+    """Check if source can be merged into target.
+    
+    Returns:
+        (can_merge, reason)
+    """
+    source_pattern = _get_branch_pattern(source)
+    target_pattern = _get_branch_pattern(target)
+    
+    target_config = BRANCH_HIERARCHY.get(target_pattern)
+    
+    if not target_config:
+        # Unknown target branch - allow by default
+        return True, "Target branch not in hierarchy"
+    
+    allowed = target_config.get("allows_from", [])
+    
+    if source_pattern in allowed:
+        return True, f"Merge allowed: {source_pattern} → {target_pattern}"
+    
+    # Check if source is at a lower level (wrong direction)
+    source_config = BRANCH_HIERARCHY.get(source_pattern)
+    if source_config:
+        source_level = source_config.get("level", 99)
+        target_level = target_config.get("level", 99)
+        
+        if source_level < target_level:
+            return False, f"Wrong direction: {source_pattern} (level {source_level}) cannot merge into {target_pattern} (level {target_level})"
+    
+    return False, f"Not allowed: {source_pattern} → {target_pattern}. Allowed sources: {', '.join(allowed)}"
+
+
+@click.group()
+def branch():
+    """Branch hierarchy management.
+    
+    Enforce a tiered branch model for safe AI development.
+    Changes flow upward: agent/* → feature/* → develop → main
+    """
+    pass
+
+
+@branch.command("status")
+def status_cmd():
+    """Show current branch status and hierarchy."""
+    cwd = Path.cwd()
+    
+    if not _is_git_repo(cwd):
+        console.print("[red]Error:[/] Not a git repository")
+        return
+    
+    current = _get_current_branch(cwd)
+    all_branches = _get_all_branches(cwd)
+    
+    console.print(Panel.fit(
+        f"[bold]Branch Hierarchy[/]\nCurrent: [cyan]{current}[/]",
+        border_style="blue"
+    ))
+    
+    # Build hierarchy tree
+    tree = Tree("[bold]Branch Hierarchy[/]")
+    
+    main_node = tree.add("🔒 [bold green]main[/] - Production")
+    develop_node = main_node.add("📦 [yellow]develop[/] - Integration")
+    
+    # Group branches
+    feature_branches = [b for b in all_branches if b.startswith("feature/")]
+    agent_branches = [b for b in all_branches if b.startswith("agent/")]
+    hotfix_branches = [b for b in all_branches if b.startswith("hotfix/")]
+    
+    if feature_branches:
+        features = develop_node.add(f"🔧 [cyan]feature/*[/] ({len(feature_branches)})")
+        for fb in feature_branches[:5]:
+            is_current = "← current" if fb == current else ""
+            features.add(f"[dim]{fb}[/] {is_current}")
+        if len(feature_branches) > 5:
+            features.add(f"[dim]... and {len(feature_branches) - 5} more[/]")
+    
+    if agent_branches:
+        agents = develop_node.add(f"🤖 [magenta]agent/*[/] ({len(agent_branches)})")
+        for ab in agent_branches[:5]:
+            is_current = "← current" if ab == current else ""
+            agents.add(f"[dim]{ab}[/] {is_current}")
+        if len(agent_branches) > 5:
+            agents.add(f"[dim]... and {len(agent_branches) - 5} more[/]")
+    
+    if hotfix_branches:
+        hotfixes = main_node.add(f"🚨 [red]hotfix/*[/] ({len(hotfix_branches)})")
+        for hb in hotfix_branches[:3]:
+            hotfixes.add(f"[dim]{hb}[/]")
+    
+    console.print(tree)
+    
+    # Show allowed merges for current branch
+    current_pattern = _get_branch_pattern(current)
+    console.print(f"\n[bold]Current Branch:[/] {current} ({current_pattern})")
+    
+    # Where can we merge to?
+    merge_targets = []
+    for target, config in BRANCH_HIERARCHY.items():
+        if current_pattern in config.get("allows_from", []):
+            merge_targets.append(target)
+    
+    if merge_targets:
+        console.print(f"[green]Can merge to:[/] {', '.join(merge_targets)}")
+    else:
+        console.print("[dim]No merge targets in hierarchy[/]")
+
+
+@branch.command("check")
+@click.argument("target", required=False)
+@click.option("--source", "-s", help="Source branch (default: current)")
+def check_cmd(target: str, source: str):
+    """Check if merge is allowed by hierarchy.
+    
+    \b
+    Examples:
+      up branch check develop              # Check current → develop
+      up branch check main -s develop      # Check develop → main
+    """
+    cwd = Path.cwd()
+    
+    if not _is_git_repo(cwd):
+        console.print("[red]Error:[/] Not a git repository")
+        return
+    
+    source_branch = source or _get_current_branch(cwd)
+    target_branch = target or "develop"
+    
+    can_merge, reason = _can_merge(source_branch, target_branch)
+    
+    if can_merge:
+        console.print(f"[green]✓[/] {reason}")
+        console.print(f"\n  {source_branch} → {target_branch}")
+    else:
+        console.print(f"[red]✗[/] {reason}")
+        
+        # Suggest correct flow
+        source_pattern = _get_branch_pattern(source_branch)
+        source_config = BRANCH_HIERARCHY.get(source_pattern)
+        
+        if source_config:
+            # Find where source can go
+            for t, config in BRANCH_HIERARCHY.items():
+                if source_pattern in config.get("allows_from", []):
+                    console.print(f"\n[dim]Suggestion: Merge to {t} first[/]")
+                    break
+
+
+@branch.command("enforce")
+@click.option("--enable", is_flag=True, help="Enable enforcement")
+@click.option("--disable", is_flag=True, help="Disable enforcement")
+def enforce_cmd(enable: bool, disable: bool):
+    """Enable/disable branch hierarchy enforcement.
+    
+    When enabled, 'up agent merge' will check hierarchy before merging.
+    """
+    cwd = Path.cwd()
+    
+    if not _is_git_repo(cwd):
+        console.print("[red]Error:[/] Not a git repository")
+        return
+    
+    # Store setting in .up/config.json
+    config_dir = cwd / ".up"
+    config_file = config_dir / "config.json"
+    
+    import json
+    
+    config = {}
+    if config_file.exists():
+        try:
+            config = json.loads(config_file.read_text())
+        except json.JSONDecodeError:
+            pass
+    
+    if enable:
+        config["branch_hierarchy_enforcement"] = True
+        console.print("[green]✓[/] Branch hierarchy enforcement enabled")
+    elif disable:
+        config["branch_hierarchy_enforcement"] = False
+        console.print("[yellow]○[/] Branch hierarchy enforcement disabled")
+    else:
+        current = config.get("branch_hierarchy_enforcement", False)
+        status = "[green]enabled[/]" if current else "[dim]disabled[/]"
+        console.print(f"Branch hierarchy enforcement: {status}")
+        console.print("\nUse [cyan]--enable[/] or [cyan]--disable[/] to change")
+        return
+    
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_file.write_text(json.dumps(config, indent=2))
+
+
+@branch.command("create")
+@click.argument("name")
+@click.option("--type", "branch_type", type=click.Choice(["feature", "agent", "hotfix"]), 
+              default="feature", help="Branch type")
+@click.option("--from", "from_branch", default="develop", help="Base branch")
+def create_cmd(name: str, branch_type: str, from_branch: str):
+    """Create a new branch following hierarchy.
+    
+    \b
+    Examples:
+      up branch create auth                  # feature/auth from develop
+      up branch create US-007 --type agent   # agent/US-007 from develop
+      up branch create fix-login --type hotfix --from main
+    """
+    cwd = Path.cwd()
+    
+    if not _is_git_repo(cwd):
+        console.print("[red]Error:[/] Not a git repository")
+        return
+    
+    # Build branch name
+    if branch_type == "feature":
+        full_name = f"feature/{name}"
+    elif branch_type == "agent":
+        full_name = f"agent/{name}"
+    elif branch_type == "hotfix":
+        full_name = f"hotfix/{name}"
+        from_branch = "main"  # Hotfixes always from main
+    else:
+        full_name = name
+    
+    # Create branch
+    result = subprocess.run(
+        ["git", "checkout", "-b", full_name, from_branch],
+        cwd=cwd,
+        capture_output=True,
+        text=True
+    )
+    
+    if result.returncode == 0:
+        console.print(f"[green]✓[/] Created branch: [cyan]{full_name}[/]")
+        console.print(f"  Based on: {from_branch}")
+        
+        # Show merge path
+        target = "develop" if branch_type in ["feature", "agent"] else "main"
+        console.print(f"\n[dim]Merge path: {full_name} → {target}[/]")
+    else:
+        console.print(f"[red]Error:[/] Failed to create branch")
+        console.print(f"[dim]{result.stderr}[/]")