swarm_engine_core/context/

resolver.rs

//! ContextResolver - スコープに応じたコンテキスト解決
//!
//! ContextStore + ContextView → ResolvedContext の変換を担当。
//!
//! # 使用例
//!
//! ```ignore
//! let store = ContextStore::new(tick)
//!     .with_worker(worker_ctx)
//!     .with_manager(mgr_ctx);
//!
//! // Manager用（全体が見える）
//! let mgr_view = ContextView::global(ManagerId(0));
//! let mgr_context = ContextResolver::resolve(&store, &mgr_view);
//!
//! // Worker用（自分 + Neighbor のみ）
//! let worker_view = ContextView::local_with_neighbors(
//!     WorkerId(0),
//!     vec![WorkerId(1)],
//! );
//! let worker_context = ContextResolver::resolve(&store, &worker_view);
//! ```

use crate::types::WorkerId;

use super::store::{
    ActionCandidate, ContextStore, ContextTarget, ContextView, ResolvedContext, WorkerContext,
};
use crate::agent::{ManagerId, WorkerScope};

// ============================================================================
// ContextResolver
// ============================================================================

/// コンテキスト解決器
///
/// ContextStore と ContextView から ResolvedContext を生成する。
pub struct ContextResolver;

impl ContextResolver {
    /// ContextStore + View → ResolvedContext
    pub fn resolve(store: &ContextStore, view: &ContextView) -> ResolvedContext {
        match view {
            ContextView::Global { manager_id } => Self::resolve_global(store, *manager_id),
            ContextView::Local {
                worker_id,
                neighbor_ids,
            } => Self::resolve_local(store, *worker_id, neighbor_ids),
            ContextView::Custom {
                name: _,
                visible_worker_ids,
                visible_manager_ids: _,
            } => Self::resolve_custom(store, visible_worker_ids),
        }
    }

    /// Global View の解決（Manager用）
    ///
    /// 全ての Worker 情報と Escalation が見える。
    fn resolve_global(store: &ContextStore, manager_id: ManagerId) -> ResolvedContext {
        let global = store.global.clone();

        // 全 Worker が見える
        let visible_workers: Vec<WorkerContext> = store.workers.values().cloned().collect();

        // 全 Escalation が見える
        let escalations = store.escalations.clone();

        // Action候補（全体から取得）
        let candidates = store
            .actions
            .as_ref()
            .map(ActionCandidate::from_config)
            .unwrap_or_default();

        ResolvedContext::new(global, ContextTarget::Manager(manager_id))
            .with_workers(visible_workers)
            .with_escalations(escalations)
            .with_candidates(candidates)
            .with_metadata(store.metadata.clone())
    }

    /// Local View の解決（Worker用）
    ///
    /// 自分自身と Neighbor の情報のみ見える。
    fn resolve_local(
        store: &ContextStore,
        worker_id: WorkerId,
        neighbor_ids: &[WorkerId],
    ) -> ResolvedContext {
        let global = store.global.clone();

        // 自分 + Neighbor のみ見える
        let mut visible_worker_ids = vec![worker_id];
        visible_worker_ids.extend(neighbor_ids.iter().copied());

        let visible_workers: Vec<WorkerContext> = visible_worker_ids
            .iter()
            .filter_map(|id| store.workers.get(id).cloned())
            .collect();

        // 可視範囲の Escalation のみ
        let escalations: Vec<_> = store
            .escalations
            .iter()
            .filter(|(wid, _)| visible_worker_ids.contains(wid))
            .cloned()
            .collect();

        // Action候補（全体から取得）
        let candidates = store
            .actions
            .as_ref()
            .map(ActionCandidate::from_config)
            .unwrap_or_default();

        // Worker用のメタデータ（グローバルから必要なものだけコピー）
        let mut metadata = std::collections::HashMap::new();
        if let Some(task) = store.get("task") {
            metadata.insert("task".to_string(), task.clone());
        }
        if let Some(hint) = store.get("hint") {
            metadata.insert("hint".to_string(), hint.clone());
        }

        ResolvedContext::new(global, ContextTarget::Worker(worker_id))
            .with_workers(visible_workers)
            .with_escalations(escalations)
            .with_candidates(candidates)
            .with_metadata(metadata)
    }

    /// Custom View の解決
    fn resolve_custom(store: &ContextStore, visible_worker_ids: &[WorkerId]) -> ResolvedContext {
        let global = store.global.clone();

        let visible_workers: Vec<WorkerContext> = visible_worker_ids
            .iter()
            .filter_map(|id| store.workers.get(id).cloned())
            .collect();

        let escalations: Vec<_> = store
            .escalations
            .iter()
            .filter(|(wid, _)| visible_worker_ids.contains(wid))
            .cloned()
            .collect();

        let candidates = store
            .actions
            .as_ref()
            .map(ActionCandidate::from_config)
            .unwrap_or_default();

        // Custom の場合、最初の Worker を target とする（暫定）
        let target = visible_worker_ids
            .first()
            .map(|&id| ContextTarget::Worker(id))
            .unwrap_or(ContextTarget::Worker(WorkerId(0)));

        ResolvedContext::new(global, target)
            .with_workers(visible_workers)
            .with_escalations(escalations)
            .with_candidates(candidates)
            .with_metadata(store.metadata.clone())
    }

    // ========================================================================
    // Scope-based Resolution (for Worker prompts)
    // ========================================================================

    /// WorkerScope に応じてコンテキストを解決（Worker 向け）
    ///
    /// Manager が Guidance で指定した Scope に基づいて、
    /// Worker に渡す情報量を制御する。
    ///
    /// # Arguments
    ///
    /// * `store` - コンテキストストア
    /// * `worker_id` - 対象 Worker ID
    /// * `scope` - 情報スコープ
    ///
    /// # Example
    ///
    /// ```ignore
    /// // Minimal: 自分の last_output のみ
    /// let ctx = ContextResolver::resolve_with_scope(&store, worker_id, &WorkerScope::Minimal);
    /// assert!(ctx.visible_workers.is_empty());
    /// assert!(ctx.self_last_output.is_some());
    ///
    /// // SelfDetail: 自分の詳細情報
    /// let ctx = ContextResolver::resolve_with_scope(&store, worker_id, &WorkerScope::SelfDetail);
    /// assert_eq!(ctx.visible_workers.len(), 1);
    /// ```
    pub fn resolve_with_scope(
        store: &ContextStore,
        worker_id: WorkerId,
        scope: &WorkerScope,
    ) -> ResolvedContext {
        let global = store.global.clone();

        // Action 候補は常に取得
        let candidates = store
            .actions
            .as_ref()
            .map(ActionCandidate::from_config)
            .unwrap_or_default();

        match scope {
            WorkerScope::Idle => {
                // Idle: 最小限のコンテキスト（candidates のみ）
                ResolvedContext::new(global, ContextTarget::Worker(worker_id))
                    .with_candidates(candidates)
            }

            WorkerScope::Minimal => {
                // Minimal: 自分の last_output のみ
                let self_output = store
                    .workers
                    .get(&worker_id)
                    .and_then(|w| w.metadata.get("last_output"))
                    .and_then(|v| v.as_str())
                    .map(String::from);

                ResolvedContext::new(global, ContextTarget::Worker(worker_id))
                    .with_self_last_output(self_output)
                    .with_candidates(candidates)
            }

            WorkerScope::SelfDetail => {
                // SelfDetail: 自分の詳細情報（WorkerContext 全体）
                let self_ctx = store.workers.get(&worker_id).cloned();
                let visible_workers = self_ctx.into_iter().collect();

                ResolvedContext::new(global, ContextTarget::Worker(worker_id))
                    .with_workers(visible_workers)
                    .with_candidates(candidates)
            }

            WorkerScope::WithTeamSummary => {
                // WithTeamSummary: 自分 + チームのサマリー（last_action のみ）
                let visible_workers: Vec<WorkerContext> = store
                    .workers
                    .values()
                    .map(|w| {
                        // サマリー版: id, last_action, last_success のみ
                        WorkerContext {
                            id: w.id,
                            consecutive_failures: 0,
                            last_action: w.last_action.clone(),
                            last_success: w.last_success,
                            history_len: 0,
                            has_escalation: w.has_escalation,
                            candidates: Vec::new(),
                            metadata: std::collections::HashMap::new(),
                        }
                    })
                    .collect();

                ResolvedContext::new(global, ContextTarget::Worker(worker_id))
                    .with_workers(visible_workers)
                    .with_candidates(candidates)
            }

            WorkerScope::WithTeamDetail => {
                // WithTeamDetail: 自分 + チームの詳細（全情報）
                let visible_workers: Vec<WorkerContext> = store.workers.values().cloned().collect();

                let escalations = store.escalations.clone();

                ResolvedContext::new(global, ContextTarget::Worker(worker_id))
                    .with_workers(visible_workers)
                    .with_escalations(escalations)
                    .with_candidates(candidates)
            }
        }
    }
}

// ============================================================================
// NeighborStrategy - Neighbor決定戦略
// ============================================================================

/// Neighbor決定戦略
///
/// Worker の可視範囲を決定する戦略。
pub trait NeighborStrategy: Send + Sync {
    /// 指定 Worker の Neighbor を決定
    fn neighbors(&self, worker_id: WorkerId, all_workers: &[WorkerId]) -> Vec<WorkerId>;
}

/// 全員が見える戦略（デフォルト）
#[derive(Debug, Clone, Default)]
pub struct AllVisibleStrategy;

impl NeighborStrategy for AllVisibleStrategy {
    fn neighbors(&self, _worker_id: WorkerId, all_workers: &[WorkerId]) -> Vec<WorkerId> {
        all_workers.to_vec()
    }
}

/// 隣接N件のみ見える戦略
#[derive(Debug, Clone)]
pub struct AdjacentStrategy {
    /// 前後何件見えるか
    pub radius: usize,
}

impl AdjacentStrategy {
    pub fn new(radius: usize) -> Self {
        Self { radius }
    }
}

impl NeighborStrategy for AdjacentStrategy {
    fn neighbors(&self, worker_id: WorkerId, all_workers: &[WorkerId]) -> Vec<WorkerId> {
        let idx = worker_id.0;

        all_workers
            .iter()
            .enumerate()
            .filter(|(i, _)| {
                let diff = (*i as isize - idx as isize).unsigned_abs();
                diff > 0 && diff <= self.radius
            })
            .map(|(_, &id)| id)
            .collect()
    }
}

/// Escalation中のWorkerのみ見える戦略
#[derive(Debug, Clone, Default)]
pub struct EscalationOnlyStrategy;

impl NeighborStrategy for EscalationOnlyStrategy {
    fn neighbors(&self, _worker_id: WorkerId, _all_workers: &[WorkerId]) -> Vec<WorkerId> {
        // 実際の実装では ContextStore を参照してEscalation中のWorkerを返す
        // ここでは簡易版として空を返す
        Vec::new()
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use crate::context::ManagerContext;

    fn create_test_store() -> ContextStore {
        ContextStore::new(10)
            .with_worker(
                WorkerContext::new(WorkerId(0))
                    .with_last_action("read:/a", true)
                    .with_candidates(vec!["read".into(), "grep".into()]),
            )
            .with_worker(
                WorkerContext::new(WorkerId(1))
                    .with_last_action("grep:pattern", false)
                    .with_escalation(true),
            )
            .with_worker(WorkerContext::new(WorkerId(2)).with_failures(3))
            .with_manager(ManagerContext::new(ManagerId(0)))
            .insert("task", "Find the bug")
            .insert("hint", "Check error logs")
    }

    #[test]
    fn test_resolve_global() {
        let store = create_test_store();
        let view = ContextView::global(ManagerId(0));
        let resolved = ContextResolver::resolve(&store, &view);

        // Manager は全 Worker が見える
        assert_eq!(resolved.visible_workers.len(), 3);
        assert!(resolved.is_manager());
        assert_eq!(resolved.global.tick, 10);
    }

    #[test]
    fn test_resolve_local_no_neighbors() {
        let store = create_test_store();
        let view = ContextView::local(WorkerId(0));
        let resolved = ContextResolver::resolve(&store, &view);

        // 自分のみ見える
        assert_eq!(resolved.visible_workers.len(), 1);
        assert_eq!(resolved.visible_workers[0].id, WorkerId(0));
        assert!(resolved.is_worker());
    }

    #[test]
    fn test_resolve_local_with_neighbors() {
        let store = create_test_store();
        let view = ContextView::local_with_neighbors(WorkerId(0), vec![WorkerId(1)]);
        let resolved = ContextResolver::resolve(&store, &view);

        // 自分 + Neighbor(1) が見える
        assert_eq!(resolved.visible_workers.len(), 2);
        let ids: Vec<_> = resolved.visible_workers.iter().map(|w| w.id).collect();
        assert!(ids.contains(&WorkerId(0)));
        assert!(ids.contains(&WorkerId(1)));
    }

    #[test]
    fn test_resolve_local_filters_escalations() {
        let store = create_test_store()
            .with_escalation(
                WorkerId(1),
                crate::state::Escalation::consecutive_failures(3, 5),
            )
            .with_escalation(
                WorkerId(2),
                crate::state::Escalation::consecutive_failures(5, 8),
            );

        // Worker 0 は Worker 1 のみ Neighbor
        let view = ContextView::local_with_neighbors(WorkerId(0), vec![WorkerId(1)]);
        let resolved = ContextResolver::resolve(&store, &view);

        // Worker 1 の Escalation のみ見える（Worker 2 のは見えない）
        assert_eq!(resolved.escalations.len(), 1);
        assert_eq!(resolved.escalations[0].0, WorkerId(1));
    }

    #[test]
    fn test_adjacent_strategy() {
        let strategy = AdjacentStrategy::new(1);
        let all = vec![WorkerId(0), WorkerId(1), WorkerId(2), WorkerId(3)];

        let neighbors = strategy.neighbors(WorkerId(1), &all);
        assert!(neighbors.contains(&WorkerId(0)));
        assert!(neighbors.contains(&WorkerId(2)));
        assert!(!neighbors.contains(&WorkerId(3)));
    }
}