JARVIS/backend/app/services/skill_service.py

"""
Skill Service - 技能管理服务层
负责技能的创建、查询、更新、删除等操作
"""

import hashlib
from datetime import UTC, datetime, timedelta
from typing import Optional
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, and_, or_
from app.agents.schemas.learning import SkillCandidate
from app.agents.skills.models import SkillLifecycleDecision
from app.models.skill import Skill
from app.models.user import User


class SkillService:
    def __init__(self, db: AsyncSession):
        self.db = db

    async def create(self, user_id: str, data: dict) -> Skill:
        """创建新技能"""
        skill = Skill(
            owner_id=user_id,
            name=data.get("name"),
            description=data.get("description"),
            instructions=data.get("instructions"),
            agent_type=data.get("agent_type"),
            tools=data.get("tools", []),
            required_context=data.get("required_context", []),
            output_format=data.get("output_format"),
            visibility=data.get("visibility", "private"),
            team_id=data.get("team_id"),
            is_active=data.get("is_active", True),
            status=data.get("status", "active"),
            scope=data.get("scope", []),
            effectiveness=data.get("effectiveness", 0.0),
            review_after=data.get("review_after"),
        )
        self.db.add(skill)
        await self.db.commit()
        await self.db.refresh(skill)
        return skill

    async def get_by_id(self, skill_id: str) -> Optional[Skill]:
        """根据ID获取技能"""
        result = await self.db.execute(
            select(Skill).where(Skill.id == skill_id)
        )
        return result.scalar_one_or_none()

    async def get_by_name_for_user(self, user_id: str, name: str) -> Optional[Skill]:
        access_scope = or_(
            Skill.owner_id == user_id,
            Skill.visibility == "market",
            Skill.team_id == user_id,
        )
        result = await self.db.execute(
            select(Skill).where(and_(Skill.name == name, access_scope))
        )
        return result.scalar_one_or_none()

    async def list_for_user(
        self,
        user_id: str,
        agent_type: Optional[str] = None,
        visibility: Optional[str] = None,
    ) -> list[Skill]:
        """
        列出用户可访问的技能：自己的 + 市场的 + 团队的
        """
        access_scope = or_(
            Skill.owner_id == user_id,
            Skill.visibility == "market",
            Skill.team_id == user_id,
        )

        filters = [access_scope, Skill.is_active == True, Skill.status != "retired"]

        if agent_type:
            filters.append(Skill.agent_type == agent_type)

        if visibility:
            filters.append(Skill.visibility == visibility)

        query = select(Skill).where(and_(*filters))

        result = await self.db.execute(query)
        return list(result.scalars().all())

    async def update(self, skill_id: str, user_id: str, data: dict) -> Optional[Skill]:
        """更新技能（仅所有者可更新）"""
        skill = await self.get_by_id(skill_id)
        if not skill:
            return None

        # 检查是否是所有者
        if skill.owner_id != user_id:
            return None

        # 更新字段
        update_fields = [
            "name", "description", "instructions", "agent_type",
            "tools", "required_context", "output_format", "visibility",
            "team_id", "is_active", "status", "scope", "effectiveness", "review_after"
        ]

        for field in update_fields:
            if field in data:
                setattr(skill, field, data[field])

        await self.db.commit()
        await self.db.refresh(skill)
        return skill

    async def delete(self, skill_id: str, user_id: str) -> bool:
        """删除技能（仅所有者可删除）"""
        skill = await self.get_by_id(skill_id)
        if not skill:
            return False

        # 检查是否是所有者
        if skill.owner_id != user_id:
            return False

        await self.db.delete(skill)
        await self.db.commit()
        return True

    async def get_by_agent_type(self, agent_type: str) -> list[Skill]:
        """
        获取指定 agent_type 的技能（用于 agent 运行时：市场 + 私有）
        """
        result = await self.db.execute(
            select(Skill).where(
                and_(
                    Skill.agent_type == agent_type,
                    Skill.is_active == True,
                    Skill.status == "active",
                    or_(
                        Skill.visibility == "market",
                        Skill.visibility == "private"
                    )
                )
            )
        )
        return list(result.scalars().all())

    async def list_runtime_candidates(
        self,
        user_id: str,
        *,
        agent_type: Optional[str] = None,
        include_shadow: bool = True,
        include_learned: bool = True,
    ) -> list[Skill]:
        allowed_statuses = ["active", "shadow"] if include_shadow else ["active"]
        access_scope = or_(
            Skill.owner_id == user_id,
            Skill.visibility == "market",
            Skill.team_id == user_id,
        )

        filters = [
            access_scope,
            Skill.is_active == True,
            Skill.status.in_(allowed_statuses),
        ]
        if not include_learned:
            filters.append(Skill.is_builtin == True)
        if agent_type:
            filters.append(Skill.agent_type == agent_type)

        result = await self.db.execute(select(Skill).where(and_(*filters)))
        return list(result.scalars().all())

    async def upsert_learned_candidate(
        self,
        *,
        user_id: str,
        candidate: SkillCandidate,
        primary_agent: str | None,
        evidence_refs: list[dict] | None = None,
    ) -> SkillLifecycleDecision:
        source_hash = self._build_candidate_source_hash(candidate)
        skill = await self.get_by_name_for_user(user_id, candidate.name)
        if skill is None:
            review_after = datetime.now(UTC) + timedelta(days=7)
            skill = Skill(
                owner_id=user_id,
                name=candidate.name,
                description=candidate.summary,
                instructions=candidate.summary,
                agent_type=primary_agent or "master",
                tools=[],
                required_context=[],
                output_format=None,
                visibility="private",
                is_active=True,
                status="candidate",
                scope=[primary_agent or "master", "learned", candidate.candidate_type],
                effectiveness=candidate.confidence,
                review_after=review_after,
                candidate_count=1,
                candidate_source_hashes=[source_hash],
            )
            self.db.add(skill)
            await self.db.commit()
            await self.db.refresh(skill)
            return SkillLifecycleDecision(
                skill_name=skill.name,
                action="created_candidate",
                previous_status=None,
                new_status="candidate",
                reason="First learned candidate created from retrospective evidence.",
                evidence_refs=evidence_refs or [],
                confidence=candidate.confidence,
                review_after=review_after,
            )

        previous_status = skill.status
        known_hashes = list(skill.candidate_source_hashes or [])
        is_duplicate_candidate = source_hash in known_hashes
        if not is_duplicate_candidate:
            skill.candidate_count = int(skill.candidate_count or 0) + 1
            known_hashes.append(source_hash)
        skill.candidate_source_hashes = known_hashes
        current_effectiveness = float(skill.effectiveness or 0.0)
        skill.effectiveness = round(max(current_effectiveness, float(candidate.confidence or 0.0)), 3)
        skill.review_after = datetime.now(UTC) + timedelta(days=7)
        if primary_agent and primary_agent not in (skill.scope or []):
            skill.scope = [*(skill.scope or []), primary_agent]

        action = "no_change"
        reason = "Candidate evidence refreshed."
        if is_duplicate_candidate:
            reason = "Duplicate candidate evidence ignored for promotion counting."
        if (
            not is_duplicate_candidate
            and skill.status == "candidate"
            and skill.candidate_count >= 2
            and skill.effectiveness >= 0.6
        ):
            skill.status = "shadow"
            action = "promoted_to_shadow"
            reason = "Repeated candidate evidence promoted the learned skill to shadow."

        await self.db.commit()
        await self.db.refresh(skill)
        return SkillLifecycleDecision(
            skill_name=skill.name,
            action=action,
            previous_status=previous_status,
            new_status=skill.status,
            reason=reason,
            evidence_refs=evidence_refs or [],
            confidence=skill.effectiveness,
            review_after=skill.review_after,
        )

    async def record_activation_feedback(
        self,
        *,
        user_id: str,
        skill_name: str,
        outcome_score: float,
        evidence_refs: list[dict] | None = None,
    ) -> SkillLifecycleDecision | None:
        skill = await self.get_by_name_for_user(user_id, skill_name)
        if skill is None or skill.status not in {"shadow", "active", "deprecated"}:
            return None

        previous_status = skill.status
        previous_activation_count = int(skill.activation_count or 0)
        skill.activation_count = previous_activation_count + 1
        skill.last_activated_at = datetime.now(UTC)

        previous_effectiveness = float(skill.effectiveness or 0.0)
        if previous_activation_count <= 0:
            skill.effectiveness = round(outcome_score, 3)
        else:
            skill.effectiveness = round(
                ((previous_effectiveness * previous_activation_count) + outcome_score)
                / skill.activation_count,
                3,
            )

        action = "feedback_recorded"
        reason = "Activation outcome recorded."
        if skill.status == "shadow" and skill.activation_count >= 2 and skill.effectiveness >= 0.7:
            skill.status = "active"
            action = "promoted_to_active"
            reason = "Shadow skill proved effective enough to become active."
        elif skill.status == "active" and skill.activation_count >= 3 and skill.effectiveness < 0.35:
            skill.status = "deprecated"
            action = "degraded_to_deprecated"
            reason = "Active skill underperformed repeatedly and was deprecated."
        elif skill.status == "deprecated" and skill.activation_count >= 4 and skill.effectiveness < 0.2:
            skill.status = "retired"
            action = "retired"
            reason = "Deprecated skill stayed ineffective and was retired."
        elif skill.status == "deprecated" and skill.effectiveness >= 0.65 and outcome_score >= 0.8:
            skill.status = "active"
            action = "reactivated"
            reason = "Deprecated skill recovered with strong positive feedback."

        skill.review_after = datetime.now(UTC) + timedelta(days=7)
        await self.db.commit()
        await self.db.refresh(skill)
        return SkillLifecycleDecision(
            skill_name=skill.name,
            action=action,
            previous_status=previous_status,
            new_status=skill.status,
            reason=reason,
            evidence_refs=evidence_refs or [],
            confidence=skill.effectiveness,
            review_after=skill.review_after,
        )

    async def run_decay_review(
        self,
        *,
        user_id: str,
        as_of: datetime | None = None,
    ) -> list[SkillLifecycleDecision]:
        review_time = as_of or datetime.now(UTC)
        result = await self.db.execute(
            select(Skill).where(
                and_(
                    Skill.owner_id == user_id,
                    Skill.is_active == True,
                    Skill.status.in_(["shadow", "active", "deprecated"]),
                    Skill.review_after.is_not(None),
                    Skill.review_after <= review_time,
                )
            )
        )
        skills = list(result.scalars().all())
        decisions: list[SkillLifecycleDecision] = []
        for skill in skills:
            previous_status = skill.status
            action = "no_change"
            reason = "Review completed without status change."

            if skill.status == "shadow" and float(skill.effectiveness or 0.0) < 0.45:
                skill.status = "deprecated"
                action = "degraded_to_deprecated"
                reason = "Shadow skill review found low effectiveness."
            elif skill.status == "deprecated" and float(skill.effectiveness or 0.0) < 0.2:
                skill.status = "retired"
                action = "retired"
                reason = "Deprecated skill remained weak through review."

            skill.review_after = review_time + timedelta(days=7)
            decisions.append(
                SkillLifecycleDecision(
                    skill_name=skill.name,
                    action=action,
                    previous_status=previous_status,
                    new_status=skill.status,
                    reason=reason,
                    confidence=skill.effectiveness,
                    review_after=skill.review_after,
                )
            )

        await self.db.commit()
        return decisions

    @staticmethod
    def _build_candidate_source_hash(candidate: SkillCandidate) -> str:
        raw = (
            f"{candidate.name}|{candidate.summary}|"
            f"{','.join(candidate.source_pattern_ids)}|"
            f"{len(candidate.evidence_refs)}"
        ).encode("utf-8")
        return hashlib.sha1(raw).hexdigest()