sibyl-cli 0.2.0__py3-none-any.whl

parallel_developer/stores/session_manifest.py

@@ -0,0 +1,165 @@
+"""Session manifest management for the interactive parallel developer CLI."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+import yaml
+
+
+@dataclass(slots=True)
+class PaneRecord:
+    role: str  # "main" | "boss" | "worker"
+    name: Optional[str]
+    session_id: str
+    worktree: Optional[str] = None
+
+
+@dataclass(slots=True)
+class SessionManifest:
+    session_id: str
+    created_at: str
+    tmux_session: str
+    worker_count: int
+    mode: str
+    logs_dir: str
+    latest_instruction: Optional[str] = None
+    scoreboard: Dict[str, Dict[str, object]] = field(default_factory=dict)
+    conversation_log: Optional[str] = None
+    selected_session_id: Optional[str] = None
+    main: PaneRecord = field(default_factory=lambda: PaneRecord(role="main", name=None, session_id=""))
+    boss: Optional[PaneRecord] = None
+    workers: Dict[str, PaneRecord] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, object]:
+        return {
+            "session_id": self.session_id,
+            "created_at": self.created_at,
+            "tmux_session": self.tmux_session,
+            "worker_count": self.worker_count,
+            "mode": self.mode,
+            "logs_dir": self.logs_dir,
+            "latest_instruction": self.latest_instruction,
+            "scoreboard": self.scoreboard,
+            "conversation_log": self.conversation_log,
+            "selected_session_id": self.selected_session_id,
+            "main": asdict(self.main),
+            "boss": asdict(self.boss) if self.boss else None,
+            "workers": {name: asdict(record) for name, record in self.workers.items()},
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, object]) -> "SessionManifest":
+        workers = {
+            name: PaneRecord(**record)
+            for name, record in (data.get("workers") or {}).items()
+        }
+        boss_data = data.get("boss")
+        return cls(
+            session_id=data["session_id"],
+            created_at=data["created_at"],
+            tmux_session=data["tmux_session"],
+            worker_count=int(data.get("worker_count", len(workers))),
+            mode=data.get("mode", "parallel"),
+            logs_dir=data["logs_dir"],
+            latest_instruction=data.get("latest_instruction"),
+            scoreboard=data.get("scoreboard", {}) or {},
+            conversation_log=data.get("conversation_log"),
+            selected_session_id=data.get("selected_session_id"),
+            main=PaneRecord(**data.get("main", {})),
+            boss=PaneRecord(**boss_data) if boss_data else None,
+            workers=workers,
+        )
+
+
+@dataclass(slots=True)
+class SessionReference:
+    session_id: str
+    tmux_session: str
+    manifest_path: Path
+    created_at: str
+    worker_count: int
+    mode: str
+    latest_instruction: Optional[str]
+    logs_dir: Path
+
+
+class ManifestStore:
+    """Persist CLI session manifests and maintain an index for /resume."""
+
+    def __init__(self, base_dir: Optional[Path] = None) -> None:
+        self.base_dir = base_dir or Path.home() / ".parallel-dev" / "manifests"
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self.index_path = self.base_dir / "index.json"
+        if not self.index_path.exists():
+            self.index_path.write_text(json.dumps({"sessions": {}}), encoding="utf-8")
+
+    def save_manifest(self, manifest: SessionManifest) -> None:
+        manifest_path = self.base_dir / f"{manifest.session_id}.yaml"
+        manifest_path.write_text(
+            yaml.safe_dump(manifest.to_dict(), sort_keys=False),
+            encoding="utf-8",
+        )
+        self._update_index(
+            SessionReference(
+                session_id=manifest.session_id,
+                tmux_session=manifest.tmux_session,
+                manifest_path=manifest_path,
+                created_at=manifest.created_at,
+                worker_count=manifest.worker_count,
+                mode=manifest.mode,
+                latest_instruction=manifest.latest_instruction,
+                logs_dir=Path(manifest.logs_dir),
+            )
+        )
+
+    def list_sessions(self) -> List[SessionReference]:
+        data = self._load_index()
+        sessions = []
+        for session_id, payload in data.get("sessions", {}).items():
+            try:
+                sessions.append(
+                    SessionReference(
+                        session_id=session_id,
+                        tmux_session=payload["tmux_session"],
+                        manifest_path=Path(payload["manifest_path"]),
+                        created_at=payload["created_at"],
+                        worker_count=int(payload.get("worker_count", 0)),
+                        mode=payload.get("mode", "parallel"),
+                        latest_instruction=payload.get("latest_instruction"),
+                        logs_dir=Path(payload["logs_dir"]),
+                    )
+                )
+            except KeyError:
+                continue
+        sessions.sort(key=lambda ref: ref.created_at, reverse=True)
+        return sessions
+
+    def load_manifest(self, session_id: str) -> SessionManifest:
+        data = self._load_index()
+        payload = data.get("sessions", {}).get(session_id)
+        if not payload:
+            raise KeyError(f"Session {session_id!r} not found in manifest index.")
+        manifest_path = Path(payload["manifest_path"])
+        manifest_data = yaml.safe_load(manifest_path.read_text(encoding="utf-8")) or {}
+        return SessionManifest.from_dict(manifest_data)
+
+    def _update_index(self, reference: SessionReference) -> None:
+        data = self._load_index()
+        data.setdefault("sessions", {})[reference.session_id] = {
+            "tmux_session": reference.tmux_session,
+            "manifest_path": str(reference.manifest_path),
+            "created_at": reference.created_at,
+            "worker_count": reference.worker_count,
+            "mode": reference.mode,
+            "latest_instruction": reference.latest_instruction,
+            "logs_dir": str(reference.logs_dir),
+        }
+        self.index_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    def _load_index(self) -> Dict[str, object]:
+        return json.loads(self.index_path.read_text(encoding="utf-8"))

parallel_developer/stores/settings_store.py

@@ -0,0 +1,242 @@
+"""Persistence helper for CLI settings stored in the user configuration directory."""
+
+from __future__ import annotations
+
+import os
+import platform
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional
+
+import yaml
+from platformdirs import PlatformDirs
+
+CONFIG_FILENAME = "config.yaml"
+ENV_CONFIG_PATH = "PARALLEL_DEV_CONFIG_PATH"
+ENV_WORKTREE_ROOT = "PARALLEL_DEV_WORKTREE_ROOT"
+_UNSET = object()
+
+
+def default_config_dir() -> Path:
+    system = platform.system().lower()
+    if "windows" in system:
+        dirs = PlatformDirs(appname="ParallelDeveloper", appauthor="ParallelDeveloper", roaming=True)
+        return Path(dirs.user_config_path)
+    return Path.home() / ".parallel-dev"
+
+
+def resolve_settings_path(explicit_path: Optional[Path] = None) -> Path:
+    if explicit_path is not None:
+        return Path(explicit_path)
+    env_path = os.getenv(ENV_CONFIG_PATH)
+    if env_path:
+        return Path(env_path).expanduser()
+    return default_config_dir() / CONFIG_FILENAME
+
+
+def resolve_worktree_root(config_value: Optional[str], fallback: Path) -> Path:
+    env_value = os.getenv(ENV_WORKTREE_ROOT)
+    if env_value:
+        return Path(env_value).expanduser()
+    if config_value:
+        return Path(config_value).expanduser()
+    return Path(fallback)
+
+
+@dataclass
+class SettingsData:
+    attach: str = "auto"
+    boss: str = "score"
+    flow: str = "full_auto"
+    parallel: str = "3"
+    mode: str = "parallel"
+    commit: str = "manual"
+    merge: str = "auto"
+    worktree_root: Optional[str] = None
+
+
+class SettingsStore:
+    """Load and persist CLI configuration flags."""
+
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._data: SettingsData = self._load()
+
+    @staticmethod
+    def _normalize_merge(value: Optional[str]) -> str:
+        if value is None:
+            return "auto"
+        token = str(value).strip().lower()
+        if token not in {"manual", "auto"}:
+            return "auto"
+        return token
+
+    @property
+    def attach(self) -> str:
+        return self._data.attach
+
+    @attach.setter
+    def attach(self, value: str) -> None:
+        self._data.attach = value
+        self._save()
+
+    @property
+    def boss(self) -> str:
+        return self._data.boss
+
+    @boss.setter
+    def boss(self, value: str) -> None:
+        self._data.boss = value
+        self._save()
+
+    @property
+    def flow(self) -> str:
+        return self._data.flow
+
+    @flow.setter
+    def flow(self, value: str) -> None:
+        self._data.flow = value
+        self._save()
+
+    @property
+    def parallel(self) -> str:
+        return self._data.parallel
+
+    @parallel.setter
+    def parallel(self, value: str) -> None:
+        self._data.parallel = value
+        self._save()
+
+    @property
+    def mode(self) -> str:
+        return self._data.mode
+
+    @mode.setter
+    def mode(self, value: str) -> None:
+        self._data.mode = value
+        self._save()
+
+    @property
+    def commit(self) -> str:
+        return self._data.commit
+
+    @commit.setter
+    def commit(self, value: str) -> None:
+        self._data.commit = value
+        self._save()
+
+    @property
+    def worktree_root(self) -> Optional[str]:
+        return self._data.worktree_root
+
+    @property
+    def merge(self) -> str:
+        return self._data.merge
+
+    @merge.setter
+    def merge(self, value: str) -> None:
+        self._data.merge = value
+        self._save()
+
+    @worktree_root.setter
+    def worktree_root(self, value: Optional[object]) -> None:
+        self._data.worktree_root = str(value) if value else None
+        self._save()
+
+    def snapshot(self) -> Dict[str, object]:
+        payload: Dict[str, object] = {
+            "commands": {
+                "attach": self._data.attach,
+                "boss": self._data.boss,
+                "flow": self._data.flow,
+                "parallel": self._data.parallel,
+                "mode": self._data.mode,
+                "commit": self._data.commit,
+                "merge": self._data.merge,
+            }
+        }
+        if self._data.worktree_root:
+            payload["paths"] = {"worktree_root": self._data.worktree_root}
+        return payload
+
+    def update(
+        self,
+        *,
+        attach: Optional[str] = None,
+        boss: Optional[str] = None,
+        flow: Optional[str] = None,
+        parallel: Optional[str] = None,
+        mode: Optional[str] = None,
+        commit: Optional[str] = None,
+        merge: Optional[str] = None,
+        worktree_root: object = _UNSET,
+    ) -> None:
+        if attach is not None:
+            self._data.attach = attach
+        if boss is not None:
+            self._data.boss = boss
+        if flow is not None:
+            self._data.flow = flow
+        if parallel is not None:
+            self._data.parallel = parallel
+        if mode is not None:
+            self._data.mode = mode
+        if commit is not None:
+            self._data.commit = commit
+        if merge is not None:
+            self._data.merge = merge
+        if worktree_root is not _UNSET:
+            self._data.worktree_root = str(worktree_root) if worktree_root else None
+        self._save()
+
+    def _load(self) -> SettingsData:
+        payload: Dict[str, object]
+        if self._path.exists():
+            try:
+                payload = yaml.safe_load(self._path.read_text(encoding="utf-8")) or {}
+            except yaml.YAMLError:
+                payload = {}
+        else:
+            payload = {}
+
+        commands = payload.get("commands") if isinstance(payload, dict) else None
+
+        paths_data = payload.get("paths") if isinstance(payload, dict) else None
+        worktree_root_value: Optional[str] = None
+        if isinstance(paths_data, dict):
+            raw_root = paths_data.get("worktree_root")
+            if raw_root:
+                worktree_root_value = str(raw_root)
+        if isinstance(commands, dict):
+            return SettingsData(
+                attach=str(commands.get("attach", "auto")),
+                boss=str(commands.get("boss", "score")),
+                flow=str(commands.get("flow", "full_auto")),
+                parallel=str(commands.get("parallel", "3")),
+                mode=str(commands.get("mode", "parallel")),
+                commit=str(commands.get("commit", "manual")),
+                merge=self._normalize_merge(commands.get("merge")),
+                worktree_root=worktree_root_value,
+            )
+
+        # Legacy YAML keys fallback
+        return SettingsData(
+            attach=str(payload.get("attach_mode", "auto")),
+            boss=str(payload.get("boss_mode", "score")),
+            flow=str(payload.get("flow_mode", "full_auto")),
+            parallel=str(payload.get("worker_count", "3")),
+            mode=str(payload.get("session_mode", "parallel")),
+            commit="auto" if bool(payload.get("auto_commit", False)) else "manual",
+            merge="auto",
+            worktree_root=None,
+        )
+
+    def _save(self) -> None:
+        try:
+            self._path.write_text(
+                yaml.safe_dump(self.snapshot(), sort_keys=True, allow_unicode=True),
+                encoding="utf-8",
+            )
+        except OSError:
+            pass

parallel_developer/ui/widgets.py

@@ -0,0 +1,269 @@
+"""UI widgets extracted from the parallel developer CLI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+from rich.text import Text
+from textual import events
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import OptionList, RichLog, Static, TextArea
+
+if TYPE_CHECKING:
+    from parallel_developer.controller import SessionConfig
+
+__all__ = [
+    "PaletteItem",
+    "ControllerEvent",
+    "StatusPanel",
+    "EventLog",
+    "CommandTextArea",
+    "CommandHint",
+    "CommandPalette",
+]
+
+
+@dataclass
+class PaletteItem:
+    label: str
+    value: object
+
+
+class ControllerEvent(Message):
+    def __init__(self, event_type: str, payload: Optional[Dict[str, object]] = None) -> None:
+        super().__init__()
+        self.event_type = event_type
+        self.payload = payload or {}
+
+
+class StatusPanel(Static):
+    def update_status(self, config: "SessionConfig", message: str) -> None:
+        flow_value = getattr(config, "flow_mode", None)
+        if hasattr(flow_value, "value"):
+            flow_text = flow_value.value  # type: ignore[attr-defined]
+        elif flow_value is not None:
+            flow_text = str(flow_value)
+        else:
+            flow_text = "manual"
+        lines = [
+            f"tmux session : {config.tmux_session}",
+            f"mode         : {config.mode.value}",
+            f"flow         : {flow_text}",
+            f"workers      : {config.worker_count}",
+            f"logs root    : {config.logs_root}",
+            f"status       : {message}",
+        ]
+        self.update("\n".join(lines))
+
+
+class EventLog(RichLog):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, highlight=True, markup=True, **kwargs)
+        self.wrap = True
+        self.auto_scroll = True
+        self.min_width = 0
+        self._entries: List[str] = []
+
+    def log(self, text: str) -> None:
+        for line in text.splitlines():
+            self._entries.append(line)
+            self._write_line(line)
+
+    def _write_line(self, line: str) -> None:
+        if self.markup:
+            renderable = Text.from_markup(line)
+        else:
+            renderable = Text(line)
+        renderable.no_wrap = False
+        renderable.overflow = "fold"
+        super().write(renderable)
+
+    def on_resize(self, event: events.Resize) -> None:
+        super().on_resize(event)
+        self._redraw()
+
+    def _redraw(self) -> None:
+        if not self._entries:
+            return
+        if not getattr(self, "_size_known", False):
+            return
+        super().clear()
+        for line in self._entries:
+            self._write_line(line)
+
+    @property
+    def entries(self) -> List[str]:
+        return list(self._entries)
+
+
+class CommandTextArea(TextArea):
+    async def _on_key(self, event: events.Key) -> None:  # type: ignore[override]
+        key = event.key or ""
+        name = event.name or ""
+        aliases = set(event.aliases)
+
+        if not hasattr(self, "_shift_next_enter"):
+            self._shift_next_enter = False  # type: ignore[attr-defined]
+
+        if key == "shift":
+            event.stop()
+            event.prevent_default()
+            self._shift_next_enter = True  # type: ignore[attr-defined]
+            return
+
+        if key in {"ctrl+enter", "meta+enter"} or name in {"ctrl_enter", "meta_enter"} or aliases.intersection({"ctrl+enter", "meta+enter"}):
+            event.stop()
+            event.prevent_default()
+            self._shift_next_enter = False  # type: ignore[attr-defined]
+            app = self.app
+            if hasattr(app, "_submit_command_input"):
+                app._submit_command_input()  # type: ignore[attr-defined]
+            return
+
+        if key == "shift+enter" or name == "shift_enter" or "shift+enter" in aliases:
+            event.stop()
+            event.prevent_default()
+            self._shift_next_enter = False  # type: ignore[attr-defined]
+            self.insert("\n")
+            return
+
+        if key == "tab" or name == "tab" or "tab" in aliases:
+            event.stop()
+            event.prevent_default()
+            self._shift_next_enter = False  # type: ignore[attr-defined]
+            handler = getattr(self.app, "_handle_tab_navigation", None)
+            if callable(handler):
+                handler(reverse=False)
+            return
+
+        if key == "shift+tab" or name == "shift_tab" or "shift+tab" in aliases:
+            event.stop()
+            event.prevent_default()
+            self._shift_next_enter = False  # type: ignore[attr-defined]
+            handler = getattr(self.app, "_handle_tab_navigation", None)
+            if callable(handler):
+                handler(reverse=True)
+            return
+
+        if key == "enter":
+            event.stop()
+            event.prevent_default()
+            if getattr(self, "_shift_next_enter", False):
+                self._shift_next_enter = False  # type: ignore[attr-defined]
+                self.insert("\n")
+            else:
+                app = self.app
+                if hasattr(app, "_submit_command_input"):
+                    app._submit_command_input()  # type: ignore[attr-defined]
+            return
+
+        self._shift_next_enter = False  # type: ignore[attr-defined]
+        await super()._on_key(event)
+
+    def action_cursor_down(self, select: bool = False) -> None:  # type: ignore[override]
+        if select:
+            super().action_cursor_down(select)
+            return
+        app = self.app
+        if getattr(getattr(app, "command_palette", None), "display", False):
+            app.command_palette.move_next()  # type: ignore[union-attr]
+            return
+        super().action_cursor_down(select)
+
+    def action_cursor_up(self, select: bool = False) -> None:  # type: ignore[override]
+        if select:
+            super().action_cursor_up(select)
+            return
+        app = self.app
+        if getattr(getattr(app, "command_palette", None), "display", False):
+            app.command_palette.move_previous()  # type: ignore[union-attr]
+            return
+        super().action_cursor_up(select)
+
+    def action_cursor_end(self, select: bool = False) -> None:  # type: ignore[override]
+        doc = getattr(self, "document", None)
+        if doc is None:
+            self.move_cursor((0, 0), select=select)
+            return
+        line_count = getattr(doc, "line_count", 0)
+        if line_count <= 0:
+            self.move_cursor((0, 0), select=select)
+            return
+        last_row = line_count - 1
+        try:
+            last_line = doc.get_line(last_row)
+            last_col = len(last_line)
+        except Exception:  # pragma: no cover - document API should not fail
+            last_row, last_col = 0, 0
+        self.move_cursor((last_row, last_col), select=select)
+        self.scroll_cursor_visible()
+
+
+class CommandHint(Static):
+    def update_hint(self, paused: bool = False) -> None:
+        suffix = ""
+        if paused:
+            suffix = " | [orange1]一時停止モード: ESCで巻き戻し、入力はワーカーへ送信[/]"
+        self.update(
+            "Commands : /attach, /parallel, /mode, /flow, /resume, /log, /status, /scoreboard, /done, /help, /exit | ESC: 一時停止/巻き戻し"
+            + suffix
+        )
+
+
+class CommandPalette(Static):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.display = False
+        self._items: List[PaletteItem] = []
+        self._active_index: int = 0
+        self._renderable: Text = Text()
+        self._max_items: int = 7
+
+    def set_items(self, items: List[PaletteItem]) -> None:
+        self._items = items[: self._max_items]
+        self._active_index = 0
+        if not self._items:
+            self.display = False
+            self._renderable = Text()
+            return
+        self.display = True
+        self._rebuild_renderable()
+
+    def _rebuild_renderable(self) -> None:
+        if not self._items:
+            self._renderable = Text()
+            return
+        lines: List[Text] = []
+        for idx, item in enumerate(self._items):
+            prefix = "▶ " if idx == self._active_index else "  "
+            style = "bold yellow" if idx == self._active_index else ""
+            lines.append(Text(prefix + item.label, style=style))
+        combined = Text()
+        for idx, segment in enumerate(lines):
+            if idx:
+                combined.append("\n")
+            combined.append(segment)
+        self._renderable = combined
+        self.refresh()
+
+    def move_next(self) -> None:
+        if not self._items:
+            return
+        self._active_index = (self._active_index + 1) % len(self._items)
+        self._rebuild_renderable()
+
+    def move_previous(self) -> None:
+        if not self._items:
+            return
+        self._active_index = (self._active_index - 1) % len(self._items)
+        self._rebuild_renderable()
+
+    def get_active_item(self) -> Optional[PaletteItem]:
+        if not self._items:
+            return None
+        return self._items[self._active_index]
+
+    def render(self) -> Text:
+        return self._renderable

sibyl_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: sibyl-cli
+Version: 0.2.0
+Summary: CLI orchestrator for parallel Codex agents with tmux and git worktree integration.
+Author: Parallel Developer Team
+Requires-Python: >=3.11
+Requires-Dist: gitpython>=3.1.45
+Requires-Dist: libtmux>=0.46.2
+Requires-Dist: platformdirs>=4.3.6
+Requires-Dist: pydantic>=2.9
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=13.9.2
+Requires-Dist: textual>=0.51.1
+Requires-Dist: typer>=0.12.3
+Requires-Dist: watchfiles>=0.23.0