galangal-orchestrate 0.2.11__py3-none-any.whl

galangal/commands/pause.py

@@ -0,0 +1,40 @@
+"""
+galangal pause - Pause the active task.
+"""
+
+import argparse
+
+from galangal.core.state import Stage, load_state
+from galangal.core.tasks import get_active_task
+from galangal.ui.console import console, print_error, print_info
+
+
+def cmd_pause(args: argparse.Namespace) -> int:
+    """Pause the active task for a break or shutdown."""
+    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_info(f"Task '{active}' is already complete.")
+        console.print("Use 'complete' to create PR and move to done/.")
+        return 0
+
+    console.print("\n" + "=" * 60)
+    console.print("[yellow]⏸️  TASK PAUSED[/yellow]")
+    console.print("=" * 60)
+    console.print(f"\nTask: {state.task_name}")
+    console.print(f"Stage: {state.stage.value} (attempt {state.attempt})")
+    console.print(f"Type: {state.task_type.display_name()}")
+    console.print(f"Description: {state.task_description[:60]}...")
+    console.print("\nYour progress is saved. You can safely shut down now.")
+    console.print("\nTo resume later, run:")
+    console.print("  [cyan]galangal resume[/cyan]")
+    console.print("=" * 60)
+    return 0

galangal/commands/prompts.py

@@ -0,0 +1,98 @@
+"""
+galangal prompts - Manage stage prompts.
+"""
+
+import argparse
+import shutil
+from pathlib import Path
+
+from galangal.config.loader import get_prompts_dir
+from galangal.core.state import Stage
+from galangal.prompts.builder import PromptBuilder
+from galangal.ui.console import console, print_success, print_error, print_info
+
+
+def cmd_prompts_export(args: argparse.Namespace) -> int:
+    """Export default prompts to .galangal/prompts/ for customization."""
+    prompts_dir = get_prompts_dir()
+    defaults_dir = Path(__file__).parent.parent / "prompts" / "defaults"
+
+    if not defaults_dir.exists():
+        print_error("Default prompts directory not found.")
+        return 1
+
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+
+    exported = []
+    skipped = []
+
+    for prompt_file in defaults_dir.glob("*.md"):
+        dest = prompts_dir / prompt_file.name
+        if dest.exists():
+            skipped.append(prompt_file.name)
+        else:
+            shutil.copy(prompt_file, dest)
+            exported.append(prompt_file.name)
+
+    if exported:
+        print_success(f"Exported {len(exported)} prompts to .galangal/prompts/")
+        for name in exported:
+            console.print(f"  [green]✓[/green] {name}")
+
+    if skipped:
+        print_info(f"Skipped {len(skipped)} existing prompts (won't overwrite)")
+        for name in skipped:
+            console.print(f"  [dim]○[/dim] {name}")
+
+    console.print("\n[dim]Edit these files to customize prompts for your project.[/dim]")
+    console.print("[dim]Project prompts override package defaults.[/dim]")
+
+    return 0
+
+
+def cmd_prompts_show(args: argparse.Namespace) -> int:
+    """Show the effective prompt for a stage."""
+    stage_name = args.stage.upper()
+
+    try:
+        stage = Stage.from_str(stage_name)
+    except ValueError:
+        print_error(f"Invalid stage: '{args.stage}'")
+        valid = ", ".join(s.value.lower() for s in Stage if s != Stage.COMPLETE)
+        console.print(f"[dim]Valid stages: {valid}[/dim]")
+        return 1
+
+    if stage == Stage.COMPLETE:
+        print_error("COMPLETE stage has no prompt.")
+        return 1
+
+    builder = PromptBuilder()
+    prompt = builder.get_stage_prompt(stage)
+
+    # Determine source
+    prompts_dir = get_prompts_dir()
+    override_path = prompts_dir / f"{stage_name.lower()}.md"
+    source = "project override" if override_path.exists() else "package default"
+
+    console.print(f"\n[bold]Stage:[/bold] {stage.value}")
+    console.print(f"[bold]Source:[/bold] {source}")
+    console.print("[dim]" + "=" * 60 + "[/dim]")
+    console.print(prompt)
+    console.print("[dim]" + "=" * 60 + "[/dim]")
+
+    return 0
+
+
+def cmd_prompts(args: argparse.Namespace) -> int:
+    """Prompts management command router."""
+    if hasattr(args, "prompts_command") and args.prompts_command:
+        if args.prompts_command == "export":
+            return cmd_prompts_export(args)
+        elif args.prompts_command == "show":
+            return cmd_prompts_show(args)
+
+    console.print("Usage: galangal prompts <command>")
+    console.print("\nCommands:")
+    console.print("  export    Export default prompts for customization")
+    console.print("  show      Show effective prompt for a stage")
+    return 1

galangal/commands/reset.py

@@ -0,0 +1,43 @@
+"""
+galangal reset - Delete the active task.
+"""
+
+import argparse
+import shutil
+
+from rich.prompt import Prompt
+
+from galangal.core.state import get_task_dir
+from galangal.core.tasks import get_active_task, clear_active_task
+from galangal.ui.console import print_error, print_info, print_success
+
+
+def cmd_reset(args: argparse.Namespace) -> int:
+    """Delete the active task."""
+    active = get_active_task()
+    if not active:
+        print_error("No active task.")
+        return 0
+
+    task_dir = get_task_dir(active)
+    if not task_dir.exists():
+        print_info("Task directory not found.")
+        clear_active_task()
+        return 0
+
+    if not args.force:
+        confirm = (
+            Prompt.ask(
+                f"Delete task '{active}' and all its artifacts? [y/N]", default="n"
+            )
+            .strip()
+            .lower()
+        )
+        if confirm != "y":
+            print_info("Reset cancelled.")
+            return 1
+
+    shutil.rmtree(task_dir)
+    clear_active_task()
+    print_success(f"Task '{active}' deleted.")
+    return 0

galangal/commands/resume.py

@@ -0,0 +1,29 @@
+"""
+galangal resume - Resume the active task.
+"""
+
+import argparse
+
+from galangal.core.state import load_state
+from galangal.core.tasks import get_active_task
+from galangal.core.workflow import run_workflow
+from galangal.ui.console import console, print_error
+
+
+def cmd_resume(args: argparse.Namespace) -> int:
+    """Resume the active task."""
+    active = get_active_task()
+    if not active:
+        print_error("No active task. Use 'list' to see tasks, 'switch' to select one.")
+        return 1
+
+    state = load_state(active)
+    if state is None:
+        print_error(f"Could not load state for '{active}'.")
+        return 1
+
+    console.print(f"[bold]Resuming task:[/bold] {active}")
+    console.print(f"[dim]Stage:[/dim] {state.stage.value}")
+    console.print(f"[dim]Type:[/dim] {state.task_type.display_name()}")
+    run_workflow(state)
+    return 0

galangal/commands/skip.py

@@ -0,0 +1,216 @@
+"""
+galangal skip-* commands - Skip various stages.
+"""
+
+import argparse
+from datetime import datetime, timezone
+
+from rich.prompt import Prompt
+
+from galangal.core.state import (
+    Stage,
+    load_state,
+    save_state,
+    STAGE_ORDER,
+    TASK_TYPE_SKIP_STAGES,
+)
+from galangal.core.tasks import get_active_task
+from galangal.core.artifacts import artifact_exists, write_artifact
+from galangal.core.workflow import run_workflow
+from galangal.ui.console import console, print_error, print_success, print_info
+
+
+def _skip_stage(
+    stage: Stage,
+    skip_artifact: str,
+    prompt_text: str,
+    default_reason: str,
+) -> int:
+    """Generic skip stage handler."""
+    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 artifact_exists(skip_artifact, active):
+        print_info(f"{stage.value} already marked as skipped.")
+        return 0
+
+    # Check if task type already skips this stage
+    if stage in TASK_TYPE_SKIP_STAGES.get(state.task_type, set()):
+        print_info(f"{stage.value} already skipped by task type '{state.task_type.value}'.")
+        return 0
+
+    reason = Prompt.ask(prompt_text, default=default_reason).strip()
+
+    skip_content = f"""# {stage.value} Stage Skipped
+
+Date: {datetime.now(timezone.utc).isoformat()}
+Reason: {reason}
+"""
+    write_artifact(skip_artifact, skip_content, active)
+
+    print_success(f"{stage.value} stage marked as skipped: {reason}")
+
+    if state.stage == stage:
+        console.print("Resuming workflow...")
+        run_workflow(state)
+
+    return 0
+
+
+def cmd_skip_design(args: argparse.Namespace) -> int:
+    """Skip design stage for trivial tasks."""
+    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 not in [Stage.PM, Stage.DESIGN]:
+        print_error(
+            f"Can only skip design before or during DESIGN stage. Current: {state.stage.value}"
+        )
+        return 1
+
+    if artifact_exists("DESIGN_SKIP.md", active):
+        print_info("Design already marked as skipped.")
+        return 0
+
+    # Check if task type already skips this stage
+    if Stage.DESIGN in TASK_TYPE_SKIP_STAGES.get(state.task_type, set()):
+        print_info(f"Design already skipped by task type '{state.task_type.value}'.")
+        return 0
+
+    reason = Prompt.ask(
+        "Reason for skipping design", default="Trivial task, no design needed"
+    ).strip()
+
+    skip_content = f"""# Design Stage Skipped
+
+Date: {datetime.now(timezone.utc).isoformat()}
+Reason: {reason}
+"""
+    write_artifact("DESIGN_SKIP.md", skip_content, active)
+    write_artifact(
+        "APPROVAL.md", f"# Auto-Approval\n\nDesign skipped: {reason}\n", active
+    )
+
+    print_success(f"Design stage marked as skipped: {reason}")
+
+    if state.stage == Stage.DESIGN:
+        console.print("Resuming workflow...")
+        run_workflow(state)
+
+    return 0
+
+
+def cmd_skip_security(args: argparse.Namespace) -> int:
+    """Skip security stage for non-code changes."""
+    return _skip_stage(
+        Stage.SECURITY,
+        "SECURITY_SKIP.md",
+        "Reason for skipping security",
+        "No code changes",
+    )
+
+
+def cmd_skip_migration(args: argparse.Namespace) -> int:
+    """Skip migration stage."""
+    return _skip_stage(
+        Stage.MIGRATION,
+        "MIGRATION_SKIP.md",
+        "Reason for skipping migration",
+        "No database changes",
+    )
+
+
+def cmd_skip_contract(args: argparse.Namespace) -> int:
+    """Skip contract stage."""
+    return _skip_stage(
+        Stage.CONTRACT,
+        "CONTRACT_SKIP.md",
+        "Reason for skipping contract",
+        "No API changes",
+    )
+
+
+def cmd_skip_benchmark(args: argparse.Namespace) -> int:
+    """Skip benchmark stage."""
+    return _skip_stage(
+        Stage.BENCHMARK,
+        "BENCHMARK_SKIP.md",
+        "Reason for skipping benchmark",
+        "No performance requirements",
+    )
+
+
+def cmd_skip_to(args: argparse.Namespace) -> int:
+    """Jump to a specific stage (for debugging/re-running)."""
+    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
+
+    # Parse target stage
+    target_stage_str = args.stage.upper()
+    try:
+        target_stage = Stage.from_str(target_stage_str)
+    except ValueError:
+        print_error(f"Invalid stage: '{args.stage}'")
+        valid_stages = ", ".join(s.value for s in Stage)
+        console.print(f"[dim]Valid stages: {valid_stages}[/dim]")
+        return 1
+
+    if target_stage == Stage.COMPLETE:
+        print_error("Cannot skip to COMPLETE. Use 'complete' command instead.")
+        return 1
+
+    current_stage = state.stage
+    current_idx = STAGE_ORDER.index(current_stage) if current_stage in STAGE_ORDER else -1
+    target_idx = STAGE_ORDER.index(target_stage)
+
+    # Warn if skipping backwards or forwards
+    if target_idx < current_idx:
+        console.print(f"[yellow]⚠️  Going backwards: {current_stage.value} → {target_stage.value}[/yellow]")
+    elif target_idx > current_idx:
+        console.print(f"[yellow]⚠️  Skipping forward: {current_stage.value} → {target_stage.value}[/yellow]")
+    else:
+        console.print(f"[dim]Re-running current stage: {target_stage.value}[/dim]")
+
+    if not args.force:
+        confirm = Prompt.ask(f"Jump to {target_stage.value}? [y/N]", default="n").strip().lower()
+        if confirm != "y":
+            print_info("Cancelled.")
+            return 0
+
+    # Update state
+    state.stage = target_stage
+    state.attempt = 1
+    state.last_failure = None
+    state.awaiting_approval = False
+    state.clarification_required = False
+    save_state(state)
+
+    print_success(f"Jumped to stage: {target_stage.value}")
+
+    # Optionally resume immediately
+    if args.resume:
+        console.print("\n[dim]Resuming workflow...[/dim]")
+        run_workflow(state)
+
+    return 0

galangal/commands/start.py

@@ -0,0 +1,144 @@
+"""
+galangal start - Start a new task.
+"""
+
+import argparse
+
+from rich.prompt import Prompt
+
+from galangal.config.loader import get_config
+from galangal.core.state import (
+    Stage,
+    TaskType,
+    WorkflowState,
+    save_state,
+    get_task_dir,
+    TASK_TYPE_SKIP_STAGES,
+)
+from galangal.core.tasks import (
+    generate_task_name,
+    task_name_exists,
+    set_active_task,
+    create_task_branch,
+)
+from galangal.core.workflow import run_workflow
+from galangal.ui.console import (
+    console,
+    print_success,
+    print_error,
+    print_warning,
+    display_task_type_menu,
+    get_task_type_from_input,
+)
+
+
+def select_task_type() -> TaskType:
+    """Interactive task type selection."""
+    display_task_type_menu()
+
+    while True:
+        choice = Prompt.ask("Select type [1-6]", default="1").strip()
+        task_type = get_task_type_from_input(choice)
+        if task_type:
+            console.print(f"\n[green]✓ Task type:[/green] {task_type.display_name()}")
+
+            # Show which stages will be skipped
+            skipped = TASK_TYPE_SKIP_STAGES.get(task_type, set())
+            if skipped:
+                skip_names = [s.value for s in skipped]
+                console.print(f"[dim]   Stages to skip: {', '.join(skip_names)}[/dim]")
+
+            return task_type
+
+        print_error(f"Invalid choice: '{choice}'. Enter 1-6 or type name.")
+
+
+def prompt_for_description() -> str:
+    """Prompt user for multi-line task description."""
+    console.print(
+        "\n[bold]Enter task description[/bold] (press Enter twice to finish):"
+    )
+    console.print("[dim]" + "-" * 40 + "[/dim]")
+    lines = []
+    empty_count = 0
+
+    while True:
+        try:
+            line = input()
+            if line == "":
+                empty_count += 1
+                if empty_count >= 2:
+                    break
+                lines.append(line)
+            else:
+                empty_count = 0
+                lines.append(line)
+        except EOFError:
+            break
+
+    while lines and lines[-1] == "":
+        lines.pop()
+
+    return "\n".join(lines)
+
+
+def cmd_start(args: argparse.Namespace) -> int:
+    """Start a new task."""
+    config = get_config()
+    description = " ".join(args.description) if args.description else ""
+
+    # Select task type first
+    task_type = select_task_type()
+
+    # Prompt for description if not provided
+    if not description:
+        description = prompt_for_description()
+        if not description.strip():
+            print_error("Task description required")
+            return 1
+
+    # Generate or use provided task name
+    if args.name:
+        task_name = args.name
+        if task_name_exists(task_name):
+            print_error(f"Task '{task_name}' already exists. Use a different name.")
+            return 1
+        task_dir = get_task_dir(task_name)
+    else:
+        console.print("[dim]Generating task name...[/dim]", end=" ")
+        base_name = generate_task_name(description)
+        task_name = base_name
+
+        suffix = 2
+        while task_name_exists(task_name):
+            task_name = f"{base_name}-{suffix}"
+            suffix += 1
+
+        task_dir = get_task_dir(task_name)
+        console.print(f"[cyan]{task_name}[/cyan]")
+
+    # Create git branch
+    success, msg = create_task_branch(task_name)
+    if not success:
+        print_warning(msg)
+    else:
+        print_success(msg)
+
+    # Create task directory
+    task_dir.mkdir(parents=True, exist_ok=True)
+    (task_dir / "logs").mkdir(exist_ok=True)
+
+    # Initialize state with task type
+    state = WorkflowState.new(description, task_name, task_type)
+    save_state(state)
+
+    # Set as active task
+    set_active_task(task_name)
+
+    console.print(f"\n[bold]Created task:[/bold] {task_name}")
+    console.print(f"[dim]Location:[/dim] {config.tasks_dir}/{task_name}/")
+    console.print(f"[dim]Type:[/dim] {task_type.display_name()}")
+    console.print(f"[dim]Description:[/dim] {description[:60]}...")
+
+    run_workflow(state)
+    return 0

galangal/commands/status.py

@@ -0,0 +1,62 @@
+"""
+galangal status - Show active task status.
+"""
+
+import argparse
+
+from galangal.core.state import load_state
+from galangal.core.tasks import get_active_task
+from galangal.core.artifacts import artifact_exists
+from galangal.ui.console import console, print_error, print_info, display_status
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    """Show status of active task."""
+    active = get_active_task()
+    if not active:
+        print_info("No active task. Use 'list' to see tasks, 'switch' to select one.")
+        return 0
+
+    state = load_state(active)
+    if state is None:
+        print_error(f"Could not load state for '{active}'.")
+        return 1
+
+    # Collect artifact status
+    artifacts = []
+    for name in [
+        "SPEC.md",
+        "PLAN.md",
+        "APPROVAL.md",
+        "DESIGN.md",
+        "DESIGN_REVIEW.md",
+        "DESIGN_SKIP.md",
+        "PREFLIGHT_REPORT.md",
+        "MIGRATION_REPORT.md",
+        "MIGRATION_SKIP.md",
+        "TEST_PLAN.md",
+        "CONTRACT_REPORT.md",
+        "CONTRACT_SKIP.md",
+        "QA_REPORT.md",
+        "BENCHMARK_REPORT.md",
+        "BENCHMARK_SKIP.md",
+        "SECURITY_CHECKLIST.md",
+        "SECURITY_SKIP.md",
+        "REVIEW_NOTES.md",
+        "DOCS_REPORT.md",
+        "ROLLBACK.md",
+    ]:
+        artifacts.append((name, artifact_exists(name, active)))
+
+    display_status(
+        task_name=active,
+        stage=state.stage,
+        task_type=state.task_type,
+        attempt=state.attempt,
+        awaiting_approval=state.awaiting_approval,
+        last_failure=state.last_failure,
+        description=state.task_description,
+        artifacts=artifacts,
+    )
+
+    return 0

galangal/commands/switch.py

@@ -0,0 +1,28 @@
+"""
+galangal switch - Switch to a different task.
+"""
+
+import argparse
+
+from galangal.core.state import load_state, get_task_dir
+from galangal.core.tasks import set_active_task
+from galangal.ui.console import console, print_error, print_success
+
+
+def cmd_switch(args: argparse.Namespace) -> int:
+    """Switch to a different task."""
+    task_name = args.task_name
+    task_dir = get_task_dir(task_name)
+
+    if not task_dir.exists():
+        print_error(f"Task '{task_name}' not found.")
+        return 1
+
+    set_active_task(task_name)
+    state = load_state(task_name)
+    if state:
+        print_success(f"Switched to: {task_name}")
+        console.print(f"[dim]Stage:[/dim] {state.stage.value}")
+        console.print(f"[dim]Type:[/dim] {state.task_type.display_name()}")
+        console.print(f"[dim]Description:[/dim] {state.task_description[:60]}...")
+    return 0

galangal/config/__init__.py

@@ -0,0 +1,13 @@
+"""Configuration management."""
+
+from galangal.config.loader import load_config, get_project_root, get_config
+from galangal.config.schema import GalangalConfig, ProjectConfig, StageConfig
+
+__all__ = [
+    "load_config",
+    "get_project_root",
+    "get_config",
+    "GalangalConfig",
+    "ProjectConfig",
+    "StageConfig",
+]