galangal-orchestrate 0.13.0__py3-none-any.whl

galangal/commands/github.py

@@ -0,0 +1,355 @@
+"""
+galangal github - GitHub integration commands.
+"""
+
+import argparse
+import platform
+
+from galangal.ui.console import console, print_error, print_info, print_success, print_warning
+
+GH_INSTALL_INSTRUCTIONS = """
+GitHub CLI (gh) is required for GitHub integration.
+
+Installation instructions:
+
+  macOS:
+    brew install gh
+
+  Windows:
+    winget install GitHub.cli
+    # or download from https://github.com/cli/cli/releases
+
+  Linux (Debian/Ubuntu):
+    curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
+    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+    sudo apt update && sudo apt install gh
+
+  Linux (Fedora):
+    sudo dnf install gh
+
+  Linux (Arch):
+    sudo pacman -S github-cli
+
+After installation, authenticate with:
+    gh auth login
+
+For more info: https://cli.github.com
+"""
+
+
+def _get_platform_install_hint() -> str:
+    """Get platform-specific installation hint."""
+    system = platform.system().lower()
+    if system == "darwin":
+        return "brew install gh"
+    elif system == "windows":
+        return "winget install GitHub.cli"
+    elif system == "linux":
+        return "See https://cli.github.com for Linux install instructions"
+    return "See https://cli.github.com"
+
+
+def require_github_ready():
+    """
+    Check GitHub readiness and print error if not ready.
+
+    Returns:
+        GitHubReadyCheck if ready, None if not ready (error already printed).
+    """
+    from galangal.github.client import ensure_github_ready
+
+    check = ensure_github_ready()
+    if not check:
+        print_error("GitHub integration not ready. Run 'galangal github check' for details.")
+        return None
+    return check
+
+
+def cmd_github_setup(args: argparse.Namespace) -> int:
+    """Set up GitHub integration by creating required labels."""
+    from galangal.config.loader import get_config
+    from galangal.github.client import GitHubClient
+
+    console.print("\n[bold]GitHub Integration Setup[/bold]\n")
+
+    client = GitHubClient()
+
+    # Step 1: Check if gh is installed
+    gh_installed, gh_version = client.check_installation()
+    if not gh_installed:
+        print_error("GitHub CLI (gh) is not installed")
+        console.print(f"\n[dim]Quick install: {_get_platform_install_hint()}[/dim]")
+        if getattr(args, "help_install", False):
+            console.print(GH_INSTALL_INSTRUCTIONS)
+        else:
+            console.print(
+                "\n[dim]Run 'galangal github setup --help-install' for detailed instructions[/dim]"
+            )
+        return 1
+
+    print_success(f"GitHub CLI installed: {gh_version}")
+
+    # Step 2: Check authentication
+    authenticated, auth_user, _ = client.check_auth()
+    if not authenticated:
+        print_error("Not authenticated with GitHub")
+        console.print("\n[dim]Run: gh auth login[/dim]")
+        return 1
+
+    print_success(f"Authenticated as: {auth_user}")
+
+    # Step 3: Check repository access
+    repo_accessible, repo_name = client.check_repo_access()
+    if not repo_accessible:
+        print_error("Cannot access repository")
+        console.print("\n[dim]Ensure you're in a git repo with a GitHub remote[/dim]")
+        return 1
+
+    print_success(f"Repository: {repo_name}")
+
+    console.print("\n[dim]─────────────────────────────────────[/dim]")
+    console.print("\n[bold]Creating labels...[/bold]\n")
+
+    # Step 4: Create required labels
+    config = get_config()
+    github_config = config.github
+
+    labels_to_create = [
+        (
+            github_config.pickup_label,
+            github_config.label_colors.get(github_config.pickup_label, "7C3AED"),
+            "Issues for galangal to work on",
+        ),
+        (
+            github_config.in_progress_label,
+            github_config.label_colors.get(github_config.in_progress_label, "FCD34D"),
+            "Issue is being worked on by galangal",
+        ),
+    ]
+
+    created_count = 0
+    for label_name, color, description in labels_to_create:
+        success, was_created = client.create_label_if_missing(label_name, color, description)
+        if success:
+            if was_created:
+                print_success(f"Created label: {label_name}")
+                created_count += 1
+            else:
+                print_info(f"Label already exists: {label_name}")
+        else:
+            print_error(f"Failed to create label: {label_name}")
+
+    # Step 5: Show summary and next steps
+    console.print("\n[dim]─────────────────────────────────────[/dim]")
+    console.print("\n[bold]Setup complete![/bold]\n")
+
+    if created_count > 0:
+        console.print(f"Created {created_count} new label(s).\n")
+
+    console.print("[bold]How to use GitHub integration:[/bold]")
+    console.print(
+        f"  1. Add the '[cyan]{github_config.pickup_label}[/cyan]' label to issues you want galangal to work on"
+    )
+    console.print(
+        "  2. Run '[cyan]galangal start[/cyan]' and select 'GitHub issue' as the task source"
+    )
+    console.print(
+        "  3. Or run '[cyan]galangal github run[/cyan]' to process all labeled issues automatically"
+    )
+
+    console.print("\n[bold]Label to task type mapping:[/bold]")
+    mapping = github_config.label_mapping
+    console.print(f"  bug_fix:  {', '.join(mapping.bug)}")
+    console.print(f"  feature:  {', '.join(mapping.feature)}")
+    console.print(f"  docs:     {', '.join(mapping.docs)}")
+    console.print(f"  refactor: {', '.join(mapping.refactor)}")
+    console.print(f"  chore:    {', '.join(mapping.chore)}")
+    console.print(f"  hotfix:   {', '.join(mapping.hotfix)}")
+
+    console.print(
+        "\n[dim]Customize mappings in .galangal/config.yaml under 'github.label_mapping'[/dim]"
+    )
+
+    return 0
+
+
+def cmd_github_check(args: argparse.Namespace) -> int:
+    """Check GitHub CLI installation and repository access."""
+    from galangal.github.client import GitHubClient
+
+    console.print("\n[bold]GitHub Integration Check[/bold]\n")
+
+    client = GitHubClient()
+    result = client.check_setup()
+
+    # Display results
+    console.print("[dim]─────────────────────────────────────[/dim]")
+
+    # 1. gh CLI installation
+    if result.gh_installed:
+        print_success(f"gh CLI installed: {result.gh_version}")
+    else:
+        print_error("gh CLI not installed")
+        console.print("  [dim]Install from: https://cli.github.com[/dim]")
+
+    # 2. Authentication
+    if result.authenticated:
+        print_success(f"Authenticated as: {result.auth_user}")
+        if result.auth_scopes:
+            console.print(f"  [dim]Scopes: {', '.join(result.auth_scopes)}[/dim]")
+    elif result.gh_installed:
+        print_error("Not authenticated")
+        console.print("  [dim]Run: gh auth login[/dim]")
+
+    # 3. Repository access
+    if result.repo_accessible:
+        print_success(f"Repository: {result.repo_name}")
+    elif result.authenticated:
+        print_error("Cannot access repository")
+        console.print("  [dim]Ensure you're in a git repo with a GitHub remote[/dim]")
+
+    console.print("[dim]─────────────────────────────────────[/dim]\n")
+
+    # Summary
+    if result.is_ready:
+        print_success("GitHub integration is ready")
+        return 0
+    else:
+        print_error("GitHub integration not ready")
+        if result.errors:
+            console.print("\n[bold]Issues to resolve:[/bold]")
+            for error in result.errors:
+                console.print(f"  • {error}")
+        return 1
+
+
+def cmd_github_issues(args: argparse.Namespace) -> int:
+    """List GitHub issues with the galangal label."""
+    from rich.table import Table
+
+    from galangal.github.client import GitHubError
+    from galangal.github.issues import GALANGAL_LABEL, list_issues
+
+    # First check setup
+    if not require_github_ready():
+        return 1
+
+    label = getattr(args, "label", GALANGAL_LABEL) or GALANGAL_LABEL
+
+    try:
+        issues = list_issues(label=label, limit=args.limit if hasattr(args, "limit") else 50)
+    except GitHubError as e:
+        print_error(f"Failed to list issues: {e}")
+        return 1
+
+    if not issues:
+        print_info(f"No open issues found with label '{label}'")
+        console.print(f"\n[dim]To tag an issue for galangal, add the '{label}' label.[/dim]")
+        return 0
+
+    # Display table
+    table = Table(title=f"Issues with '{label}' label")
+    table.add_column("#", style="cyan", width=6)
+    table.add_column("Title", style="bold", max_width=50)
+    table.add_column("Labels", style="dim")
+    table.add_column("Author", style="dim")
+
+    for issue in issues:
+        other_labels = [lbl for lbl in issue.labels if lbl != label]
+        labels_str = ", ".join(other_labels[:3])
+        if len(other_labels) > 3:
+            labels_str += f" +{len(other_labels) - 3}"
+
+        table.add_row(
+            str(issue.number),
+            issue.title[:50] + ("..." if len(issue.title) > 50 else ""),
+            labels_str,
+            issue.author,
+        )
+
+    console.print(table)
+    console.print(f"\n[dim]Found {len(issues)} issue(s)[/dim]")
+
+    return 0
+
+
+def cmd_github_run(args: argparse.Namespace) -> int:
+    """Process all galangal-labeled GitHub issues headlessly."""
+    from galangal.core.state import load_state
+    from galangal.core.tasks import create_task_from_issue
+    from galangal.core.workflow import run_workflow
+    from galangal.github.client import GitHubError
+    from galangal.github.issues import GALANGAL_LABEL, list_issues
+
+    console.print("\n[bold]GitHub Issues Batch Processor[/bold]\n")
+
+    # Check setup
+    check = require_github_ready()
+    if not check:
+        return 1
+
+    # List issues
+    label = getattr(args, "label", GALANGAL_LABEL) or GALANGAL_LABEL
+    dry_run = getattr(args, "dry_run", False)
+
+    try:
+        issues = list_issues(label=label)
+    except GitHubError as e:
+        print_error(f"Failed to list issues: {e}")
+        return 1
+
+    if not issues:
+        print_info(f"No open issues found with label '{label}'")
+        return 0
+
+    console.print(f"Found {len(issues)} issue(s) to process\n")
+    console.print("[dim]─────────────────────────────────────[/dim]")
+
+    if dry_run:
+        print_info("DRY RUN - no tasks will be created\n")
+        for issue in issues:
+            console.print(f"  [cyan]#{issue.number}[/cyan] {issue.title[:60]}")
+        return 0
+
+    # Process each issue
+    processed = 0
+    failed = 0
+
+    for issue in issues:
+        console.print(f"\n[bold]Processing issue #{issue.number}:[/bold] {issue.title[:50]}")
+
+        # Create task from issue (handles name generation, screenshots, marking in-progress)
+        task_result = create_task_from_issue(issue, repo_name=check.repo_name)
+
+        if not task_result.success:
+            print_error(f"Failed to create task: {task_result.message}")
+            failed += 1
+            break  # Stop on first failure
+
+        print_success(f"Created task: {task_result.task_name}")
+        if task_result.screenshots:
+            print_info(f"Downloaded {len(task_result.screenshots)} screenshot(s)")
+        print_info("Marked issue as in-progress")
+
+        # Run workflow
+        state = load_state(task_result.task_name)
+        if state:
+            console.print("[dim]Running workflow...[/dim]")
+            result = run_workflow(state)
+
+            if result in ("done", "complete"):
+                print_success(f"Issue #{issue.number} completed successfully")
+                processed += 1
+            else:
+                print_warning(f"Issue #{issue.number} workflow ended with: {result}")
+                failed += 1
+                break  # Stop on first failure
+
+    # Summary
+    console.print("\n[dim]─────────────────────────────────────[/dim]")
+    console.print("\n[bold]Summary:[/bold]")
+    console.print(f"  Processed: {processed}")
+    console.print(f"  Failed: {failed}")
+    console.print(f"  Remaining: {len(issues) - processed - failed}")
+
+    return 0 if failed == 0 else 1

galangal/commands/init.py

@@ -0,0 +1,177 @@
+"""
+galangal init - Initialize galangal in a project.
+"""
+
+import argparse
+
+import yaml
+from rich.prompt import Confirm, Prompt
+
+from galangal.config.defaults import generate_default_config
+from galangal.config.loader import find_project_root
+from galangal.ui.console import console, print_info, print_success, print_warning
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    """Initialize galangal in the current project."""
+    console.print(
+        "\n[bold cyan]╔══════════════════════════════════════════════════════════════╗[/bold cyan]"
+    )
+    console.print(
+        "[bold cyan]║[/bold cyan]              [bold]Galangal Orchestrate[/bold]                          [bold cyan]║[/bold cyan]"
+    )
+    console.print(
+        "[bold cyan]║[/bold cyan]          AI-Driven Development Workflow                     [bold cyan]║[/bold cyan]"
+    )
+    console.print(
+        "[bold cyan]╚══════════════════════════════════════════════════════════════╝[/bold cyan]\n"
+    )
+
+    project_root = find_project_root()
+    galangal_dir = project_root / ".galangal"
+    config_file = galangal_dir / "config.yaml"
+
+    # Check for --quick flag (non-interactive mode)
+    quick_mode = getattr(args, "quick", False)
+
+    if galangal_dir.exists():
+        existing_config = None
+        if config_file.exists():
+            try:
+                existing_config = yaml.safe_load(config_file.read_text())
+            except yaml.YAMLError:
+                existing_config = None
+
+        if existing_config and not quick_mode:
+            # Check for missing sections
+            from galangal.commands.init_wizard import check_missing_sections
+
+            missing = check_missing_sections(existing_config)
+
+            if missing:
+                print_info(f"Galangal already initialized in {project_root}")
+                print_warning(f"Missing configuration sections: {', '.join(missing)}")
+
+                if Confirm.ask("Run setup wizard to configure missing sections?", default=True):
+                    return _run_wizard_update(project_root, galangal_dir, existing_config)
+            else:
+                print_info(f"Galangal already initialized in {project_root}")
+
+            if Confirm.ask("Reinitialize with setup wizard?", default=False):
+                return _run_wizard_new(project_root, galangal_dir)
+
+            return 0
+        else:
+            print_info(f"Galangal already initialized in {project_root}")
+            if not Confirm.ask("Reinitialize?", default=False):
+                return 0
+
+    console.print(f"[dim]Project root: {project_root}[/dim]\n")
+
+    # Decide between wizard and quick mode
+    if quick_mode:
+        return _run_quick_init(project_root, galangal_dir)
+    else:
+        use_wizard = Confirm.ask(
+            "Run interactive setup wizard? (recommended for first-time setup)",
+            default=True,
+        )
+
+        if use_wizard:
+            return _run_wizard_new(project_root, galangal_dir)
+        else:
+            return _run_quick_init(project_root, galangal_dir)
+
+
+def _run_wizard_new(project_root, galangal_dir) -> int:
+    """Run the full setup wizard for new initialization."""
+    from galangal.commands.init_wizard import run_wizard
+
+    config = run_wizard(project_root, existing_config=None)
+
+    # Create directories
+    galangal_dir.mkdir(exist_ok=True)
+    (galangal_dir / "prompts").mkdir(exist_ok=True)
+
+    # Write config
+    config_content = config.to_yaml()
+    (galangal_dir / "config.yaml").write_text(config_content)
+
+    print_success("Created .galangal/config.yaml")
+    print_success("Created .galangal/prompts/ (empty - uses defaults)")
+
+    # Add to .gitignore
+    _update_gitignore(project_root)
+
+    _show_next_steps()
+    return 0
+
+
+def _run_wizard_update(project_root, galangal_dir, existing_config: dict) -> int:
+    """Run the setup wizard in update mode for missing sections."""
+    from galangal.commands.init_wizard import run_wizard
+
+    config = run_wizard(project_root, existing_config=existing_config)
+
+    # Write updated config
+    config_content = config.to_yaml()
+    (galangal_dir / "config.yaml").write_text(config_content)
+
+    print_success("Updated .galangal/config.yaml")
+
+    _show_next_steps()
+    return 0
+
+
+def _run_quick_init(project_root, galangal_dir) -> int:
+    """Run quick initialization without wizard (original behavior)."""
+    # Get project name
+    default_name = project_root.name
+    project_name = Prompt.ask("Project name", default=default_name)
+
+    # Create .galangal directory
+    galangal_dir.mkdir(exist_ok=True)
+    (galangal_dir / "prompts").mkdir(exist_ok=True)
+
+    # Generate config
+    config_content = generate_default_config(project_name=project_name)
+    (galangal_dir / "config.yaml").write_text(config_content)
+
+    print_success("Created .galangal/config.yaml")
+    print_success("Created .galangal/prompts/ (empty - uses defaults)")
+
+    # Add to .gitignore
+    _update_gitignore(project_root)
+
+    console.print("\n[dim]Tip: Run 'galangal init' again to use the setup wizard.[/dim]")
+    _show_next_steps()
+    return 0
+
+
+def _update_gitignore(project_root) -> None:
+    """Add galangal-tasks/ to .gitignore if not present."""
+    gitignore = project_root / ".gitignore"
+    tasks_entry = "galangal-tasks/"
+
+    if gitignore.exists():
+        content = gitignore.read_text()
+        if tasks_entry not in content:
+            with open(gitignore, "a") as f:
+                f.write(f"\n# Galangal task artifacts\n{tasks_entry}\n")
+            print_success(f"Added {tasks_entry} to .gitignore")
+    else:
+        gitignore.write_text(f"# Galangal task artifacts\n{tasks_entry}\n")
+        print_success(f"Created .gitignore with {tasks_entry}")
+
+
+def _show_next_steps() -> None:
+    """Show next steps after initialization."""
+    console.print("\n[bold green]Initialization complete![/bold green]\n")
+    console.print("To customize prompts for your project:")
+    console.print(
+        "  [cyan]galangal prompts export[/cyan]    # Export defaults to .galangal/prompts/"
+    )
+    console.print("\nNext steps:")
+    console.print('  [cyan]galangal start "Your first task"[/cyan]')
+    console.print("\nFor GitHub Issues integration:")
+    console.print("  [cyan]galangal github setup[/cyan]      # Create labels and configure")