sibyl-cli 0.2.0__py3-none-any.whl

parallel_developer/controller/commands.py

@@ -0,0 +1,132 @@
+"""Controller command definitions and helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Awaitable, Callable, Dict, List, Optional
+
+
+@dataclass
+class CommandSuggestion:
+    name: str
+    description: str
+
+
+@dataclass
+class CommandOption:
+    label: str
+    value: object
+    description: Optional[str] = None
+    display: Optional[str] = None
+
+
+@dataclass
+class CommandSpecEntry:
+    description: str
+    handler: Callable[[Optional[object]], Awaitable[None]]
+    options: Optional[List[CommandOption]] = None
+    options_provider: Optional[Callable[[], List[CommandOption]]] = None
+
+
+def build_command_specs(
+    controller,
+    *,
+    flow_mode_cls,
+    boss_mode_cls,
+    merge_mode_cls,
+) -> Dict[str, CommandSpecEntry]:
+    FlowMode = flow_mode_cls  # alias for brevity
+    MergeMode = merge_mode_cls
+    specs = {
+        "/attach": CommandSpecEntry(
+            "tmux接続の方法を切り替える",
+            controller._cmd_attach,
+            options=[
+                CommandOption("auto - 自動でターミナルを開く", "auto", "自動でターミナルを開く"),
+                CommandOption("manual - コマンド入力で手動接続", "manual", "コマンド入力で手動接続"),
+                CommandOption("now - 即座にtmux attachを実行", "now", "即座にtmux attachを実行"),
+            ],
+        ),
+        "/boss": CommandSpecEntry(
+            "Bossの挙動を切り替える",
+            controller._cmd_boss,
+            options=[
+                CommandOption("skip - Boss評価をスキップ", boss_mode_cls.SKIP.value, "Boss評価をスキップ"),
+                CommandOption("score - 採点のみ実施", boss_mode_cls.SCORE.value, "採点のみ実施"),
+                CommandOption("rewrite - 採点後にBossが統合実装", boss_mode_cls.REWRITE.value, "採点後にBossが統合実装"),
+            ],
+        ),
+        "/flow": CommandSpecEntry(
+            "フロー自動化レベルを切り替える",
+            controller._cmd_flow,
+            options=[
+                CommandOption("manual - 採点段階への移行や採択を手動で行う", FlowMode.MANUAL.value, "採点段階への移行や採択を手動で行う"),
+                CommandOption("auto_review - 採点段階への移行は自動、採択は手動", FlowMode.AUTO_REVIEW.value, "採点段階への移行は自動、採択は手動"),
+                CommandOption("auto_select - 採点段階への移行は手動、採択は自動", FlowMode.AUTO_SELECT.value, "採点段階への移行は手動、採択は自動"),
+                CommandOption("full_auto - 採点段階への移行・採択まで自動", FlowMode.FULL_AUTO.value, "採点段階への移行・採択まで自動"),
+            ],
+        ),
+        "/merge": CommandSpecEntry(
+            "マージ方式を切り替える",
+            controller._cmd_merge,
+            options=[
+                CommandOption(
+                    "manual - ホストが従来どおりマージ",
+                    MergeMode.MANUAL.value,
+                    "ホスト側がFast-Forwardなどを実行",
+                ),
+                CommandOption(
+                    "auto - エージェントがコミット・統合作業",
+                    MergeMode.AUTO.value,
+                    "採択エージェントにコミット/統合手順を送る",
+                ),
+            ],
+        ),
+        "/parallel": CommandSpecEntry(
+            "ワーカー数を設定する",
+            controller._cmd_parallel,
+            options=[CommandOption(f"{n} - ワーカーを{n}人起動", str(n), f"ワーカーを{n}人起動") for n in range(1, 5)],
+        ),
+        "/mode": CommandSpecEntry(
+            "実行対象を切り替える",
+            controller._cmd_mode,
+            options=[
+                CommandOption("main - メインCodexのみ稼働", "main", "メインCodexのみ稼働"),
+                CommandOption("parallel - メイン+ワーカーを起動", "parallel", "メイン+ワーカーを起動"),
+            ],
+        ),
+        "/resume": CommandSpecEntry(
+            "保存セッションを再開する",
+            controller._cmd_resume,
+            options_provider=controller._build_resume_options,
+        ),
+        "/continue": CommandSpecEntry("ワーカーの作業を続行する", controller._cmd_continue),
+        "/log": CommandSpecEntry(
+            "ログをコピーや保存する",
+            controller._cmd_log,
+            options=[
+                CommandOption("copy - ログをクリップボードへコピー", "copy", "ログをクリップボードへコピー"),
+                CommandOption("save - ログをファイルへ保存", "save", "ログをファイルへ保存"),
+            ],
+        ),
+        "/commit": CommandSpecEntry(
+            "Gitコミットを操作する",
+            controller._cmd_commit,
+            options=[
+                CommandOption("manual - 現在の変更をコミット", "manual", "現在の変更をその場でコミット"),
+                CommandOption("auto - 自動コミットをON/OFF", "auto", "サイクル開始時に自動コミットをON/OFF"),
+            ],
+        ),
+        "/status": CommandSpecEntry(
+            "現在の状態を表示する",
+            controller._cmd_status,
+        ),
+        "/scoreboard": CommandSpecEntry(
+            "最新スコアを表示する",
+            controller._cmd_scoreboard,
+        ),
+        "/done": CommandSpecEntry("採点フェーズへ移行する", controller._cmd_done),
+        "/help": CommandSpecEntry("コマンド一覧を表示する", controller._cmd_help),
+        "/exit": CommandSpecEntry("CLI を終了する", controller._cmd_exit),
+    }
+    return specs

parallel_developer/controller/events.py

@@ -0,0 +1,17 @@
+"""Controller → UI 間で利用するイベント種別を定義。"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class ControllerEventType(str, Enum):
+    STATUS = "status"
+    LOG = "log"
+    LOG_COPY = "log_copy"
+    LOG_SAVE = "log_save"
+    SCOREBOARD = "scoreboard"
+    SELECTION_REQUEST = "selection_request"
+    SELECTION_FINISHED = "selection_finished"
+    PAUSE_STATE = "pause_state"
+    QUIT = "quit"

parallel_developer/controller/flow.py

@@ -0,0 +1,43 @@
+"""Workerフロー制御の補助機能をまとめたモジュール。"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, TYPE_CHECKING
+
+from .events import ControllerEventType
+from ..orchestrator import CycleLayout, WorkerDecision
+
+if TYPE_CHECKING:  # pragma: no cover
+    from . import CLIController
+
+
+class WorkerFlowHelper:
+    """Controllerのワーカーフロー関連処理をまとめるヘルパー。"""
+
+    def __init__(self, controller: "CLIController", flow_mode_cls) -> None:
+        self._controller = controller
+        self._controller_event_type = ControllerEventType
+        self._flow_mode_cls = flow_mode_cls
+
+    def handle_worker_decision(
+        self,
+        fork_map: Mapping[str, str],
+        completion_info: Mapping[str, Any],
+        layout: CycleLayout,
+    ) -> WorkerDecision:
+        c = self._controller
+        flow_mode = getattr(c, "_flow_mode", self._flow_mode_cls.MANUAL)
+        if flow_mode in {self._flow_mode_cls.AUTO_REVIEW, self._flow_mode_cls.FULL_AUTO}:
+            c._emit(
+                self._controller_event_type.LOG,
+                {
+                    "text": f"[flow {c._flow_mode_display()}] ワーカーの処理が完了しました。採点フェーズへ進みます。",
+                },
+            )
+            return WorkerDecision(action="done")
+
+        command = c._await_worker_command()
+        if str(command).lower() == "continue":
+            instruction = c._await_continuation_instruction()
+            return WorkerDecision(action="continue", instruction=instruction)
+        return WorkerDecision(action="done")

parallel_developer/controller/history.py

@@ -0,0 +1,70 @@
+"""Controller input/cycle history helpers."""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .controller import CLIController, Orchestrator, CycleLayout  # noqa: F401
+
+
+class HistoryManager:
+    """Handles input history and cycle snapshots for CLIController."""
+
+    def __init__(self) -> None:
+        self._input_history: List[str] = []
+        self._history_cursor: int = 0
+        self._cycle_history: List[Dict[str, object]] = []
+
+    # Input history ---------------------------------------------------------
+    def record_input(self, text: str) -> None:
+        entry = text.strip()
+        if not entry:
+            return
+        if self._input_history and self._input_history[-1] == entry:
+            self._history_cursor = len(self._input_history)
+            return
+        self._input_history.append(entry)
+        self._history_cursor = len(self._input_history)
+
+    def history_previous(self) -> Optional[str]:
+        if not self._input_history:
+            return None
+        if self._history_cursor > 0:
+            self._history_cursor -= 1
+        return self._input_history[self._history_cursor]
+
+    def history_next(self) -> Optional[str]:
+        if not self._input_history:
+            return None
+        if self._history_cursor < len(self._input_history) - 1:
+            self._history_cursor += 1
+            return self._input_history[self._history_cursor]
+        self._history_cursor = len(self._input_history)
+        return ""
+
+    def reset_cursor(self) -> None:
+        self._history_cursor = len(self._input_history)
+
+    # Cycle history ---------------------------------------------------------
+    def record_cycle_snapshot(self, result, cycle_id: int, last_instruction: Optional[str]) -> None:
+        snapshot = {
+            "cycle_id": cycle_id,
+            "selected_session": result.selected_session,
+            "scoreboard": dict(result.sessions_summary),
+            "instruction": last_instruction,
+        }
+        self._cycle_history.append(snapshot)
+
+    def last_snapshot(self) -> Optional[Dict[str, object]]:
+        if not self._cycle_history:
+            return None
+        return self._cycle_history[-1]
+
+    def pop_snapshot(self) -> Optional[Dict[str, object]]:
+        if not self._cycle_history:
+            return None
+        return self._cycle_history.pop()
+
+    def set_cycle_history(self, history_list: List[Dict[str, object]]) -> None:
+        self._cycle_history = history_list

parallel_developer/controller/pause.py

@@ -0,0 +1,94 @@
+"""Pause/escape handling helpers for CLIController."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+from subprocess import PIPE
+from typing import List, Optional, TYPE_CHECKING
+
+from .events import ControllerEventType
+
+if TYPE_CHECKING:  # pragma: no cover
+    from . import CLIController
+
+
+class PauseHelper:
+    """Encapsulates pause state transitions and broadcast logic."""
+
+    def __init__(self, controller: "CLIController") -> None:
+        self._controller = controller
+
+    def handle_escape(self) -> None:
+        controller = self._controller
+        controller.broadcast_escape()
+        if not controller._paused:
+            controller._paused = True
+            controller._emit(ControllerEventType.LOG, {"text": "一時停止モードに入りました。追加指示は現在のワーカーペインへ送信されます。"})
+            controller._emit_status("一時停止モード")
+            controller._emit_pause_state()
+            return
+        if controller._running:
+            current_id = controller._current_cycle_id
+            if current_id is not None:
+                controller._cancelled_cycles.add(current_id)
+            controller._current_cycle_id = None
+            controller._running = False
+        if controller._continue_future and not controller._continue_future.done():
+            controller._continue_future.set_result("done")
+        if controller._continuation_input_future and not controller._continuation_input_future.done():
+            controller._continuation_input_future.set_result("")
+        controller._awaiting_continuation_input = False
+        controller._paused = False
+        controller._emit(ControllerEventType.LOG, {"text": "現在のサイクルをキャンセルし、前の状態へ戻しました。"})
+        controller._emit_status("待機中")
+        controller._emit_pause_state()
+        controller._perform_revert(silent=True)
+
+    async def dispatch_paused_instruction(self, instruction: str) -> None:
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, lambda: self._send_instruction_to_panes(instruction))
+
+    def _send_instruction_to_panes(self, instruction: str) -> None:
+        controller = self._controller
+        session_name = controller._config.tmux_session
+        pane_ids = self._tmux_list_panes()
+        if pane_ids is None:
+            return
+        if len(pane_ids) <= 2:
+            controller._emit(ControllerEventType.LOG, {"text": f"tmuxセッション {session_name} にワーカーペインが見つからず、追加指示を送信できませんでした。"})
+            return
+        worker_panes = pane_ids[2:]
+        for pane_id in worker_panes:
+            subprocess.run(
+                ["tmux", "send-keys", "-t", pane_id, instruction, "Enter"],
+                check=False,
+            )
+        preview = instruction.replace("\n", " ")[:60]
+        if len(instruction) > 60:
+            preview += "..."
+        controller._emit(ControllerEventType.LOG, {"text": f"[pause] {len(worker_panes)} ワーカーペインへ追加指示を送信: {preview}"})
+        controller._paused = False
+        controller._emit_pause_state()
+        controller._emit_status("待機中")
+
+    def _tmux_list_panes(self) -> Optional[List[str]]:
+        controller = self._controller
+        session_name = controller._config.tmux_session
+        try:
+            result = subprocess.run(
+                ["tmux", "list-panes", "-t", session_name, "-F", "#{pane_id}"],
+                check=False,
+                stdout=PIPE,
+                stderr=PIPE,
+                text=True,
+            )
+        except FileNotFoundError:
+            controller._emit(ControllerEventType.LOG, {"text": "tmux コマンドが見つかりません。tmuxがインストールされているか確認してください。"})
+            return None
+        if result.returncode != 0:
+            message = (result.stderr or result.stdout or "").strip()
+            if message:
+                controller._emit(ControllerEventType.LOG, {"text": f"tmux list-panes に失敗しました: {message}"})
+            return None
+        return [line.strip() for line in (result.stdout or "").splitlines() if line.strip()]

parallel_developer/controller/workflow_runner.py

@@ -0,0 +1,135 @@
+"""CLIController の指示実行フローを担当する WorkflowRunner."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+from .events import ControllerEventType
+from ..orchestrator import CandidateInfo, OrchestrationResult, SelectionDecision
+
+if TYPE_CHECKING:  # pragma: no cover
+    from . import CLIController
+
+
+class WorkflowRunner:
+    """CLIController から切り離した実行フロー管理."""
+
+    def __init__(self, controller: "CLIController") -> None:
+        self._controller = controller
+
+    async def run(self, instruction: str) -> None:
+        c = self._controller
+        if c._running:
+            c._emit(ControllerEventType.LOG, {"text": "別の指示を処理中です。完了を待ってから再度実行してください。"})
+            return
+        if c._selection_context:
+            c._emit(ControllerEventType.LOG, {"text": "候補選択待ちです。/pick <n> で選択してください。"})
+            return
+
+        c._maybe_auto_commit()
+
+        c._cycle_counter += 1
+        cycle_id = c._cycle_counter
+        c._current_cycle_id = cycle_id
+        c._running = True
+        c._emit_status("メインセッションを準備中...")
+        c._active_main_session_id = None
+        c._pre_cycle_selected_session = c._last_selected_session
+        c._pre_cycle_selected_session_set = True
+
+        logs_dir = c._create_cycle_logs_dir()
+
+        orchestrator = c._builder(
+            worker_count=c._config.worker_count,
+            log_dir=logs_dir,
+            session_name=c._config.tmux_session,
+            reuse_existing_session=c._config.reuse_existing_session,
+            session_namespace=c._session_namespace,
+            boss_mode=c._config.boss_mode,
+            project_root=c._worktree_root,
+            worktree_storage_root=c._worktree_storage_root,
+            log_hook=self._controller._log_hook,
+            merge_mode=c._config.merge_mode,
+        )
+        c._active_orchestrator = orchestrator
+        c._last_tmux_manager = getattr(orchestrator, "_tmux", None)
+        main_hook = getattr(orchestrator, "set_main_session_hook", None)
+        if callable(main_hook):
+            main_hook(c._on_main_session_started)
+        worker_decider = getattr(orchestrator, "set_worker_decider", None)
+        if callable(worker_decider):
+            worker_decider(c._handle_worker_decision)
+
+        loop = asyncio.get_running_loop()
+
+        def selector(
+            candidates: List[CandidateInfo],
+            scoreboard: Optional[Dict[str, Dict[str, object]]] = None,
+        ) -> SelectionDecision:
+            return c._select_candidates(candidates, scoreboard)
+
+        resume_session = c._last_selected_session
+
+        def run_cycle() -> OrchestrationResult:
+            return orchestrator.run_cycle(
+                instruction,
+                selector=selector,
+                resume_session_id=resume_session,
+            )
+
+        auto_attach_task: Optional[asyncio.Task[None]] = None
+        cancelled = False
+        try:
+            c._emit(ControllerEventType.LOG, {"text": f"指示を開始: {instruction}"})
+            if c._attach_mode == "auto":
+                auto_attach_task = asyncio.create_task(c._handle_attach_command(force=False))
+            result: OrchestrationResult = await loop.run_in_executor(None, run_cycle)
+            if getattr(result, "merge_outcome", None) is not None:
+                c._handle_merge_outcome(result.merge_outcome)
+            if cycle_id in c._cancelled_cycles:
+                cancelled = True
+                c._cancelled_cycles.discard(cycle_id)
+            else:
+                c._last_scoreboard = dict(result.sessions_summary)
+                c._last_instruction = instruction
+                c._last_selected_session = result.selected_session
+                c._active_main_session_id = result.selected_session
+                c._config.reuse_existing_session = True
+                c._emit(ControllerEventType.SCOREBOARD, {"scoreboard": c._last_scoreboard})
+                c._emit(ControllerEventType.LOG, {"text": "指示が完了しました。"})
+                if result.artifact:
+                    manifest = c._build_manifest(result, logs_dir)
+                    c._manifest_store.save_manifest(manifest)
+                    c._emit(ControllerEventType.LOG, {"text": f"セッションを保存しました: {manifest.session_id}"})
+                c._record_cycle_snapshot(result, cycle_id)
+        except Exception as exc:  # noqa: BLE001
+            c._emit(ControllerEventType.LOG, {"text": f"エラーが発生しました: {exc}"})
+        finally:
+            c._selection_context = None
+            if c._current_cycle_id == cycle_id:
+                c._current_cycle_id = None
+            c._running = False
+            c._awaiting_continuation_input = False
+            if c._continuation_input_future and not c._continuation_input_future.done():
+                c._continuation_input_future.set_result("")
+            c._continuation_input_future = None
+            if cancelled:
+                c._emit_status("待機中")
+                c._emit_pause_state()
+                c._perform_revert(silent=True)
+            else:
+                c._emit_status("一時停止中" if c._paused else "待機中")
+                c._emit_pause_state()
+            if auto_attach_task:
+                try:
+                    await auto_attach_task
+                except Exception:  # noqa: BLE001
+                    pass
+            c._pre_cycle_selected_session = None
+            c._pre_cycle_selected_session_set = False
+
+        if cancelled and c._queued_instruction:
+            queued = c._queued_instruction
+            c._queued_instruction = None
+            await self.run(queued)