galangal-orchestrate 0.2.11__py3-none-any.whl

galangal/__init__.py

@@ -0,0 +1,8 @@
+"""
+Galangal Orchestrate - AI-driven development workflow orchestrator.
+
+A deterministic workflow system that guides AI assistants through
+structured development stages: PM -> DESIGN -> DEV -> TEST -> QA -> REVIEW -> DOCS.
+"""
+
+__version__ = "0.2.11"

galangal/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m galangal`."""
+
+from galangal.cli import main
+
+if __name__ == "__main__":
+    main()

galangal/ai/__init__.py

@@ -0,0 +1,6 @@
+"""AI backend abstractions."""
+
+from galangal.ai.base import AIBackend
+from galangal.ai.claude import ClaudeBackend
+
+__all__ = ["AIBackend", "ClaudeBackend"]

galangal/ai/base.py

@@ -0,0 +1,55 @@
+"""
+Abstract base class for AI backends.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from galangal.ui.tui import StageUI
+
+
+class AIBackend(ABC):
+    """Abstract base class for AI backends."""
+
+    @abstractmethod
+    def invoke(
+        self,
+        prompt: str,
+        timeout: int = 14400,
+        max_turns: int = 200,
+        ui: Optional["StageUI"] = None,
+    ) -> tuple[bool, str]:
+        """
+        Invoke the AI with a prompt for a full stage execution.
+
+        Args:
+            prompt: The full prompt to send
+            timeout: Maximum time in seconds
+            max_turns: Maximum conversation turns
+            ui: Optional TUI for progress display
+
+        Returns:
+            (success, output) tuple
+        """
+        pass
+
+    @abstractmethod
+    def generate_text(self, prompt: str, timeout: int = 30) -> str:
+        """
+        Simple text generation (for PR titles, commit messages, task names).
+
+        Args:
+            prompt: The prompt to send
+            timeout: Maximum time in seconds
+
+        Returns:
+            Generated text, or empty string on failure
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the backend name."""
+        pass

galangal/ai/claude.py

@@ -0,0 +1,278 @@
+"""
+Claude CLI backend implementation.
+"""
+
+import json
+import select
+import subprocess
+import time
+from typing import Optional, TYPE_CHECKING
+
+from galangal.ai.base import AIBackend
+from galangal.config.loader import get_project_root
+
+if TYPE_CHECKING:
+    from galangal.ui.tui import StageUI
+
+# Reference to global pause flag
+_pause_requested = False
+
+
+def set_pause_requested(value: bool) -> None:
+    """Set the pause requested flag."""
+    global _pause_requested
+    _pause_requested = value
+
+
+def get_pause_requested() -> bool:
+    """Get the pause requested flag."""
+    return _pause_requested
+
+
+class ClaudeBackend(AIBackend):
+    """Claude CLI backend."""
+
+    @property
+    def name(self) -> str:
+        return "claude"
+
+    def invoke(
+        self,
+        prompt: str,
+        timeout: int = 14400,
+        max_turns: int = 200,
+        ui: Optional["StageUI"] = None,
+    ) -> tuple[bool, str]:
+        """Invoke Claude Code with a prompt."""
+        cmd = [
+            "claude",
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--max-turns",
+            str(max_turns),
+            "--permission-mode",
+            "acceptEdits",
+        ]
+
+        try:
+            process = subprocess.Popen(
+                cmd,
+                cwd=get_project_root(),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+
+            output_lines: list[str] = []
+            last_status_time = time.time()
+            start_time = time.time()
+            pending_tools: list[tuple[str, str]] = []
+
+            if ui:
+                ui.set_status("starting", "initializing Claude")
+
+            while True:
+                retcode = process.poll()
+
+                if process.stdout:
+                    ready, _, _ = select.select([process.stdout], [], [], 0.5)
+
+                    if ready:
+                        line = process.stdout.readline()
+                        if line:
+                            output_lines.append(line)
+                            if ui:
+                                ui.add_raw_line(line)
+                            self._process_stream_line(line, ui, pending_tools)
+                    else:
+                        idle_time = time.time() - last_status_time
+                        if idle_time > 3 and ui:
+                            if pending_tools:
+                                tool_name = pending_tools[-1][1]
+                                ui.set_status("waiting", f"{tool_name}...")
+                            else:
+                                ui.set_status("waiting", "API response")
+                            last_status_time = time.time()
+
+                if retcode is not None:
+                    break
+
+                if _pause_requested:
+                    process.terminate()
+                    try:
+                        process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        process.kill()
+                    if ui:
+                        ui.add_activity("Paused by user request", "⏸️")
+                        ui.finish(success=False)
+                    return False, "PAUSED: User requested pause"
+
+                if time.time() - start_time > timeout:
+                    process.kill()
+                    if ui:
+                        ui.add_activity(f"Timeout after {timeout}s", "❌")
+                    return False, f"Claude timed out after {timeout}s"
+
+            remaining_out, _ = process.communicate(timeout=10)
+            if remaining_out:
+                output_lines.append(remaining_out)
+
+            full_output = "".join(output_lines)
+
+            if "max turns" in full_output.lower() or "reached max" in full_output.lower():
+                if ui:
+                    ui.add_activity("Max turns reached", "❌")
+                return (
+                    False,
+                    "Claude reached max turns limit - task may be too complex or stuck in a loop",
+                )
+
+            result_text = ""
+            for line in output_lines:
+                try:
+                    data = json.loads(line.strip())
+                    if data.get("type") == "result":
+                        result_text = data.get("result", "")
+                        if ui:
+                            ui.set_turns(data.get("num_turns", 0))
+                        break
+                except (json.JSONDecodeError, KeyError):
+                    pass
+
+            if process.returncode == 0:
+                return True, result_text or full_output
+            return False, f"Claude failed (exit {process.returncode}):\n{full_output}"
+
+        except subprocess.TimeoutExpired:
+            process.kill()
+            return False, f"Claude timed out after {timeout}s"
+        except Exception as e:
+            return False, f"Claude invocation error: {e}"
+
+    def _process_stream_line(
+        self,
+        line: str,
+        ui: Optional["StageUI"],
+        pending_tools: list[tuple[str, str]],
+    ) -> None:
+        """Process a single line of streaming output."""
+        try:
+            data = json.loads(line.strip())
+            msg_type = data.get("type", "")
+
+            if msg_type == "assistant" and "tool_use" in str(data):
+                self._handle_assistant_message(data, ui, pending_tools)
+            elif msg_type == "user":
+                self._handle_user_message(data, ui, pending_tools)
+            elif msg_type == "system":
+                self._handle_system_message(data, ui)
+
+        except (json.JSONDecodeError, KeyError, TypeError):
+            pass
+
+    def _handle_assistant_message(
+        self,
+        data: dict,
+        ui: Optional["StageUI"],
+        pending_tools: list[tuple[str, str]],
+    ) -> None:
+        """Handle assistant message with tool use."""
+        content = data.get("message", {}).get("content", [])
+
+        for item in content:
+            if item.get("type") == "tool_use":
+                tool_name = item.get("name", "")
+                tool_id = item.get("id", "")
+                if tool_id:
+                    pending_tools.append((tool_id, tool_name))
+
+                if ui:
+                    if tool_name in ["Write", "Edit"]:
+                        tool_input = item.get("input", {})
+                        file_path = tool_input.get("file_path", "") or tool_input.get("path", "")
+                        if file_path:
+                            short_path = file_path.split("/")[-1] if "/" in file_path else file_path
+                            ui.add_activity(f"{tool_name}: {short_path}", "✏️")
+                            ui.set_status("writing", short_path)
+
+                    elif tool_name == "Read":
+                        tool_input = item.get("input", {})
+                        file_path = tool_input.get("file_path", "") or tool_input.get("path", "")
+                        if file_path:
+                            short_path = file_path.split("/")[-1] if "/" in file_path else file_path
+                            ui.add_activity(f"Read: {short_path}", "📖")
+                            ui.set_status("reading", short_path)
+
+                    elif tool_name == "Bash":
+                        cmd_preview = item.get("input", {}).get("command", "")[:140]
+                        ui.add_activity(f"Bash: {cmd_preview}", "🔧")
+                        ui.set_status("running", "bash")
+
+                    elif tool_name in ["Grep", "Glob"]:
+                        pattern = item.get("input", {}).get("pattern", "")[:80]
+                        ui.add_activity(f"{tool_name}: {pattern}", "🔍")
+                        ui.set_status("searching", pattern[:40])
+
+                    elif tool_name == "Task":
+                        desc = item.get("input", {}).get("description", "agent")
+                        ui.add_activity(f"Task: {desc}", "🤖")
+                        ui.set_status("agent", desc[:25])
+
+                    elif tool_name not in ["TodoWrite"]:
+                        ui.add_activity(f"{tool_name}", "⚡")
+                        ui.set_status("executing", tool_name)
+
+            elif item.get("type") == "thinking":
+                if ui:
+                    ui.set_status("thinking")
+
+    def _handle_user_message(
+        self,
+        data: dict,
+        ui: Optional["StageUI"],
+        pending_tools: list[tuple[str, str]],
+    ) -> None:
+        """Handle user message with tool results."""
+        content = data.get("message", {}).get("content", [])
+
+        for item in content:
+            if item.get("type") == "tool_result":
+                tool_id = item.get("tool_use_id", "")
+                is_error = item.get("is_error", False)
+                pending_tools[:] = [
+                    (tid, tname) for tid, tname in pending_tools if tid != tool_id
+                ]
+                if is_error and ui:
+                    ui.set_status("error", "tool failed")
+
+    def _handle_system_message(self, data: dict, ui: Optional["StageUI"]) -> None:
+        """Handle system messages."""
+        message = data.get("message", "")
+        subtype = data.get("subtype", "")
+
+        if "rate" in message.lower():
+            if ui:
+                ui.add_activity("Rate limited - waiting", "🚦")
+                ui.set_status("rate_limited", "waiting...")
+        elif subtype and ui:
+            ui.set_status(subtype)
+
+    def generate_text(self, prompt: str, timeout: int = 30) -> str:
+        """Simple text generation."""
+        try:
+            result = subprocess.run(
+                ["claude", "-p", prompt, "--output-format", "text"],
+                cwd=get_project_root(),
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, Exception):
+            pass
+        return ""

galangal/ai/gemini.py

@@ -0,0 +1,38 @@
+"""
+Gemini backend implementation (stub for future use).
+"""
+
+from typing import Optional, TYPE_CHECKING
+
+from galangal.ai.base import AIBackend
+
+if TYPE_CHECKING:
+    from galangal.ui.tui import StageUI
+
+
+class GeminiBackend(AIBackend):
+    """
+    Gemini backend (stub implementation).
+
+    TODO: Implement when Gemini CLI or API support is added.
+    """
+
+    @property
+    def name(self) -> str:
+        return "gemini"
+
+    def invoke(
+        self,
+        prompt: str,
+        timeout: int = 14400,
+        max_turns: int = 200,
+        ui: Optional["StageUI"] = None,
+    ) -> tuple[bool, str]:
+        """Invoke Gemini with a prompt."""
+        # TODO: Implement Gemini invocation
+        return False, "Gemini backend not yet implemented"
+
+    def generate_text(self, prompt: str, timeout: int = 30) -> str:
+        """Simple text generation with Gemini."""
+        # TODO: Implement Gemini text generation
+        return ""

galangal/cli.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""
+Galangal Orchestrate - AI-Driven Development Workflow CLI
+
+Usage:
+    galangal init                           - Initialize in current project
+    galangal start "task description"       - Start new task
+    galangal start "desc" --name my-task    - Start with explicit name
+    galangal list                           - List all tasks
+    galangal switch <task-name>             - Switch active task
+    galangal status                         - Show active task status
+    galangal resume                         - Continue active task
+    galangal pause                          - Pause task for break/shutdown
+    galangal approve                        - Record plan approval
+    galangal approve-design                 - Record design review
+    galangal skip-design                    - Skip design for trivial tasks
+    galangal skip-security                  - Skip security for non-code changes
+    galangal reset                          - Delete active task
+    galangal complete                       - Move task to done/, create PR
+    galangal prompts export                 - Export default prompts for customization
+"""
+
+import argparse
+import sys
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Galangal Orchestrate - AI-Driven Development Workflow",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  galangal init
+  galangal start "Add user authentication"
+  galangal start "Add auth" --name add-auth-feature
+  galangal list
+  galangal switch add-auth-feature
+  galangal status
+  galangal resume
+  galangal pause
+  galangal approve
+  galangal approve-design
+  galangal skip-design
+  galangal skip-to DEV
+  galangal skip-to TEST --resume
+  galangal complete
+  galangal reset
+  galangal prompts export
+
+Task Types:
+  At task start, you'll select from:
+    [1] Feature   - New functionality (full workflow)
+    [2] Bug Fix   - Fix broken behavior (skip design)
+    [3] Refactor  - Restructure code (skip design, security)
+    [4] Chore     - Dependencies, config, tooling
+    [5] Docs      - Documentation only (minimal stages)
+    [6] Hotfix    - Critical fix (expedited)
+
+Workflow:
+  PM -> DESIGN -> PREFLIGHT -> DEV -> MIGRATION* -> TEST ->
+  CONTRACT* -> QA -> BENCHMARK* -> SECURITY -> REVIEW -> DOCS -> COMPLETE
+
+  * = Conditional stages (auto-skipped if condition not met)
+
+Tip: Press Ctrl+C during execution to pause gracefully.
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # init
+    init_parser = subparsers.add_parser("init", help="Initialize galangal in current project")
+    init_parser.set_defaults(func=_cmd_init)
+
+    # start
+    start_parser = subparsers.add_parser("start", help="Start new task")
+    start_parser.add_argument(
+        "description", nargs="*", help="Task description (prompted if not provided)"
+    )
+    start_parser.add_argument(
+        "--name", "-n", help="Task name (auto-generated if not provided)"
+    )
+    start_parser.add_argument(
+        "--type", "-t",
+        choices=["feature", "bugfix", "refactor", "chore", "docs", "hotfix", "1", "2", "3", "4", "5", "6"],
+        help="Task type (skip interactive selection)"
+    )
+    start_parser.set_defaults(func=_cmd_start)
+
+    # list
+    list_parser = subparsers.add_parser("list", help="List all tasks")
+    list_parser.set_defaults(func=_cmd_list)
+
+    # switch
+    switch_parser = subparsers.add_parser("switch", help="Switch active task")
+    switch_parser.add_argument("task_name", help="Task name to switch to")
+    switch_parser.set_defaults(func=_cmd_switch)
+
+    # resume
+    resume_parser = subparsers.add_parser("resume", help="Resume active task")
+    resume_parser.set_defaults(func=_cmd_resume)
+
+    # pause
+    pause_parser = subparsers.add_parser("pause", help="Pause task for break/shutdown")
+    pause_parser.set_defaults(func=_cmd_pause)
+
+    # status
+    status_parser = subparsers.add_parser("status", help="Show active task status")
+    status_parser.set_defaults(func=_cmd_status)
+
+    # approve
+    approve_parser = subparsers.add_parser("approve", help="Record plan approval")
+    approve_parser.set_defaults(func=_cmd_approve)
+
+    # approve-design
+    approve_design_parser = subparsers.add_parser(
+        "approve-design", help="Record design review approval"
+    )
+    approve_design_parser.set_defaults(func=_cmd_approve_design)
+
+    # skip-design
+    skip_design_parser = subparsers.add_parser(
+        "skip-design", help="Skip design stage for trivial tasks"
+    )
+    skip_design_parser.set_defaults(func=_cmd_skip_design)
+
+    # skip-security
+    skip_security_parser = subparsers.add_parser(
+        "skip-security", help="Skip security stage for non-code changes"
+    )
+    skip_security_parser.set_defaults(func=_cmd_skip_security)
+
+    # skip-migration
+    skip_migration_parser = subparsers.add_parser(
+        "skip-migration", help="Skip migration stage"
+    )
+    skip_migration_parser.set_defaults(func=_cmd_skip_migration)
+
+    # skip-contract
+    skip_contract_parser = subparsers.add_parser(
+        "skip-contract", help="Skip contract stage"
+    )
+    skip_contract_parser.set_defaults(func=_cmd_skip_contract)
+
+    # skip-benchmark
+    skip_benchmark_parser = subparsers.add_parser(
+        "skip-benchmark", help="Skip benchmark stage"
+    )
+    skip_benchmark_parser.set_defaults(func=_cmd_skip_benchmark)
+
+    # skip-to
+    skip_to_parser = subparsers.add_parser(
+        "skip-to", help="Jump to a specific stage (for debugging/re-running)"
+    )
+    skip_to_parser.add_argument(
+        "stage", help="Target stage (e.g., DEV, TEST, SECURITY)"
+    )
+    skip_to_parser.add_argument(
+        "--force", "-f", action="store_true", help="Skip confirmation"
+    )
+    skip_to_parser.add_argument(
+        "--resume", "-r", action="store_true", help="Resume workflow immediately after jumping"
+    )
+    skip_to_parser.set_defaults(func=_cmd_skip_to)
+
+    # reset
+    reset_parser = subparsers.add_parser("reset", help="Delete active task")
+    reset_parser.add_argument(
+        "--force", "-f", action="store_true", help="Skip confirmation"
+    )
+    reset_parser.set_defaults(func=_cmd_reset)
+
+    # complete
+    complete_parser = subparsers.add_parser(
+        "complete", help="Move completed task to done/, create PR"
+    )
+    complete_parser.add_argument(
+        "--force", "-f", action="store_true", help="Continue on commit errors"
+    )
+    complete_parser.set_defaults(func=_cmd_complete)
+
+    # prompts
+    prompts_parser = subparsers.add_parser("prompts", help="Manage prompts")
+    prompts_subparsers = prompts_parser.add_subparsers(dest="prompts_command")
+    prompts_export = prompts_subparsers.add_parser(
+        "export", help="Export default prompts for customization"
+    )
+    prompts_export.set_defaults(func=_cmd_prompts_export)
+    prompts_show = prompts_subparsers.add_parser(
+        "show", help="Show effective prompt for a stage"
+    )
+    prompts_show.add_argument("stage", help="Stage name (e.g., pm, dev, test)")
+    prompts_show.set_defaults(func=_cmd_prompts_show)
+
+    args = parser.parse_args()
+    return args.func(args)
+
+
+# Command wrappers that import lazily to speed up CLI startup
+def _cmd_init(args):
+    from galangal.commands.init import cmd_init
+    return cmd_init(args)
+
+
+def _cmd_start(args):
+    from galangal.commands.start import cmd_start
+    return cmd_start(args)
+
+
+def _cmd_list(args):
+    from galangal.commands.list import cmd_list
+    return cmd_list(args)
+
+
+def _cmd_switch(args):
+    from galangal.commands.switch import cmd_switch
+    return cmd_switch(args)
+
+
+def _cmd_resume(args):
+    from galangal.commands.resume import cmd_resume
+    return cmd_resume(args)
+
+
+def _cmd_pause(args):
+    from galangal.commands.pause import cmd_pause
+    return cmd_pause(args)
+
+
+def _cmd_status(args):
+    from galangal.commands.status import cmd_status
+    return cmd_status(args)
+
+
+def _cmd_approve(args):
+    from galangal.commands.approve import cmd_approve
+    return cmd_approve(args)
+
+
+def _cmd_approve_design(args):
+    from galangal.commands.approve import cmd_approve_design
+    return cmd_approve_design(args)
+
+
+def _cmd_skip_design(args):
+    from galangal.commands.skip import cmd_skip_design
+    return cmd_skip_design(args)
+
+
+def _cmd_skip_security(args):
+    from galangal.commands.skip import cmd_skip_security
+    return cmd_skip_security(args)
+
+
+def _cmd_skip_migration(args):
+    from galangal.commands.skip import cmd_skip_migration
+    return cmd_skip_migration(args)
+
+
+def _cmd_skip_contract(args):
+    from galangal.commands.skip import cmd_skip_contract
+    return cmd_skip_contract(args)
+
+
+def _cmd_skip_benchmark(args):
+    from galangal.commands.skip import cmd_skip_benchmark
+    return cmd_skip_benchmark(args)
+
+
+def _cmd_skip_to(args):
+    from galangal.commands.skip import cmd_skip_to
+    return cmd_skip_to(args)
+
+
+def _cmd_reset(args):
+    from galangal.commands.reset import cmd_reset
+    return cmd_reset(args)
+
+
+def _cmd_complete(args):
+    from galangal.commands.complete import cmd_complete
+    return cmd_complete(args)
+
+
+def _cmd_prompts_export(args):
+    from galangal.commands.prompts import cmd_prompts_export
+    return cmd_prompts_export(args)
+
+
+def _cmd_prompts_show(args):
+    from galangal.commands.prompts import cmd_prompts_show
+    return cmd_prompts_show(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())