galangal-orchestrate 0.13.0__py3-none-any.whl

galangal/prompts/defaults/security.md

@@ -0,0 +1,84 @@
+# Security Stage
+
+You are a Security Engineer reviewing the implementation for vulnerabilities.
+
+## Scope
+
+**DO:**
+- Review code changes for security issues
+- Run automated security scans (dependency audit, secret detection)
+- Check for common vulnerabilities (OWASP Top 10)
+- Document findings and waivers
+
+**DO NOT:**
+- Run the full test suite
+- Make code changes (only document issues)
+- Run linting or other QA checks
+
+## Documentation Configuration
+
+Check the "Documentation Configuration" section in the context above for:
+- **Security Audit Directory**: Where to store persistent security audit reports
+- **Update Security Audit**: Whether to create/update security audit documentation (YES/NO)
+
+If **Update Security Audit** is YES:
+- Store persistent security audit reports in the configured security audit directory
+- These reports should be tracked in version control
+- Include security policy documentation and vulnerability tracking
+
+If **Update Security Audit** is NO:
+- Only create the SECURITY_CHECKLIST.md artifact (not persisted to repo)
+- Skip creating files in the security audit directory
+
+## Output
+
+Create `SECURITY_CHECKLIST.md` in the task's artifacts directory:
+
+```markdown
+# Security Review: [Task Title]
+
+## Change Summary
+- What does this change do?
+- Does it handle user input? [Yes/No]
+- Does it modify authentication/authorization? [Yes/No]
+- Does it handle secrets or credentials? [Yes/No]
+
+## Automated Scan Results
+
+### Dependency Audit
+- Status: [PASS/FAIL]
+- Issues: [Count or None]
+
+### Secret Detection
+- Status: [PASS/FAIL]
+- Secrets Found: [Count or None]
+
+## Manual Review
+
+### Input Validation
+- [ ] User input sanitized
+- [ ] No injection vulnerabilities
+
+### Authentication & Authorization
+- [ ] Proper auth required
+- [ ] Authorization checks in place
+
+## Known Issues / Waivers
+| Issue | Severity | Justification |
+|-------|----------|---------------|
+| [Issue] | [High/Med/Low] | [Why accepted] |
+
+## Recommendation
+
+**APPROVED** - Safe to deploy
+OR
+**REJECTED** - Must fix: [list blocking issues]
+```
+
+## Process
+
+1. Review code changes for security implications
+2. Run available security scans
+3. Document any issues found
+4. If issues are pre-existing or waived, document the justification
+5. Provide final APPROVED or REJECTED recommendation

galangal/prompts/defaults/test.md

@@ -0,0 +1,91 @@
+# TEST Stage - Test Implementation
+
+You are a Test Engineer writing tests for the implemented feature.
+
+## Your Task
+
+Create comprehensive tests that verify the implementation meets the acceptance criteria in SPEC.md.
+
+## CRITICAL: Do NOT Fix Implementation Bugs
+
+**Your job is to WRITE TESTS and REPORT results, not to fix the implementation.**
+
+If tests fail because the implementation is wrong:
+1. Document the failures clearly in TEST_PLAN.md
+2. Set **Status:** FAIL
+3. The workflow will automatically roll back to DEV with your failure report
+4. DO NOT attempt to modify the implementation code to make tests pass
+
+If tests fail because your test code is wrong (e.g., wrong selector, typo):
+- You may fix your test code
+- But if after 2-3 attempts the test still fails, assume it's an implementation issue
+
+## Your Output
+
+Create TEST_PLAN.md in the task's artifacts directory:
+
+```markdown
+# Test Plan: [Task Title]
+
+## Test Coverage
+
+### Unit Tests
+| Test | Description | File |
+|------|-------------|------|
+| test_xxx | Tests that... | path/to/test.py |
+
+### Integration Tests
+| Test | Description | File |
+|------|-------------|------|
+| test_xxx | Tests that... | path/to/test.py |
+
+## Test Results
+
+**Status:** PASS / FAIL
+
+### Summary
+- Total tests: X
+- Passed: X
+- Failed: X
+
+### Failed Tests (if any)
+| Test | Error | Likely Cause |
+|------|-------|--------------|
+| test_xxx | Expected X got Y | Implementation missing feature Z |
+
+### Details
+[Output from test run]
+```
+
+## Process
+
+1. Read SPEC.md for acceptance criteria
+2. Read PLAN.md for what was implemented
+3. Analyze the implementation to understand what needs testing
+4. Write tests that verify:
+   - Core functionality works
+   - Edge cases are handled
+   - Error conditions are handled properly
+5. Run the newly created tests
+6. Document results in TEST_PLAN.md with accurate PASS/FAIL status
+
+## Important Rules
+
+- Test the behavior, not the implementation details
+- Include both happy path and error cases
+- Follow existing test patterns in the codebase
+- Tests should be deterministic (no flaky tests)
+- **DO NOT modify implementation code** - only write/fix test code
+- If tests fail due to implementation bugs, report FAIL status clearly
+- After 2-3 failed attempts to fix a test, assume implementation is wrong and report FAIL
+
+## Non-Blocking Test Execution
+
+**CRITICAL**: Tests must run non-interactively. Never use modes that wait for user input:
+
+- **Playwright**: Use `--reporter=list` or set `PLAYWRIGHT_HTML_OPEN=never`
+- **Jest/Vitest**: Never use `--watch` mode
+- **Cypress**: Use `cypress run` (not `cypress open`)
+- **Any framework**: Avoid watch mode, interactive mode, or GUI mode
+
+If a test command hangs waiting for input, the workflow will stall. Always use CI-friendly, non-interactive test commands.

galangal/results.py

@@ -0,0 +1,176 @@
+"""
+Structured result types for operations and stage execution.
+
+This module provides type-safe result objects instead of tuple[bool, str]
+with magic string prefixes like "PREFLIGHT_FAILED:" or "ROLLBACK:".
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from galangal.core.state import Stage
+
+
+class StageResultType(Enum):
+    """Types of outcomes from stage execution."""
+
+    SUCCESS = auto()
+    PREFLIGHT_FAILED = auto()
+    VALIDATION_FAILED = auto()
+    ROLLBACK_REQUIRED = auto()
+    CLARIFICATION_NEEDED = auto()
+    USER_DECISION_NEEDED = auto()  # Decision file missing, user must confirm
+    PAUSED = auto()
+    TIMEOUT = auto()
+    MAX_TURNS = auto()
+    ERROR = auto()
+
+
+@dataclass
+class Result:
+    """Base result for simple operations."""
+
+    success: bool
+    message: str
+
+    def __bool__(self) -> bool:
+        """Allow using result directly in boolean context."""
+        return self.success
+
+
+@dataclass
+class StageResult(Result):
+    """Result from stage execution with structured outcome type.
+
+    Replaces the old pattern of encoding state in message strings like:
+    - "PREFLIGHT_FAILED:details"
+    - "ROLLBACK:DEV:reason"
+
+    Now the type field explicitly indicates the outcome, and structured
+    fields hold the relevant data.
+    """
+
+    type: StageResultType = StageResultType.SUCCESS
+    rollback_to: Stage | None = None
+    output: str | None = None
+    is_fast_track: bool = False  # True for minor rollbacks (skip passed stages)
+
+    @classmethod
+    def create_success(cls, message: str = "", output: str | None = None) -> StageResult:
+        """Create a successful stage result."""
+        return cls(
+            success=True,
+            message=message,
+            type=StageResultType.SUCCESS,
+            output=output,
+        )
+
+    @classmethod
+    def preflight_failed(cls, message: str, details: str = "") -> StageResult:
+        """Create a preflight failure result."""
+        return cls(
+            success=False,
+            message=message,
+            type=StageResultType.PREFLIGHT_FAILED,
+            output=details,
+        )
+
+    @classmethod
+    def validation_failed(cls, message: str) -> StageResult:
+        """Create a validation failure result."""
+        return cls(
+            success=False,
+            message=message,
+            type=StageResultType.VALIDATION_FAILED,
+        )
+
+    @classmethod
+    def rollback_required(
+        cls,
+        message: str,
+        rollback_to: Stage,
+        output: str | None = None,
+        is_fast_track: bool = False,
+    ) -> StageResult:
+        """Create a rollback required result.
+
+        Args:
+            message: Description of why rollback is needed.
+            rollback_to: Stage to roll back to.
+            output: Optional detailed output.
+            is_fast_track: If True, this is a minor rollback that should
+                skip stages that already passed (REQUEST_MINOR_CHANGES).
+        """
+        return cls(
+            success=False,
+            message=message,
+            type=StageResultType.ROLLBACK_REQUIRED,
+            rollback_to=rollback_to,
+            output=output,
+            is_fast_track=is_fast_track,
+        )
+
+    @classmethod
+    def clarification_needed(cls, message: str = "") -> StageResult:
+        """Create a clarification needed result."""
+        return cls(
+            success=False,
+            message=message or "Clarification required. Please provide ANSWERS.md.",
+            type=StageResultType.CLARIFICATION_NEEDED,
+        )
+
+    @classmethod
+    def paused(cls, message: str = "User requested pause") -> StageResult:
+        """Create a paused result."""
+        return cls(
+            success=False,
+            message=message,
+            type=StageResultType.PAUSED,
+        )
+
+    @classmethod
+    def timeout(cls, timeout_seconds: int) -> StageResult:
+        """Create a timeout result."""
+        return cls(
+            success=False,
+            message=f"Timed out after {timeout_seconds}s",
+            type=StageResultType.TIMEOUT,
+        )
+
+    @classmethod
+    def max_turns(cls, output: str = "") -> StageResult:
+        """Create a max turns exceeded result."""
+        return cls(
+            success=False,
+            message="Max turns exceeded",
+            type=StageResultType.MAX_TURNS,
+            output=output,
+        )
+
+    @classmethod
+    def error(cls, message: str, output: str | None = None) -> StageResult:
+        """Create a general error result."""
+        return cls(
+            success=False,
+            message=message,
+            type=StageResultType.ERROR,
+            output=output,
+        )
+
+    @classmethod
+    def user_decision_needed(cls, message: str, artifact_content: str | None = None) -> StageResult:
+        """Create a result indicating user must confirm the stage decision.
+
+        Used when the AI-generated decision file is missing or unclear.
+        The user will be prompted to review the artifact and approve/reject.
+        """
+        return cls(
+            success=False,
+            message=message,
+            type=StageResultType.USER_DECISION_NEEDED,
+            output=artifact_content,
+        )

galangal/ui/__init__.py

@@ -0,0 +1,5 @@
+"""UI components."""
+
+from galangal.ui.console import console, print_error, print_info, print_success, print_warning
+
+__all__ = ["console", "print_success", "print_error", "print_warning", "print_info"]

galangal/ui/console.py

@@ -0,0 +1,126 @@
+"""
+Console output utilities using Rich.
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from galangal.core.state import TASK_TYPE_SKIP_STAGES, Stage, TaskType
+from galangal.core.utils import debug_log
+
+console = Console()
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    debug_log("[SUCCESS]", content=message)
+    console.print(f"[green]✓ {message}[/green]")
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    debug_log("[ERROR]", content=message)
+    console.print(f"[red]✗ {message}[/red]")
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message."""
+    debug_log("[WARNING]", content=message)
+    console.print(f"[yellow]⚠ {message}[/yellow]")
+
+
+def print_info(message: str) -> None:
+    """Print an info message."""
+    debug_log("[INFO]", content=message)
+    console.print(f"[blue]ℹ {message}[/blue]")
+
+
+def display_task_list(tasks: list[tuple[str, str, str, str]], active: str | None) -> None:
+    """Display a table of tasks."""
+    if not tasks:
+        print_info("No tasks found.")
+        return
+
+    table = Table(title="Tasks")
+    table.add_column("", style="cyan", width=2)
+    table.add_column("Name", style="bold")
+    table.add_column("Stage")
+    table.add_column("Type")
+    table.add_column("Description")
+
+    for name, stage, task_type, desc in tasks:
+        marker = "→" if name == active else ""
+        stage_style = "green" if stage == "COMPLETE" else "yellow"
+        table.add_row(
+            marker,
+            name,
+            f"[{stage_style}]{stage}[/{stage_style}]",
+            task_type,
+            desc,
+        )
+
+    console.print(table)
+
+
+def display_status(
+    task_name: str,
+    stage: Stage,
+    task_type: TaskType,
+    attempt: int,
+    awaiting_approval: bool,
+    last_failure: str | None,
+    description: str,
+    artifacts: list[tuple[str, bool]],
+) -> None:
+    """Display detailed task status."""
+    status_color = "green" if stage == Stage.COMPLETE else "yellow"
+
+    console.print(Panel(f"[bold]{task_name}[/bold]", title="Task Status"))
+    console.print(f"[dim]Stage:[/dim] [{status_color}]{stage.value}[/{status_color}]")
+    console.print(f"[dim]Type:[/dim] {task_type.display_name()}")
+    console.print(f"[dim]Attempt:[/dim] {attempt}")
+    console.print(f"[dim]Description:[/dim] {description[:100]}...")
+
+    if awaiting_approval:
+        console.print("[yellow]⏳ Awaiting approval[/yellow]")
+
+    if last_failure:
+        console.print(f"[red]Last failure:[/red] {last_failure[:200]}...")
+
+    # Artifacts
+    console.print("\n[bold]Artifacts:[/bold]")
+    for name, exists in artifacts:
+        icon = "✓" if exists else "○"
+        color = "green" if exists else "dim"
+        console.print(f"  [{color}]{icon} {name}[/{color}]")
+
+
+def display_task_type_menu() -> None:
+    """Display the task type selection menu."""
+    console.print("\n[bold]Select task type:[/bold]")
+    for i, task_type in enumerate(TaskType, 1):
+        skipped = TASK_TYPE_SKIP_STAGES.get(task_type, set())
+        skip_info = f" [dim](skips: {', '.join(s.value for s in skipped)})[/dim]" if skipped else ""
+        console.print(f"  [{i}] {task_type.display_name()} - {task_type.description()}{skip_info}")
+
+
+def get_task_type_from_input(choice: str) -> TaskType | None:
+    """Convert user input to TaskType."""
+    task_types = list(TaskType)
+
+    # Try numeric selection
+    try:
+        idx = int(choice) - 1
+        if 0 <= idx < len(task_types):
+            return task_types[idx]
+    except ValueError:
+        pass
+
+    # Try name match
+    choice_lower = choice.lower().replace(" ", "_").replace("-", "_")
+    for tt in TaskType:
+        if tt.value == choice_lower or tt.display_name().lower() == choice.lower():
+            return tt
+
+    return None

galangal/ui/tui/__init__.py

@@ -0,0 +1,56 @@
+"""
+Textual TUI for workflow execution display.
+
+This package provides:
+- WorkflowTUIApp: Main TUI application for workflow execution
+- PromptType: Enum of prompt types the TUI can show
+- StageUI: Interface for stage execution UI updates
+- TUIAdapter: Adapter connecting ClaudeBackend to TUI
+- run_stage_with_tui: Entry point for running a single stage with TUI
+"""
+
+from galangal.ui.tui.adapters import PromptType, StageUI, TUIAdapter
+from galangal.ui.tui.app import StageTUIApp, WorkflowTUIApp
+from galangal.ui.tui.entry import run_stage_with_tui
+from galangal.ui.tui.modals import MultilineInputModal, PromptModal, PromptOption, TextInputModal
+from galangal.ui.tui.types import (
+    ActivityCategory,
+    ActivityEntry,
+    ActivityLevel,
+    export_activity_log,
+)
+from galangal.ui.tui.widgets import (
+    CurrentActionWidget,
+    ErrorPanelWidget,
+    FilesPanelWidget,
+    HeaderWidget,
+    StageProgressWidget,
+)
+
+__all__ = [
+    # Main app
+    "WorkflowTUIApp",
+    "StageTUIApp",
+    # Adapters and interfaces
+    "PromptType",
+    "StageUI",
+    "TUIAdapter",
+    # Entry points
+    "run_stage_with_tui",
+    # Activity log types
+    "ActivityEntry",
+    "ActivityLevel",
+    "ActivityCategory",
+    "export_activity_log",
+    # Widgets
+    "HeaderWidget",
+    "StageProgressWidget",
+    "CurrentActionWidget",
+    "ErrorPanelWidget",
+    "FilesPanelWidget",
+    # Modals
+    "PromptOption",
+    "PromptModal",
+    "TextInputModal",
+    "MultilineInputModal",
+]