sibyl-cli 0.2.0__py3-none-any.whl

parallel_developer/services/log_manager.py

@@ -0,0 +1,161 @@
+"""オーケストレーションログを集約するサービス."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Mapping
+
+import yaml
+
+
+class LogManager:
+    """各サイクルのメタデータを YAML/JSONL として永続化する."""
+
+    def __init__(self, logs_dir: Path) -> None:
+        self.logs_dir = Path(logs_dir)
+        self.logs_dir.mkdir(parents=True, exist_ok=True)
+        self.cycles_dir = self.logs_dir / "cycles"
+        self.cycles_dir.mkdir(parents=True, exist_ok=True)
+
+    def record_cycle(
+        self,
+        *,
+        instruction: str,
+        layout: Mapping[str, Any],
+        fork_map: Mapping[str, str],
+        completion: Mapping[str, Any],
+        result: Any,
+    ) -> Dict[str, Path]:
+        timestamp = datetime.utcnow().strftime("%y-%m-%d-%H%M%S")
+        payload = {
+            "instruction": instruction,
+            "layout": dict(layout),
+            "fork_map": dict(fork_map),
+            "completion": dict(completion),
+            "result": {
+                "selected_session": getattr(result, "selected_session", None),
+                "sessions_summary": getattr(result, "sessions_summary", None),
+            },
+        }
+        outcome = getattr(result, "merge_outcome", None)
+        if outcome is not None:
+            payload["result"]["merge_outcome"] = {
+                "strategy": getattr(outcome, "strategy", None).value if getattr(outcome, "strategy", None) else None,
+                "status": getattr(outcome, "status", None),
+                "branch": getattr(outcome, "branch", None),
+                "error": getattr(outcome, "error", None),
+                "reason": getattr(outcome, "reason", None),
+            }
+        path = self.cycles_dir / f"{timestamp}.yaml"
+        path.write_text(
+            yaml.safe_dump(payload, sort_keys=False),
+            encoding="utf-8",
+        )
+        jsonl_path = self.cycles_dir / f"{timestamp}.jsonl"
+        events = self._build_cycle_events(
+            instruction=instruction,
+            layout=layout,
+            fork_map=fork_map,
+            completion=completion,
+            result=result,
+        )
+        with jsonl_path.open("w", encoding="utf-8") as fh:
+            for event in events:
+                fh.write(json.dumps(event, ensure_ascii=False) + "\n")
+        return {"yaml": path, "jsonl": jsonl_path}
+
+    def _build_cycle_events(
+        self,
+        *,
+        instruction: str,
+        layout: Mapping[str, Any],
+        fork_map: Mapping[str, str],
+        completion: Mapping[str, Any],
+        result: Any,
+    ) -> List[Dict[str, Any]]:
+        timestamp = datetime.utcnow().isoformat(timespec="seconds")
+        events: List[Dict[str, Any]] = []
+
+        events.append(
+            {
+                "type": "instruction",
+                "timestamp": timestamp,
+                "instruction": instruction,
+                "layout": dict(layout),
+            }
+        )
+
+        if fork_map:
+            events.append(
+                {
+                    "type": "fork",
+                    "timestamp": timestamp,
+                    "fork_map": dict(fork_map),
+                }
+            )
+
+        if completion:
+            events.append(
+                {
+                    "type": "completion",
+                    "timestamp": timestamp,
+                    "completion": dict(completion),
+                }
+            )
+
+        scoreboard = getattr(result, "sessions_summary", None) or {}
+        if scoreboard:
+            events.append(
+                {
+                    "type": "scoreboard",
+                    "timestamp": timestamp,
+                    "scoreboard": scoreboard,
+                }
+            )
+
+        selected_session = getattr(result, "selected_session", None)
+        selected_key = None
+        for key, data in scoreboard.items():
+            if data.get("selected"):
+                selected_key = key
+                break
+        events.append(
+            {
+                "type": "selection",
+                "timestamp": timestamp,
+                "selected_session": selected_session,
+                "selected_key": selected_key,
+            }
+        )
+
+        outcome = getattr(result, "merge_outcome", None)
+        if outcome is not None:
+            events.append(
+                {
+                    "type": "merge_outcome",
+                    "timestamp": timestamp,
+                    "strategy": getattr(outcome, "strategy", None).value if getattr(outcome, "strategy", None) else None,
+                    "status": getattr(outcome, "status", None),
+                    "branch": getattr(outcome, "branch", None),
+                    "error": getattr(outcome, "error", None),
+                    "reason": getattr(outcome, "reason", None),
+                }
+            )
+
+        artifact = getattr(result, "artifact", None)
+        if artifact is not None:
+            events.append(
+                {
+                    "type": "artifact",
+                    "timestamp": timestamp,
+                    "main_session_id": getattr(artifact, "main_session_id", None),
+                    "worker_sessions": getattr(artifact, "worker_sessions", {}),
+                    "boss_session_id": getattr(artifact, "boss_session_id", None),
+                    "worker_paths": {k: str(v) for k, v in getattr(artifact, "worker_paths", {}).items()},
+                    "boss_path": str(getattr(artifact, "boss_path", "")) if getattr(artifact, "boss_path", None) else None,
+                }
+            )
+
+        return events

parallel_developer/services/tmux_manager.py

@@ -0,0 +1,245 @@
+"""tmux レイアウトとキーストロークを制御するサービス."""
+
+from __future__ import annotations
+
+import shlex
+import time
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Optional, Sequence, TYPE_CHECKING, List
+
+import libtmux
+
+if TYPE_CHECKING:  # pragma: no cover - 型チェック専用
+    from .codex_monitor import CodexMonitor
+
+
+class TmuxLayoutManager:
+    """Parallel Codex 用の tmux セッションを構成・制御する."""
+
+    def __init__(
+        self,
+        session_name: str,
+        worker_count: int,
+        monitor: "CodexMonitor",
+        *,
+        root_path: Path,
+        startup_delay: float = 0.0,
+        backtrack_delay: float = 0.05,
+        reuse_existing_session: bool = False,
+        session_namespace: Optional[str] = None,
+    ) -> None:
+        self.session_name = session_name
+        self.worker_count = worker_count
+        self.monitor = monitor
+        self.root_path = Path(root_path)
+        self.boss_path = self.root_path
+        self.startup_delay = startup_delay
+        self.backtrack_delay = backtrack_delay
+        self.reuse_existing_session = reuse_existing_session
+        self.session_namespace = session_namespace
+        self._server = libtmux.Server()
+
+    def set_boss_path(self, path: Path) -> None:
+        self.boss_path = Path(path)
+
+    def set_reuse_existing_session(self, reuse: bool) -> None:
+        self.reuse_existing_session = reuse
+
+    def ensure_layout(self, *, session_name: str, worker_count: int) -> dict[str, Any]:
+        if session_name != self.session_name or worker_count != self.worker_count:
+            raise ValueError("session_name/worker_count mismatch with manager configuration")
+
+        session = self._get_or_create_session(fresh=not self.reuse_existing_session)
+        window = getattr(session, "attached_window", None) or session.windows[0]
+
+        target_pane_count = self.worker_count + 2  # main + boss + workers
+        while len(window.panes) < target_pane_count:
+            self._split_largest_pane(window)
+            window.select_layout("tiled")
+            window = getattr(session, "attached_window", None) or session.windows[0]
+        window.select_layout("tiled")
+
+        panes = window.panes
+        layout = {
+            "main": panes[0].pane_id,
+            "boss": panes[1].pane_id,
+            "workers": [pane.pane_id for pane in panes[2 : 2 + self.worker_count]],
+        }
+        self._apply_role_labels(session, layout)
+        return layout
+
+    def launch_main_session(self, *, pane_id: str) -> None:
+        codex = self._codex_command("codex")
+        command = f"cd {shlex.quote(str(self.root_path))} && {codex}"
+        self._send_command(pane_id, command)
+        self._maybe_wait()
+
+    def resume_session(self, *, pane_id: str, workdir: Path, session_id: str) -> None:
+        codex = self._codex_command(f"codex resume {shlex.quote(str(session_id))}")
+        command = f"cd {shlex.quote(str(workdir))} && {codex}"
+        self._send_command(pane_id, command)
+        self._maybe_wait()
+
+    def fork_boss(self, *, pane_id: str, base_session_id: str, boss_path: Path) -> None:
+        self.interrupt_pane(pane_id=pane_id)
+        command = f"cd {shlex.quote(str(boss_path))} && {self._codex_command(f'codex resume {shlex.quote(str(base_session_id))}')}"
+        self._send_command(pane_id, command)
+        self._maybe_wait()
+        pane = self._get_pane(pane_id)
+        pane.send_keys("C-[", enter=False)
+        time.sleep(self.backtrack_delay)
+        pane.send_keys("C-[", enter=False)
+        time.sleep(self.backtrack_delay)
+        pane.send_keys("", enter=True)
+        time.sleep(self.backtrack_delay)
+        self._maybe_wait()
+
+    def fork_workers(
+        self,
+        *,
+        workers: Iterable[str],
+        base_session_id: str,
+        pane_paths: Mapping[str, Path],
+    ) -> List[str]:
+        if not base_session_id:
+            raise RuntimeError("base_session_id が空です。メインセッションのIDが取得できていません。")
+        worker_list = list(workers)
+        for pane_id in worker_list:
+            try:
+                worker_path = Path(pane_paths[pane_id])
+            except KeyError as exc:
+                raise RuntimeError(f"pane {pane_id!r} に対応するワークツリーパスがありません") from exc
+            self.interrupt_pane(pane_id=pane_id)
+            command = f"cd {shlex.quote(str(worker_path))} && {self._codex_command(f'codex resume {shlex.quote(str(base_session_id))}')}"
+            self._send_command(pane_id, command)
+        self._maybe_wait()
+        if worker_list:
+            self._broadcast_keys(worker_list, "C-[", enter=False)
+            self._broadcast_keys(worker_list, "C-[", enter=False)
+            for pane_id in worker_list:
+                pane = self._get_pane(pane_id)
+                pane.send_keys("", enter=True)
+        self._maybe_wait()
+        return worker_list
+
+    def send_instruction_to_pane(self, *, pane_id: str, instruction: str) -> None:
+        self._send_text(pane_id, instruction)
+
+    def prepare_for_instruction(self, *, pane_id: str) -> None:
+        pane = self._get_pane(pane_id)
+        pane.send_keys("C-c", enter=False)
+        if self.backtrack_delay > 0:
+            time.sleep(self.backtrack_delay)
+
+    def promote_to_main(self, *, session_id: str, pane_id: str) -> None:
+        command = self._codex_command(f"codex resume {shlex.quote(str(session_id))}")
+        if self.backtrack_delay > 0:
+            time.sleep(self.backtrack_delay)
+        self._send_command(pane_id, command)
+
+    def interrupt_pane(self, *, pane_id: str) -> None:
+        pane = self._get_pane(pane_id)
+        pane.send_keys("C-c", enter=False)
+        if self.backtrack_delay > 0:
+            time.sleep(self.backtrack_delay)
+        pane.send_keys("C-c", enter=False)
+        if self.backtrack_delay > 0:
+            time.sleep(self.backtrack_delay)
+
+    def _apply_role_labels(self, session, layout: Mapping[str, Any]) -> None:
+        try:
+            self._set_pane_title(session, layout.get("main"), "MAIN")
+            self._set_pane_title(session, layout.get("boss"), "BOSS")
+            for index, pane_id in enumerate(layout.get("workers", []), start=1):
+                self._set_pane_title(session, pane_id, f"WORKER-{index}")
+        except Exception:  # pragma: no cover - tmux互換対策
+            pass
+
+    def _set_pane_title(self, session, pane_id: Optional[str], title: str) -> None:
+        if not pane_id:
+            return
+        try:
+            session.cmd("select-pane", "-t", pane_id, "-T", title)
+        except Exception:  # pragma: no cover - 古いtmux向け
+            pass
+
+    def _split_largest_pane(self, window) -> None:
+        panes = list(window.panes)
+        if not panes:
+            window.split_window(attach=False)
+            return
+        largest = max(panes, key=lambda pane: int(pane.height) * int(pane.width))
+        window.select_pane(largest.pane_id)
+        window.split_window(attach=False)
+
+    def _get_or_create_session(self, fresh: bool = False):
+        session = self._server.find_where({"session_name": self.session_name})
+        if session is not None and not fresh:
+            self._configure_session(session)
+            return session
+
+        kill_existing = fresh and session is not None
+        session = self._server.new_session(
+            session_name=self.session_name,
+            attach=False,
+            kill_session=kill_existing,
+        )
+        self._configure_session(session)
+        return session
+
+    def _get_pane(self, pane_id: str):
+        pane = self._find_pane(pane_id)
+        if pane is not None:
+            return pane
+        self._server = libtmux.Server()
+        pane = self._find_pane(pane_id)
+        if pane is not None:
+            return pane
+        raise RuntimeError(f"Pane {pane_id!r} not found in tmux session {self.session_name}")
+
+    def _find_pane(self, pane_id: str):
+        for session in getattr(self._server, "sessions", []):
+            for window in getattr(session, "windows", []):
+                for pane in getattr(window, "panes", []):
+                    if getattr(pane, "pane_id", None) == pane_id:
+                        return pane
+        return None
+
+    def _send_command(self, pane_id: str, command: str) -> None:
+        pane = self._get_pane(pane_id)
+        pane.send_keys(command, enter=True)
+
+    def _maybe_wait(self) -> None:
+        if self.startup_delay > 0:
+            time.sleep(self.startup_delay)
+
+    def _send_text(self, pane_id: str, text: str) -> None:
+        pane = self._get_pane(pane_id)
+        payload = text.replace("\r\n", "\n")
+        pane.send_keys(f"\x1b[200~{payload}\x1b[201~", enter=True)
+
+    def _codex_command(self, command: str) -> str:
+        return command
+
+    def _broadcast_keys(self, pane_ids: Sequence[str], key: str, *, enter: bool) -> None:
+        for pane_id in pane_ids:
+            pane = self._get_pane(pane_id)
+            pane.send_keys(key, enter=enter)
+        if self.backtrack_delay > 0:
+            time.sleep(self.backtrack_delay)
+
+    def _configure_session(self, session) -> None:
+        commands = [
+            ("set-option", "-g", "mouse", "on"),
+            ("set-option", "-g", "pane-border-style", "fg=green"),
+            ("set-option", "-g", "pane-active-border-style", "fg=orange"),
+            ("set-option", "-g", "pane-border-status", "top"),
+            ("set-option", "-g", "pane-border-format", "#{pane_title}"),
+            ("set-option", "-g", "display-panes-colour", "green"),
+            ("set-option", "-g", "display-panes-active-colour", "orange"),
+        ]
+        for args in commands:
+            try:
+                session.cmd(*args)
+            except Exception:  # pragma: no cover - 一部オプション非対応のtmux向けフォールバック
+                continue

parallel_developer/services/worktree_manager.py

@@ -0,0 +1,119 @@
+"""Git worktree を管理するサービス."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Dict, Optional
+
+import git
+
+
+class WorktreeManager:
+    """ワーカー/ボス用の git worktree を生成・整備する."""
+
+    def __init__(
+        self,
+        root: Path,
+        worker_count: int,
+        session_namespace: Optional[str] = None,
+        storage_root: Optional[Path] = None,
+    ) -> None:
+        self.root = Path(root)
+        self.worker_count = worker_count
+        self.session_namespace = session_namespace
+        self._repo = git.Repo(self.root)
+        self._ensure_repo_initialized()
+        self._storage_root = Path(storage_root) if storage_root is not None else self.root
+        self._session_root = self._resolve_session_root()
+        self.worktrees_dir = self._session_root / "worktrees"
+        self.boss_path = self.worktrees_dir / "boss"
+        self._worker_branch_template, self._boss_branch = self._resolve_branch_templates()
+        self._initialized = False
+        self._worker_paths: Dict[str, Path] = {}
+
+    def prepare(self) -> Dict[str, Path]:
+        self.worktrees_dir.mkdir(parents=True, exist_ok=True)
+        mapping: Dict[str, Path] = {}
+        for index in range(1, self.worker_count + 1):
+            worker_name = f"worker-{index}"
+            worktree_path = self.worktrees_dir / worker_name
+            branch_name = self.worker_branch(worker_name)
+            if not self._initialized or worker_name not in self._worker_paths:
+                self._recreate_worktree(worktree_path, branch_name)
+            else:
+                self._reset_worktree(worktree_path)
+            mapping[worker_name] = worktree_path
+        if self._initialized:
+            existing = set(self._worker_paths)
+            target = set(mapping)
+            for obsolete in existing - target:
+                self._remove_worktree(self.worktrees_dir / obsolete)
+
+        if not self._initialized:
+            self._recreate_worktree(self.boss_path, self.boss_branch)
+        else:
+            self._reset_worktree(self.boss_path)
+        self._worker_paths = mapping
+        self._initialized = True
+        return mapping
+
+    def worker_branch(self, worker_name: str) -> str:
+        return self._worker_branch_template.format(name=worker_name)
+
+    @property
+    def boss_branch(self) -> str:
+        return self._boss_branch
+
+    def _ensure_repo_initialized(self) -> None:
+        try:
+            _ = self._repo.head.commit  # type: ignore[attr-defined]
+        except ValueError as exc:
+            raise RuntimeError(
+                "Git repository has no commits. Create an initial commit before running parallel-dev."
+            ) from exc
+
+    def _recreate_worktree(self, path: Path, branch_name: str) -> None:
+        if path.exists():
+            try:
+                self._repo.git.worktree("remove", "--force", str(path))
+            except git.GitCommandError:
+                shutil.rmtree(path, ignore_errors=True)
+        if path.exists():
+            shutil.rmtree(path, ignore_errors=True)
+        self._repo.git.worktree(
+            "add",
+            "-B",
+            branch_name,
+            str(path),
+            "HEAD",
+        )
+
+    def _reset_worktree(self, path: Path) -> None:
+        if not path.exists():
+            return
+        repo = git.Repo(path)
+        repo.git.reset("--hard", "HEAD")
+        repo.git.clean("-fdx")
+
+    def _remove_worktree(self, path: Path) -> None:
+        if not path.exists():
+            return
+        try:
+            self._repo.git.worktree("remove", "--force", str(path))
+        except git.GitCommandError:
+            shutil.rmtree(path, ignore_errors=True)
+        if path.exists():
+            shutil.rmtree(path, ignore_errors=True)
+
+    def _resolve_session_root(self) -> Path:
+        base = self._storage_root / ".parallel-dev"
+        if self.session_namespace:
+            return base / "sessions" / self.session_namespace
+        return base
+
+    def _resolve_branch_templates(self) -> tuple[str, str]:
+        if self.session_namespace:
+            prefix = f"parallel-dev/{self.session_namespace}"
+            return f"{prefix}/{{name}}", f"{prefix}/boss"
+        return "parallel-dev/{name}", "parallel-dev/boss"

parallel_developer/stores/__init__.py

@@ -0,0 +1,20 @@
+"""Persistence-related store helpers."""
+
+from .session_manifest import ManifestStore, PaneRecord, SessionManifest, SessionReference
+from .settings_store import (
+    SettingsStore,
+    default_config_dir,
+    resolve_settings_path,
+    resolve_worktree_root,
+)
+
+__all__ = [
+    "ManifestStore",
+    "PaneRecord",
+    "SessionManifest",
+    "SessionReference",
+    "SettingsStore",
+    "default_config_dir",
+    "resolve_settings_path",
+    "resolve_worktree_root",
+]