galangal-orchestrate 0.2.11__py3-none-any.whl

galangal/commands/__init__.py

@@ -0,0 +1,42 @@
+"""CLI commands."""
+
+from galangal.commands.init import cmd_init
+from galangal.commands.start import cmd_start
+from galangal.commands.resume import cmd_resume
+from galangal.commands.status import cmd_status
+from galangal.commands.list import cmd_list
+from galangal.commands.switch import cmd_switch
+from galangal.commands.pause import cmd_pause
+from galangal.commands.approve import cmd_approve, cmd_approve_design
+from galangal.commands.skip import (
+    cmd_skip_design,
+    cmd_skip_security,
+    cmd_skip_migration,
+    cmd_skip_contract,
+    cmd_skip_benchmark,
+    cmd_skip_to,
+)
+from galangal.commands.reset import cmd_reset
+from galangal.commands.complete import cmd_complete
+from galangal.commands.prompts import cmd_prompts
+
+__all__ = [
+    "cmd_init",
+    "cmd_start",
+    "cmd_resume",
+    "cmd_status",
+    "cmd_list",
+    "cmd_switch",
+    "cmd_pause",
+    "cmd_approve",
+    "cmd_approve_design",
+    "cmd_skip_design",
+    "cmd_skip_security",
+    "cmd_skip_migration",
+    "cmd_skip_contract",
+    "cmd_skip_benchmark",
+    "cmd_skip_to",
+    "cmd_reset",
+    "cmd_complete",
+    "cmd_prompts",
+]

galangal/commands/approve.py

@@ -0,0 +1,187 @@
+"""
+galangal approve - Record approval for plans and designs.
+"""
+
+import argparse
+from datetime import datetime, timezone
+
+from rich.prompt import Prompt
+
+from galangal.core.state import Stage, load_state, save_state
+from galangal.core.tasks import get_active_task
+from galangal.core.artifacts import artifact_exists, read_artifact, write_artifact
+from galangal.core.workflow import run_workflow
+from galangal.ui.console import console, print_error, print_success, print_info
+
+
+def prompt_plan_approval(task_name: str, state) -> str:
+    """
+    Interactive approval prompt for PLAN.md.
+    Returns: 'approved', 'rejected', or 'quit'
+    """
+    console.print("\n" + "=" * 60)
+    console.print("[bold yellow]⏸️  APPROVAL REQUIRED[/bold yellow]")
+    console.print("=" * 60)
+    console.print(f"\nTask: {task_name}")
+    console.print(f"Stage: PM → [yellow]APPROVAL GATE[/yellow] → DESIGN")
+
+    # Show PLAN.md content
+    plan = read_artifact("PLAN.md", task_name)
+    if plan:
+        console.print("\n[bold]PLAN.md Preview:[/bold]")
+        console.print("[dim]" + "-" * 40 + "[/dim]")
+        # Show first 1500 chars
+        preview = plan[:1500] + ("..." if len(plan) > 1500 else "")
+        console.print(preview)
+        console.print("[dim]" + "-" * 40 + "[/dim]")
+
+    console.print("\n[bold]Options:[/bold]")
+    console.print("  [green]y[/green] - Approve plan and continue to DESIGN")
+    console.print("  [red]n[/red] - Reject and restart PM stage")
+    console.print("  [yellow]q[/yellow] - Quit/pause (resume later)")
+
+    while True:
+        choice = Prompt.ask("Your choice", default="y").strip().lower()
+
+        if choice in ["y", "yes", "approve"]:
+            approver = Prompt.ask("Approver name", default="")
+
+            approval_content = f"""# Plan Approval
+
+- **Status:** Approved
+- **Approved By:** {approver or "Not specified"}
+- **Date:** {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
+"""
+            write_artifact("APPROVAL.md", approval_content, task_name)
+            print_success("Plan approved!")
+            return "approved"
+
+        elif choice in ["n", "no", "reject"]:
+            reason = Prompt.ask("Rejection reason", default="Needs revision")
+            state.stage = Stage.PM
+            state.attempt = 1
+            state.last_failure = f"Plan rejected: {reason}"
+            save_state(state)
+            print_info("Plan rejected. Restarting PM stage.")
+            return "rejected"
+
+        elif choice in ["q", "quit", "pause"]:
+            return "quit"
+
+        else:
+            print_error("Invalid choice. Enter y/n/q")
+
+
+def prompt_design_approval(task_name: str, state) -> str:
+    """
+    Interactive approval prompt for DESIGN.md.
+    Returns: 'approved', 'rejected', or 'quit'
+    """
+    console.print("\n" + "=" * 60)
+    console.print("[bold yellow]⏸️  DESIGN REVIEW REQUIRED[/bold yellow]")
+    console.print("=" * 60)
+    console.print(f"\nTask: {task_name}")
+    console.print(f"Stage: DESIGN → [yellow]REVIEW GATE[/yellow] → DEV")
+
+    # Show DESIGN.md content
+    design = read_artifact("DESIGN.md", task_name)
+    if design:
+        console.print("\n[bold]DESIGN.md Preview:[/bold]")
+        console.print("[dim]" + "-" * 40 + "[/dim]")
+        preview = design[:2000] + ("..." if len(design) > 2000 else "")
+        console.print(preview)
+        console.print("[dim]" + "-" * 40 + "[/dim]")
+
+    console.print("\n[bold]Options:[/bold]")
+    console.print("  [green]y[/green] - Approve design and continue to DEV")
+    console.print("  [red]n[/red] - Reject and restart DESIGN stage")
+    console.print("  [yellow]q[/yellow] - Quit/pause (resume later)")
+
+    while True:
+        choice = Prompt.ask("Your choice", default="y").strip().lower()
+
+        if choice in ["y", "yes", "approve"]:
+            approver = Prompt.ask("Reviewer name", default="")
+
+            review_content = f"""# Design Review
+
+**Status:** Approved
+**Date:** {datetime.now(timezone.utc).isoformat()}
+**Reviewer:** {approver or "Not specified"}
+
+## Review Notes
+
+Design reviewed and approved for implementation.
+"""
+            write_artifact("DESIGN_REVIEW.md", review_content, task_name)
+            print_success("Design approved!")
+            return "approved"
+
+        elif choice in ["n", "no", "reject"]:
+            reason = Prompt.ask("Rejection reason", default="Needs revision")
+            state.stage = Stage.DESIGN
+            state.attempt = 1
+            state.last_failure = f"Design rejected: {reason}"
+            save_state(state)
+            print_info("Design rejected. Restarting DESIGN stage.")
+            return "rejected"
+
+        elif choice in ["q", "quit", "pause"]:
+            return "quit"
+
+        else:
+            print_error("Invalid choice. Enter y/n/q")
+
+
+def cmd_approve(args: argparse.Namespace) -> int:
+    """Record human approval for active task (fallback command)."""
+    active = get_active_task()
+    if not active:
+        print_error("No active task.")
+        return 1
+
+    state = load_state(active)
+    if state is None:
+        print_error(f"Could not load state for '{active}'.")
+        return 1
+
+    if state.stage != Stage.DESIGN or artifact_exists("APPROVAL.md", active):
+        print_error("Approval not needed at this stage.")
+        return 1
+
+    result = prompt_plan_approval(active, state)
+    if result == "approved":
+        run_workflow(state)
+    return 0 if result == "approved" else 1
+
+
+def cmd_approve_design(args: argparse.Namespace) -> int:
+    """Record design review approval for active task (fallback command)."""
+    active = get_active_task()
+    if not active:
+        print_error("No active task.")
+        return 1
+
+    state = load_state(active)
+    if state is None:
+        print_error(f"Could not load state for '{active}'.")
+        return 1
+
+    if state.stage != Stage.DEV:
+        print_error(
+            f"Design approval is for DEV stage. Current stage: {state.stage.value}"
+        )
+        return 1
+
+    if artifact_exists("DESIGN_REVIEW.md", active):
+        print_error("DESIGN_REVIEW.md already exists.")
+        return 1
+
+    if not artifact_exists("DESIGN.md", active):
+        print_error("DESIGN.md not found. Design stage may not have completed.")
+        return 1
+
+    result = prompt_design_approval(active, state)
+    if result == "approved":
+        run_workflow(state)
+    return 0 if result == "approved" else 1

galangal/commands/complete.py

@@ -0,0 +1,268 @@
+"""
+galangal complete - Complete a task, commit, and create PR.
+"""
+
+import argparse
+import shutil
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+from rich.prompt import Prompt
+
+from galangal.config.loader import get_project_root, get_config, get_done_dir
+from galangal.core.state import Stage, load_state, get_task_dir
+from galangal.core.tasks import get_active_task, clear_active_task, get_current_branch
+from galangal.core.artifacts import read_artifact, run_command
+from galangal.ai.claude import ClaudeBackend
+from galangal.ui.console import console, print_error, print_info, print_success, print_warning
+
+
+def generate_pr_title(task_name: str, description: str, task_type: str) -> str:
+    """Generate a concise PR title using AI."""
+    backend = ClaudeBackend()
+
+    prompt = f"""Generate a concise pull request title for this task.
+
+Task: {task_name}
+Type: {task_type}
+Description: {description[:500]}
+
+Requirements:
+1. Max 72 characters
+2. Start with type prefix based on task type:
+   - Feature → "feat: ..."
+   - Bug Fix → "fix: ..."
+   - Refactor → "refactor: ..."
+   - Chore → "chore: ..."
+   - Docs → "docs: ..."
+   - Hotfix → "fix: ..."
+3. Be specific about what changed
+4. Use imperative mood ("Add feature" not "Added feature")
+5. No period at end
+
+Output ONLY the title, nothing else."""
+
+    title = backend.generate_text(prompt, timeout=30)
+    if title:
+        title = title.split("\n")[0].strip()
+        return title[:72] if len(title) > 72 else title
+
+    # Fallback
+    return description[:72] if len(description) > 72 else description
+
+
+def generate_commit_summary(task_name: str, description: str) -> str:
+    """Generate a commit message summary using AI."""
+    backend = ClaudeBackend()
+
+    spec = read_artifact("SPEC.md", task_name) or ""
+    plan = read_artifact("PLAN.md", task_name) or ""
+
+    code, diff_stat, _ = run_command(["git", "diff", "--stat", "main...HEAD"])
+    code, changed_files, _ = run_command(["git", "diff", "--name-only", "main...HEAD"])
+
+    prompt = f"""Generate a concise git commit message for this task. Follow conventional commit format.
+
+Task: {task_name}
+Description: {description}
+
+Specification summary:
+{spec[:1000] if spec else "(none)"}
+
+Implementation plan summary:
+{plan[:800] if plan else "(none)"}
+
+Files changed:
+{changed_files[:1000] if changed_files else "(none)"}
+
+Requirements:
+1. First line: type(scope): brief description (max 72 chars)
+   - Types: feat, fix, refactor, chore, docs, test, style, perf
+2. Blank line
+3. Body: 2-4 bullet points summarizing key changes
+4. Do NOT include any co-authored-by or generated-by lines
+
+Output ONLY the commit message, nothing else."""
+
+    summary = backend.generate_text(prompt, timeout=60)
+    if summary:
+        return summary.strip()
+
+    return f"{description[:72]}"
+
+
+def create_pull_request(task_name: str, description: str, task_type: str) -> tuple[bool, str]:
+    """Create a pull request for the task branch."""
+    config = get_config()
+    branch_name = config.branch_pattern.format(task_name=task_name)
+    base_branch = config.pr.base_branch
+
+    code, current_branch, _ = run_command(["git", "branch", "--show-current"])
+    current_branch = current_branch.strip()
+
+    if current_branch != branch_name:
+        code, _, err = run_command(["git", "checkout", branch_name])
+        if code != 0:
+            return False, f"Could not switch to branch {branch_name}: {err}"
+
+    code, out, err = run_command(["git", "push", "-u", "origin", branch_name])
+    if code != 0:
+        if "Everything up-to-date" not in out and "Everything up-to-date" not in err:
+            return False, f"Failed to push branch: {err or out}"
+
+    spec_content = read_artifact("SPEC.md", task_name) or description
+
+    console.print("[dim]Generating PR title...[/dim]")
+    pr_title = generate_pr_title(task_name, description, task_type)
+
+    # Build PR body
+    pr_body = f"""## Summary
+{spec_content[:1500] if len(spec_content) > 1500 else spec_content}
+
+---
+"""
+    # Add codex review if configured
+    if config.pr.codex_review:
+        pr_body += "@codex review\n"
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
+        f.write(pr_body)
+        body_file = f.name
+
+    try:
+        code, out, err = run_command(
+            [
+                "gh",
+                "pr",
+                "create",
+                "--title",
+                pr_title,
+                "--body-file",
+                body_file,
+                "--base",
+                base_branch,
+            ]
+        )
+    finally:
+        Path(body_file).unlink(missing_ok=True)
+
+    if code != 0:
+        combined_output = (out + err).lower()
+        if "already exists" in combined_output:
+            return True, "PR already exists"
+        if "pull request create failed" in combined_output:
+            code2, pr_url, _ = run_command(
+                ["gh", "pr", "view", "--json", "url", "-q", ".url"]
+            )
+            if code2 == 0 and pr_url.strip():
+                return True, pr_url.strip()
+        return False, f"Failed to create PR: {err or out}"
+
+    return True, out.strip()
+
+
+def commit_changes(task_name: str, description: str) -> tuple[bool, str]:
+    """Commit all changes for a task."""
+    code, status_out, _ = run_command(["git", "status", "--porcelain"])
+    if code != 0:
+        return False, "Failed to check git status"
+
+    if not status_out.strip():
+        return True, "No changes to commit"
+
+    changes = [line for line in status_out.strip().split("\n") if line.strip()]
+    change_count = len(changes)
+
+    console.print(f"[dim]Committing {change_count} changed files...[/dim]")
+
+    code, _, err = run_command(["git", "add", "-A"])
+    if code != 0:
+        return False, f"Failed to stage changes: {err}"
+
+    console.print("[dim]Generating commit summary...[/dim]")
+    summary = generate_commit_summary(task_name, description)
+
+    commit_msg = f"""{summary}
+
+Task: {task_name}
+Changes: {change_count} files"""
+
+    code, out, err = run_command(["git", "commit", "-m", commit_msg])
+    if code != 0:
+        return False, f"Failed to commit: {err or out}"
+
+    return True, f"Committed {change_count} files"
+
+
+def finalize_task(task_name: str, state, force: bool = False) -> bool:
+    """Finalize a completed task: move to done/, commit, create PR."""
+    config = get_config()
+    project_root = get_project_root()
+    done_dir = get_done_dir()
+
+    # 1. Move to done/
+    task_dir = get_task_dir(task_name)
+    done_dir.mkdir(parents=True, exist_ok=True)
+    dest = done_dir / task_name
+
+    if dest.exists():
+        dest = done_dir / f"{task_name}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+
+    console.print(f"[dim]Moving task to {dest.relative_to(project_root)}/...[/dim]")
+    shutil.move(str(task_dir), str(dest))
+    clear_active_task()
+
+    # 2. Commit changes
+    console.print("[dim]Committing changes...[/dim]")
+    success, msg = commit_changes(task_name, state.task_description)
+    if success:
+        print_success(msg)
+    else:
+        print_warning(msg)
+        if not force:
+            confirm = Prompt.ask("Continue anyway? [y/N]", default="n").strip().lower()
+            if confirm != "y":
+                shutil.move(str(dest), str(task_dir))
+                from galangal.core.tasks import set_active_task
+                set_active_task(task_name)
+                print_info("Aborted. Task restored to original location.")
+                return False
+
+    # 3. Create PR
+    console.print("[dim]Creating pull request...[/dim]")
+    success, msg = create_pull_request(task_name, state.task_description, state.task_type.display_name())
+    if success:
+        console.print(f"[green]PR:[/green] {msg}")
+    else:
+        print_warning(f"Could not create PR: {msg}")
+        console.print("You may need to create the PR manually.")
+
+    print_success(f"Task '{task_name}' completed and moved to {config.tasks_dir}/done/")
+
+    # 4. Switch back to main
+    run_command(["git", "checkout", config.pr.base_branch])
+    console.print(f"[dim]Switched back to {config.pr.base_branch} branch[/dim]")
+
+    return True
+
+
+def cmd_complete(args: argparse.Namespace) -> int:
+    """Move completed task to done/, commit, create PR."""
+    active = get_active_task()
+    if not active:
+        print_error("No active task.")
+        return 1
+
+    state = load_state(active)
+    if state is None:
+        print_error(f"Could not load state for '{active}'.")
+        return 1
+
+    if state.stage != Stage.COMPLETE:
+        print_error(f"Task is at stage {state.stage.value}, not COMPLETE.")
+        console.print("Run 'resume' to continue the workflow.")
+        return 1
+
+    success = finalize_task(active, state, force=args.force)
+    return 0 if success else 1

galangal/commands/init.py

@@ -0,0 +1,173 @@
+"""
+galangal init - Initialize galangal in a project.
+"""
+
+import argparse
+from pathlib import Path
+
+from rich.prompt import Prompt, Confirm
+
+from galangal.config.defaults import generate_default_config
+from galangal.config.loader import find_project_root
+from galangal.ui.console import console, print_success, print_error, print_info
+
+
+def detect_stacks(project_root: Path) -> list[dict[str, str]]:
+    """Detect technology stacks in the project."""
+    stacks = []
+
+    # Python detection
+    if (project_root / "pyproject.toml").exists() or (project_root / "setup.py").exists():
+        framework = None
+        # Check for framework
+        if (project_root / "requirements.txt").exists():
+            reqs = (project_root / "requirements.txt").read_text().lower()
+            if "fastapi" in reqs:
+                framework = "fastapi"
+            elif "django" in reqs:
+                framework = "django"
+            elif "flask" in reqs:
+                framework = "flask"
+        stacks.append({"language": "python", "framework": framework, "root": None})
+
+    # Check subdirectories for separate stacks
+    for subdir in ["backend", "api", "server"]:
+        subpath = project_root / subdir
+        if subpath.exists():
+            if (subpath / "pyproject.toml").exists() or (subpath / "requirements.txt").exists():
+                framework = None
+                if (subpath / "requirements.txt").exists():
+                    reqs = (subpath / "requirements.txt").read_text().lower()
+                    if "fastapi" in reqs:
+                        framework = "fastapi"
+                    elif "django" in reqs:
+                        framework = "django"
+                # Only add if not already detected at root
+                if not any(s.get("root") is None and s["language"] == "python" for s in stacks):
+                    stacks.append({"language": "python", "framework": framework, "root": f"{subdir}/"})
+
+    # TypeScript/JavaScript detection
+    if (project_root / "package.json").exists():
+        pkg = (project_root / "package.json").read_text().lower()
+        framework = None
+        if "vite" in pkg:
+            framework = "vite"
+        elif "next" in pkg:
+            framework = "next"
+        elif "react" in pkg:
+            framework = "react"
+        elif "vue" in pkg:
+            framework = "vue"
+        elif "angular" in pkg:
+            framework = "angular"
+        stacks.append({"language": "typescript", "framework": framework, "root": None})
+
+    # Check subdirectories for frontend
+    for subdir in ["frontend", "admin", "web", "client", "app"]:
+        subpath = project_root / subdir
+        if subpath.exists() and (subpath / "package.json").exists():
+            pkg = (subpath / "package.json").read_text().lower()
+            framework = None
+            if "vite" in pkg:
+                framework = "vite"
+            elif "next" in pkg:
+                framework = "next"
+            elif "react" in pkg:
+                framework = "react"
+            # Only add if not already detected at root
+            if not any(s.get("root") is None and s["language"] == "typescript" for s in stacks):
+                stacks.append({"language": "typescript", "framework": framework, "root": f"{subdir}/"})
+
+    # PHP detection
+    if (project_root / "composer.json").exists():
+        composer = (project_root / "composer.json").read_text().lower()
+        framework = None
+        if "symfony" in composer:
+            framework = "symfony"
+        elif "laravel" in composer:
+            framework = "laravel"
+        stacks.append({"language": "php", "framework": framework, "root": None})
+
+    # Go detection
+    if (project_root / "go.mod").exists():
+        stacks.append({"language": "go", "framework": None, "root": None})
+
+    # Rust detection
+    if (project_root / "Cargo.toml").exists():
+        stacks.append({"language": "rust", "framework": None, "root": None})
+
+    return stacks
+
+
+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"
+
+    if galangal_dir.exists():
+        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]")
+    console.print("\n[bold]Scanning project structure...[/bold]\n")
+
+    # Detect stacks
+    stacks = detect_stacks(project_root)
+
+    if stacks:
+        console.print("[bold]Detected stacks:[/bold]")
+        for i, stack in enumerate(stacks, 1):
+            framework = f"/{stack['framework']}" if stack.get("framework") else ""
+            root = f" ({stack['root']})" if stack.get("root") else ""
+            console.print(f"  [{i}] {stack['language'].title()}{framework}{root}")
+
+        if not Confirm.ask("\nIs this correct?", default=True):
+            console.print("[dim]You can edit .galangal/config.yaml after initialization.[/dim]")
+    else:
+        console.print("[yellow]No stacks detected. You can configure them in .galangal/config.yaml[/yellow]")
+        stacks = [{"language": "python", "framework": None, "root": None}]
+
+    # 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,
+        stacks=stacks,
+    )
+    (galangal_dir / "config.yaml").write_text(config_content)
+
+    print_success(f"Created .galangal/config.yaml")
+    print_success(f"Created .galangal/prompts/ (empty - uses defaults)")
+
+    # Add to .gitignore
+    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}")
+
+    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]")
+
+    return 0

galangal/commands/list.py

@@ -0,0 +1,20 @@
+"""
+galangal list - List all tasks.
+"""
+
+import argparse
+
+from galangal.core.tasks import get_active_task, list_tasks
+from galangal.ui.console import console, display_task_list
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    """List all tasks."""
+    tasks = list_tasks()
+    active = get_active_task()
+
+    display_task_list(tasks, active)
+
+    if active:
+        console.print("\n[dim]→ = active task[/dim]")
+    return 0