ensemble-claude 0.3.0__py3-none-any.whl

ensemble/config.py

@@ -0,0 +1,218 @@
+"""Ensemble configuration management.
+
+Handles global (~/.config/ensemble/) and local (.ensemble/) configuration.
+"""
+
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+from ensemble.templates import get_template_path
+
+# Default configuration values
+DEFAULT_CONFIG = {
+    "version": "0.3.0",
+    "session": {
+        "name": "ensemble",
+        "attach": True,
+    },
+    "agents": {
+        "conductor": "conductor.md",
+        "dispatch": "dispatch.md",
+        "worker": "worker.md",
+        "reviewer": "reviewer.md",
+        "security_reviewer": "security-reviewer.md",
+        "integrator": "integrator.md",
+        "learner": "learner.md",
+    },
+    "workflow": {
+        "default": "default.yaml",
+        "simple": "simple.yaml",
+        "heavy": "heavy.yaml",
+        "worktree": "worktree.yaml",
+    },
+    "limits": {
+        "max_parallel_workers": 4,
+        "max_iterations": 15,
+    },
+}
+
+
+def get_global_config_dir() -> Path:
+    """Get the global configuration directory path."""
+    return Path.home() / ".config" / "ensemble"
+
+
+def get_local_config_dir() -> Path:
+    """Get the local configuration directory path (current project)."""
+    return Path.cwd() / ".ensemble"
+
+
+def ensure_global_config() -> Path:
+    """Ensure global configuration directory exists with defaults.
+
+    Creates ~/.config/ensemble/ with default templates if it doesn't exist.
+
+    Returns:
+        Path to the global config directory
+    """
+    global_dir = get_global_config_dir()
+
+    if not global_dir.exists():
+        global_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy default config
+        _write_default_config(global_dir / "config.yaml")
+
+        # Copy agent templates
+        _copy_default_templates(global_dir)
+
+    return global_dir
+
+
+def _write_default_config(config_path: Path) -> None:
+    """Write default configuration to file."""
+    with open(config_path, "w") as f:
+        yaml.dump(DEFAULT_CONFIG, f, default_flow_style=False, sort_keys=False)
+
+
+def _copy_default_templates(global_dir: Path) -> None:
+    """Copy default templates to global config directory."""
+    # Copy agents
+    agents_dir = global_dir / "agents"
+    agents_dir.mkdir(exist_ok=True)
+
+    template_agents = get_template_path("agents")
+    if template_agents.exists():
+        for agent_file in template_agents.glob("*.md"):
+            shutil.copy(agent_file, agents_dir / agent_file.name)
+
+    # Copy workflows
+    workflows_dir = global_dir / "workflows"
+    workflows_dir.mkdir(exist_ok=True)
+
+    template_workflows = get_template_path("workflows")
+    if template_workflows.exists():
+        for workflow_file in template_workflows.glob("*.yaml"):
+            shutil.copy(workflow_file, workflows_dir / workflow_file.name)
+
+
+def load_config() -> dict[str, Any]:
+    """Load merged configuration (global + local).
+
+    Priority (highest first):
+    1. Local project config (.ensemble/config.yaml)
+    2. Global config (~/.config/ensemble/config.yaml)
+    3. Default values
+
+    Returns:
+        Merged configuration dictionary
+    """
+    config = DEFAULT_CONFIG.copy()
+
+    # Load global config
+    global_config_file = get_global_config_dir() / "config.yaml"
+    if global_config_file.exists():
+        with open(global_config_file) as f:
+            global_config = yaml.safe_load(f) or {}
+            config = _deep_merge(config, global_config)
+
+    # Load local config (overrides global)
+    local_config_file = get_local_config_dir() / "config.yaml"
+    if local_config_file.exists():
+        with open(local_config_file) as f:
+            local_config = yaml.safe_load(f) or {}
+            config = _deep_merge(config, local_config)
+
+    return config
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Deep merge two dictionaries.
+
+    Args:
+        base: Base dictionary
+        override: Dictionary with overriding values
+
+    Returns:
+        Merged dictionary
+    """
+    result = base.copy()
+
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+
+    return result
+
+
+def resolve_agent_path(agent_name: str) -> Optional[Path]:
+    """Resolve the path to an agent definition file.
+
+    Priority (highest first):
+    1. Local project: ./.claude/agents/{agent}.md
+    2. Global config: ~/.config/ensemble/agents/{agent}.md
+    3. Package template: ensemble/templates/agents/{agent}.md
+
+    Args:
+        agent_name: Name of the agent (e.g., "conductor", "dispatch")
+
+    Returns:
+        Path to the agent file, or None if not found
+    """
+    filename = f"{agent_name}.md"
+
+    # Check local
+    local_path = Path.cwd() / ".claude" / "agents" / filename
+    if local_path.exists():
+        return local_path
+
+    # Check global
+    global_path = get_global_config_dir() / "agents" / filename
+    if global_path.exists():
+        return global_path
+
+    # Check package template
+    template_path = get_template_path("agents") / filename
+    if template_path.exists():
+        return template_path
+
+    return None
+
+
+def resolve_workflow_path(workflow_name: str) -> Optional[Path]:
+    """Resolve the path to a workflow definition file.
+
+    Priority (highest first):
+    1. Local project: ./.ensemble/workflows/{workflow}.yaml
+    2. Global config: ~/.config/ensemble/workflows/{workflow}.yaml
+    3. Package template: ensemble/templates/workflows/{workflow}.yaml
+
+    Args:
+        workflow_name: Name of the workflow (e.g., "default", "simple")
+
+    Returns:
+        Path to the workflow file, or None if not found
+    """
+    filename = f"{workflow_name}.yaml"
+
+    # Check local
+    local_path = Path.cwd() / ".ensemble" / "workflows" / filename
+    if local_path.exists():
+        return local_path
+
+    # Check global
+    global_path = get_global_config_dir() / "workflows" / filename
+    if global_path.exists():
+        return global_path
+
+    # Check package template
+    template_path = get_template_path("workflows") / filename
+    if template_path.exists():
+        return template_path
+
+    return None

ensemble/dashboard.py

@@ -0,0 +1,168 @@
+"""
+ダッシュボード更新モジュール
+
+status/dashboard.md を更新してリアルタイムの進捗を表示する。
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from ensemble.lock import atomic_write
+
+
+class DashboardUpdater:
+    """
+    ダッシュボード更新クラス
+
+    Markdownファイルを更新してタスクの進捗状況を表示する。
+    """
+
+    def __init__(self, status_dir: Path | None = None) -> None:
+        """
+        ダッシュボードアップデータを初期化する
+
+        Args:
+            status_dir: ステータスディレクトリ（デフォルト: status/）
+        """
+        self.status_dir = status_dir if status_dir else Path("status")
+        self.status_dir.mkdir(parents=True, exist_ok=True)
+        self.dashboard_path = self.status_dir / "dashboard.md"
+
+        # 内部状態
+        self._phase = "idle"
+        self._current_task = ""
+        self._completed = 0
+        self._total = 0
+        self._agents: dict[str, dict[str, str]] = {}
+        self._logs: list[str] = []
+
+        # 初期化時にダッシュボードを作成
+        self._write_dashboard()
+
+    def update_status(
+        self,
+        phase: str,
+        current_task: str,
+        agents: dict[str, str] | None = None,
+    ) -> None:
+        """
+        ステータスを更新する
+
+        Args:
+            phase: 現在のフェーズ
+            current_task: 現在のタスク
+            agents: エージェントステータス {"name": "status"}
+        """
+        self._phase = phase
+        self._current_task = current_task
+        if agents:
+            for name, status in agents.items():
+                self._agents[name] = {"status": status, "task": ""}
+        self._write_dashboard()
+
+    def add_log_entry(self, message: str) -> None:
+        """
+        ログエントリを追加する
+
+        Args:
+            message: ログメッセージ
+        """
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        self._logs.append(f"[{timestamp}] {message}")
+        # 最新10件のみ保持
+        self._logs = self._logs[-10:]
+        self._write_dashboard()
+
+    def set_phase(self, phase: str) -> None:
+        """
+        フェーズを設定する
+
+        Args:
+            phase: フェーズ名
+        """
+        self._phase = phase
+        self._write_dashboard()
+
+    def set_progress(self, completed: int, total: int) -> None:
+        """
+        進捗を設定する
+
+        Args:
+            completed: 完了タスク数
+            total: 総タスク数
+        """
+        self._completed = completed
+        self._total = total
+        self._write_dashboard()
+
+    def set_agent_status(
+        self, name: str, status: str, task: str = ""
+    ) -> None:
+        """
+        エージェントのステータスを設定する
+
+        Args:
+            name: エージェント名
+            status: ステータス
+            task: 実行中のタスク
+        """
+        self._agents[name] = {"status": status, "task": task}
+        self._write_dashboard()
+
+    def clear(self) -> None:
+        """
+        ダッシュボードをリセットする
+        """
+        self._phase = "idle"
+        self._current_task = ""
+        self._completed = 0
+        self._total = 0
+        self._agents = {}
+        self._logs = []
+        self._write_dashboard()
+
+    def _write_dashboard(self) -> None:
+        """ダッシュボードファイルを書き込む"""
+        now = datetime.now()
+
+        # エージェントテーブル
+        agent_rows = ""
+        for name, info in self._agents.items():
+            agent_rows += f"| {name} | {info['status']} | {info.get('task', '')} |\n"
+        if not agent_rows:
+            agent_rows = "| - | - | - |\n"
+
+        # ログセクション
+        log_section = "\n".join(self._logs) if self._logs else "(no logs)"
+
+        # 進捗表示
+        if self._total > 0:
+            progress = f"{self._completed}/{self._total}"
+        else:
+            progress = "-"
+
+        content = f"""# Ensemble Dashboard
+
+**Last Updated**: {now.strftime("%Y-%m-%d %H:%M:%S")}
+
+## Status
+
+| Phase | Current Task | Progress |
+|-------|--------------|----------|
+| {self._phase} | {self._current_task} | {progress} |
+
+## Agents
+
+| Agent | Status | Task |
+|-------|--------|------|
+{agent_rows}
+## Recent Logs
+
+```
+{log_section}
+```
+"""
+        atomic_write(str(self.dashboard_path), content)

ensemble/helpers.py

@@ -0,0 +1,79 @@
+"""
+src/ensemble/helpers.py - ヘルパー関数
+
+Ensemble固有のヘルパー関数を提供する。
+"""
+
+import re
+from pathlib import Path
+
+
+def sanitize_task_id(task_id: str) -> str:
+    """
+    タスクIDをサニタイズする
+
+    Args:
+        task_id: サニタイズするタスクID
+
+    Returns:
+        サニタイズされたタスクID
+    """
+    # 英数字、ハイフン、アンダースコアのみ許可
+    return re.sub(r"[^a-zA-Z0-9\-_]", "_", task_id)
+
+
+def get_queue_path(queue_type: str, base_dir: str = ".") -> Path:
+    """
+    キューディレクトリのパスを取得する
+
+    Args:
+        queue_type: キューの種類（tasks, reports, ack）
+        base_dir: ベースディレクトリ
+
+    Returns:
+        キューディレクトリのパス
+    """
+    valid_types = {"tasks", "reports", "ack", "conductor"}
+    if queue_type not in valid_types:
+        raise ValueError(f"Invalid queue type: {queue_type}")
+    return Path(base_dir) / "queue" / queue_type
+
+
+def parse_worker_id(pane_name: str) -> int | None:
+    """
+    ペイン名からワーカーIDを抽出する
+
+    Args:
+        pane_name: ペイン名（例: "worker-1", "worker-2"）
+
+    Returns:
+        ワーカーID。抽出できない場合はNone
+    """
+    match = re.match(r"worker-(\d+)", pane_name)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+def format_duration(seconds: float) -> str:
+    """
+    秒数を人間が読みやすい形式に変換する
+
+    Args:
+        seconds: 秒数
+
+    Returns:
+        "1h 23m 45s" 形式の文字列
+    """
+    hours, remainder = divmod(int(seconds), 3600)
+    minutes, secs = divmod(remainder, 60)
+
+    parts = []
+    if hours > 0:
+        parts.append(f"{hours}h")
+    if minutes > 0:
+        parts.append(f"{minutes}m")
+    if secs > 0 or not parts:
+        parts.append(f"{secs}s")
+
+    return " ".join(parts)

ensemble/lock.py

@@ -0,0 +1,77 @@
+"""
+アトミックロック機構
+
+ファイルベースのアトミック操作を提供する。
+mvコマンド（os.rename）のアトミック性を利用。
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+
+
+def atomic_write(filepath: str, content: str) -> bool:
+    """
+    アトミックな書き込みを行う
+
+    tmp作成 → mv（アトミック）で安全に書き込む。
+    同一ファイルシステム上でのos.renameはアトミック。
+
+    Args:
+        filepath: 書き込み先ファイルパス
+        content: 書き込む内容
+
+    Returns:
+        成功時True、失敗時False
+    """
+    dir_path = os.path.dirname(filepath)
+
+    # 親ディレクトリが存在しない場合は失敗
+    if dir_path and not os.path.exists(dir_path):
+        return False
+
+    try:
+        # tmpファイルを同じディレクトリに作成（同一ファイルシステム保証）
+        fd, tmp_path = tempfile.mkstemp(dir=dir_path if dir_path else ".")
+        try:
+            os.write(fd, content.encode("utf-8"))
+            os.close(fd)
+            os.rename(tmp_path, filepath)  # アトミック
+            return True
+        except Exception:
+            # 失敗時はtmpファイルを削除
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            return False
+    except Exception:
+        return False
+
+
+def atomic_claim(filepath: str, processing_dir: str) -> str | None:
+    """
+    アトミックなタスク取得を行う
+
+    mv（アトミック）で処理中ディレクトリへ移動することで、
+    複数プロセス間での排他制御を実現。
+
+    Args:
+        filepath: 取得対象のファイルパス
+        processing_dir: 処理中ファイルの移動先ディレクトリ
+
+    Returns:
+        成功時は移動先パス、失敗時（別プロセスが先に取得）はNone
+    """
+    filename = os.path.basename(filepath)
+    dest = os.path.join(processing_dir, filename)
+
+    try:
+        os.rename(filepath, dest)  # アトミック
+        return dest
+    except FileNotFoundError:
+        # 別プロセスが先に取得した場合
+        return None
+    except Exception:
+        return None

ensemble/logger.py

@@ -0,0 +1,80 @@
+"""
+Ensembleログ出力モジュール
+
+コンソール: テキスト形式（人間が読みやすい）
+ファイル: JSON形式（機械可読、分析容易）
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+class EnsembleLogger:
+    """
+    Ensemble用ログ出力クラス
+
+    コンソール: テキスト形式（人間が読みやすい）
+    ファイル: JSON形式（機械可読、分析容易）
+    """
+
+    def __init__(self, name: str = "ensemble", log_dir: Path | None = None) -> None:
+        """
+        ロガーを初期化する
+
+        Args:
+            name: ロガー名
+            log_dir: ログ出力ディレクトリ（デフォルト: logs/）
+        """
+        self.name = name
+        self.log_dir = log_dir if log_dir else Path("logs")
+        self.log_dir.mkdir(exist_ok=True)
+
+    def _get_log_file(self) -> Path:
+        """今日のログファイルパスを取得"""
+        today = datetime.now().strftime("%Y%m%d")
+        return self.log_dir / f"ensemble-{today}.log"
+
+    def log(self, level: str, message: str, **kwargs: Any) -> None:
+        """
+        構造化ログを出力する
+
+        Args:
+            level: ログレベル (DEBUG, INFO, WARNING, ERROR)
+            message: ログメッセージ
+            **kwargs: 追加の構造化データ
+        """
+        now = datetime.now()
+
+        # コンソール: テキスト形式
+        time_str = now.strftime("%H:%M:%S")
+        print(f"{time_str} [{level}] {message}")
+
+        # ファイル: JSON形式
+        log_entry = {
+            "timestamp": now.isoformat(),
+            "level": level,
+            "message": message,
+            **kwargs,
+        }
+        with open(self._get_log_file(), "a") as f:
+            f.write(json.dumps(log_entry) + "\n")
+
+    def debug(self, message: str, **kwargs: Any) -> None:
+        """DEBUGレベルでログ出力"""
+        self.log("DEBUG", message, **kwargs)
+
+    def info(self, message: str, **kwargs: Any) -> None:
+        """INFOレベルでログ出力"""
+        self.log("INFO", message, **kwargs)
+
+    def warning(self, message: str, **kwargs: Any) -> None:
+        """WARNINGレベルでログ出力"""
+        self.log("WARNING", message, **kwargs)
+
+    def error(self, message: str, **kwargs: Any) -> None:
+        """ERRORレベルでログ出力"""
+        self.log("ERROR", message, **kwargs)